Dropped Python 3.7 support and added full generic strict Pyright and Mypy compliant type hinting

Author: wolph

.gitignore

@@ -4,3 +4,4 @@
 /docs/_build
 /cover
 /.eggs
+/.*

pyrightconfig.json

@@ -7,17 +7,19 @@
 
 from . import types
 
+_N = types.TypeVar('_N', int, float)
+
 
 async def acount(
-    start: float = 0,
-    step: float = 1,
+    start: _N = 0,
+    step: _N = 1,
     delay: float = 0,
-    stop: types.Optional[float] = None,
-) -> types.AsyncIterator[float]:
+    stop: types.Optional[_N] = None,
+) -> types.AsyncIterator[_N]:
     '''Asyncio version of itertools.count()'''
     for item in itertools.count(start, step):  # pragma: no branch
         if stop is not None and item >= stop:
             break
 
-        yield item
+        yield types.cast(_N, item)
         await asyncio.sleep(delay)

python_utils/aio.py

@@ -1,3 +1,4 @@
+# pyright: reportIncompatibleMethodOverride=false
 import abc
 import typing
 from typing import Any, Generator
@@ -22,28 +23,32 @@
 
 # Using types.Union instead of | since Python 3.7 doesn't fully support it
 DictUpdateArgs = types.Union[
-    types.Mapping,
-    types.Iterable[types.Union[types.Tuple[Any, Any], types.Mapping]],
+    types.Mapping[types.Any, types.Any],
+    types.Iterable[
+        types.Union[types.Tuple[Any, Any], types.Mapping[types.Any, types.Any]]
+    ],
     '_typeshed.SupportsKeysAndGetItem[KT, VT]',
 ]
 
 
 class CastedDictBase(types.Dict[KT, VT], abc.ABC):
-    _key_cast: KT_cast
-    _value_cast: VT_cast
+    _key_cast: KT_cast[KT]
+    _value_cast: VT_cast[VT]
 
     def __init__(
         self,
-        key_cast: KT_cast = None,
-        value_cast: VT_cast = None,
-        *args: DictUpdateArgs,
+        key_cast: KT_cast[KT] = None,
+        value_cast: VT_cast[VT] = None,
+        *args: DictUpdateArgs[KT, VT],
         **kwargs: VT,
     ) -> None:
         self._value_cast = value_cast
         self._key_cast = key_cast
         self.update(*args, **kwargs)
 
-    def update(self, *args: DictUpdateArgs, **kwargs: VT) -> None:
+    def update(
+        self, *args: DictUpdateArgs[types.Any, types.Any], **kwargs: types.Any
+    ) -> None:
         if args:
             kwargs.update(*args)
 
@@ -93,7 +98,7 @@ class CastedDict(CastedDictBase[KT, VT]):
     {1: 2, '3': '4', '5': '6', '7': '8'}
     '''
 
-    def __setitem__(self, key: Any, value: Any) -> None:
+    def __setitem__(self, key: typing.Any, value: typing.Any) -> None:
         if self._value_cast is not None:
             value = self._value_cast(value)
 
@@ -146,13 +151,13 @@ class LazyCastedDict(CastedDictBase[KT, VT]):
     '4'
     '''
 
-    def __setitem__(self, key: Any, value: Any) -> None:
+    def __setitem__(self, key: types.Any, value: types.Any):
         if self._key_cast is not None:
             key = self._key_cast(key)
 
         super().__setitem__(key, value)
 
-    def __getitem__(self, key: Any) -> VT:
+    def __getitem__(self, key: types.Any) -> VT:
         if self._key_cast is not None:
             key = self._key_cast(key)
 
@@ -163,9 +168,7 @@ def __getitem__(self, key: Any) -> VT:
 
         return value
 
-    def items(  # type: ignore
-        self,
-    ) -> Generator[types.Tuple[KT, VT], None, None]:
+    def items(self) -> Generator[tuple[KT, VT], None, None]:  # type: ignore
         if self._value_cast is None:
             yield from super().items()
         else:
@@ -247,7 +250,7 @@ def append(self, value: HT) -> None:
         self._set.add(value)
         super().append(value)
 
-    def __contains__(self, item):
+    def __contains__(self, item: HT) -> bool:  # type: ignore
         return item in self._set
 
     @types.overload
@@ -258,29 +261,37 @@ def __setitem__(self, indices: types.SupportsIndex, values: HT) -> None:
     def __setitem__(self, indices: slice, values: types.Iterable[HT]) -> None:
         ...
 
-    def __setitem__(self, indices, values) -> None:
+    def __setitem__(
+        self,
+        indices: types.Union[slice, types.SupportsIndex],
+        values: types.Union[types.Iterable[HT], HT],
+    ) -> None:
         if isinstance(indices, slice):
