Improved typings

Author: JrooTJunior

magic_filter/__init__.py

@@ -1,7 +1,13 @@
 from . import operations
 from .attrdict import AttrDict
-from .magic import MagicFilter
+from .magic import MagicFilter, MagicT
 
-__all__ = ("operations", "MagicFilter", "F", "AttrDict")
+__all__ = (
+    "operations",
+    "MagicFilter",
+    "MagicT",
+    "F",
+    "AttrDict",
+)
 
 F = MagicFilter()

magic_filter/magic.py

@@ -1,7 +1,7 @@
 import operator
 import re
 from functools import wraps
-from typing import Any, Callable, Optional, Pattern, Sequence, Tuple, Union
+from typing import Any, Callable, Optional, Pattern, Sequence, Tuple, Type, TypeVar, Union
 
 from magic_filter.exceptions import RejectOperations, SwitchModeToAll, SwitchModeToAny
 from magic_filter.operations import (
@@ -16,6 +16,8 @@
 )
 from magic_filter.operations.function import ImportantFunctionOperation
 
+MagicT = TypeVar("MagicT", bound="MagicFilter")
+
 
 class MagicFilter:
     __slots__ = ("_operations",)
@@ -32,16 +34,16 @@ def wrapper(value: Any) -> Any:
         return wrapper
 
     @classmethod
-    def _new(cls, operations: Tuple[BaseOperation, ...]) -> "MagicFilter":
+    def _new(cls: Type[MagicT], operations: Tuple[BaseOperation, ...]) -> MagicT:
         return cls(operations=operations)
 
-    def _extend(self, operation: BaseOperation) -> "MagicFilter":
+    def _extend(self: MagicT, operation: BaseOperation) -> MagicT:
         return self._new(self._operations + (operation,))
 
-    def _replace_last(self, operation: BaseOperation) -> "MagicFilter":
+    def _replace_last(self: MagicT, operation: BaseOperation) -> MagicT:
         return self._new(self._operations[:-1] + (operation,))
 
-    def _exclude_last(self) -> "MagicFilter":
+    def _exclude_last(self: MagicT) -> MagicT:
         return self._new(self._operations[:-1])
 
     def _resolve(self, value: Any, operations: Optional[Tuple[BaseOperation, ...]] = None) -> Any:
@@ -69,36 +71,36 @@ def _resolve(self, value: Any, operations: Optional[Tuple[BaseOperation, ...]] =
             rejected = False
         return value
 
-    def resolve(self, value: Any) -> Any:
+    def resolve(self: MagicT, value: Any) -> Any:
         return self._resolve(value=value)
 
-    def __getattr__(self, item: Any) -> "MagicFilter":
+    def __getattr__(self: MagicT, item: Any) -> MagicT:
         return self._extend(GetAttributeOperation(name=item))
 
     attr_ = __getattr__
 
-    def __getitem__(self, item: Any) -> "MagicFilter":
+    def __getitem__(self: MagicT, item: Any) -> MagicT:
         return self._extend(GetItemOperation(key=item))
 
-    def __eq__(self, other: Any) -> "MagicFilter":  # type: ignore
+    def __eq__(self: MagicT, other: Any) -> MagicT:  # type: ignore
         return self._extend(ComparatorOperation(right=other, comparator=operator.eq))
 
-    def __ne__(self, other: Any) -> "MagicFilter":  # type: ignore
+    def __ne__(self: MagicT, other: Any) -> MagicT:  # type: ignore
         return self._extend(ComparatorOperation(right=other, comparator=operator.ne))
 
-    def __lt__(self, other: Any) -> "MagicFilter":
+    def __lt__(self: MagicT, other: Any) -> MagicT:
         return self._extend(ComparatorOperation(right=other, comparator=operator.lt))
 
-    def __gt__(self, other: Any) -> "MagicFilter":
+    def __gt__(self: MagicT, other: Any) -> MagicT:
         return self._extend(ComparatorOperation(right=other, comparator=operator.gt))
 
-    def __le__(self, other: Any) -> "MagicFilter":
+    def __le__(self: MagicT, other: Any) -> MagicT:
         return self._extend(ComparatorOperation(right=other, comparator=operator.le))
 
-    def __ge__(self, other: Any) -> "MagicFilter":
+    def __ge__(self: MagicT, other: Any) -> MagicT:
         return self._extend(ComparatorOperation(right=other, comparator=operator.ge))
 
-    def __invert__(self) -> "MagicFilter":
+    def __invert__(self: MagicT) -> MagicT:
         if (
             self._operations
             and isinstance(self._operations[-1], ImportantFunctionOperation)
@@ -107,116 +109,116 @@ def __invert__(self) -> "MagicFilter":
             return self._exclude_last()
         return self._extend(ImportantFunctionOperation(function=operator.not_))
 
-    def __call__(self, *args: Any, **kwargs: Any) -> "MagicFilter":
+    def __call__(self: MagicT, *args: Any, **kwargs: Any) -> MagicT:
         return self._extend(CallOperation(args=args, kwargs=kwargs))
 
-    def __and__(self, other: Any) -> "MagicFilter":
+    def __and__(self: MagicT, other: Any) -> MagicT:
         if isinstance(other, MagicFilter):
             return self._extend(CombinationOperation.and_op(right=other))
         return self._extend(CombinationOperation(right=other, combinator=operator.and_))
 
-    def __rand__(self, other: Any) -> "MagicFilter":
+    def __rand__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.and_))
 
