python-utils 3.8.1__tar.gz → 3.9.0__tar.gz

{python-utils-3.8.1/python_utils.egg-info → python_utils-3.9.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: python-utils
-Version: 3.8.1
+Version: 3.9.0
 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.0/_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.1 → python_utils-3.9.0}/_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.1 → python_utils-3.9.0}/_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.1 → python_utils-3.9.0}/_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.1 → python_utils-3.9.0}/_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.1 → python_utils-3.9.0}/_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.1 → python_utils-3.9.0}/_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
@@ -46,15 +46,15 @@ async def test_aio_timeout_generator(
     '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.007, 0.5, 0.01, itertools.count, 2),
+        (0.01, 0.007, 0.5, 0.01, itertools.count(), 2),
         (0.01, 0.006, 1.0, None, 'abc', 'c'),
         (
             timedelta(seconds=0.01),
             timedelta(seconds=0.006),
             2.0,
             timedelta(seconds=0.01),
-            itertools.count,  # type: ignore
+            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,17 +79,17 @@ 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)
             yield i
@@ -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.8.1 → python_utils-3.9.0}/pyproject.toml

@@ -5,8 +5,15 @@ skip-string-normalization = true
 
 [tool.pyright]
 # include = ['python_utils']
-include = ['python_utils', '_python_utils_tests']
-strict = ['python_utils', '_python_utils_tests']
+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.8'
+pythonVersion = '3.9'
+
+[tool.mypy]
+strict = true
+check_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = '_python_utils_tests.*'

python_utils-3.9.0/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.0'

{python-utils-3.8.1 → python_utils-3.9.0}/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,
@@ -35,7 +85,6 @@ from .time import (
 __all__ = [
     'aio',
     'generators',
-    'compat',
     'converters',
     'decorators',
     'formatters',

python_utils-3.9.0/python_utils/aio.py

@@ -0,0 +1,117 @@
+"""Asyncio equivalents to regular Python functions."""
+
+import asyncio
+import itertools
+import typing
+
+from . import types
+
+_N = types.TypeVar('_N', int, float)
+_T = types.TypeVar('_T')
+_K = types.TypeVar('_K')
+_V = types.TypeVar('_V')
+
+
+async def acount(
+    start: _N = 0,
+    step: _N = 1,
+    delay: float = 0,
+    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
+        await asyncio.sleep(delay)
+
+
+@typing.overload
+async def acontainer(
+    iterable: types.Union[
+        types.AsyncIterable[_T],
+        types.Callable[..., types.AsyncIterable[_T]],
+    ],
+    container: types.Type[types.Tuple[_T, ...]],
+) -> types.Tuple[_T, ...]: ...
+
+
+@typing.overload
+async def acontainer(
+    iterable: types.Union[
+        types.AsyncIterable[_T],
+        types.Callable[..., types.AsyncIterable[_T]],
+    ],
+    container: types.Type[types.List[_T]] = list,
+) -> types.List[_T]: ...
+
+
+@typing.overload
+async def acontainer(
+    iterable: types.Union[
+        types.AsyncIterable[_T],
+        types.Callable[..., types.AsyncIterable[_T]],
+    ],
+    container: types.Type[types.Set[_T]],
+) -> types.Set[_T]: ...
+
+
+async def acontainer(
+    iterable: types.Union[
+        types.AsyncIterable[_T],
+        types.Callable[..., types.AsyncIterable[_T]],
+    ],
+    container: types.Callable[
+        [types.Iterable[_T]], types.Collection[_T]
+    ] = list,
+) -> types.Collection[_T]:
+    """
+    Asyncio version of list()/set()/tuple()/etc() using an async for loop.
+
+    So instead of doing `[item async for item in iterable]` you can do
+    `await acontainer(iterable)`.
+
+    """
+    iterable_: types.AsyncIterable[_T]
+    if callable(iterable):
+        iterable_ = iterable()
+    else:
+        iterable_ = iterable
+
+    item: _T
+    items: types.List[_T] = []
+    async for item in iterable_:  # pragma: no branch
+        items.append(item)
+
+    return container(items)
+
+
+async def adict(
+    iterable: types.Union[
+        types.AsyncIterable[types.Tuple[_K, _V]],
+        types.Callable[..., types.AsyncIterable[types.Tuple[_K, _V]]],
+    ],
+    container: types.Callable[
+        [types.Iterable[types.Tuple[_K, _V]]], types.Mapping[_K, _V]
+    ] = dict,
+) -> types.Mapping[_K, _V]:
+    """
+    Asyncio version of dict() using an async for loop.
+
+    So instead of doing `{key: value async for key, value in iterable}` you
+    can do `await adict(iterable)`.
+
+    """
+    iterable_: types.AsyncIterable[types.Tuple[_K, _V]]
+    if callable(iterable):
+        iterable_ = iterable()
+    else:
+        iterable_ = iterable
+
+    item: types.Tuple[_K, _V]
+    items: types.List[types.Tuple[_K, _V]] = []
+    async for item in iterable_:  # pragma: no branch
+        items.append(item)
+
+    return container(items)