dycw-utilities 0.127.0__tar.gz → 0.173.4__tar.gz

dycw_utilities-0.173.4/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.3
+Name: dycw-utilities
+Version: 0.173.4
+Author: Derek Wan
+Author-email: Derek Wan <d.wan@icloud.com>
+Requires-Dist: atomicwrites>=1.4.1,<1.5
+Requires-Dist: typing-extensions>=4.15.0,<4.16
+Requires-Dist: tzlocal>=5.3.1,<5.4
+Requires-Dist: whenever>=0.9.4,<0.10
+Requires-Dist: coloredlogs>=15.0.1,<15.1 ; extra == 'logging'
+Requires-Dist: dycw-pytest-only>=2.1.1,<2.2 ; extra == 'test'
+Requires-Dist: hypothesis>=6.148.8,<6.149 ; extra == 'test'
+Requires-Dist: pytest>=9.0.2,<9.1 ; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.3.0,<1.4 ; extra == 'test'
+Requires-Dist: pytest-cov>=7.0.0,<7.1 ; extra == 'test'
+Requires-Dist: pytest-instafail>=0.5.0,<0.6 ; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures>=1.4.0,<1.5 ; extra == 'test'
+Requires-Dist: pytest-randomly>=4.0.1,<4.1 ; extra == 'test'
+Requires-Dist: pytest-regressions>=2.8.3,<2.9 ; extra == 'test'
+Requires-Dist: pytest-repeat>=0.9.4,<0.10 ; extra == 'test'
+Requires-Dist: pytest-rerunfailures>=16.1,<16.2 ; extra == 'test'
+Requires-Dist: pytest-rng>=1.0.0,<1.1 ; extra == 'test'
+Requires-Dist: pytest-timeout>=2.4.0,<2.5 ; extra == 'test'
+Requires-Dist: pytest-xdist>=3.8.0,<3.9 ; extra == 'test'
+Requires-Dist: testbook>=0.4.2,<0.5 ; extra == 'test'
+Requires-Python: >=3.12
+Provides-Extra: logging
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+[![PyPI version](https://badge.fury.io/py/dycw-utilities.svg)](https://badge.fury.io/py/dycw-utilities)
+
+# `dycw-utilities`
+
+[All the Python functions I don't want to write twice.](https://github.com/nvim-lua/plenary.nvim)
+
+## Installation
+
+- `pip install dycw-utilities`
+
+or with [extras](https://github.com/dycw/python-utilities/blob/master/pyproject.toml).

dycw_utilities-0.173.4/pyproject.toml

@@ -0,0 +1,330 @@
+# build-system
+[build-system]
+  build-backend = "uv_build"
+  requires = ["uv_build"]
+
+# dependency groups
+[dependency-groups]
+  aeventkit = ["aeventkit >=2.1.0, <2.2"]
+  altair = ["altair >=5.5.0, <5.6"]
+  altair-test = ["polars", "img2pdf", "vl-convert-python"]
+  atools = ["atools >=0.14.2, <0.15"]
+  cachetools = ["cachetools >=6.2.4, <6.3"]
+  click = ["click >=8.3.1, <8.4"]
+  core = [
+    "atomicwrites >=1.4.1, <1.5",
+    "typing-extensions >=4.15.0, <4.16",
+    "tzlocal >=5.3.1, <5.4",
+    "whenever >=0.9.4, <0.10",
+  ]
+  cryptography = ["cryptography >=46.0.3, <46.1"]
+  cvxpy = ["cvxpy >=1.7.5, <1.8"]
+  dataclasses-test = ["orjson", "polars"]
+  dev = [
+    "coloredlogs >=15.0.1, <15.1",
+    "coverage-conditional-plugin >=0.9.0, <0.10",
+    "dycw-pytest-only >=2.1.1, <2.2",
+    "pyright[nodejs] >=1.1.407, <1.2",
+    "pytest-cov >=7.0.0, <7.1",
+    "pytest-timeout >=2.4.0, <2.5",
+  ]
+  fastapi = ["fastapi >=0.127.0, <0.128"]
+  fastapi-test = ["httpx", "uvicorn"]
+  fpdf2 = ["fpdf2 >=2.8.5, <2.9"]
+  gitpython = ["gitpython >=3.1.45, <3.2"]
+  hashlib-test = ["orjson"]
+  http-test = ["orjson"]
+  hypothesis = ["hypothesis >=6.148.8, <6.149"]
+  hypothesis-test = ["libcst", "numpy", "pathvalidate", "pytest-rerunfailures"]
+  inflect = ["inflect >=7.5.0, <7.6"]
+  jinja2 = ["jinja2 >=3.1.6, <3.2"]
+  jupyter-test = ["pandas", "polars"]
+  libcst = ["libcst >=1.8.6, <1.9"]
+  lightweight-charts = ["lightweight-charts >=2.1, <2.2"]
+  lightweight-charts-test = ["polars", "pyarrow"]
+  math-test = ["numpy"]
+  memory-profiler = ["memory-profiler >=0.61.0, <0.62"]
+  more-itertools = ["more-itertools >=10.8.0, <10.9"]
+  numpy = ["numpy >=2.4.0, <2.5"]
+  operator = ["polars"]
+  optuna = ["optuna >=4.6.0, <4.7"]
+  orjson = ["orjson >=3.11.5, <3.12"]
+  orjson-test = ["polars"]
+  polars = ["polars >=1.36.1, <1.37"]
+  polars-ols = ["polars-ols >=0.3.5, <0.4"]
+  polars-ols-test = ["scikit-learn"]
+  polars-test = ["numpy", "scipy", "statsmodels"]
+  pottery = ["pottery >=3.0.1, <3.1"]
+  pottery-test = ["orjson"]
+  pqdm = ["pqdm >=0.2.0, <0.3"]
+  psutil = ["psutil >=7.2.0, <7.3"]
+  pydantic = ["pydantic >=2.12.5, <2.13"]
+  pydantic-settings = ["pydantic-settings >=2.12.0, <2.13"]
+  pydantic-settings-sops = ["pydantic-settings-sops"]
+  pydantic-settings-test = ["pyyaml", "tomlkit"]
+  pyinstrument = ["pyinstrument >=5.1.1, <5.2"]
+  pytest = [
+    "pytest >=9.0.2, <9.1",
+    "pytest-asyncio >=1.3.0, <1.4",
+    "pytest-randomly >=4.0.1, <4.1",
+    "pytest-timeout >=2.4.0, <2.5",
+    "pytest-xdist >=3.8.0, <3.9",
+  ]
+  pytest-regressions = ["pytest-regressions >=2.8.3, <2.9"]
+  pytest-regressions-test = ["orjson", "polars"]
+  pytest-test = ["orjson", "pytest-rerunfailures", "pytest-rng"]
+  redis = ["redis >=7.1.0, <7.2", "orjson"]
+  redis-test = ["pytest-rerunfailures"]
+  reprlib-test = ["rich"]
+  scipy = ["scipy >=1.16.3, <1.17"]
+  sklearn = ["scikit-learn >=1.8.0, <1.9"]
+  slack-sdk = ["slack-sdk >=3.39.0, <3.40"]
+  slack-sdk-test = ["aiohttp"]
+  sqlalchemy = ["sqlalchemy >=2.0.45, <2.1", "psycopg"]
+  sqlalchemy-polars = ["sqlalchemy", "polars"]
+  sqlalchemy-polars-test = ["aiosqlite", "asyncpg", "greenlet"]
+  sqlalchemy-test = ["aiosqlite", "asyncpg", "greenlet"]
+  statsmodels = ["statsmodels >=0.14.6, <0.15"]
+  testbook = ["testbook >=0.4.2, <0.5"]
+  tzdata = ["tzdata >=2025.3, <2025.4"]
+  whenever-test = ["pathvalidate"]
+
+# project
+[project]
+  authors = [{ email = "d.wan@icloud.com", name = "Derek Wan" }]
+  dependencies = [
+    "atomicwrites >=1.4.1, <1.5",
+    "typing-extensions >=4.15.0, <4.16",
+    "tzlocal >=5.3.1, <5.4",
+    "whenever >=0.9.4, <0.10",
+  ]
+  name = "dycw-utilities"
+  readme = "README.md"
+  requires-python = ">= 3.12"
+  version = "0.173.4"
+
+  [project.entry-points.pytest11]
+    pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
+    pytest-regressions = "utilities.pytest_plugins.pytest_regressions"
+
+  [project.optional-dependencies]
+    logging = ["coloredlogs >=15.0.1, <15.1"]
+    test = [
+      "dycw-pytest-only >=2.1.1, <2.2",
+      "hypothesis >=6.148.8, <6.149",
+      "pytest >=9.0.2, <9.1",
+      "pytest-asyncio >=1.3.0, <1.4",
+      "pytest-cov >=7.0.0, <7.1",
+      "pytest-instafail >=0.5.0, <0.6",
+      "pytest-lazy-fixtures >=1.4.0, <1.5",
+      "pytest-randomly >=4.0.1, <4.1",
+      "pytest-regressions >=2.8.3, <2.9",
+      "pytest-repeat >=0.9.4, <0.10",
+      "pytest-rerunfailures >=16.1, <16.2",
+      "pytest-rng >=1.0.0, <1.1",
+      "pytest-timeout >=2.4.0, <2.5",
+      "pytest-xdist >=3.8.0, <3.9",
+      "testbook >=0.4.2, <0.5",
+    ]
+
+  [project.scripts]
+
+# tool
+[tool]
+
+  # bump-my-version
+  [tool.bumpversion]
+    allow_dirty = true
+    current_version = "0.173.4"
+
+    [[tool.bumpversion.files]]
+      filename = "src/utilities/__init__.py"
+      replace = "__version__ = \"{new_version}\""
+      search = "__version__ = \"{current_version}\""
+
+  # coverage
+  [tool.coverage]
+    [tool.coverage.coverage_conditional_plugin]
+      [tool.coverage.coverage_conditional_plugin.rules]
+        skipif-ci = '"CI" in os_environ'
+        skipif-ci-and-mac = '("CI" in os_environ) and (sys_platform == "darwin")'
+        skipif-ci-and-not-linux = '("CI" in os_environ) and (sys_platform != "linux")'
+        skipif-ci-or-mac = '("CI" in os_environ) or (sys_platform == "darwin")'
+        skipif-linux = 'sys_platform == "linux"'
+        skipif-mac = 'sys_platform == "darwin"'
+        skipif-not-linux = 'sys_platform != "linux"'
+        skipif-not-macos = 'sys_platform != "darwin"'
+
+    [tool.coverage.html]
+      directory = ".coverage/html"
+
+    [tool.coverage.report]
+      exclude_also = [
+        "@overload",
+        "assert_never",
+        "case never:",
+        "if TYPE_CHECKING:",
+      ]
+      fail_under = 100.0
+      skip_covered = true
+      skip_empty = true
+
+    [tool.coverage.run]
+      branch = true
+      data_file = ".coverage/data"
+      omit = [
+        "src/utilities/__init__.py",
+        "src/utilities/pytest_plugins/*.py",
+        "src/utilities/streamlit.py",
+      ]
+      parallel = true
+      plugins = ["coverage_conditional_plugin"]
+      source = ["src/utilities"]
+
+  # pyright
+  [tool.pyright]
+    deprecateTypingAliases = true
+    enableReachabilityAnalysis = false
+    ignore = ["**/_typeshed/**"]
+    pythonVersion = "3.12"
+    reportCallInDefaultInitializer = true
+    reportImplicitOverride = true
+    reportImplicitStringConcatenation = true
+    reportImportCycles = true
+    reportMissingSuperCall = true
+    reportMissingTypeArgument = false
+    reportMissingTypeStubs = false
+    reportPrivateUsage = false
+    reportPropertyTypeMismatch = true
+    reportUninitializedInstanceVariable = true
+    reportUnknownArgumentType = false
+    reportUnknownMemberType = false
+    reportUnknownParameterType = false
+    reportUnknownVariableType = false
+    reportUnnecessaryComparison = false
+    reportUnnecessaryTypeIgnoreComment = true
+    reportUnusedCallResult = true
+    reportUnusedImport = false
+    reportUnusedVariable = false
+    typeCheckingMode = "strict"
+
+  # pytest
+  [tool.pytest]
+    addopts = [
+      "-ra",
+      "-vv",
+      "--color=auto",
+      "--durations=10",
+      "--durations-min=10",
+      "--timeout=600",
+    ]
+    asyncio_default_fixture_loop_scope = "function"
+    asyncio_mode = "auto"
+    collect_imported_tests = false
+    empty_parameter_set_mark = "fail_at_collect"
+    filterwarnings = [
+      "error",
+      "ignore:<aiosqlite.*core.*Connection .*> was delete before being closed:ResourceWarning",                                          # sqlalchemy
+      "ignore:Exception ignored in.* <coroutine object .* at .*>:pytest.PytestUnraisableExceptionWarning",
+      "ignore:Exception in thread Thread-.*:pytest.PytestUnhandledThreadExceptionWarning",
+      "ignore:Jupyter is migrating its paths to use standard platformdirs:DeprecationWarning",                                           # jupyter
+      "ignore:ResourceTracker called reentrantly for resource cleanup, which is unsupported:UserWarning",
+      "ignore:The garbage collector is trying to clean up non-checked-in connection <AdaptedConnection <Connection(.*)>:RuntimeWarning", # sqlalchemy
+      "ignore:Using fork.* can cause Polars to deadlock in the child process:RuntimeWarning",                                            # polars/pqdm
+      "ignore:coroutine 'AsyncConnection.close' was never awaited:RuntimeWarning",
+      "ignore:loop is closed:ResourceWarning",                                                                                           # redis
+      "ignore:unclosed <StreamWriter .*>:ResourceWarning",                                                                               # redis
+      "ignore:unclosed <socket.*socket .*>:ResourceWarning",                                                                             # redis
+      "ignore:unclosed Connection <redis.*asyncio.*connection.*Connection.*>:ResourceWarning",                                           # redis
+      "ignore:unclosed connection <asyncpg.*connection.*Connection.*>:ResourceWarning",                                                  # asyncpg
+      "ignore:unclosed database in <sqlite3.*Connection .*>:ResourceWarning",                                                            # sqlalchemy
+      "ignore:unclosed event loop <_UnixSelectorEventLoop .*>:ResourceWarning",                                                          # redis
+      "ignore:unclosed file <_io.*TextIOWrapper .*>:ResourceWarning",                                                                    # logging
+      "ignore:unclosed transport <_SelectorSocketTransport .*>:ResourceWarning",                                                         # redis
+      "ignore:Do not expect file_or_dir in Namespace:UserWarning",                                                                       # pytest
+    ]
+    minversion = "9.0"
+    strict = true
+    testpaths = ["src/tests"]
+    timeout = "600"
+    xfail_strict = true
+
+  # ruff
+  [tool.ruff]
+    src = ["src"]
+    target-version = "py312"
+    unsafe-fixes = true
+
+    [tool.ruff.format]
+      preview = true
+      skip-magic-trailing-comma = true
+
+    [tool.ruff.lint]
+      explicit-preview-rules = true
+      fixable = ["ALL"]
+      ignore = [
+        "ANN401",   # any-type
+        "A005",     # stdlib-module-shadowing
+        "ASYNC109", # async-function-with-timeout
+        "C901",     # complex-structure
+        "CPY",      # flake8-copyright
+        "D",        # pydocstyle
+        "DOC",      # pydoclint
+        "E501",     # line-too-long
+        "PD",       # pandas-vet
+        "PERF203",  # try-except-in-loop
+        "PLC0415",  # import-outside-top-level
+        "PLR0911",  # too-many-return-statements
+        "PLR0912",  # too-many-branches
+        "PLR0913",  # too-many-arguments
+        "PLR0915",  # too-many-statements
+        "PLR2004",  # magic-value-comparison
+        "PT012",    # pytest-raises-with-multiple-statements
+        "PT013",    # pytest-incorrect-pytest-import
+        "S202",     # tarfile-unsafe-members
+        "S310",     # suspicious-url-open-usage
+        "S311",     # suspicious-non-cryptographic-random-usage
+        "S602",     # subprocess-popen-with-shell-equals-true
+        "S603",     # subprocess-without-shell-equals-true
+        "S607",     # start-process-with-partial-path
+        # preview
+        "S101", # assert
+        # formatter
+        "W191",   # tab-indentation
+        "E111",   # indentation-with-invalid-multiple
+        "E114",   # indentation-with-invalid-multiple-comment
+        "E117",   # over-indented
+        "COM812", # missing-trailing-comma
+        "COM819", # prohibited-trailing-comma
+        "ISC001", # single-line-implicit-string-concatenation
+        "ISC002", # multi-line-implicit-string-concatenation
+      ]
+      preview = true
+      select = [
+        "ALL",
+        "RUF022", # unsorted-dunder-all
+      ]
+
+      [tool.ruff.lint.extend-per-file-ignores]
+        "src/tests/**/*.py" = [
+          "S101",   # assert
+          "SLF001", # private-member-access
+        ]
+        "src/tests/test_typing_funcs/no_future.py" = [
+          "I002",
+        ] # missing-required-import
+
+      [tool.ruff.lint.flake8-tidy-imports]
+        ban-relative-imports = "all"
+
+      [tool.ruff.lint.isort]
+        required-imports = ["from __future__ import annotations"]
+        split-on-trailing-comma = false
+
+  # uv
+  [tool.uv]
+    default-groups = "all"
+
+    [tool.uv.build-backend]
+      module-name = "utilities"
+      module-root = "src"

{dycw_utilities-0.127.0 → dycw_utilities-0.173.4}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.127.0"
+__version__ = "0.173.4"

dycw_utilities-0.127.0/src/utilities/eventkit.py → dycw_utilities-0.173.4/src/utilities/aeventkit.py

@@ -1,18 +1,9 @@
 from __future__ import annotations
 
-from asyncio import iscoroutinefunction
 from dataclasses import dataclass
 from functools import wraps
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Generic,
-    Self,
-    TypeVar,
-    assert_never,
-    cast,
-    override,
-)
+from inspect import iscoroutinefunction
+from typing import TYPE_CHECKING, Any, Self, assert_never, cast, override
 
 from eventkit import (
     Constant,
@@ -38,33 +29,29 @@ from eventkit import (
 
 from utilities.functions import apply_decorators
 from utilities.iterables import always_iterable
-from utilities.logging import get_logger
-from utilities.types import TCallable, TCallableMaybeCoroutine1None, TypeLike
+from utilities.logging import to_logger
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from utilities.types import Coroutine1, LoggerOrName, MaybeCoroutine1, MaybeIterable
-
-
-_TEvent = TypeVar("_TEvent", bound=Event)
+    from utilities.types import Coro, LoggerLike, MaybeCoro, MaybeIterable, TypeLike
 
 
 ##
 
 
-def add_listener(
-    event: _TEvent,
-    listener: Callable[..., MaybeCoroutine1[None]],
+def add_listener[E: Event, F: Callable](
+    event: E,
+    listener: Callable[..., MaybeCoro[None]],
     /,
     *,
-    error: Callable[[Event, BaseException], MaybeCoroutine1[None]] | None = None,
+    error: Callable[[Event, BaseException], MaybeCoro[None]] | None = None,
     ignore: TypeLike[BaseException] | None = None,
-    logger: LoggerOrName | None = None,
-    decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
-    done: Callable[..., MaybeCoroutine1[None]] | None = None,
+    logger: LoggerLike | None = None,
+    decorators: MaybeIterable[Callable[[F], F]] | None = None,
+    done: Callable[..., MaybeCoro[None]] | None = None,
     keep_ref: bool = False,
-) -> _TEvent:
+) -> E:
     """Connect a listener to an event."""
     lifted = lift_listener(
         listener,
@@ -74,14 +61,14 @@ def add_listener(
         logger=logger,
         decorators=decorators,
     )
-    return cast("_TEvent", event.connect(lifted, done=done, keep_ref=keep_ref))
+    return cast("E", event.connect(lifted, done=done, keep_ref=keep_ref))
 
 
 ##
 
 
 @dataclass(repr=False, kw_only=True)
-class LiftedEvent(Generic[TCallableMaybeCoroutine1None]):
+class LiftedEvent[F: Callable[..., MaybeCoro[None]]]:
     """A lifted version of `Event`."""
 
     event: Event
@@ -98,16 +85,16 @@ class LiftedEvent(Generic[TCallableMaybeCoroutine1None]):
     def value(self) -> Any:
         return self.event.value()  # pragma: no cover
 
-    def connect(
+    def connect[F2: Callable](
         self,
-        listener: TCallableMaybeCoroutine1None,
+        listener: F,
         /,
         *,
-        error: Callable[[Event, BaseException], MaybeCoroutine1[None]] | None = None,
+        error: Callable[[Event, BaseException], MaybeCoro[None]] | None = None,
         ignore: TypeLike[BaseException] | None = None,
-        logger: LoggerOrName | None = None,
-        decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
-        done: Callable[..., MaybeCoroutine1[None]] | None = None,
+        logger: LoggerLike | None = None,
+        decorators: MaybeIterable[Callable[[F2], F2]] | None = None,
+        done: Callable[..., MaybeCoro[None]] | None = None,
         keep_ref: bool = False,
     ) -> Event:
         return add_listener(
@@ -182,7 +169,8 @@ class LiftedEvent(Generic[TCallableMaybeCoroutine1None]):
     def __await__(self) -> Any:
         return self.event.__await__()  # pragma: no cover
 
-    __aiter__ = aiter
+    def __aiter__(self) -> Any:
+        return self.event.aiter()  # pragma: no cover
 
     def __contains__(self, c: Any, /) -> bool:
         return self.event.__contains__(c)  # pragma: no cover
@@ -256,26 +244,26 @@ class LiftedEvent(Generic[TCallableMaybeCoroutine1None]):
 ##
 
 
-class TypedEvent(Event, Generic[TCallableMaybeCoroutine1None]):
+class TypedEvent[F: Callable[..., MaybeCoro[None]]](Event):
     """A typed version of `Event`."""
 
     @override
-    def connect(
+    def connect[F2: Callable](
         self,
-        listener: TCallableMaybeCoroutine1None,
-        error: Callable[[Self, BaseException], MaybeCoroutine1[None]] | None = None,
-        done: Callable[[Self], MaybeCoroutine1[None]] | None = None,
+        listener: F,
+        error: Callable[[Self, BaseException], MaybeCoro[None]] | None = None,
+        done: Callable[[Self], MaybeCoro[None]] | None = None,
         keep_ref: bool = False,
         *,
         ignore: TypeLike[BaseException] | None = None,
-        logger: LoggerOrName | None = None,
-        decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
+        logger: LoggerLike | None = None,
+        decorators: MaybeIterable[Callable[[F2], F2]] | None = None,
     ) -> Self:
         lifted = lift_listener(
             listener,
             self,
             error=cast(
-                "Callable[[Event, BaseException], MaybeCoroutine1[None]] | None", error
+                "Callable[[Event, BaseException], MaybeCoro[None]] | None", error
             ),
             ignore=ignore,
             logger=logger,
@@ -289,16 +277,16 @@ class TypedEvent(Event, Generic[TCallableMaybeCoroutine1None]):
 ##
 
 
-def lift_listener(
-    listener: Callable[..., MaybeCoroutine1[None]],
+def lift_listener[F1: Callable[..., MaybeCoro[None]], F2: Callable](
+    listener: F1,
     event: Event,
     /,
     *,
-    error: Callable[[Event, BaseException], MaybeCoroutine1[None]] | None = None,
+    error: Callable[[Event, BaseException], MaybeCoro[None]] | None = None,
     ignore: TypeLike[BaseException] | None = None,
-    logger: LoggerOrName | None = None,
-    decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
-) -> Callable[..., MaybeCoroutine1[None]]:
+    logger: LoggerLike | None = None,
+    decorators: MaybeIterable[Callable[[F2], F2]] | None = None,
+) -> F1:
     match error, bool(iscoroutinefunction(listener)):
         case None, False:
             listener_typed = cast("Callable[..., None]", listener)
@@ -310,12 +298,12 @@ def lift_listener(
                 except Exception as exc:  # noqa: BLE001
                     if (ignore is not None) and isinstance(exc, ignore):
                         return
-                    get_logger(logger=logger).exception("")
+                    to_logger(logger).exception("")
 
             lifted = listener_no_error_sync
 
         case None, True:
-            listener_typed = cast("Callable[..., Coroutine1[None]]", listener)
+            listener_typed = cast("Callable[..., Coro[None]]", listener)
 
             @wraps(listener)
             async def listener_no_error_async(*args: Any, **kwargs: Any) -> None:
@@ -324,7 +312,7 @@ def lift_listener(
                 except Exception as exc:  # noqa: BLE001
                     if (ignore is not None) and isinstance(exc, ignore):
                         return
-                    get_logger(logger=logger).exception("")
+                    to_logger(logger).exception("")
 
             lifted = listener_no_error_async
         case _, _:
@@ -346,11 +334,11 @@ def lift_listener(
                 case False, True:
                     listener_typed = cast("Callable[..., None]", listener)
                     error_typed = cast(
-                        "Callable[[Event, Exception], Coroutine1[None]]", error
+                        "Callable[[Event, Exception], Coro[None]]", error
                     )
                     raise LiftListenerError(listener=listener_typed, error=error_typed)
                 case True, _:
-                    listener_typed = cast("Callable[..., Coroutine1[None]]", listener)
+                    listener_typed = cast("Callable[..., Coro[None]]", listener)
 
                     @wraps(listener)
                     async def listener_have_error_async(
@@ -363,8 +351,7 @@ def lift_listener(
                                 return None
                             if iscoroutinefunction(error):
                                 error_typed = cast(
-                                    "Callable[[Event, Exception], Coroutine1[None]]",
-                                    error,
+                                    "Callable[[Event, Exception], Coro[None]]", error
                                 )
                                 return await error_typed(event, exc)
                             error_typed = cast(
@@ -373,20 +360,20 @@ def lift_listener(
                             error_typed(event, exc)
 
                     lifted = listener_have_error_async
-                case _ as never:
+                case never:
                     assert_never(never)
-        case _ as never:
+        case never:
             assert_never(never)
 
     if decorators is not None:
         lifted = apply_decorators(lifted, *always_iterable(decorators))
-    return lifted
+    return cast("F1", lifted)
 
 
 @dataclass(kw_only=True, slots=True)
 class LiftListenerError(Exception):
     listener: Callable[..., None]
-    error: Callable[[Event, Exception], Coroutine1[None]]
+    error: Callable[[Event, Exception], Coro[None]]
 
     @override
     def __str__(self) -> str: