fixed some ruff lints

Author: LostInDarkMath

pedantic/decorators/__init__.py

@@ -1,11 +1,34 @@
-from .fn_deco_context_manager import safe_contextmanager, safe_async_contextmanager
+from .class_decorators import for_all_methods, pedantic_class, pedantic_class_require_docstring, trace_class
+from .cls_deco_frozen_dataclass import frozen_dataclass, frozen_type_safe_dataclass
+from .fn_deco_context_manager import safe_async_contextmanager, safe_contextmanager
 from .fn_deco_deprecated import deprecated
-from .fn_deco_in_subprocess import in_subprocess, calculate_in_subprocess
+from .fn_deco_in_subprocess import calculate_in_subprocess, in_subprocess
 from .fn_deco_overrides import overrides
 from .fn_deco_pedantic import pedantic, pedantic_require_docstring
 from .fn_deco_require_kwargs import require_kwargs
 from .fn_deco_retry import retry, retry_func
 from .fn_deco_trace import trace
 from .fn_deco_trace_if_returns import trace_if_returns
-from .class_decorators import pedantic_class, pedantic_class_require_docstring, trace_class, for_all_methods
-from .cls_deco_frozen_dataclass import frozen_dataclass, frozen_type_safe_dataclass
+
+__all__ = [
+    'calculate_in_subprocess',
+    'deprecated',
+    'deprecated',
+    'for_all_methods',
+    'frozen_dataclass',
+    'frozen_type_safe_dataclass',
+    'in_subprocess',
+    'overrides',
+    'pedantic',
+    'pedantic_class',
+    'pedantic_class_require_docstring',
+    'pedantic_require_docstring',
+    'require_kwargs',
+    'retry',
+    'retry_func',
+    'safe_async_contextmanager',
+    'safe_contextmanager',
+    'trace',
+    'trace_class',
+    'trace_if_returns',
+]

pedantic/decorators/class_decorators.py

@@ -1,27 +1,28 @@
 import enum
 import types
+from collections.abc import Callable
 from dataclasses import is_dataclass
-from typing import Callable, Optional, Dict, Type
 
-from pedantic.constants import TYPE_VAR_ATTR_NAME, TYPE_VAR_METHOD_NAME, F, C, TYPE_VAR_SELF
-from pedantic.decorators import trace
+from pedantic.constants import TYPE_VAR_ATTR_NAME, TYPE_VAR_METHOD_NAME, TYPE_VAR_SELF, C, F
+from pedantic.decorators.fn_deco_trace import trace
 from pedantic.decorators.fn_deco_pedantic import pedantic, pedantic_require_docstring
 from pedantic.env_var_logic import is_enabled
 from pedantic.exceptions import PedanticTypeCheckException
-from pedantic.type_checking_logic.check_generic_classes import check_instance_of_generic_class_and_get_type_vars, \
-    is_instance_of_generic_class
+from pedantic.type_checking_logic.check_generic_classes import (
+    check_instance_of_generic_class_and_get_type_vars,
+    is_instance_of_generic_class,
+)
 
 
-def for_all_methods(decorator: F) -> Callable[[Type[C]], Type[C]]:
+def for_all_methods(decorator: F) -> Callable[[type[C]], type[C]]:
     """
-        Applies a decorator to all methods of a class.
+    Applies a decorator to all methods of a class.
 
-        Example:
-
-        >>> @for_all_methods(pedantic)
-        ... class MyClass(object):
-        ...     def m1(self): pass
-        ...     def m2(self, x): pass
+    Example:
+    >>> @for_all_methods(pedantic)
+    ... class MyClass(object):
+    ...     def m1(self): pass
+    ...     def m2(self, x): pass
     """
     def decorate(cls: C) -> C:
         if not is_enabled():
@@ -54,30 +55,30 @@ def decorate(cls: C) -> C:
 
 
 def pedantic_class(cls: C) -> C:
-    """ Shortcut for @for_all_methods(pedantic) """
+    """Shortcut for @for_all_methods(pedantic)"""
     return for_all_methods(decorator=pedantic)(cls=cls)
 
 
 def pedantic_class_require_docstring(cls: C) -> C:
