python-utils 3.8.2__tar.gz → 3.9.1__tar.gz

{python-utils-3.8.2/python_utils.egg-info → python_utils-3.9.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: python-utils
-Version: 3.8.2
+Version: 3.9.1
 Summary: Python Utils is a module with some convenient utilities not included with the standard Python install
 Home-page: https://github.com/WoLpH/python-utils
 Author: Rick van Hattem
 Author-email: Wolph@wol.ph
 License: BSD
 Classifier: License :: OSI Approved :: BSD License
-Requires-Python: >3.8.0
+Requires-Python: >=3.9.0
 License-File: LICENSE
 Requires-Dist: typing_extensions>3.10.0.2
 Provides-Extra: loguru
@@ -17,7 +17,8 @@ Requires-Dist: mock; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: python-utils; extra == "docs"
 Provides-Extra: tests
-Requires-Dist: flake8; extra == "tests"
+Requires-Dist: ruff; extra == "tests"
+Requires-Dist: pyright; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
 Requires-Dist: pytest-mypy; extra == "tests"
@@ -25,6 +26,9 @@ Requires-Dist: pytest-asyncio; extra == "tests"
 Requires-Dist: sphinx; extra == "tests"
 Requires-Dist: types-setuptools; extra == "tests"
 Requires-Dist: loguru; extra == "tests"
+Requires-Dist: loguru-mypy; extra == "tests"
+Requires-Dist: mypy-ipython; extra == "tests"
+Requires-Dist: blessings; extra == "tests"
 
 Useful Python Utils
 ==============================================================================

python_utils-3.9.1/_python_utils_tests/test_aio.py

@@ -0,0 +1,68 @@
+import asyncio
+
+import pytest
+
+from python_utils import types
+from python_utils.aio import acontainer, acount, adict
+
+
+@pytest.mark.asyncio
+async def test_acount(monkeypatch: pytest.MonkeyPatch) -> None:
+    sleeps: types.List[float] = []
+
+    async def mock_sleep(delay: float) -> None:
+        sleeps.append(delay)
+
+    monkeypatch.setattr(asyncio, 'sleep', mock_sleep)
+
+    async for _i in acount(delay=1, stop=3.5):
+        pass
+
+    assert len(sleeps) == 4
+    assert sum(sleeps) == 4
+
+
+@pytest.mark.asyncio
+async def test_acontainer() -> None:
+    async def async_gen() -> types.AsyncIterable[int]:
+        yield 1
+        yield 2
+        yield 3
+
+    async def empty_gen() -> types.AsyncIterable[int]:
+        if False:
+            yield 1
+
+    assert await acontainer(async_gen) == [1, 2, 3]
+    assert await acontainer(async_gen()) == [1, 2, 3]
+    assert await acontainer(async_gen, set) == {1, 2, 3}
+    assert await acontainer(async_gen(), set) == {1, 2, 3}
+    assert await acontainer(async_gen, list) == [1, 2, 3]
+    assert await acontainer(async_gen(), list) == [1, 2, 3]
+    assert await acontainer(async_gen, tuple) == (1, 2, 3)
+    assert await acontainer(async_gen(), tuple) == (1, 2, 3)
+    assert await acontainer(empty_gen) == []
+    assert await acontainer(empty_gen()) == []
+    assert await acontainer(empty_gen, set) == set()
+    assert await acontainer(empty_gen(), set) == set()
+    assert await acontainer(empty_gen, list) == list()
+    assert await acontainer(empty_gen(), list) == list()
+    assert await acontainer(empty_gen, tuple) == tuple()
+    assert await acontainer(empty_gen(), tuple) == tuple()
+
+
+@pytest.mark.asyncio
+async def test_adict() -> None:
+    async def async_gen() -> types.AsyncIterable[types.Tuple[int, int]]:
+        yield 1, 2
+        yield 3, 4
+        yield 5, 6
+
+    async def empty_gen() -> types.AsyncIterable[types.Tuple[int, int]]:
+        if False:
+            yield 1, 2
+
+    assert await adict(async_gen) == {1: 2, 3: 4, 5: 6}
+    assert await adict(async_gen()) == {1: 2, 3: 4, 5: 6}
+    assert await adict(empty_gen) == {}
+    assert await adict(empty_gen()) == {}

{python-utils-3.8.2 → python_utils-3.9.1}/_python_utils_tests/test_decorators.py

@@ -1,9 +1,12 @@
+import typing
 from unittest.mock import MagicMock
 
 import pytest
 
 from python_utils.decorators import sample, wraps_classmethod
 
+T = typing.TypeVar('T')
+
 
 @pytest.fixture
 def random(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
@@ -14,7 +17,7 @@ def random(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
     return mock
 
 
-def test_sample_called(random: MagicMock):
+def test_sample_called(random: MagicMock) -> None:
     demo_function = MagicMock()
     decorated = sample(0.5)(demo_function)
     random.return_value = 0.4
@@ -28,7 +31,7 @@ def test_sample_called(random: MagicMock):
     assert demo_function.call_count == 3
 
 
-def test_sample_not_called(random: MagicMock):
+def test_sample_not_called(random: MagicMock) -> None:
     demo_function = MagicMock()
     decorated = sample(0.5)(demo_function)
     random.return_value = 0.5
@@ -40,31 +43,29 @@ def test_sample_not_called(random: MagicMock):
 
 class SomeClass:
     @classmethod
-    def some_classmethod(cls, arg):  # type: ignore
-        return arg  # type: ignore
+    def some_classmethod(cls, arg: T) -> T:
+        return arg
 
     @classmethod
     def some_annotated_classmethod(cls, arg: int) -> int:
         return arg
 
 
-def test_wraps_classmethod():  # type: ignore
+def test_wraps_classmethod() -> None:
     some_class = SomeClass()
-    some_class.some_classmethod = MagicMock()
-    wrapped_method = wraps_classmethod(  # type: ignore
-        SomeClass.some_classmethod  # type: ignore
-    )(  # type: ignore
-        some_class.some_classmethod  # type: ignore
+    some_class.some_classmethod = MagicMock()  # type: ignore[method-assign]
+    wrapped_method = wraps_classmethod(SomeClass.some_classmethod)(
+        some_class.some_classmethod
     )
     wrapped_method(123)
-    some_class.some_classmethod.assert_called_with(123)  # type: ignore
+    some_class.some_classmethod.assert_called_with(123)
 
 
-def test_wraps_annotated_classmethod():  # type: ignore
+def test_wraps_annotated_classmethod() -> None:
     some_class = SomeClass()
-    some_class.some_annotated_classmethod = MagicMock()
+    some_class.some_annotated_classmethod = MagicMock()  # type: ignore[method-assign]
     wrapped_method = wraps_classmethod(SomeClass.some_annotated_classmethod)(
         some_class.some_annotated_classmethod
     )
-    wrapped_method(123)  # type: ignore
+    wrapped_method(123)
     some_class.some_annotated_classmethod.assert_called_with(123)

{python-utils-3.8.2 → python_utils-3.9.1}/_python_utils_tests/test_generators.py

@@ -7,7 +7,7 @@ from python_utils import types
 
 
 @pytest.mark.asyncio
-async def test_abatcher():
+async def test_abatcher() -> None:
     async for batch in python_utils.abatcher(python_utils.acount(stop=9), 3):
         assert len(batch) == 3
 
@@ -28,8 +28,8 @@ async def test_abatcher_timed() -> None:
 
 
 @pytest.mark.asyncio
-async def test_abatcher_timed_with_timeout():
-    async def generator():
+async def test_abatcher_timed_with_timeout() -> None:
+    async def generator() -> types.AsyncIterator[int]:
         # Test if the timeout is respected
         yield 0
         yield 1
@@ -57,12 +57,12 @@ async def test_abatcher_timed_with_timeout():
         await batcher.__anext__()
 
 
-def test_batcher():
+def test_batcher() -> None:
     batch = []
     for batch in python_utils.batcher(range(9), 3):
         assert len(batch) == 3
 
     for batch in python_utils.batcher(range(4), 3):
-        pass
+        assert batch is not None
 
     assert len(batch) == 1

{python-utils-3.8.2 → python_utils-3.9.1}/_python_utils_tests/test_import.py

@@ -1,30 +1,30 @@
 from python_utils import import_, types
 
 
-def test_import_globals_relative_import():
+def test_import_globals_relative_import() -> None:
     for i in range(-1, 5):
         relative_import(i)
 
 
-def relative_import(level: int):
+def relative_import(level: int) -> None:
     locals_: types.Dict[str, types.Any] = {}
     globals_ = {'__name__': 'python_utils.import_'}
     import_.import_global('.formatters', locals_=locals_, globals_=globals_)
     assert 'camel_to_underscore' in globals_
 
 
-def test_import_globals_without_inspection():
-    locals_ = {}
-    globals_ = {'__name__': __name__}
+def test_import_globals_without_inspection() -> None:
+    locals_: types.Dict[str, types.Any] = {}
+    globals_: types.Dict[str, types.Any] = {'__name__': __name__}
     import_.import_global(
         'python_utils.formatters', locals_=locals_, globals_=globals_
     )
     assert 'camel_to_underscore' in globals_
 
 
-def test_import_globals_single_method():
-    locals_ = {}
-    globals_ = {'__name__': __name__}
+def test_import_globals_single_method() -> None:
+    locals_: types.Dict[str, types.Any] = {}
+    globals_: types.Dict[str, types.Any] = {'__name__': __name__}
     import_.import_global(
         'python_utils.formatters',
         ['camel_to_underscore'],
@@ -34,19 +34,19 @@ def test_import_globals_single_method():
     assert 'camel_to_underscore' in globals_
 
 
-def test_import_globals_with_inspection():
+def test_import_globals_with_inspection() -> None:
     import_.import_global('python_utils.formatters')
     assert 'camel_to_underscore' in globals()
 
 
-def test_import_globals_missing_module():
+def test_import_globals_missing_module() -> None:
     import_.import_global(
         'python_utils.spam', exceptions=ImportError, locals_=locals()
     )
     assert 'camel_to_underscore' in globals()
 
 
-def test_import_locals_missing_module():
+def test_import_locals_missing_module() -> None:
     import_.import_global(
         'python_utils.spam', exceptions=ImportError, globals_=globals()
     )

{python-utils-3.8.2 → python_utils-3.9.1}/_python_utils_tests/test_logger.py

@@ -1,12 +1,12 @@
+# mypy: disable-error-code=misc
 import pytest
 
 from python_utils.loguru import Logurud
 
-
 loguru = pytest.importorskip('loguru')
 
 
-def test_logurud():
+def test_logurud() -> None:
     class MyClass(Logurud):
         pass
 

{python-utils-3.8.2 → python_utils-3.9.1}/_python_utils_tests/test_python_utils.py

@@ -1,7 +1,7 @@
 from python_utils import __about__
 
 
-def test_definitions():
+def test_definitions() -> None:
     # The setup.py requires this so we better make sure they exist :)
     assert __about__.__version__
     assert __about__.__author__

{python-utils-3.8.2 → python_utils-3.9.1}/_python_utils_tests/test_time.py

@@ -32,7 +32,7 @@ async def test_aio_timeout_generator(
     maximum_interval: float,
     iterable: types.AsyncIterable[types.Any],
     result: int,
-):
+) -> None:
     i = None
     async for i in python_utils.aio_timeout_generator(
         timeout, interval, iterable, maximum_interval=maximum_interval
@@ -45,16 +45,16 @@ async def test_aio_timeout_generator(
 @pytest.mark.parametrize(
     'timeout,interval,interval_multiplier,maximum_interval,iterable,result',
     [
-        (0.01, 0.006, 0.5, 0.01, 'abc', 'c'),
-        (0.01, 0.006, 0.5, 0.01, itertools.count, 2),  # type: ignore
-        (0.01, 0.006, 0.5, 0.01, itertools.count(), 2),
-        (0.01, 0.006, 1.0, None, 'abc', 'c'),
+        (0.1, 0.06, 0.5, 0.1, 'abc', 'c'),
+        (0.1, 0.07, 0.5, 0.1, itertools.count, 2),
+        (0.1, 0.07, 0.5, 0.1, itertools.count(), 2),
+        (0.1, 0.06, 1.0, None, 'abc', 'c'),
         (
-            timedelta(seconds=0.01),
-            timedelta(seconds=0.006),
+            timedelta(seconds=0.1),
+            timedelta(seconds=0.06),
             2.0,
-            timedelta(seconds=0.01),
-            itertools.count,  # type: ignore
+            timedelta(seconds=0.1),
+            itertools.count,
             2,
         ),
     ],
@@ -70,7 +70,7 @@ def test_timeout_generator(
         types.Callable[..., types.Iterable[types.Any]],
     ],
     result: int,
-):
+) -> None:
     i = None
     for i in python_utils.timeout_generator(
         timeout=timeout,
@@ -79,40 +79,40 @@ def test_timeout_generator(
         iterable=iterable,
         maximum_interval=maximum_interval,
     ):
-        pass
+        assert i is not None
 
     assert i == result
 
 
 @pytest.mark.asyncio
-async def test_aio_generator_timeout_detector():
+async def test_aio_generator_timeout_detector() -> None:
     # Make pyright happy
     i = None
 
-    async def generator():
+    async def generator() -> types.AsyncGenerator[int, None]:
         for i in range(10):
-            await asyncio.sleep(i / 100.0)
+            await asyncio.sleep(i / 20.0)
             yield i
 
     detector = python_utils.aio_generator_timeout_detector
     # Test regular timeout with reraise
     with pytest.raises(asyncio.TimeoutError):
-        async for i in detector(generator(), 0.05):
+        async for i in detector(generator(), 0.25):
             pass
 
     # Test regular timeout with clean exit
-    async for i in detector(generator(), 0.05, on_timeout=None):
+    async for i in detector(generator(), 0.25, on_timeout=None):
         pass
 
     assert i == 4
 
     # Test total timeout with reraise
     with pytest.raises(asyncio.TimeoutError):
-        async for i in detector(generator(), total_timeout=0.1):
+        async for i in detector(generator(), total_timeout=0.5):
             pass
 
     # Test total timeout with clean exit
-    async for i in detector(generator(), total_timeout=0.1, on_timeout=None):
+    async for i in detector(generator(), total_timeout=0.5, on_timeout=None):
         pass
 
     assert i == 4
@@ -123,26 +123,29 @@ async def test_aio_generator_timeout_detector():
 
 
 @pytest.mark.asyncio
-async def test_aio_generator_timeout_detector_decorator():
-    # Make pyright happy
-    i = None
-
+async def test_aio_generator_timeout_detector_decorator_reraise() -> None:
     # Test regular timeout with reraise
     @python_utils.aio_generator_timeout_detector_decorator(timeout=0.05)
-    async def generator_timeout():
+    async def generator_timeout() -> types.AsyncGenerator[int, None]:
         for i in range(10):
             await asyncio.sleep(i / 100.0)
             yield i
 
     with pytest.raises(asyncio.TimeoutError):
-        async for i in generator_timeout():
+        async for _ in generator_timeout():
             pass
 
+
+@pytest.mark.asyncio
+async def test_aio_generator_timeout_detector_decorator_clean_exit() -> None:
+    # Make pyright happy
+    i = None
+
     # Test regular timeout with clean exit
     @python_utils.aio_generator_timeout_detector_decorator(
         timeout=0.05, on_timeout=None
     )
-    async def generator_clean():
+    async def generator_clean() -> types.AsyncGenerator[int, None]:
         for i in range(10):
             await asyncio.sleep(i / 100.0)
             yield i
@@ -152,22 +155,33 @@ async def test_aio_generator_timeout_detector_decorator():
 
     assert i == 4
 
+
+@pytest.mark.asyncio
+async def test_aio_generator_timeout_detector_decorator_reraise_total() -> (
+    None
+):
     # Test total timeout with reraise
     @python_utils.aio_generator_timeout_detector_decorator(total_timeout=0.1)
-    async def generator_reraise():
+    async def generator_reraise() -> types.AsyncGenerator[int, None]:
         for i in range(10):
             await asyncio.sleep(i / 100.0)
             yield i
 
     with pytest.raises(asyncio.TimeoutError):
-        async for i in generator_reraise():
+        async for _ in generator_reraise():
             pass
 
+
+@pytest.mark.asyncio
+async def test_aio_generator_timeout_detector_decorator_clean_total() -> None:
+    # Make pyright happy
+    i = None
+
     # Test total timeout with clean exit
     @python_utils.aio_generator_timeout_detector_decorator(
         total_timeout=0.1, on_timeout=None
     )
-    async def generator_clean_total():
+    async def generator_clean_total() -> types.AsyncGenerator[int, None]:
         for i in range(10):
             await asyncio.sleep(i / 100.0)
             yield i

python_utils-3.9.1/pyproject.toml

@@ -0,0 +1,20 @@
+[tool.black]
+line-length = 79
+target-version = ['py37', 'py38', 'py39', 'py310', 'py311']
+skip-string-normalization = true
+
+[tool.pyright]
+# include = ['python_utils']
+include = ['python_utils', '_python_utils_tests', 'setup.py']
+strict = ['python_utils', '_python_utils_tests', 'setup.py']
+# The terminal file is very OS specific and dependent on imports so we're skipping it from type checking
+ignore = ['python_utils/terminal.py']
+pythonVersion = '3.9'
+
+[tool.mypy]
+strict = true
+check_untyped_defs = true
+files = ['python_utils', '_python_utils_tests', 'setup.py']
+
+[[tool.mypy.overrides]]
+module = '_python_utils_tests.*'

python_utils-3.9.1/python_utils/__about__.py

@@ -0,0 +1,22 @@
+"""
+This module contains metadata about the `python-utils` package.
+
+Attributes:
+    __package_name__ (str): The name of the package.
+    __author__ (str): The author of the package.
+    __author_email__ (str): The email of the author.
+    __description__ (str): A brief description of the package.
+    __url__ (str): The URL of the package's repository.
+    __version__ (str): The current version of the package.
+"""
+
+__package_name__: str = 'python-utils'
+__author__: str = 'Rick van Hattem'
+__author_email__: str = 'Wolph@wol.ph'
+__description__: str = (
+    'Python Utils is a module with some convenient utilities not included '
+    'with the standard Python install'
+)
+__url__: str = 'https://github.com/WoLpH/python-utils'
+# Omit type info due to automatic versioning script
+__version__ = '3.9.1'

{python-utils-3.8.2 → python_utils-3.9.1}/python_utils/__init__.py

@@ -1,6 +1,56 @@
+"""
+This module initializes the `python_utils` package by importing various
+submodules and functions.
+
+Submodules:
+    aio
+    converters
+    decorators
+    formatters
+    generators
+    import_
+    logger
+    terminal
+    time
+    types
+
+Functions:
+    acount
+    remap
+    scale_1024
+    to_float
+    to_int
+    to_str
+    to_unicode
+    listify
+    set_attributes
+    raise_exception
+    reraise
+    camel_to_underscore
+    timesince
+    abatcher
+    batcher
+    import_global
+    get_terminal_size
+    aio_generator_timeout_detector
+    aio_generator_timeout_detector_decorator
+    aio_timeout_generator
+    delta_to_seconds
+    delta_to_seconds_or_none
+    format_time
+    timedelta_to_seconds
+    timeout_generator
+
+Classes:
+    CastedDict
+    LazyCastedDict
+    UniqueList
+    Logged
+    LoggerBase
+"""
+
 from . import (
     aio,
-    compat,
     converters,
     decorators,
     formatters,
@@ -33,45 +83,44 @@ from .time import (
 )
 
 __all__ = [
+    'CastedDict',
+    'LazyCastedDict',
+    'Logged',
+    'LoggerBase',
+    'UniqueList',
+    'abatcher',
+    'acount',
     'aio',
-    'generators',
-    'compat',
+    'aio_generator_timeout_detector',
+    'aio_generator_timeout_detector_decorator',
+    'aio_timeout_generator',
+    'batcher',
+    'camel_to_underscore',
     'converters',
     'decorators',
+    'delta_to_seconds',
+    'delta_to_seconds_or_none',
+    'format_time',
     'formatters',
+    'generators',
+    'get_terminal_size',
     'import_',
+    'import_global',
+    'listify',
     'logger',
-    'terminal',
-    'time',
-    'types',
-    'to_int',
-    'to_float',
-    'to_unicode',
-    'to_str',
-    'scale_1024',
+    'raise_exception',
     'remap',
+    'reraise',
+    'scale_1024',
     'set_attributes',
-    'listify',
-    'camel_to_underscore',
-    'timesince',
-    'import_global',
-    'get_terminal_size',
+    'terminal',
+    'time',
     'timedelta_to_seconds',
-    'format_time',
     'timeout_generator',
-    'acount',
-    'abatcher',
-    'batcher',
-    'aio_timeout_generator',
-    'aio_generator_timeout_detector_decorator',
-    'aio_generator_timeout_detector',
-    'delta_to_seconds',
-    'delta_to_seconds_or_none',
-    'reraise',
-    'raise_exception',
-    'Logged',
-    'LoggerBase',
-    'CastedDict',
-    'LazyCastedDict',
-    'UniqueList',
+    'timesince',
+    'to_float',
+    'to_int',
+    'to_str',
+    'to_unicode',
+    'types',
 ]