-    def __or__(self, other: Any) -> "MagicFilter":
+    def __or__(self: MagicT, other: Any) -> MagicT:
         if isinstance(other, MagicFilter):
             return self._extend(CombinationOperation.or_op(right=other))
         return self._extend(CombinationOperation(right=other, combinator=operator.or_))
 
-    def __ror__(self, other: Any) -> "MagicFilter":
+    def __ror__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.or_))
 
-    def __xor__(self, other: Any) -> "MagicFilter":
+    def __xor__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.xor))
 
-    def __rxor__(self, other: Any) -> "MagicFilter":
+    def __rxor__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.xor))
 
-    def __rshift__(self, other: Any) -> "MagicFilter":
+    def __rshift__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.rshift))
 
-    def __rrshift__(self, other: Any) -> "MagicFilter":
+    def __rrshift__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.rshift))
 
-    def __lshift__(self, other: Any) -> "MagicFilter":
+    def __lshift__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.lshift))
 
-    def __rlshift__(self, other: Any) -> "MagicFilter":
+    def __rlshift__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.lshift))
 
-    def __add__(self, other: Any) -> "MagicFilter":
+    def __add__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.add))
 
-    def __radd__(self, other: Any) -> "MagicFilter":
+    def __radd__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.add))
 
-    def __sub__(self, other: Any) -> "MagicFilter":
+    def __sub__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.sub))
 
-    def __rsub__(self, other: Any) -> "MagicFilter":
+    def __rsub__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.sub))
 
-    def __mul__(self, other: Any) -> "MagicFilter":
+    def __mul__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.mul))
 
-    def __rmul__(self, other: Any) -> "MagicFilter":
+    def __rmul__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.mul))
 
-    def __truediv__(self, other: Any) -> "MagicFilter":
+    def __truediv__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.truediv))
 
-    def __rtruediv__(self, other: Any) -> "MagicFilter":
+    def __rtruediv__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.truediv))
 
-    def __floordiv__(self, other: Any) -> "MagicFilter":
+    def __floordiv__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.floordiv))
 
-    def __rfloordiv__(self, other: Any) -> "MagicFilter":
+    def __rfloordiv__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.floordiv))
 
-    def __mod__(self, other: Any) -> "MagicFilter":
+    def __mod__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.mod))
 
-    def __rmod__(self, other: Any) -> "MagicFilter":
+    def __rmod__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.mod))
 
-    def __matmul__(self, other: Any) -> "MagicFilter":
+    def __matmul__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.matmul))
 
-    def __rmatmul__(self, other: Any) -> "MagicFilter":
+    def __rmatmul__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.matmul))
 
-    def __pow__(self, other: Any) -> "MagicFilter":
+    def __pow__(self: MagicT, other: Any) -> MagicT:
         return self._extend(CombinationOperation(right=other, combinator=operator.pow))
 
-    def __rpow__(self, other: Any) -> "MagicFilter":
+    def __rpow__(self: MagicT, other: Any) -> MagicT:
         return self._extend(RCombinationOperation(left=other, combinator=operator.pow))
 
-    def __pos__(self) -> "MagicFilter":
+    def __pos__(self: MagicT) -> MagicT:
         return self._extend(FunctionOperation(function=operator.pos))
 
-    def __neg__(self) -> "MagicFilter":
+    def __neg__(self: MagicT) -> MagicT:
         return self._extend(FunctionOperation(function=operator.neg))
 
-    def is_(self, value: Any) -> "MagicFilter":
+    def is_(self: MagicT, value: Any) -> MagicT:
         return self._extend(CombinationOperation(right=value, combinator=operator.is_))
 
-    def is_not(self, value: Any) -> "MagicFilter":
+    def is_not(self: MagicT, value: Any) -> MagicT:
         return self._extend(CombinationOperation(right=value, combinator=operator.is_not))
 
-    def in_(self, iterable: Sequence[Any]) -> "MagicFilter":
+    def in_(self: MagicT, iterable: Sequence[Any]) -> MagicT:
         return self._extend(FunctionOperation.in_op(iterable))
 
-    def contains(self, value: Any) -> "MagicFilter":
+    def contains(self: MagicT, value: Any) -> MagicT:
         return self._extend(FunctionOperation.contains_op(value))
 
-    def len(self) -> "MagicFilter":
+    def len(self: MagicT) -> MagicT:
         return self._extend(FunctionOperation(len))
 
-    def regexp(self, pattern: Union[str, Pattern[str]]) -> "MagicFilter":
+    def regexp(self: MagicT, pattern: Union[str, Pattern[str]]) -> MagicT:
         if isinstance(pattern, str):
             pattern = re.compile(pattern)
         return self._extend(FunctionOperation(pattern.match))
 
-    def func(self, func: Callable[[Any], Any]) -> "MagicFilter":
+    def func(self: MagicT, func: Callable[[Any], Any]) -> MagicT:
         return self._extend(FunctionOperation(func))

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "magic-filter"
-version = "1.0.3"
+version = "1.0.4"
 description = "This package provides magic filter based on dynamic attribute getter"
 license = "MIT"
 readme = "README.md"