-    """ Shortcut for @for_all_methods(pedantic_require_docstring) """
+    """Shortcut for @for_all_methods(pedantic_require_docstring)"""
     return for_all_methods(decorator=pedantic_require_docstring)(cls=cls)
 
 
 def trace_class(cls: C) -> C:
-    """ Shortcut for @for_all_methods(trace) """
+    """Shortcut for @for_all_methods(trace)"""
     return for_all_methods(decorator=trace)(cls=cls)
 
 
-def _get_wrapped(prop: Optional[F], decorator: F) -> Optional[F]:
+def _get_wrapped(prop: F | None, decorator: F) -> F | None:
     return decorator(prop) if prop is not None else None
 
 
 def _add_type_var_attr_and_method_to_class(cls: C) -> None:
-    def type_vars(self) -> Dict:
+    def type_vars(self: C) -> dict:
         t_vars = {TYPE_VAR_SELF: cls}
 
         if is_instance_of_generic_class(instance=self):
-            type_vars_fifo = getattr(self, TYPE_VAR_ATTR_NAME, dict())
+            type_vars_fifo = getattr(self, TYPE_VAR_ATTR_NAME, {})
             type_vars_generics = check_instance_of_generic_class_and_get_type_vars(instance=self)
             setattr(self, TYPE_VAR_ATTR_NAME, {**type_vars_fifo, **type_vars_generics, **t_vars})
         else:

pedantic/decorators/cls_deco_frozen_dataclass.py

@@ -1,117 +1,117 @@
+from collections.abc import Callable
 from copy import deepcopy
 from dataclasses import dataclass, fields, replace
-from typing import Type, TypeVar, Any, Union, Callable, Dict
+from typing import Any, TypeVar
 
 from pedantic.get_context import get_context
 from pedantic.type_checking_logic.check_types import assert_value_matches_type
 
 T = TypeVar('T')
 
 
-def frozen_type_safe_dataclass(cls: Type[T]) -> Type[T]:
-    """ Shortcut for @frozen_dataclass(type_safe=True) """
+def frozen_type_safe_dataclass(cls: type[T]) -> type[T]:
+    """Shortcut for @frozen_dataclass(type_safe=True)"""
 
     return frozen_dataclass(type_safe=True)(cls)
 
 
