dycw-utilities 0.135.0__py3-none-any.whl → 0.178.1__py3-none-any.whl

utilities/logging.py

@@ -8,6 +8,7 @@ from logging import (
     Formatter,
     Handler,
     Logger,
+    LoggerAdapter,
     LogRecord,
     StreamHandler,
     basicConfig,
@@ -18,9 +19,11 @@ from logging import (
 from logging.handlers import BaseRotatingHandler, TimedRotatingFileHandler
 from pathlib import Path
 from re import Pattern
+from socket import gethostname
 from typing import (
     TYPE_CHECKING,
     Any,
+    Concatenate,
     Literal,
     NotRequired,
     Self,
@@ -30,13 +33,13 @@ from typing import (
     override,
 )
 
-from whenever import PlainDateTime, ZonedDateTime
+from whenever import ZonedDateTime
 
 from utilities.atomicwrites import move_many
 from utilities.dataclasses import replace_non_sentinel
 from utilities.errors import ImpossibleCaseError
 from utilities.iterables import OneEmptyError, always_iterable, one
-from utilities.pathlib import ensure_suffix, get_path
+from utilities.pathlib import ensure_suffix, to_path
 from utilities.re import (
     ExtractGroupError,
     ExtractGroupsError,
@@ -44,26 +47,28 @@ from utilities.re import (
     extract_groups,
 )
 from utilities.sentinel import Sentinel, sentinel
-from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import WheneverLogRecord, format_compact, get_now, get_now_local
+from utilities.whenever import (
+    WheneverLogRecord,
+    format_compact,
+    get_now_local,
+    to_zoned_date_time,
+)
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Mapping
+    from collections.abc import Callable, Iterable, Mapping, MutableMapping
     from datetime import time
     from logging import _FilterType
 
     from utilities.types import (
-        LoggerOrName,
+        LoggerLike,
         LogLevel,
         MaybeCallablePathLike,
         MaybeIterable,
         PathLike,
+        StrMapping,
     )
 
 
-_DEFAULT_FORMAT = (
-    "{zoned_datetime} | {name}:{funcName}:{lineno} | {levelname:8} | {message}"
-)
 _DEFAULT_DATEFMT = "%Y-%m-%d %H:%M:%S"
 _DEFAULT_BACKUP_COUNT: int = 100
 _DEFAULT_MAX_BYTES: int = 10 * 1024**2
@@ -73,6 +78,35 @@ _DEFAULT_WHEN: _When = "D"
 ##
 
 
+def add_adapter[**P](
+    logger: Logger,
+    process: Callable[Concatenate[str, P], str],
+    /,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> LoggerAdapter:
+    """Add an adapter to a logger."""
+
+    class CustomAdapter(LoggerAdapter):
+        @override
+        def process(
+            self, msg: str, kwargs: MutableMapping[str, Any]
+        ) -> tuple[str, MutableMapping[str, Any]]:
+            extra = cast("_ArgsAndKwargs", self.extra)
+            new_msg = process(msg, *extra["args"], **extra["kwargs"])
+            return new_msg, kwargs
+
+    return CustomAdapter(logger, extra=_ArgsAndKwargs(args=args, kwargs=kwargs))
+
+
+class _ArgsAndKwargs(TypedDict):
+    args: tuple[Any, ...]
+    kwargs: StrMapping
+
+
+##
+
+
 def add_filters(handler: Handler, /, *filters: _FilterType) -> None:
     """Add a set of filters to a handler."""
     for filter_i in filters:
@@ -84,8 +118,10 @@ def add_filters(handler: Handler, /, *filters: _FilterType) -> None:
 
 def basic_config(
     *,
-    obj: LoggerOrName | Handler | None = None,
-    format_: str = _DEFAULT_FORMAT,
+    obj: LoggerLike | Handler | None = None,
+    format_: str | None = None,
+    prefix: str | None = None,
+    hostname: bool = False,
     datefmt: str = _DEFAULT_DATEFMT,
     level: LogLevel = "INFO",
     filters: MaybeIterable[_FilterType] | None = None,
@@ -95,13 +131,19 @@ def basic_config(
     """Do the basic config."""
     match obj:
         case None:
-            basicConfig(format=format_, datefmt=datefmt, style="{", level=level)
+            if format_ is None:
+                format_use = get_format_str(prefix=prefix, hostname=hostname)
+            else:
+                format_use = format_
+            basicConfig(format=format_use, datefmt=datefmt, style="{", level=level)
         case Logger() as logger:
             logger.setLevel(level)
             logger.addHandler(handler := StreamHandler())
             basic_config(
                 obj=handler,
                 format_=format_,
+                prefix=prefix,
+                hostname=hostname,
                 datefmt=datefmt,
                 level=level,
                 filters=filters,
@@ -110,8 +152,10 @@ def basic_config(
             )
         case str() as name:
             basic_config(
-                obj=get_logger(logger=name),
+                obj=to_logger(name),
                 format_=format_,
+                prefix=prefix,
+                hostname=hostname,
                 datefmt=datefmt,
                 level=level,
                 filters=filters,
@@ -123,50 +167,32 @@ def basic_config(
             if filters is not None:
                 add_filters(handler, *always_iterable(filters))
             formatter = get_formatter(
+                prefix=prefix,
                 format_=format_,
+                hostname=hostname,
                 datefmt=datefmt,
                 plain=plain,
                 color_field_styles=color_field_styles,
             )
             handler.setFormatter(formatter)
-        case _ as never:
+        case never:
             assert_never(never)
 
 
 ##
 
 
-def filter_for_key(
-    key: str, /, *, default: bool = False
-) -> Callable[[LogRecord], bool]:
-    """Make a filter for a given attribute."""
-    if (key in _FILTER_FOR_KEY_BLACKLIST) or key.startswith("__"):
-        raise FilterForKeyError(key=key)
-
-    def filter_(record: LogRecord, /) -> bool:
-        try:
-            value = getattr(record, key)
-        except AttributeError:
-            return default
-        return bool(value)
-
-    return filter_
-
-
-# fmt: off
-_FILTER_FOR_KEY_BLACKLIST = {
-    "args", "created", "exc_info", "exc_text", "filename", "funcName", "getMessage", "levelname", "levelno", "lineno", "module", "msecs", "msg", "name", "pathname", "process", "processName", "relativeCreated", "stack_info", "taskName", "thread", "threadName"
-}
-# fmt: on
-
-
-@dataclass(kw_only=True, slots=True)
-class FilterForKeyError(Exception):
-    key: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid key: {self.key!r}"
+def get_format_str(*, prefix: str | None = None, hostname: bool = False) -> str:
+    """Generate a format string."""
+    parts: list[str] = [
+        "{zoned_datetime}",
+        f"{gethostname()}:{{process}}" if hostname else "{process}",
+        "{name}:{funcName}:{lineno}",
+        "{levelname}",
+        "{message}",
+    ]
+    joined = " | ".join(parts)
+    return joined if prefix is None else f"{prefix} {joined}"
 
 
 ##
@@ -184,7 +210,9 @@ class _FieldStyleDict(TypedDict):
 
 def get_formatter(
     *,
-    format_: str = _DEFAULT_FORMAT,
+    format_: str | None = None,
+    prefix: str | None = None,
+    hostname: bool = False,
     datefmt: str = _DEFAULT_DATEFMT,
     plain: bool = False,
     color_field_styles: Mapping[str, _FieldStyleKeys] | None = None,
@@ -192,40 +220,44 @@ def get_formatter(
     """Get the formatter; colored if available."""
     setLogRecordFactory(WheneverLogRecord)
     if plain:
-        return _get_plain_formatter(format_=format_, datefmt=datefmt)
+        return _get_plain_formatter(
+            format_=format_, prefix=prefix, hostname=hostname, datefmt=datefmt
+        )
     try:
         from coloredlogs import DEFAULT_FIELD_STYLES, ColoredFormatter
     except ModuleNotFoundError:  # pragma: no cover
-        return _get_plain_formatter(format_=format_, datefmt=datefmt)
+        return _get_plain_formatter(
+            format_=format_, prefix=prefix, hostname=hostname, datefmt=datefmt
+        )
+    format_use = (
+        get_format_str(prefix=prefix, hostname=hostname) if format_ is None else format_
+    )
     default = cast("dict[_FieldStyleKeys, _FieldStyleDict]", DEFAULT_FIELD_STYLES)
     field_styles = {cast("str", k): v for k, v in default.items()}
     field_styles["zoned_datetime"] = default["asctime"]
+    field_styles["hostname"] = default["hostname"]
+    field_styles["process"] = default["hostname"]
+    field_styles["lineno"] = default["name"]
+    field_styles["funcName"] = default["name"]
     if color_field_styles is not None:
         field_styles.update({k: default[v] for k, v in color_field_styles.items()})
     return ColoredFormatter(
-        fmt=format_, datefmt=datefmt, style="{", field_styles=field_styles
+        fmt=format_use, datefmt=datefmt, style="{", field_styles=field_styles
     )
 
 
 def _get_plain_formatter(
-    *, format_: str = _DEFAULT_FORMAT, datefmt: str = _DEFAULT_DATEFMT
+    *,
+    format_: str | None = None,
+    prefix: str | None = None,
+    hostname: bool = False,
+    datefmt: str = _DEFAULT_DATEFMT,
 ) -> Formatter:
     """Get the plain formatter."""
-    return Formatter(fmt=format_, datefmt=datefmt, style="{")
-
-
-##
-
-
-def get_logger(*, logger: LoggerOrName | None = None) -> Logger:
-    """Get a logger."""
-    match logger:
-        case Logger():
-            return logger
-        case str() | None:
-            return getLogger(logger)
-        case _ as never:
-            assert_never(never)
+    format_use = (
+        get_format_str(prefix=prefix, hostname=hostname) if format_ is None else format_
+    )
+    return Formatter(fmt=format_use, datefmt=datefmt, style="{")
 
 
 ##
@@ -254,13 +286,13 @@ class GetLoggingLevelNumberError(Exception):
 
 def setup_logging(
     *,
-    logger: LoggerOrName | None = None,
-    format_: str = _DEFAULT_FORMAT,
+    logger: LoggerLike | None = None,
+    format_: str | None = None,
     datefmt: str = _DEFAULT_DATEFMT,
     console_level: LogLevel = "INFO",
     console_prefix: str = "❯",  # noqa: RUF001
     console_filters: MaybeIterable[_FilterType] | None = None,
-    files_dir: MaybeCallablePathLike | None = None,
+    files_dir: MaybeCallablePathLike = Path.cwd,
     files_max_bytes: int = _DEFAULT_MAX_BYTES,
     files_when: _When = _DEFAULT_WHEN,
     files_interval: int = 1,
@@ -270,20 +302,20 @@ def setup_logging(
     """Set up logger."""
     basic_config(
         obj=logger,
-        format_=f"{console_prefix} {format_}",
+        prefix=console_prefix,
+        format_=format_,
         datefmt=datefmt,
         level=console_level,
         filters=console_filters,
     )
-    logger_use = get_logger(logger=logger)
+    logger_use = to_logger(logger)
     name = logger_use.name
-    dir_ = get_path(path=files_dir)
     levels: list[LogLevel] = ["DEBUG", "INFO", "ERROR"]
     for level in levels:
         lower = level.lower()
         for stem in [lower, f"{name}-{lower}"]:
             handler = SizeAndTimeRotatingFileHandler(
-                dir_.joinpath(stem).with_suffix(".txt"),
+                to_path(files_dir).joinpath(stem).with_suffix(".txt"),
                 maxBytes=files_max_bytes,
                 when=files_when,
                 interval=files_interval,
@@ -293,6 +325,7 @@ def setup_logging(
             basic_config(
                 obj=handler,
                 format_=format_,
+                hostname=True,
                 datefmt=datefmt,
                 level=level,
                 filters=files_filters,
@@ -354,9 +387,7 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
     def emit(self, record: LogRecord) -> None:
         try:
             if (self._backup_count is not None) and self._should_rollover(record):
-                self._do_rollover(  # skipif-ci-and-windows
-                    backup_count=self._backup_count
-                )
+                self._do_rollover(backup_count=self._backup_count)
             FileHandler.emit(self, record)
         except Exception:  # noqa: BLE001  # pragma: no cover
             self.handleError(record)
@@ -366,23 +397,23 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
             self.stream.close()
             self.stream = None
 
-        actions = _compute_rollover_actions(  # skipif-ci-and-windows
+        actions = _compute_rollover_actions(
             self._directory,
             self._stem,
             self._suffix,
             patterns=self._patterns,
             backup_count=backup_count,
         )
-        actions.do()  # skipif-ci-and-windows
+        actions.do()
 
         if not self.delay:  # pragma: no cover
             self.stream = self._open()
-        self._time_handler.rolloverAt = (  # skipif-ci-and-windows
-            self._time_handler.computeRollover(get_now().timestamp())
+        self._time_handler.rolloverAt = self._time_handler.computeRollover(
+            get_now_local().timestamp()
         )
 
     def _should_rollover(self, record: LogRecord, /) -> bool:
-        if self._max_bytes is not None:  # skipif-ci-and-windows
+        if self._max_bytes is not None:
             try:
                 size = self._filename.stat().st_size
             except FileNotFoundError:
@@ -390,14 +421,14 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
             else:
                 if size >= self._max_bytes:
                     return True
-        return bool(self._time_handler.shouldRollover(record))  # skipif-ci-and-windows
+        return bool(self._time_handler.shouldRollover(record))
 
 
 def _compute_rollover_patterns(stem: str, suffix: str, /) -> _RolloverPatterns:
     return _RolloverPatterns(
         pattern1=re.compile(rf"^{stem}\.(\d+){suffix}$"),
-        pattern2=re.compile(rf"^{stem}\.(\d+)__([\dT]+?){suffix}$"),
-        pattern3=re.compile(rf"^{stem}\.(\d+)__([\dT]+?)__([\dT]+?){suffix}$"),
+        pattern2=re.compile(rf"^{stem}\.(\d+)__(.+?){suffix}$"),
+        pattern3=re.compile(rf"^{stem}\.(\d+)__(.+?)__(.+?){suffix}$"),
     )
 
 
@@ -497,10 +528,8 @@ class _RotatingLogFile:
                 stem=stem,
                 suffix=suffix,
                 index=int(index),
-                start=PlainDateTime.parse_common_iso(start).assume_tz(
-                    LOCAL_TIME_ZONE_NAME
-                ),
-                end=PlainDateTime.parse_common_iso(end).assume_tz(LOCAL_TIME_ZONE_NAME),
+                start=to_zoned_date_time(start),
+                end=to_zoned_date_time(end),
             )
         try:
             index, end = extract_groups(patterns.pattern2, path.name)
@@ -512,7 +541,7 @@ class _RotatingLogFile:
                 stem=stem,
                 suffix=suffix,
                 index=int(index),
-                end=PlainDateTime.parse_common_iso(end).assume_tz(LOCAL_TIME_ZONE_NAME),
+                end=to_zoned_date_time(end),
             )
         try:
             index = extract_group(patterns.pattern1, path.name)
@@ -533,9 +562,9 @@ class _RotatingLogFile:
             case int() as index, None, None:
                 tail = str(index)
             case int() as index, None, ZonedDateTime() as end:
-                tail = f"{index}__{format_compact(end)}"
+                tail = f"{index}__{format_compact(end, path=True)}"
             case int() as index, ZonedDateTime() as start, ZonedDateTime() as end:
-                tail = f"{index}__{format_compact(start)}__{format_compact(end)}"
+                tail = f"{index}__{format_compact(start, path=True)}__{format_compact(end, path=True)}"
             case _:  # pragma: no cover
                 raise ImpossibleCaseError(
                     case=[f"{self.index=}", f"{self.start=}", f"{self.end=}"]
@@ -573,14 +602,28 @@ class _Rotation:
         return self.file.replace(index=self.index, start=self.start, end=self.end).path
 
 
+##
+
+
+def to_logger(logger: LoggerLike | None = None, /) -> Logger:
+    """Convert to a logger."""
+    match logger:
+        case Logger():
+            return logger
+        case str() | None:
+            return getLogger(logger)
+        case never:
+            assert_never(never)
+
+
 __all__ = [
-    "FilterForKeyError",
     "GetLoggingLevelNumberError",
     "SizeAndTimeRotatingFileHandler",
+    "add_adapter",
     "add_filters",
     "basic_config",
-    "filter_for_key",
-    "get_logger",
+    "get_format_str",
     "get_logging_level_number",
     "setup_logging",
+    "to_logger",
 ]

utilities/math.py

@@ -641,7 +641,10 @@ def _is_close(
 ##
 
 
-def number_of_decimals(x: float, /, *, max_decimals: int = 20) -> int:
+MAX_DECIMALS = 10
+
+
+def number_of_decimals(x: float, /, *, max_decimals: int = MAX_DECIMALS) -> int:
     """Get the number of decimals."""
     _, frac = divmod(x, 1)
     results = (
@@ -731,7 +734,7 @@ def round_(
                     return 0
                 case -1:
                     return floor(x)
-                case _ as never:
+                case never:
                     assert_never(never)
         case "standard-tie-floor":
             return _round_tie_standard(x, "floor", rel_tol=rel_tol, abs_tol=abs_tol)
@@ -743,7 +746,7 @@ def round_(
             )
         case "standard-tie-away-zero":
             return _round_tie_standard(x, "away-zero", rel_tol=rel_tol, abs_tol=abs_tol)
-        case _ as never:
+        case never:
             assert_never(never)
 
 
@@ -876,7 +879,7 @@ def sign(
             if is_negative(x, rel_tol=rel_tol, abs_tol=abs_tol):
                 return -1
             return 0
-        case _ as never:
+        case never:
             assert_never(never)
 
 
@@ -889,6 +892,7 @@ def significant_figures(x: float, /, *, n: int = 2) -> str:
 
 
 __all__ = [
+    "MAX_DECIMALS",
     "MAX_FLOAT32",
     "MAX_FLOAT64",
     "MAX_INT8",

utilities/more_itertools.py

@@ -21,57 +21,66 @@ from more_itertools import peekable as _peekable
 from utilities.functions import get_class_name
 from utilities.iterables import OneNonUniqueError, one
 from utilities.reprlib import get_repr
-from utilities.sentinel import Sentinel, sentinel
+from utilities.sentinel import Sentinel, is_sentinel, sentinel
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Mapping, Sequence
 
 
 @overload
-def bucket_mapping[T, U, UH: Hashable](
+def bucket_mapping[T, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: Callable[[T], U],
+    pre: None = None,
+    post: None = None,
+) -> Mapping[UH, Iterator[T]]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
     post: Literal["list"],
-) -> Mapping[UH, list[U]]: ...
+) -> Mapping[UH, list[T]]: ...
 @overload
-def bucket_mapping[T, U, UH: Hashable](
+def bucket_mapping[T, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: Callable[[T], U],
+    pre: None = None,
     post: Literal["tuple"],
-) -> Mapping[UH, tuple[U, ...]]: ...
+) -> Mapping[UH, tuple[T, ...]]: ...
 @overload
-def bucket_mapping[T, U, UH: Hashable](
+def bucket_mapping[T, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: Callable[[T], U],
+    pre: None = None,
     post: Literal["set"],
-) -> Mapping[UH, set[U]]: ...
+) -> Mapping[UH, set[T]]: ...
 @overload
-def bucket_mapping[T, U, UH: Hashable](
+def bucket_mapping[T, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: Callable[[T], U],
+    pre: None = None,
     post: Literal["frozenset"],
-) -> Mapping[UH, frozenset[U]]: ...
+) -> Mapping[UH, frozenset[T]]: ...
 @overload
-def bucket_mapping[T, U, UH: Hashable](
+def bucket_mapping[T, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: Callable[[T], U] | None = None,
+    pre: None = None,
     post: Literal["unique"],
-) -> Mapping[UH, U]: ...
+) -> Mapping[UH, T]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
@@ -82,59 +91,50 @@ def bucket_mapping[T, U, UH: Hashable](
     post: None = None,
 ) -> Mapping[UH, Iterator[U]]: ...
 @overload
-def bucket_mapping[T, UH: Hashable](
+def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: None = None,
+    pre: Callable[[T], U],
     post: Literal["list"],
-) -> Mapping[UH, list[T]]: ...
+) -> Mapping[UH, list[U]]: ...
 @overload
-def bucket_mapping[T, UH: Hashable](
+def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: None = None,
+    pre: Callable[[T], U],
     post: Literal["tuple"],
-) -> Mapping[UH, tuple[T, ...]]: ...
+) -> Mapping[UH, tuple[U, ...]]: ...
 @overload
-def bucket_mapping[T, UH: Hashable](
+def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: None = None,
+    pre: Callable[[T], U],
     post: Literal["set"],
-) -> Mapping[UH, set[T]]: ...
+) -> Mapping[UH, set[U]]: ...
 @overload
-def bucket_mapping[T, UH: Hashable](
+def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: None = None,
+    pre: Callable[[T], U],
     post: Literal["frozenset"],
-) -> Mapping[UH, frozenset[T]]: ...
+) -> Mapping[UH, frozenset[U]]: ...
 @overload
-def bucket_mapping[T, UH: Hashable](
+def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    pre: None = None,
+    pre: Callable[[T], U] | None = None,
     post: Literal["unique"],
-) -> Mapping[UH, T]: ...
-@overload
-def bucket_mapping[T, UH: Hashable](
-    iterable: Iterable[T],
-    func: Callable[[T], UH],
-    /,
-    *,
-    pre: None = None,
-    post: None = None,
-) -> Mapping[UH, Iterator[T]]: ...
+) -> Mapping[UH, U]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
@@ -206,7 +206,7 @@ def bucket_mapping[T, U, UH: Hashable](
             return {k: frozenset(map(pre, v)) for k, v in mapping.items()}
         case Callable(), "unique":
             return _bucket_mapping_unique({k: map(pre, v) for k, v in mapping.items()})
-        case _ as never:
+        case never:
             assert_never(never)
 
 
@@ -290,9 +290,7 @@ class peekable[T](_peekable):  # noqa: N801
     def peek[U](self, *, default: U) -> T | U: ...
     @override
     def peek(self, *, default: Any = sentinel) -> Any:  # pyright: ignore[reportIncompatibleMethodOverride]
-        if isinstance(default, Sentinel):
-            return super().peek()
-        return super().peek(default=default)
+        return super().peek() if is_sentinel(default) else super().peek(default=default)
 
     def takewhile(self, predicate: Callable[[T], bool], /) -> Iterator[T]:
         while bool(self) and predicate(self.peek()):
@@ -374,7 +372,7 @@ def _yield_splits2[T](
                 len_tail = max(len_win - head, 0)
                 if len_tail >= 1:
                     yield window, head, len_tail
-            case _ as never:
+            case never:
                 assert_never(never)