type_enforced.enforcer

  1from types import (
  2    FunctionType,
  3    MethodType,
  4    GeneratorType,
  5    BuiltinFunctionType,
  6    BuiltinMethodType,
  7    UnionType,
  8)
  9from typing import Type, Union, Sized, Literal, Callable, get_type_hints, Any
 10from functools import update_wrapper
 11from type_enforced.utils import (
 12    Partial,
 13    GenericConstraint,
 14    iterable_types,
 15    merge_type_dicts,
 16)
 17import sys, traceback, random
 18from pathlib import Path
 19
 20_NoneType = type(None)
 21_package_path = Path(__file__).parent.resolve()
 22
 23
 24class FunctionMethodEnforcer:
 25    __slots__ = (
 26        "__fn__",
 27        "__strict__",
 28        "__clean_traceback__",
 29        "__iterable_sample_pct__",
 30        "__outer_self__",
 31        "__fn_defaults__",
 32        "__fn_varnames__",
 33        "__types_parsed__",
 34        "__checkable_types__",
 35        "__return_type__",
 36        "__simple_types__",
 37        "__complex_types__",
 38        "__simple_return_type__",
 39        "__param_indices__",
 40        "__flat_subtypes__",
 41        "__wrapped__",
 42        "__name__",
 43        "__qualname__",
 44        "__doc__",
 45        "__dict__",
 46    )
 47
 48    def __init__(
 49        self,
 50        __fn__,
 51        __strict__=False,
 52        __clean_traceback__=True,
 53        __iterable_sample_pct__=100,
 54    ):
 55        """
 56        Initialize a FunctionMethodEnforcer class object as a wrapper for a passed function `__fn__`.
 57
 58        Requires:
 59
 60            - `__fn__`:
 61                - What: The function to enforce
 62                - Type: function | method | class
 63
 64        Optional:
 65
 66            - `__strict__`:
 67                - What: A boolean to enable or disable exceptions. If True, exceptions will be raised
 68                    when type checking fails. If False, exceptions will not be raised but instead a warning
 69                    will be printed to the console.
 70                - Type: bool
 71                - Default: False
 72            - `__clean_traceback__`:
 73                - What: A boolean to enable or disable cleaning of tracebacks when raising exceptions.
 74                - Type: bool
 75                - Default: True
 76            - `__iterable_sample_pct__`:
 77                - What: The percentage of items to sample when validating iterables. If 100, all items
 78                    are validated. If less than 100, the first and last items are always validated
 79                    plus a random sample of the remaining items up to the specified percentage.
 80                - Type: int | float
 81                - Default: 100
 82        """
 83        update_wrapper(self, __fn__)
 84        self.__fn__ = __fn__
 85        self.__strict__ = __strict__
 86        self.__clean_traceback__ = __clean_traceback__
 87        self.__iterable_sample_pct__ = __iterable_sample_pct__
 88        self.__outer_self__ = None
 89        self.__types_parsed__ = False
 90        self.__flat_subtypes__ = {}
 91        # Validate that the passed function or method is a method or function
 92        self.__check_method_function__()
 93        # Get input defaults for the function or method
 94        self.__get_defaults__()
 95
 96    def __get_defaults__(self):
 97        """
 98        Get the default values of the passed function or method and store them in `self.__fn_defaults__`.
 99        Also caches the function's variable names for use in `__call__`.
100        """
101        self.__fn_varnames__ = self.__fn__.__code__.co_varnames
102        self.__fn_defaults__ = {}
103        if self.__fn__.__defaults__ is not None:
104            # Get the names of all provided default values for args
105            default_varnames = list(self.__fn_varnames__)[
106                : self.__fn__.__code__.co_argcount
107            ][-len(self.__fn__.__defaults__) :]
108            # Update the output dictionary with the default values
109            self.__fn_defaults__.update(
110                dict(zip(default_varnames, self.__fn__.__defaults__))
111            )
112        if self.__fn__.__kwdefaults__ is not None:
113            # Update the output dictionary with the keyword default values
114            self.__fn_defaults__.update(self.__fn__.__kwdefaults__)
115
116    def __get_sample_indices__(self, length):
117        """
118        Get a sorted list of indices to sample for iterable validation.
119
120        If iterable_sample_pct is 0, only the first item (index 0) is checked.
121        Otherwise, always includes the first (0) and last (length-1) indices.
122        If length > 3, samples additional middle indices up to the
123        iterable_sample_pct percentage.
124        Only called when self.__iterable_sample_pct__ < 100.
125        """
126        if length == 0:
127            return []
128        if self.__iterable_sample_pct__ == 0:
129            return [0]
130        if length <= 3:
131            return range(length)
132        n = max(3, int(length * self.__iterable_sample_pct__ / 100))
133        if n >= length:
134            return range(length)
135        middle_sample = random.sample(range(1, length - 1), n - 2)
136        return sorted([0] + middle_sample + [length - 1])
137
138    def __get_sample_keys__(self, keys):
139        """
140        Get a sampled list of dict keys for iterable validation.
141
142        If iterable_sample_pct is 0, only the first key is returned.
143        Otherwise, always includes the first key plus a random sample of
144        the remaining keys up to the iterable_sample_pct percentage.
145        Only called when self.__iterable_sample_pct__ < 100.
146        """
147        if len(keys) == 0:
148            return []
149        if self.__iterable_sample_pct__ == 0 or len(keys) == 1:
150            return [keys[0]]
151        n = max(1, int(len(keys) * self.__iterable_sample_pct__ / 100))
152        if n >= len(keys):
153            return keys
154        return [keys[0]] + random.sample(keys[1:], n - 1)
155
156    def __get_checkable_types__(self):
157        """
158        Creates two class attributes:
159
160        - `self.__checkable_types__`:
161            - What: A dictionary of all annotations as checkable types
162            - Type: dict
163
164        - `self.__return_type__`:
165            - What: The return type of the function or method
166            - Type: dict | None
167        """
168        if not self.__types_parsed__:
169            self.__checkable_types__ = {
170                key: self.__get_checkable_type__(value)
171                for key, value in get_type_hints(self.__fn__).items()
172            }
173            self.__return_type__ = self.__checkable_types__.pop("return", None)
174            # Classify params: simple types can use a single
175            # isinstance call, skipping __check_type__ entirely.
176            self.__simple_types__ = {}
177            self.__complex_types__ = {}
178            for key, expected in self.__checkable_types__.items():
179                if (
180                    "__extra__" not in expected
181                    and all(v is None for v in expected.values())
182                    and all(isinstance(k, type) for k in expected.keys())
183                ):
184                    self.__simple_types__[key] = tuple(expected.keys())
185                else:
186                    self.__complex_types__[key] = expected
187            # Same classification for return type
188            if self.__return_type__ is not None and (
189                "__extra__" not in self.__return_type__
190                and all(v is None for v in self.__return_type__.values())
191                and all(
192                    isinstance(k, type) for k in self.__return_type__.keys()
193                )
194            ):
195                self.__simple_return_type__ = tuple(self.__return_type__.keys())
196            else:
197                self.__simple_return_type__ = None
198            # Pre-compute param index in co_varnames for
199            # direct arg lookup (skips assigned_vars dict).
200            self.__param_indices__ = {
201                name: i
202                for i, name in enumerate(self.__fn_varnames__)
203                if name in self.__checkable_types__
204            }
205            self.__types_parsed__ = True
206
207    def __get_checkable_type__(self, annotation):
208        """
209        Parses a type annotation and returns a nested dict structure
210        representing the checkable type(s) for validation.
211        """
212
213        if annotation is None:
214            return {_NoneType: None}
215
216        # Handle `int | str` syntax (Python 3.10+) and Unions
217        if (
218            isinstance(annotation, UnionType)
219            or getattr(annotation, "__origin__", None) == Union
220        ):
221            combined_types = {}
222            for sub_type in annotation.__args__:
223                merge_type_dicts(
224                    combined_types,
225                    self.__get_checkable_type__(sub_type),
226                )
227            return combined_types
228
229        # Handle typing.Literal
230        if getattr(annotation, "__origin__", None) == Literal:
231            return {"__extra__": {"__literal__": list(annotation.__args__)}}
232
233        # Handle generic collections
234        origin = getattr(annotation, "__origin__", None)
235        args = getattr(annotation, "__args__", ())
236
237        if origin == list:
238            if len(args) != 1:
239                self.__exception__(
240                    f"List must have a single type argument, got: {args}",
241                    raise_exception=True,
242                )
243            return {list: self.__get_checkable_type__(args[0])}
244
245        if origin == dict:
246            if len(args) != 2:
247                self.__exception__(
248                    f"Dict must have two type arguments, got: {args}",
249                    raise_exception=True,
250                )
251            key_type = self.__get_checkable_type__(args[0])
252            value_type = self.__get_checkable_type__(args[1])
253            return {dict: (key_type, value_type)}
254
255        if origin == tuple:
256            if len(args) > 2 or len(args) == 1:
257                if Ellipsis in args:
258                    self.__exception__(
259                        "Tuple with Ellipsis must have exactly two type arguments and the second must be Ellipsis.",
260                        raise_exception=True,
261                    )
262            if len(args) == 2:
263                if args[0] is Ellipsis:
264                    self.__exception__(
265                        "Tuple with Ellipsis must have exactly two type arguments and the first must not be Ellipsis.",
266                        raise_exception=True,
267                    )
268                if args[1] is Ellipsis:
269                    return {tuple: (self.__get_checkable_type__(args[0]), True)}
270            return {
271                tuple: (
272                    tuple(self.__get_checkable_type__(arg) for arg in args),
273                    False,
274                )
275            }
276
277        if origin == set:
278            if len(args) != 1:
279                self.__exception__(
280                    f"Set must have a single type argument, got: {args}",
281                    raise_exception=True,
282                )
283            return {set: self.__get_checkable_type__(args[0])}
284
285        # Handle Sized types
286        if annotation == Sized:
287            return {
288                list: None,
289                tuple: None,
290                dict: None,
291                set: None,
292                str: None,
293                bytes: None,
294                bytearray: None,
295                memoryview: None,
296                range: None,
297            }
298
299        # Handle Callable types
300        if annotation == Callable:
301            return {
302                staticmethod: None,
303                classmethod: None,
304                FunctionType: None,
305                BuiltinFunctionType: None,
306                MethodType: None,
307                BuiltinMethodType: None,
308                GeneratorType: None,
309            }
310
311        if annotation == Any:
312            return {
313                object: None,
314            }
315
316        # Handle Constraints
317        if isinstance(annotation, GenericConstraint):
318            return {"__extra__": {"__constraints__": [annotation]}}
319
320        # Handle standard types
321        if isinstance(annotation, type):
322            return {annotation: None}
323
324        # Hanldle typing.Type (for uninitialized classes)
325        if origin is type and len(args) == 1:
326            return {annotation: None}
327
328        self.__exception__(
329            f"Unsupported type hint: {annotation}", raise_exception=True
330        )
331
332    def __exception__(self, message, raise_exception=False):
333        """
334        Usage:
335
336        - Creates a class based exception message
337
338        Requires:
339
340        - `message`:
341            - Type: str
342            - What: The message to warn users with
343
344        Optional:
345
346        - `raise_exception`:
347            - Type: bool
348            - What: Forces an exception to be raised regardless of the `self.__strict__` setting.
349            - Default: False
350        """
351        if self.__strict__ or raise_exception:
352            msg = f"TypeEnforced Exception ({self.__fn__.__qualname__}): {message}"
353            if self.__clean_traceback__:
354                package_path = _package_path
355                frame = sys._getframe()
356                relevant_tb_count = 0
357                while frame is not None:
358                    frame_file = Path(frame.f_code.co_filename).resolve()
359                    try:
360                        frame_file.relative_to(package_path)
361                    except ValueError:
362                        relevant_tb_count += 1
363                    frame = frame.f_back
364                original_excepthook = sys.excepthook
365
366                def excepthook(type, value, tb):
367                    traceback.print_exception(
368                        type, value, tb, limit=relevant_tb_count
369                    )
370                    sys.excepthook = original_excepthook
371
372                sys.excepthook = excepthook
373            raise TypeError(msg)
374        else:
375            print(
376                f"TypeEnforced Warning ({self.__fn__.__qualname__}): {message}"
377            )
378
379    def __get__(self, obj, objtype):
380        """
381        Overwrite standard __get__ method to return __call__ instead for wrapped class methods.
382
383        Also stores the calling (__get__) `obj` to be passed as an initial argument for `__call__` such that methods can pass `self` correctly.
384        """
385        self.__outer_self__ = obj
386
387        def __get_fn__(*args, **kwargs):
388            return self.__call__(*args, **kwargs)
389
390        __get_fn__.__name__ = self.__fn__.__name__
391        __get_fn__.__qualname__ = self.__fn__.__qualname__
392        __get_fn__.__doc__ = self.__fn__.__doc__
393        return __get_fn__
394
395    def __check_method_function__(self):
396        """
397        Validate that `self.__fn__` is a method or function
398        """
399        if not isinstance(self.__fn__, (MethodType, FunctionType)):
400            raise Exception(
401                f"A non function/method was passed to Enforcer. See the stack trace above for more information."
402            )
403
404    def __call__(self, *args, **kwargs):
405        """
406        This method is used to validate the passed inputs and return the output of the wrapped function or method.
407        """
408        # Special code to pass self as an initial argument
409        # for validation purposes in methods
410        # See: self.__get__
411        if self.__outer_self__ is not None:
412            args = (self.__outer_self__, *args)
413        # Get a dictionary of all annotations as checkable types
414        # Note: This is only done once at first call to avoid redundant calculations
415        self.__get_checkable_types__()
416        # Fast path: simple types use direct index lookup
417        for key, types_tuple in self.__simple_types__.items():
418            idx = self.__param_indices__[key]
419            if idx < len(args):
420                obj = args[idx]
421            elif key in kwargs:
422                obj = kwargs[key]
423            else:
424                obj = self.__fn_defaults__.get(key)
425            if not isinstance(obj, types_tuple):
426                # Fall back to full check for error reporting
427                self.__check_type__(obj, self.__checkable_types__[key], key)
428        # Full validation for complex types (nested, extras, Type[X])
429        if self.__complex_types__:
430            assigned_vars = {
431                **self.__fn_defaults__,
432                **dict(zip(self.__fn_varnames__[: len(args)], args)),
433                **kwargs,
434            }
435            for key, value in self.__complex_types__.items():
436                self.__check_type__(assigned_vars.get(key), value, key)
437        # Execute the function callable
438        return_value = self.__fn__(*args, **kwargs)
439        # If a return type was passed, validate the returned object
440        if self.__return_type__ is not None:
441            if self.__simple_return_type__ is not None:
442                if not isinstance(return_value, self.__simple_return_type__):
443                    self.__check_type__(
444                        return_value, self.__return_type__, "return"
445                    )
446            else:
447                self.__check_type__(
448                    return_value, self.__return_type__, "return"
449                )
450        return return_value
451
452    def __quick_check__(self, subtype, obj):
453        subtype_id = id(subtype)
454        if subtype_id not in self.__flat_subtypes__:
455            # First call for this subtype: compute and cache
456            if all(v is None for v in subtype.values()):
457                self.__flat_subtypes__[subtype_id] = frozenset(subtype.keys())
458            else:
459                self.__flat_subtypes__[subtype_id] = None
460        flat_keys = self.__flat_subtypes__[subtype_id]
461        if flat_keys is not None:
462            values = {type(v) for v in obj}
463            if values.issubset(flat_keys):
464                return True
465        return False
466
467    def __check_type__(self, obj, expected, key):
468        """
469        Raises an exception the type of a passed `obj` (parameter) is not in the list of supplied `acceptable_types` for the argument.
470        """
471        # Special case for None
472        if obj is None and _NoneType in expected:
473            return
474        if "__extra__" in expected:
475            extra = expected["__extra__"]
476            expected = {k: v for k, v in expected.items() if k != "__extra__"}
477        else:
478            extra = None
479
480        if isinstance(obj, type):
481            # An uninitialized class is passed, we need to check if the type is in the expected types using Type[obj]
482            obj_type = Type[obj]
483            is_present = obj_type in expected
484        else:
485            obj_type = type(obj)
486            is_present = obj_type in expected or isinstance(
487                obj, tuple(expected.keys())
488            )
489
490        if not is_present:
491            # Allow for literals to be used to bypass type checks if present
492            literal = extra.get("__literal__", ()) if extra is not None else ()
493            if literal:
494                if obj not in literal:
495                    self.__exception__(
496                        f"Type mismatch for typed variable `{key}`. Expected one of the following `{list(expected.keys())}` or a literal value in `{literal}` but got type `{obj_type}` with value `{obj}` instead."
497                    )
498            # Raise an exception if the type is not in the expected types
499            else:
500                self.__exception__(
501                    f"Type mismatch for typed variable `{key}`. Expected one of the following `{list(expected.keys())}` but got `{obj_type}` with value `{obj}` instead."
502                )
503        # If the object_type is in the expected types, we can proceed with validation
504        elif obj_type in iterable_types:
505            subtype = expected.get(obj_type, None)
506            if subtype is None:
507                pass
508            # Recursive validation
509            elif obj_type == list:
510                if self.__iterable_sample_pct__ < 100:
511                    for idx in self.__get_sample_indices__(len(obj)):
512                        self.__check_type__(obj[idx], subtype, f"{key}[{idx}]")
513                # If the subtype does not contain iterables with typing, we can validate the items directly.
514                elif not self.__quick_check__(subtype, obj):
515                    for idx, item in enumerate(obj):
516                        self.__check_type__(item, subtype, f"{key}[{idx}]")
517            elif obj_type == dict:
518                key_type, val_type = subtype
519                if self.__iterable_sample_pct__ < 100:
520                    sampled_keys = self.__get_sample_keys__(list(obj.keys()))
521                    if not self.__quick_check__(key_type, sampled_keys):
522                        for dk in sampled_keys:
523                            self.__check_type__(
524                                dk, key_type, f"{key}.key[{repr(dk)}]"
525                            )
526                    if not self.__quick_check__(
527                        val_type, [obj[dk] for dk in sampled_keys]
528                    ):
529                        for dk in sampled_keys:
530                            self.__check_type__(
531                                obj[dk], val_type, f"{key}[{repr(dk)}]"
532                            )
533                else:
534                    if not self.__quick_check__(key_type, obj.keys()):
535                        for key in obj.keys():
536                            self.__check_type__(
537                                key, key_type, f"{key}.key[{repr(key)}]"
538                            )
539                    if not self.__quick_check__(val_type, obj.values()):
540                        for key, value in obj.items():
541                            self.__check_type__(
542                                value, val_type, f"{key}[{repr(key)}]"
543                            )
544            elif obj_type == tuple:
545                expected_args, is_ellipsis = subtype
546                if is_ellipsis:
547                    if self.__iterable_sample_pct__ < 100:
548                        for idx in self.__get_sample_indices__(len(obj)):
549                            self.__check_type__(
550                                obj[idx], expected_args, f"{key}[{idx}]"
551                            )
552                    elif not self.__quick_check__(expected_args, obj):
553                        for idx, item in enumerate(obj):
554                            self.__check_type__(
555                                item, expected_args, f"{key}[{idx}]"
556                            )
557                else:
558                    if len(obj) != len(expected_args):
559                        self.__exception__(
560                            f"Tuple length mismatch for `{key}`. Expected length {len(expected_args)}, got {len(obj)}"
561                        )
562                    for idx, (item, ex) in enumerate(zip(obj, expected_args)):
563                        self.__check_type__(item, ex, f"{key}[{idx}]")
564            elif obj_type == set:
565                if self.__iterable_sample_pct__ < 100:
566                    obj_list = list(obj)
567                    for idx in self.__get_sample_indices__(len(obj_list)):
568                        item = obj_list[idx]
569                        self.__check_type__(
570                            item, subtype, f"{key}[{repr(item)}]"
571                        )
572                elif not self.__quick_check__(subtype, obj):
573                    for item in obj:
574                        self.__check_type__(
575                            item, subtype, f"{key}[{repr(item)}]"
576                        )
577
578        # Validate constraints if any are present
579        if extra is not None:
580            constraints = extra.get("__constraints__", ())
581            for constraint in constraints:
582                constraint_validation_output = constraint.__validate__(key, obj)
583                if constraint_validation_output is not True:
584                    self.__exception__(
585                        f"Constraint validation error for variable `{key}` with value `{obj}`. {constraint_validation_output}"
586                    )
587
588    def __repr__(self):
589        return f"<type_enforced {self.__fn__.__module__}.{self.__fn__.__qualname__} object at {hex(id(self))}>"
590
591
592@Partial
593def Enforcer(
594    clsFnMethod,
595    enabled=True,
596    strict=True,
597    clean_traceback=True,
598    iterable_sample_pct=100,
599):
600    """
601    A wrapper to enforce types within a function or method given argument annotations.
602
603    Each wrapped item is converted into a special `FunctionMethodEnforcer` class object that validates the passed parameters for the function or method when it is called. If a function or method that is passed does not have any annotations, it is not converted into a `FunctionMethodEnforcer` class as no validation is possible.
604
605    If wrapping a class, all methods in the class that meet any of the following criteria will be wrapped individually:
606
607    - Methods with `__call__`
608    - Methods wrapped with `staticmethod` (if python >= 3.10)
609    - Methods wrapped with `classmethod` (if python >= 3.10)
610
611    Requires:
612
613    - `clsFnMethod`:
614        - What: The class, function or method that should have input types enforced
615        - Type: function | method | class
616
617    Optional:
618
619    - `enabled`:
620        - What: A boolean to enable or disable the enforcer
621        - Type: bool
622        - Default: True
623    - `strict`:
624        - What: A boolean to enable or disable exceptions. If True, exceptions will be raised when type checking fails. If False, exceptions will not be raised but instead a warning will be printed to the console.
625        - Type: bool
626        - Default: False
627        - Note: Type hints that are wrapped with the type enforcer and are invalid will still raise an exception.
628    - `clean_traceback`:
629        - What: A boolean to enable or disable cleaning of tracebacks when raising exceptions.
630        - If True, modifies the excepthook temporarily such that only the relevant stack (not in the type_enforced package) is shown.
631        - Type: bool
632        - Default: True
633    - `iterable_sample_pct`:
634        - What: The percentage (0-100) of items to validate when checking typed iterables (list,
635            dict, set, variable-length tuple). At 100 (default) every item is checked. Below 100,
636            the first and last items are always checked; if the collection has more than 3 items,
637            additional items are randomly sampled so that the total checked is at least 3.
638        - Type: int | float
639        - Default: 100
640
641
642    Example Use:
643    ```
644    >>> import type_enforced
645    >>> @type_enforced.Enforcer
646    ... def my_fn(a: int , b: [int, str] =2, c: int =3) -> None:
647    ...     pass
648    ...
649    >>> my_fn(a=1, b=2, c=3)
650    >>> my_fn(a=1, b='2', c=3)
651    >>> my_fn(a='a', b=2, c=3)
652    Traceback (most recent call last):
653      File "<stdin>", line 1, in <module>
654      File "/home/conmak/development/personal/type_enforced/type_enforced/enforcer.py", line 85, in __call__
655        self.__check_type__(assigned_vars.get(key), value, key)
656      File "/home/conmak/development/personal/type_enforced/type_enforced/enforcer.py", line 107, in __check_type__
657        self.__exception__(
658      File "/home/conmak/development/personal/type_enforced/type_enforced/enforcer.py", line 34, in __exception__
659        raise Exception(f"({self.__fn__.__qualname__}): {message}")
660    Exception: (my_fn): Type mismatch for typed variable `a`. Expected one of the following `[<class 'int'>]` but got `<class 'str'>` instead.
661    ```
662    """
663    if not hasattr(clsFnMethod, "__type_enforced_enabled__"):
664        # Special try except clause to handle cases when the object is immutable
665        try:
666            clsFnMethod.__type_enforced_enabled__ = enabled
667        except:
668            return clsFnMethod
669    if not clsFnMethod.__type_enforced_enabled__:
670        return clsFnMethod
671    if isinstance(
672        clsFnMethod, (staticmethod, classmethod, FunctionType, MethodType)
673    ):
674        # Only apply the enforcer if type_hints are present
675        # Add try except clause to better handle forward refs.
676        try:
677            if get_type_hints(clsFnMethod) == {}:
678                return clsFnMethod
679        except:
680            pass
681        if isinstance(clsFnMethod, staticmethod):
682            return staticmethod(
683                FunctionMethodEnforcer(
684                    __fn__=clsFnMethod.__func__,
685                    __strict__=strict,
686                    __clean_traceback__=clean_traceback,
687                    __iterable_sample_pct__=iterable_sample_pct,
688                )
689            )
690        elif isinstance(clsFnMethod, classmethod):
691            return classmethod(
692                FunctionMethodEnforcer(
693                    __fn__=clsFnMethod.__func__,
694                    __strict__=strict,
695                    __clean_traceback__=clean_traceback,
696                    __iterable_sample_pct__=iterable_sample_pct,
697                )
698            )
699        else:
700            return FunctionMethodEnforcer(
701                __fn__=clsFnMethod,
702                __strict__=strict,
703                __clean_traceback__=clean_traceback,
704                __iterable_sample_pct__=iterable_sample_pct,
705            )
706    elif hasattr(clsFnMethod, "__dict__"):
707        for key, value in clsFnMethod.__dict__.items():
708            # Skip the __annotate__ method if present in __dict__ as it deletes itself upon invocation
709            # Skip any previously wrapped methods if they are already a FunctionMethodEnforcer
710            if key == "__annotate__" or isinstance(
711                value, FunctionMethodEnforcer
712            ):
713                continue
714            if hasattr(value, "__call__") or isinstance(
715                value, (classmethod, staticmethod)
716            ):
717                setattr(
718                    clsFnMethod,
719                    key,
720                    Enforcer(
721                        value,
722                        enabled=enabled,
723                        strict=strict,
724                        clean_traceback=clean_traceback,
725                        iterable_sample_pct=iterable_sample_pct,
726                    ),
727                )
728        return clsFnMethod
729    else:
730        raise Exception(
731            "Enforcer can only be used on classes, methods, or functions."
732        )