-def frozen_dataclass(
-        cls: Type[T] = None,
-        type_safe: bool = False,
-        order: bool = False,
-        kw_only: bool = True,
-        slots: bool = False,
-) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
+def frozen_dataclass(  # noqa: C901
+    cls: type[T] | None = None,
+    type_safe: bool = False,
+    order: bool = False,
+    kw_only: bool = True,
+    slots: bool = False,
+) -> type[T] | Callable[[type[T]], type[T]]:
     """
-        Makes the decorated class immutable and a dataclass by adding the [@dataclass(frozen=True)]
-        decorator. Also adds useful copy_with() and validate_types() instance methods to this class (see below).
-
-        If [type_safe] is True, a type check is performed for each field after the __post_init__ method was called
-        which itself s directly called after the __init__ constructor.
-        Note this have a negative impact on the performance. It's recommend to use this for debugging and testing only.
-
-        In a nutshell, the followings methods will be added to the decorated class automatically:
-        - __init__() gives you a simple constructor like "Foo(a=6, b='hi', c=True)"
-        - __eq__() lets you compare objects easily with "a == b"
-        - __hash__() is also needed for instance comparison
-        - __repr__() gives you a nice output when you call "print(foo)"
-        - copy_with() allows you to quickly create new similar frozen instances. Use this instead of setters.
-        - deep_copy_with() allows you to create deep copies and modify them.
-        - validate_types() allows you to validate the types of the dataclass.
-                           This is called automatically when [type_safe] is True.
-
-        If the [order] parameter is True (default is False), the following comparison methods
-        will be added additionally:
-        - __lt__() lets you compare instance like "a < b"
-        - __le__() lets you compare instance like "a <= b"
-        - __gt__() lets you compare instance like "a > b"
-        - __ge__() lets you compare instance like "a >= b"
-
-        These compare the class as if it were a tuple of its fields, in order.
-        Both instances in the comparison must be of the identical type.
-
-        The parameters slots and kw_only are only applied if the Python version is greater or equal to 3.10.
-
-        Example:
-
-        >>> @frozen_dataclass
-        ... class Foo:
-        ...     a: int
-        ...     b: str
-        ...     c: bool
-        >>> foo = Foo(a=6, b='hi', c=True)
-        >>> print(foo)
-        Foo(a=6, b='hi', c=True)
-        >>> print(foo.copy_with())
-        Foo(a=6, b='hi', c=True)
-        >>> print(foo.copy_with(a=42))
-        Foo(a=42, b='hi', c=True)
-        >>> print(foo.copy_with(b='Hello'))
-        Foo(a=6, b='Hello', c=True)
-        >>> print(foo.copy_with(c=False))
-        Foo(a=6, b='hi', c=False)
-        >>> print(foo.copy_with(a=676676, b='new', c=False))
-        Foo(a=676676, b='new', c=False)
+    Makes the decorated class immutable and a dataclass by adding the [@dataclass(frozen=True)]
+    decorator. Also adds useful copy_with() and validate_types() instance methods to this class (see below).
+
+    If [type_safe] is True, a type check is performed for each field after the __post_init__ method was called
+    which itself s directly called after the __init__ constructor.
+    Note this have a negative impact on the performance. It's recommend to use this for debugging and testing only.
+
+    In a nutshell, the followings methods will be added to the decorated class automatically:
+    - __init__() gives you a simple constructor like "Foo(a=6, b='hi', c=True)"
+    - __eq__() lets you compare objects easily with "a == b"
+    - __hash__() is also needed for instance comparison
+    - __repr__() gives you a nice output when you call "print(foo)"
+    - copy_with() allows you to quickly create new similar frozen instances. Use this instead of setters.
+    - deep_copy_with() allows you to create deep copies and modify them.
+    - validate_types() allows you to validate the types of the dataclass.
+                       This is called automatically when [type_safe] is True.
+
+    If the [order] parameter is True (default is False), the following comparison methods
+    will be added additionally:
+    - __lt__() lets you compare instance like "a < b"
+    - __le__() lets you compare instance like "a <= b"
+    - __gt__() lets you compare instance like "a > b"
+    - __ge__() lets you compare instance like "a >= b"
+
+    These compare the class as if it were a tuple of its fields, in order.
+    Both instances in the comparison must be of the identical type.
+
+    The parameters slots and kw_only are only applied if the Python version is greater or equal to 3.10.
+
+    Example:
+    >>> @frozen_dataclass
+    ... class Foo:
+    ...     a: int
+    ...     b: str
+    ...     c: bool
+    >>> foo = Foo(a=6, b='hi', c=True)
+    >>> print(foo)
+    Foo(a=6, b='hi', c=True)
+    >>> print(foo.copy_with())
+    Foo(a=6, b='hi', c=True)
+    >>> print(foo.copy_with(a=42))
+    Foo(a=42, b='hi', c=True)
+    >>> print(foo.copy_with(b='Hello'))
+    Foo(a=6, b='Hello', c=True)
+    >>> print(foo.copy_with(c=False))
+    Foo(a=6, b='hi', c=False)
+    >>> print(foo.copy_with(a=676676, b='new', c=False))
+    Foo(a=676676, b='new', c=False)
     """
 
-    def decorator(cls_: Type[T]) -> Type[T]:
+    def decorator(cls_: type[T]) -> type[T]:
         args = {'frozen': True, 'order': order, 'kw_only': kw_only, 'slots': slots}
 
         if type_safe:
             old_post_init = getattr(cls_, '__post_init__', lambda _: None)
 
-            def new_post_init(self) -> None:
+            def new_post_init(self: T) -> None:
                 old_post_init(self)
                 context = get_context(depth=3, increase_depth_if_name_matches=[
                     copy_with.__name__,
                     deep_copy_with.__name__,
                 ])
                 self.validate_types(_context=context)
 
-            setattr(cls_, '__post_init__', new_post_init)  # must be done before applying dataclass()
+            cls_.__post_init__ = new_post_init  # must be done before applying dataclass()
 
         new_class = dataclass(**args)(cls_)  # slots = True will create a new class!
 