+            values = types.cast(types.Iterable[HT], values)
             if self.on_duplicate == 'ignore':
                 raise RuntimeError(
                     'ignore mode while setting slices introduces ambiguous '
                     'behaviour and is therefore not supported'
                 )
 
-            duplicates = set(values) & self._set
-            if duplicates and values != self[indices]:
-                raise ValueError('Duplicate values: %s' % duplicates)
+            duplicates: types.Set[HT] = set(values) & self._set
+            if duplicates and values != list(self[indices]):
+                raise ValueError(f'Duplicate values: {duplicates}')
 
             self._set.update(values)
-            super().__setitem__(indices, values)
         else:
+            values = types.cast(HT, values)
             if values in self._set and values != self[indices]:
                 if self.on_duplicate == 'raise':
-                    raise ValueError('Duplicate value: %s' % values)
+                    raise ValueError(f'Duplicate value: {values}')
                 else:
                     return
 
             self._set.add(values)
-            super().__setitem__(indices, values)
+
+        super().__setitem__(
+            types.cast(slice, indices), types.cast(types.List[HT], values)
+        )
 
     def __delitem__(
         self, index: types.Union[types.SupportsIndex, slice]

python_utils/containers.py

@@ -5,12 +5,14 @@
 
 from . import types
 
+_TN = types.TypeVar('_TN', bound=types.DecimalNumber)
+
 
 def to_int(
     input_: typing.Optional[str] = None,
     default: int = 0,
     exception: types.ExceptionsType = (ValueError, TypeError),
-    regexp: types.Optional[types.Pattern] = None,
+    regexp: types.Optional[types.Pattern[str]] = None,
 ) -> int:
     r'''
     Convert the given input to an integer or return default
@@ -84,8 +86,7 @@ def to_int(
 
     try:
         if regexp and input_:
-            match = regexp.search(input_)
-            if match:
+            if match := regexp.search(input_):
                 input_ = match.groups()[-1]
 
         if input_ is None:
@@ -100,7 +101,7 @@ def to_float(
     input_: str,
     default: int = 0,
     exception: types.ExceptionsType = (ValueError, TypeError),
-    regexp: types.Optional[types.Pattern] = None,
+    regexp: types.Optional[types.Pattern[str]] = None,
 ) -> types.Number:
     r'''
     Convert the given `input_` to an integer or return default
@@ -165,8 +166,7 @@ def to_float(
 
     try:
         if regexp:
-            match = regexp.search(input_)
-            if match:
+            if match := regexp.search(input_):
                 input_ = match.group(1)
         return float(input_)
     except exception:
@@ -223,9 +223,7 @@ def to_str(
     >>> to_str(Foo)
     "<class 'python_utils.converters.Foo'>"
     '''
-    if isinstance(input_, bytes):
-        pass
-    else:
+    if not isinstance(input_, bytes):
         if not hasattr(input_, 'encode'):
             input_ = str(input_)
 
@@ -263,12 +261,12 @@ def scale_1024(
 
 
 def remap(
-    value: types.DecimalNumber,
-    old_min: types.DecimalNumber,
-    old_max: types.DecimalNumber,
-    new_min: types.DecimalNumber,
-    new_max: types.DecimalNumber,
-) -> types.DecimalNumber:
+    value: _TN,
+    old_min: _TN,
+    old_max: _TN,
+    new_min: _TN,
+    new_max: _TN,
+) -> _TN:
     '''
     remap a value from one range into another.
 
@@ -362,24 +360,22 @@ def remap(
     else:
         type_ = int
 
-    value = type_(value)
-    old_min = type_(old_min)
-    old_max = type_(old_max)
-    new_max = type_(new_max)
-    new_min = type_(new_min)
+    value = types.cast(_TN, type_(value))
+    old_min = types.cast(_TN, type_(old_min))
+    old_max = types.cast(_TN, type_(old_max))
+    new_max = types.cast(_TN, type_(new_max))
+    new_min = types.cast(_TN, type_(new_min))
 
-    old_range = old_max - old_min  # type: ignore
-    new_range = new_max - new_min  # type: ignore
+    # These might not be floats but the Python type system doesn't understand the
+    # generic type system in this case
+    old_range = types.cast(float, old_max) - types.cast(float, old_min)
+    new_range = types.cast(float, new_max) - types.cast(float, new_min)
 
     if old_range == 0:
-        raise ValueError(
-            'Input range ({}-{}) is empty'.format(old_min, old_max)
-        )
+        raise ValueError(f'Input range ({old_min}-{old_max}) is empty')
 
     if new_range == 0:
-        raise ValueError(
-            'Output range ({}-{}) is empty'.format(new_min, new_max)
-        )
+        raise ValueError(f'Output range ({new_min}-{new_max}) is empty')
 
     new_value = (value - old_min) * new_range  # type: ignore
 
@@ -390,4 +386,4 @@ def remap(
 
     new_value += new_min  # type: ignore
 
-    return new_value
+    return types.cast(_TN, new_value)