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

utilities/jinja2.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, assert_never, override
+
+from jinja2 import BaseLoader, BytecodeCache, Environment, FileSystemLoader, Undefined
+from jinja2.defaults import (
+    BLOCK_END_STRING,
+    BLOCK_START_STRING,
+    COMMENT_END_STRING,
+    COMMENT_START_STRING,
+    LINE_COMMENT_PREFIX,
+    LINE_STATEMENT_PREFIX,
+    LSTRIP_BLOCKS,
+    NEWLINE_SEQUENCE,
+    TRIM_BLOCKS,
+    VARIABLE_END_STRING,
+    VARIABLE_START_STRING,
+)
+
+from utilities.core import kebab_case, pascal_case, snake_case, write_text
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pathlib import Path
+
+    from jinja2.ext import Extension
+
+    from utilities.types import StrMapping
+
+
+class EnhancedEnvironment(Environment):
+    """Environment with enhanced features."""
+
+    @override
+    def __init__(
+        self,
+        block_start_string: str = BLOCK_START_STRING,
+        block_end_string: str = BLOCK_END_STRING,
+        variable_start_string: str = VARIABLE_START_STRING,
+        variable_end_string: str = VARIABLE_END_STRING,
+        comment_start_string: str = COMMENT_START_STRING,
+        comment_end_string: str = COMMENT_END_STRING,
+        line_statement_prefix: str | None = LINE_STATEMENT_PREFIX,
+        line_comment_prefix: str | None = LINE_COMMENT_PREFIX,
+        trim_blocks: bool = TRIM_BLOCKS,
+        lstrip_blocks: bool = LSTRIP_BLOCKS,
+        newline_sequence: Literal["\n", "\r\n", "\r"] = NEWLINE_SEQUENCE,
+        keep_trailing_newline: bool = True,
+        extensions: Sequence[str | type[Extension]] = (),
+        optimized: bool = True,
+        undefined: type[Undefined] = Undefined,
+        finalize: Callable[..., Any] | None = None,
+        autoescape: bool | Callable[[str | None], bool] = False,
+        loader: BaseLoader | None = None,
+        cache_size: int = 400,
+        auto_reload: bool = True,
+        bytecode_cache: BytecodeCache | None = None,
+        enable_async: bool = False,
+    ) -> None:
+        super().__init__(
+            block_start_string,
+            block_end_string,
+            variable_start_string,
+            variable_end_string,
+            comment_start_string,
+            comment_end_string,
+            line_statement_prefix,
+            line_comment_prefix,
+            trim_blocks,
+            lstrip_blocks,
+            newline_sequence,
+            keep_trailing_newline,
+            extensions,
+            optimized,
+            undefined,
+            finalize,
+            autoescape,
+            loader,
+            cache_size,
+            auto_reload,
+            bytecode_cache,
+            enable_async,
+        )
+        self.filters["kebab"] = kebab_case
+        self.filters["pascal"] = pascal_case
+        self.filters["snake"] = snake_case
+
+
+@dataclass(order=True, unsafe_hash=True, kw_only=True, slots=True)
+class TemplateJob:
+    """A template with an associated rendering job."""
+
+    template: Path
+    kwargs: StrMapping
+    target: Path
+    mode: Literal["write", "append"] = "write"
+
+    def __post_init__(self) -> None:
+        if not self.template.exists():
+            raise _TemplateJobTemplateDoesNotExistError(path=self.template)
+        if (self.mode == "append") and not self.target.exists():
+            raise _TemplateJobTargetDoesNotExistError(path=self.template)
+
+    def run(self) -> None:
+        """Run the job."""
+        match self.mode:
+            case "write":
+                write_text(self.target, self.rendered, overwrite=True)
+            case "append":
+                with self.target.open(mode="a") as fh:
+                    _ = fh.write(self.rendered)
+            case never:
+                assert_never(never)
+
+    @property
+    def rendered(self) -> str:
+        """The template, rendered."""
+        env = EnhancedEnvironment(loader=FileSystemLoader(self.template.parent))
+        return env.get_template(self.template.name).render(self.kwargs)
+
+
+@dataclass(kw_only=True, slots=True)
+class TemplateJobError(Exception): ...
+
+
+@dataclass(kw_only=True, slots=True)
+class _TemplateJobTemplateDoesNotExistError(TemplateJobError):
+    path: Path
+
+    @override
+    def __str__(self) -> str:
+        return f"Template {str(self.path)!r} does not exist"
+
+
+@dataclass(kw_only=True, slots=True)
+class _TemplateJobTargetDoesNotExistError(TemplateJobError):
+    path: Path
+
+    @override
+    def __str__(self) -> str:
+        return f"Target {str(self.path)!r} does not exist"
+
+
+__all__ = ["EnhancedEnvironment", "TemplateJob", "TemplateJobError"]

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,
@@ -387,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)
@@ -399,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_local().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:
@@ -423,7 +421,7 @@ 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:
@@ -494,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,
@@ -481,49 +478,51 @@ def _object_hook(
             if match := _NONE_PATTERN.search(text):
                 return None
             if match := _DATE_PATTERN.search(text):
-                return Date.parse_common_iso(match.group(1))
+                return Date.parse_iso(match.group(1))
             if match := _DATE_DELTA_PATTERN.search(text):
-                return DateDelta.parse_common_iso(match.group(1))
+                return DateDelta.parse_iso(match.group(1))
             if match := _DATE_PERIOD_PATTERN.search(text):
-                start, end = map(Date.parse_common_iso, match.group(1).split(","))
+                start, end = map(Date.parse_iso, match.group(1).split(","))
                 return DatePeriod(start, end)
             if match := _DATE_TIME_DELTA_PATTERN.search(text):
-                return DateTimeDelta.parse_common_iso(match.group(1))
+                return DateTimeDelta.parse_iso(match.group(1))
             if match := _FLOAT_PATTERN.search(text):
                 return float(match.group(1))
             if match := _MONTH_DAY_PATTERN.search(text):
-                return MonthDay.parse_common_iso(match.group(1))
+                return MonthDay.parse_iso(match.group(1))
             if match := _PATH_PATTERN.search(text):
                 return Path(match.group(1))
             if match := _PLAIN_DATE_TIME_PATTERN.search(text):
-                return PlainDateTime.parse_common_iso(match.group(1))
+                return PlainDateTime.parse_iso(match.group(1))
             if match := _PY_DATE_PATTERN.search(text):
-                return Date.parse_common_iso(match.group(1)).py_date()
+                return Date.parse_iso(match.group(1)).py_date()
             if match := _PY_PLAIN_DATE_TIME_PATTERN.search(text):
-                return PlainDateTime.parse_common_iso(match.group(1)).py_datetime()
+                return PlainDateTime.parse_iso(match.group(1)).py_datetime()
             if match := _PY_TIME_PATTERN.search(text):
-                return Time.parse_common_iso(match.group(1)).py_time()
+                return Time.parse_iso(match.group(1)).py_time()
             if match := _PY_ZONED_DATE_TIME_PATTERN.search(text):
-                return ZonedDateTime.parse_common_iso(match.group(1)).py_datetime()
+                return ZonedDateTime.parse_iso(match.group(1)).py_datetime()
             if match := _TIME_PATTERN.search(text):
-                return Time.parse_common_iso(match.group(1))
+                return Time.parse_iso(match.group(1))
             if match := _TIME_DELTA_PATTERN.search(text):
-                return TimeDelta.parse_common_iso(match.group(1))
+                return TimeDelta.parse_iso(match.group(1))
             if match := _TIME_PERIOD_PATTERN.search(text):
-                start, end = map(Time.parse_common_iso, match.group(1).split(","))
+                start, end = map(Time.parse_iso, match.group(1).split(","))
                 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_common_iso(match.group(1))
+                return YearMonth.parse_iso(match.group(1))
             if match := _ZONED_DATE_TIME_PATTERN.search(text):
-                return ZonedDateTime.parse_common_iso(match.group(1))
+                return ZonedDateTime.parse_iso(match.group(1))
             if match := _ZONED_DATE_TIME_PERIOD_PATTERN.search(text):
                 start, end = match.group(1).split(",")
-                end = ZonedDateTime.parse_common_iso(end)
-                start = PlainDateTime.parse_common_iso(start).assume_tz(end.tz)
+                end = ZonedDateTime.parse_iso(end)
+                start = PlainDateTime.parse_iso(start).assume_tz(end.tz)
                 return ZonedDateTimePeriod(start, end)
             if (
                 exc_class := _object_hook_exception_class(
@@ -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(
@@ -1178,7 +1177,7 @@ def _get_log_records_one(
     path = Path(path)
     try:
         lines = path.read_text().splitlines()
-    except UnicodeDecodeError as error:  # skipif-ci-and-windows
+    except UnicodeDecodeError as error:
         return _GetLogRecordsOneOutput(path=path, file_ok=False, other_errors=[error])
     num_lines_blank, num_lines_error = 0, 0
     missing: set[str] = set()
@@ -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__ = [