-        def copy_with(self, **kwargs: Any) -> T:
+        def copy_with(self: T, **kwargs: Any) -> T:
             """
-                Creates a new immutable instance that by copying all fields of this instance replaced by the new values.
-                Keep in mind that this is a shallow copy!
+            Creates a new immutable instance that by copying all fields of this instance replaced by the new values.
+            Keep in mind that this is a shallow copy!
             """
 
             return replace(self, **kwargs)
 
-        def deep_copy_with(self, **kwargs: Any) -> T:
+        def deep_copy_with(self: T, **kwargs: Any) -> T:
             """
-                Creates a new immutable instance that by deep copying all fields of
-                this instance replaced by the new values.
+            Creates a new immutable instance that by deep copying all fields of
+            this instance replaced by the new values.
             """
 
             current_values = {field.name: deepcopy(getattr(self, field.name)) for field in fields(self)}
             return new_class(**{**current_values, **kwargs})
 
-        def validate_types(self, *, _context: Dict[str, Type] = None) -> None:
+        def validate_types(self: T, *, _context: dict[str, type] | None = None) -> None:
             """
-                Checks that all instance variable have the correct type.
-                Raises a [PedanticTypeCheckException] if at least one type is incorrect.
+            Checks that all instance variable have the correct type.
+            Raises a [PedanticTypeCheckException] if at least one type is incorrect.
             """
 
             props = fields(new_class)

pedantic/decorators/fn_deco_context_manager.py

@@ -1,12 +1,13 @@
-from contextlib import contextmanager, asynccontextmanager
+from collections.abc import AsyncIterator, Callable, Iterator
+from contextlib import AbstractAsyncContextManager, AbstractContextManager, asynccontextmanager, contextmanager
 from functools import wraps
 from inspect import isasyncgenfunction, isgeneratorfunction
-from typing import Callable, TypeVar, Iterator, ContextManager, AsyncContextManager, AsyncIterator
+from typing import Any, TypeVar
 
 T = TypeVar('T')
 
 
-def safe_contextmanager(f: Callable[..., Iterator[T]]) -> Callable[..., ContextManager[T]]:
+def safe_contextmanager(f: Callable[..., Iterator[T]]) -> Callable[..., AbstractContextManager[T]]:
     """
     @safe_contextmanager decorator.
 
@@ -49,21 +50,21 @@ def some_generator(<arguments>):
         raise AssertionError(f'{f.__name__} is not a generator.')
 
     @wraps(f)
-    def wrapper(*args, **kwargs) -> Iterator[T]:
+    def wrapper(*args: Any, **kwargs: Any) -> Iterator[T]:
         iterator = f(*args, **kwargs)
 
         try:
             yield next(iterator)
         finally:
-            try:
+            try:  # noqa: SIM105
                 next(iterator)
             except StopIteration:
                 pass  # this is intended
 
-    return contextmanager(wrapper)  # type: ignore
+    return contextmanager(wrapper)
 
 
-def safe_async_contextmanager(f: Callable[..., AsyncIterator[T]]) -> Callable[..., AsyncContextManager[T]]:
+def safe_async_contextmanager(f: Callable[..., AsyncIterator[T]]) -> Callable[..., AbstractAsyncContextManager[T]]:
     """
     @safe_async_contextmanager decorator.
 
@@ -100,7 +101,7 @@ async def some_async_generator(<arguments>):
                 <body>
             finally:
                 <cleanup>
-        """
+    """
 
     if not isasyncgenfunction(f):
         if not isgeneratorfunction(f):
@@ -110,15 +111,15 @@ async def some_async_generator(<arguments>):
                              f'So you need to use "safe_contextmanager" instead.')
 
     @wraps(f)
-    async def wrapper(*args, **kwargs) -> Iterator[T]:
+    async def wrapper(*args: Any, **kwargs: Any) -> Iterator[T]:
         iterator = f(*args, **kwargs)
 
         try:
             yield await anext(iterator)
         finally:
-            try:
+            try:  # noqa: SIM105
                 await anext(iterator)
             except StopAsyncIteration:
-                pass  # this is intended
+                pass
 
-    return asynccontextmanager(wrapper)  # type: ignore
+    return asynccontextmanager(wrapper)