dycw-utilities 0.175.17__py3-none-any.whl → 0.185.8__py3-none-any.whl

utilities/jinja2.py

@@ -9,7 +9,6 @@ from jinja2.defaults import (
     BLOCK_START_STRING,
     COMMENT_END_STRING,
     COMMENT_START_STRING,
-    KEEP_TRAILING_NEWLINE,
     LINE_COMMENT_PREFIX,
     LINE_STATEMENT_PREFIX,
     LSTRIP_BLOCKS,
@@ -19,8 +18,7 @@ from jinja2.defaults import (
     VARIABLE_START_STRING,
 )
 
-from utilities.atomicwrites import writer
-from utilities.text import kebab_case, pascal_case, snake_case
+from utilities.core import kebab_case, pascal_case, snake_case, write_text
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
@@ -48,7 +46,7 @@ class EnhancedEnvironment(Environment):
         trim_blocks: bool = TRIM_BLOCKS,
         lstrip_blocks: bool = LSTRIP_BLOCKS,
         newline_sequence: Literal["\n", "\r\n", "\r"] = NEWLINE_SEQUENCE,
-        keep_trailing_newline: bool = KEEP_TRAILING_NEWLINE,
+        keep_trailing_newline: bool = True,
         extensions: Sequence[str | type[Extension]] = (),
         optimized: bool = True,
         undefined: type[Undefined] = Undefined,
@@ -108,8 +106,7 @@ class TemplateJob:
         """Run the job."""
         match self.mode:
             case "write":
-                with writer(self.target, overwrite=True) as temp:
-                    _ = temp.write_text(self.rendered)
+                write_text(self.target, self.rendered, overwrite=True)
             case "append":
                 with self.target.open(mode="a") as fh:
                     _ = fh.write(self.rendered)

utilities/jupyter.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 from contextlib import ExitStack
 from dataclasses import dataclass, field, replace
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Self
+from typing import TYPE_CHECKING, Self
 
 from utilities.ipython import check_ipython_class
 
 if TYPE_CHECKING:
     from types import TracebackType
 
+    from utilities.types import StrDict
+
 
 def is_jupyter() -> bool:
     """Check if `jupyter` is running."""
@@ -55,7 +57,7 @@ class _Show:
         except ModuleNotFoundError:  # pragma: no cover
             pass
         else:
-            kwargs: dict[str, Any] = {}
+            kwargs: StrDict = {}
             if self.dp is not None:
                 kwargs["display.precision"] = self.dp
             if self.rows is not None:
@@ -72,7 +74,7 @@ class _Show:
         except ModuleNotFoundError:  # pragma: no cover
             pass
         else:
-            kwargs: dict[str, Any] = {}
+            kwargs: StrDict = {}
             if self.dp is not None:
                 kwargs["float_precision"] = self.dp
             if self.rows is not None:

utilities/libcst.py

@@ -72,7 +72,7 @@ class GenerateImportFromError(Exception):
 ##
 
 
-@dataclass(kw_only=True, slots=True)
+@dataclass(order=True, unsafe_hash=True, kw_only=True, slots=True)
 class _ParseImportOutput:
     module: str
     name: str | None = None

utilities/lightweight_charts.py

@@ -3,10 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, override
 
-from utilities.atomicwrites import writer  # pragma: no cover
 from utilities.contextlib import enhanced_async_context_manager
-from utilities.iterables import OneEmptyError, OneNonUniqueError, one
-from utilities.reprlib import get_repr
+from utilities.core import OneEmptyError, OneNonUniqueError, one, repr_, write_bytes
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
@@ -25,8 +23,8 @@ if TYPE_CHECKING:
 def save_chart(chart: Chart, path: PathLike, /, *, overwrite: bool = False) -> None:
     """Atomically save a chart to disk."""
     chart.show(block=False)  # pragma: no cover
-    with writer(path, overwrite=overwrite) as temp:  # pragma: no cover
-        _ = temp.write_bytes(chart.screenshot())
+    data = chart.screenshot()  # pragma: no cover
+    write_bytes(path, data, overwrite=overwrite)  # pragma: no cover
     chart.exit()  # pragma: no cover
 
 
@@ -72,7 +70,7 @@ class _SetDataFrameNonUniqueError(SetDataFrameError):
 
     @override
     def __str__(self) -> str:
-        return f"{get_repr(self.schema)} must contain exactly 1 date/datetime column; got {self.first!r}, {self.second!r} and perhaps more"
+        return f"{repr_(self.schema)} must contain exactly 1 date/datetime column; got {self.first!r}, {self.second!r} and perhaps more"
 
 
 ##

utilities/logging.py

@@ -35,24 +35,23 @@ from typing import (
 
 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, to_path
-from utilities.re import (
+from utilities.constants import SECOND, Sentinel, sentinel
+from utilities.core import (
     ExtractGroupError,
     ExtractGroupsError,
+    OneEmptyError,
+    always_iterable,
     extract_group,
     extract_groups,
-)
-from utilities.sentinel import Sentinel, sentinel
-from utilities.whenever import (
-    WheneverLogRecord,
-    format_compact,
     get_now_local,
-    to_zoned_date_time,
+    move_many,
+    one,
+    replace_non_sentinel,
 )
+from utilities.errors import ImpossibleCaseError
+from utilities.functions import in_seconds
+from utilities.pathlib import ensure_suffix, to_path
+from utilities.whenever import WheneverLogRecord, format_compact, to_zoned_date_time
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Mapping, MutableMapping
@@ -60,6 +59,7 @@ if TYPE_CHECKING:
     from logging import _FilterType
 
     from utilities.types import (
+        Duration,
         LoggerLike,
         LogLevel,
         MaybeCallablePathLike,
@@ -356,7 +356,7 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
         errors: Literal["strict", "ignore", "replace"] | None = None,
         maxBytes: int = _DEFAULT_MAX_BYTES,
         when: _When = _DEFAULT_WHEN,
-        interval: int = 1,
+        interval: Duration = SECOND,
         backupCount: int = _DEFAULT_BACKUP_COUNT,
         utc: bool = False,
         atTime: time | None = None,
@@ -374,7 +374,7 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
         self._time_handler = TimedRotatingFileHandler(
             path,
             when=when,
-            interval=interval,
+            interval=cast("Any", in_seconds(interval)),  # float is OK
             backupCount=backupCount,
             encoding=encoding,
             delay=delay,
@@ -492,7 +492,9 @@ class _RolloverActions:
     def do(self) -> None:
         for deletion in self.deletions:
             deletion.delete()
-        move_many(*((r.file.path, r.destination) for r in self.rotations))
+        move_many(
+            *((r.file.path, r.destination) for r in self.rotations), overwrite=True
+        )
 
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)

utilities/math.py

@@ -7,28 +7,13 @@ from math import ceil, exp, floor, isclose, isfinite, isinf, isnan, log, log10,
 from re import Match, search
 from typing import TYPE_CHECKING, Literal, assert_never, overload, override
 
+from utilities.core import ExtractGroupsError, extract_groups
 from utilities.errors import ImpossibleCaseError
-from utilities.re import ExtractGroupsError, extract_groups
 
 if TYPE_CHECKING:
     from utilities.types import MathRoundMode, Number, Sign
 
 
-MIN_FLOAT32, MAX_FLOAT32 = -3.4028234663852886e38, 3.4028234663852886e38
-MIN_FLOAT64, MAX_FLOAT64 = -1.7976931348623157e308, 1.7976931348623157e308
-MIN_INT8, MAX_INT8 = -(2 ** (8 - 1)), 2 ** (8 - 1) - 1
-MIN_INT16, MAX_INT16 = -(2 ** (16 - 1)), 2 ** (16 - 1) - 1
-MIN_INT32, MAX_INT32 = -(2 ** (32 - 1)), 2 ** (32 - 1) - 1
-MIN_INT64, MAX_INT64 = -(2 ** (64 - 1)), 2 ** (64 - 1) - 1
-MIN_UINT8, MAX_UINT8 = 0, 2**8 - 1
-MIN_UINT16, MAX_UINT16 = 0, 2**16 - 1
-MIN_UINT32, MAX_UINT32 = 0, 2**32 - 1
-MIN_UINT64, MAX_UINT64 = 0, 2**64 - 1
-
-
-##
-
-
 def check_integer(
     n: int,
     /,
@@ -893,26 +878,6 @@ def significant_figures(x: float, /, *, n: int = 2) -> str:
 
 __all__ = [
     "MAX_DECIMALS",
-    "MAX_FLOAT32",
-    "MAX_FLOAT64",
-    "MAX_INT8",
-    "MAX_INT16",
-    "MAX_INT32",
-    "MAX_INT64",
-    "MAX_UINT8",
-    "MAX_UINT16",
-    "MAX_UINT32",
-    "MAX_UINT64",
-    "MIN_FLOAT32",
-    "MIN_FLOAT64",
-    "MIN_INT8",
-    "MIN_INT16",
-    "MIN_INT32",
-    "MIN_INT64",
-    "MIN_UINT8",
-    "MIN_UINT16",
-    "MIN_UINT32",
-    "MIN_UINT64",
     "CheckIntegerError",
     "EWMParametersError",
     "ParseNumberError",

utilities/more_itertools.py

@@ -18,10 +18,8 @@ from typing import (
 from more_itertools import bucket, partition, split_into
 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, is_sentinel, sentinel
+from utilities.constants import Sentinel, sentinel
+from utilities.core import OneNonUniqueError, get_class_name, is_sentinel, one, repr_
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Mapping, Sequence
@@ -232,7 +230,7 @@ class BucketMappingError[K: Hashable, V](Exception):
     @override
     def __str__(self) -> str:
         parts = [
-            f"{get_repr(key)} (#1: {get_repr(first)}, #2: {get_repr(second)})"
+            f"{repr_(key)} (#1: {repr_(first)}, #2: {repr_(second)})"
             for key, (first, second) in self.errors.items()
         ]
         desc = ", ".join(parts)
@@ -316,7 +314,7 @@ class Split[T]:
         tail_first = indent("tail=", spaces)
         tail_rest = indent(repr(self.tail), 2 * spaces)
         joined = f"{head_first}\n{head_rest}\n{tail_first}\n{tail_rest}"
-        return f"{cls}(\n{joined}\n)"
+        return f"{cls}(\n{joined}\n)\n"
 
 
 def yield_splits[T](

utilities/numpy.py

@@ -39,7 +39,8 @@ from numpy.linalg import det, eig
 from numpy.random import default_rng
 from numpy.typing import NDArray
 
-from utilities.iterables import always_iterable, is_iterable_not_str
+from utilities.core import always_iterable
+from utilities.iterables import is_iterable_not_str
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable

utilities/operator.py

@@ -6,8 +6,8 @@ from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, cast, override
 
 import utilities.math
+from utilities.core import repr_
 from utilities.iterables import SortIterableError, sort_iterable
-from utilities.reprlib import get_repr
 from utilities.typing import is_dataclass_instance
 
 if TYPE_CHECKING:
@@ -109,7 +109,7 @@ class IsEqualError(Exception):
 
     @override
     def __str__(self) -> str:
-        return f"Unable to sort {get_repr(self.x)} and {get_repr(self.y)}"  # pragma: no cover
+        return f"Unable to sort {repr_(self.x)} and {repr_(self.y)}"  # pragma: no cover
 
 
 __all__ = ["IsEqualError", "is_equal"]

utilities/orjson.py

@@ -37,23 +37,15 @@ from whenever import (
 )
 
 from utilities.concurrent import concurrent_map
+from utilities.constants import LOCAL_TIME_ZONE, MAX_INT64, MIN_INT64
+from utilities.core import OneEmptyError, always_iterable, one, read_bytes, write_bytes
 from utilities.dataclasses import dataclass_to_dict
 from utilities.functions import ensure_class
-from utilities.gzip import read_binary
-from utilities.iterables import (
-    OneEmptyError,
-    always_iterable,
-    merge_sets,
-    one,
-    one_unique,
-)
-from utilities.json import write_formatted_json
+from utilities.iterables import merge_sets
 from utilities.logging import get_logging_level_number
-from utilities.math import MAX_INT64, MIN_INT64
 from utilities.types import Dataclass, LogLevel, MaybeIterable, PathLike, StrMapping
-from utilities.typing import is_string_mapping
-from utilities.tzlocal import LOCAL_TIME_ZONE
-from utilities.version import Version, parse_version
+from utilities.typing import is_str_mapping
+from utilities.version import Version2, Version3
 from utilities.whenever import (
     DatePeriod,
     TimePeriod,
@@ -99,7 +91,8 @@ class _Prefixes(StrEnum):
     tuple_ = "tu"
     unserializable = "un"
     uuid = "uu"
-    version = "v"
+    version2 = "v2"
+    version3 = "v3"
     year_month = "ym"
     zoned_date_time = "zd"
     zoned_date_time_period = "zp"
@@ -213,8 +206,10 @@ def _pre_process(
             return f"[{_Prefixes.exception_class.value}|{error_cls.__qualname__}]"
         case UUID() as uuid:
             return f"[{_Prefixes.uuid.value}]{uuid}"
-        case Version() as version:
-            return f"[{_Prefixes.version.value}]{version}"
+        case Version2() as version:
+            return f"[{_Prefixes.version2.value}]{version}"
+        case Version3() as version:
+            return f"[{_Prefixes.version3.value}]{version}"
         case YearMonth() as year_month:
             return f"[{_Prefixes.year_month.value}]{year_month}"
         case ZonedDateTime() as date_time:
@@ -409,7 +404,8 @@ class DeerializeError(Exception):
     _TIME_DELTA_PATTERN,
     _TIME_PERIOD_PATTERN,
     _UUID_PATTERN,
-    _VERSION_PATTERN,
+    _VERSION2_PATTERN,
+    _VERSION3_PATTERN,
     _YEAR_MONTH_PATTERN,
     _ZONED_DATE_TIME_PATTERN,
     _ZONED_DATE_TIME_PERIOD_PATTERN,
@@ -433,7 +429,8 @@ class DeerializeError(Exception):
         _Prefixes.time_delta,
         _Prefixes.time_period,
         _Prefixes.uuid,
-        _Prefixes.version,
+        _Prefixes.version2,
+        _Prefixes.version3,
         _Prefixes.year_month,
         _Prefixes.zoned_date_time,
         _Prefixes.zoned_date_time_period,
@@ -514,8 +511,10 @@ def _object_hook(
                 return TimePeriod(start, end)
             if match := _UUID_PATTERN.search(text):
                 return UUID(match.group(1))
-            if match := _VERSION_PATTERN.search(text):
-                return parse_version(match.group(1))
+            if match := _VERSION2_PATTERN.search(text):
+                return Version2.parse(match.group(1))
+            if match := _VERSION3_PATTERN.search(text):
+                return Version3.parse(match.group(1))
             if match := _YEAR_MONTH_PATTERN.search(text):
                 return YearMonth.parse_iso(match.group(1))
             if match := _ZONED_DATE_TIME_PATTERN.search(text):
@@ -566,7 +565,7 @@ def _object_hook(
                     ) is not None:
                         return container
                 if (
-                    is_string_mapping(value)
+                    is_str_mapping(value)
                     and (
                         dataclass := _object_hook_dataclass(
                             key,
@@ -587,7 +586,7 @@ def _object_hook(
                 ) is not None:
                     return enum
                 if (
-                    is_string_mapping(value)
+                    is_str_mapping(value)
                     and (
                         exc_instance := _object_hook_exception_instance(
                             key, value, data=data, objects=objects, redirects=redirects
@@ -953,7 +952,7 @@ class GetLogRecordsOutput:
             for r in self.records
         ]
         if len(records) >= 1:
-            time_zone = one_unique(ZoneInfo(r.datetime.tz) for r in records)
+            time_zone = one({ZoneInfo(r.datetime.tz) for r in records})
         else:
             time_zone = LOCAL_TIME_ZONE
         return DataFrame(
@@ -1263,7 +1262,7 @@ def read_object(
     redirects: Mapping[str, type[Any]] | None = None,
 ) -> Any:
     """Read an object from disk."""
-    data = read_binary(path, decompress=decompress)
+    data = read_bytes(path, decompress=decompress)
     return deserialize(
         data, dataclass_hook=dataclass_hook, objects=objects, redirects=redirects
     )
@@ -1293,7 +1292,7 @@ def write_object(
         dataclass_hook=dataclass_hook,
         dataclass_defaults=dataclass_defaults,
     )
-    write_formatted_json(data, path, compress=compress, overwrite=overwrite)
+    write_bytes(path, data, compress=compress, overwrite=overwrite, json=True)
 
 
 __all__ = [

utilities/os.py

@@ -1,43 +1,12 @@
 from __future__ import annotations
 
-from contextlib import suppress
 from dataclasses import dataclass
-from os import cpu_count, environ, getenv
-from typing import TYPE_CHECKING, Literal, assert_never, overload, override
+from typing import TYPE_CHECKING, assert_never, override
 
-from utilities.contextlib import enhanced_context_manager
-from utilities.iterables import OneStrEmptyError, one_str
-from utilities.platform import SYSTEM
+from utilities.constants import CPU_COUNT
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator, Mapping
-
-
-type IntOrAll = int | Literal["all"]
-
-
-##
-
-
-def get_cpu_count() -> int:
-    """Get the CPU count."""
-    count = cpu_count()
-    if count is None:  # pragma: no cover
-        raise GetCPUCountError
-    return count
-
-
-@dataclass(kw_only=True, slots=True)
-class GetCPUCountError(Exception):
-    @override
-    def __str__(self) -> str:
-        return "CPU count must not be None"  # pragma: no cover
-
-
-CPU_COUNT = get_cpu_count()
-
-
-##
+    from utilities.types import IntOrAll
 
 
 def get_cpu_use(*, n: IntOrAll = "all") -> int:
@@ -62,154 +31,4 @@ class GetCPUUseError(Exception):
         return f"Invalid number of CPUs to use: {self.n}"
 
 
-##
-
-
-@overload
-def get_env_var(
-    key: str, /, *, case_sensitive: bool = False, default: str, nullable: bool = False
-) -> str: ...
-@overload
-def get_env_var(
-    key: str,
-    /,
-    *,
-    case_sensitive: bool = False,
-    default: None = None,
-    nullable: Literal[False] = False,
-) -> str: ...
-@overload
-def get_env_var(
-    key: str,
-    /,
-    *,
-    case_sensitive: bool = False,
-    default: str | None = None,
-    nullable: bool = False,
-) -> str | None: ...
-def get_env_var(
-    key: str,
-    /,
-    *,
-    case_sensitive: bool = False,
-    default: str | None = None,
-    nullable: bool = False,
-) -> str | None:
-    """Get an environment variable."""
-    try:
-        key_use = one_str(environ, key, case_sensitive=case_sensitive)
-    except OneStrEmptyError:
-        match default, nullable:
-            case None, False:
-                raise GetEnvVarError(key=key, case_sensitive=case_sensitive) from None
-            case None, True:
-                return None
-            case str(), _:
-                return default
-            case never:
-                assert_never(never)
-    return environ[key_use]
-
-
-@dataclass(kw_only=True, slots=True)
-class GetEnvVarError(Exception):
-    key: str
-    case_sensitive: bool = False
-
-    @override
-    def __str__(self) -> str:
-        desc = f"No environment variable {self.key!r}"
-        return desc if self.case_sensitive else f"{desc} (modulo case)"
-
-
-##
-
-
-def get_effective_group_id() -> int | None:
-    """Get the effective group ID."""
-    match SYSTEM:
-        case "windows":  # skipif-not-windows
-            return None
-        case "mac" | "linux":  # skipif-windows
-            from os import getegid
-
-            return getegid()
-        case never:
-            assert_never(never)
-
-
-def get_effective_user_id() -> int | None:
-    """Get the effective user ID."""
-    match SYSTEM:
-        case "windows":  # skipif-not-windows
-            return None
-        case "mac" | "linux":  # skipif-windows
-            from os import geteuid
-
-            return geteuid()
-        case never:
-            assert_never(never)
-
-
-EFFECTIVE_USER_ID = get_effective_user_id()
-EFFECTIVE_GROUP_ID = get_effective_group_id()
-
-
-##
-
-
-def is_debug() -> bool:
-    """Check if we are in `DEBUG` mode."""
-    return get_env_var("DEBUG", nullable=True) is not None
-
-
-##
-
-
-def is_pytest() -> bool:
-    """Check if `pytest` is running."""
-    return get_env_var("PYTEST_VERSION", nullable=True) is not None
-
-
-##
-
-
-@enhanced_context_manager
-def temp_environ(
-    env: Mapping[str, str | None] | None = None, **env_kwargs: str | None
-) -> Iterator[None]:
-    """Context manager with temporary environment variable set."""
-    mapping: dict[str, str | None] = ({} if env is None else dict(env)) | env_kwargs
-    prev = {key: getenv(key) for key in mapping}
-
-    def apply(mapping: Mapping[str, str | None], /) -> None:
-        for key, value in mapping.items():
-            if value is None:
-                with suppress(KeyError):
-                    del environ[key]
-            else:
-                environ[key] = value
-
-    apply(mapping)
-    try:
-        yield
-    finally:
-        apply(prev)
-
-
-__all__ = [
-    "CPU_COUNT",
-    "EFFECTIVE_GROUP_ID",
-    "EFFECTIVE_USER_ID",
-    "GetCPUCountError",
-    "GetCPUUseError",
-    "IntOrAll",
-    "get_cpu_count",
-    "get_cpu_use",
-    "get_effective_group_id",
-    "get_effective_user_id",
-    "get_env_var",
-    "is_debug",
-    "is_pytest",
-    "temp_environ",
-]
+__all__ = ["GetCPUUseError", "get_cpu_use"]