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

utilities/orjson.py

@@ -5,7 +5,7 @@ import re
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from contextlib import suppress
 from dataclasses import dataclass, field, replace
-from enum import Enum, unique
+from enum import Enum, StrEnum, unique
 from functools import cached_property, partial
 from itertools import chain
 from logging import Formatter, LogRecord
@@ -14,18 +14,32 @@ from pathlib import Path
 from re import Pattern, search
 from typing import TYPE_CHECKING, Any, Literal, Self, assert_never, overload, override
 from uuid import UUID
+from zoneinfo import ZoneInfo
 
 from orjson import (
     OPT_PASSTHROUGH_DATACLASS,
     OPT_PASSTHROUGH_DATETIME,
     OPT_SORT_KEYS,
+    JSONDecodeError,
     dumps,
     loads,
 )
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    MonthDay,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    YearMonth,
+    ZonedDateTime,
+)
 
 from utilities.concurrent import concurrent_map
 from utilities.dataclasses import dataclass_to_dict
-from utilities.functions import ensure_class, is_string_mapping
+from utilities.functions import ensure_class
+from utilities.gzip import read_binary
 from utilities.iterables import (
     OneEmptyError,
     always_iterable,
@@ -33,31 +47,19 @@ from utilities.iterables import (
     one,
     one_unique,
 )
+from utilities.json import write_formatted_json
 from utilities.logging import get_logging_level_number
 from utilities.math import MAX_INT64, MIN_INT64
-from utilities.types import (
-    Dataclass,
-    DateOrDateTime,
-    LogLevel,
-    MaybeIterable,
-    PathLike,
-    StrMapping,
-)
-from utilities.tzlocal import get_local_time_zone
-from utilities.uuid import UUID_PATTERN
+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.whenever import (
-    parse_date,
-    parse_plain_datetime,
-    parse_time,
-    parse_timedelta,
-    parse_zoned_datetime,
-    serialize_date,
-    serialize_datetime,
-    serialize_time,
-    serialize_timedelta,
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
+    from_timestamp,
 )
-from utilities.zoneinfo import ensure_time_zone
 
 if TYPE_CHECKING:
     from collections.abc import Set as AbstractSet
@@ -70,28 +72,37 @@ if TYPE_CHECKING:
 
 
 @unique
-class _Prefixes(Enum):
+class _Prefixes(StrEnum):
     dataclass = "dc"
     date = "d"
-    datetime = "dt"
+    date_delta = "dd"
+    date_period = "dp"
+    date_time_delta = "D"
     enum = "e"
-    exception_class = "exc"
-    exception_instance = "exi"
+    exception_class = "Ex"
+    exception_instance = "ex"
     float_ = "fl"
     frozenset_ = "fr"
     list_ = "l"
-    nan = "nan"
-    none = "none"
+    month_day = "md"
+    none = "0"
     path = "p"
-    pos_inf = "pos_inf"
-    neg_inf = "neg_inf"
+    plain_date_time = "pd"
+    py_date = "!d"
+    py_plain_date_time = "!pd"
+    py_time = "!ti"
+    py_zoned_date_time = "!zd"
     set_ = "s"
-    timedelta = "td"
-    time = "tm"
+    time = "ti"
+    time_delta = "td"
+    time_period = "tp"
     tuple_ = "tu"
     unserializable = "un"
     uuid = "uu"
     version = "v"
+    year_month = "ym"
+    zoned_date_time = "zd"
+    zoned_date_time_period = "zp"
 
 
 type _DataclassHook = Callable[[type[Dataclass], StrMapping], StrMapping]
@@ -162,14 +173,14 @@ def _pre_process(
         # singletons
         case None:
             return f"[{_Prefixes.none.value}]"
-        case dt.datetime() as datetime:
-            return f"[{_Prefixes.datetime.value}]{serialize_datetime(datetime)}"
-        case dt.date() as date:  # after datetime
-            return f"[{_Prefixes.date.value}]{serialize_date(date)}"
-        case dt.time() as time:
-            return f"[{_Prefixes.time.value}]{serialize_time(time)}"
-        case dt.timedelta() as timedelta:
-            return f"[{_Prefixes.timedelta.value}]{serialize_timedelta(timedelta)}"
+        case Date() as date:
+            return f"[{_Prefixes.date.value}]{date}"
+        case DateDelta() as date:
+            return f"[{_Prefixes.date_delta.value}]{date}"
+        case DatePeriod() as period:
+            return f"[{_Prefixes.date_period.value}]{period.start},{period.end}"
+        case DateTimeDelta() as date_time_delta:
+            return f"[{_Prefixes.date_time_delta.value}]{date_time_delta}"
         case Exception() as error_:
             return {
                 f"[{_Prefixes.exception_instance.value}|{type(error_).__qualname__}]": pre(
@@ -184,16 +195,48 @@ def _pre_process(
             if MIN_INT64 <= int_ <= MAX_INT64:
                 return int_
             raise _SerializeIntegerError(obj=int_)
-        case UUID() as uuid:
-            return f"[{_Prefixes.uuid.value}]{uuid}"
+        case MonthDay() as month_day:
+            return f"[{_Prefixes.month_day.value}]{month_day!s}"
         case Path() as path:
             return f"[{_Prefixes.path.value}]{path!s}"
-        case str() as str_:
-            return str_
+        case PlainDateTime() as date_time:
+            return f"[{_Prefixes.plain_date_time.value}]{date_time}"
+        case str() as text:
+            return text
+        case Time() as time:
+            return f"[{_Prefixes.time.value}]{time}"
+        case TimeDelta() as time_delta:
+            return f"[{_Prefixes.time_delta.value}]{time_delta}"
+        case TimePeriod() as period:
+            return f"[{_Prefixes.time_period.value}]{period.start},{period.end}"
         case type() as error_cls if issubclass(error_cls, Exception):
             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!s}"
+            return f"[{_Prefixes.version.value}]{version}"
+        case YearMonth() as year_month:
+            return f"[{_Prefixes.year_month.value}]{year_month}"
+        case ZonedDateTime() as date_time:
+            return f"[{_Prefixes.zoned_date_time.value}]{date_time}"
+        case ZonedDateTimePeriod() as period:
+            return f"[{_Prefixes.zoned_date_time_period.value}]{period.start.to_plain()},{period.end}"
+        case dt.datetime() as py_datetime:
+            match py_datetime.tzinfo:
+                case None:
+                    datetime = PlainDateTime.from_py_datetime(py_datetime)
+                    return f"[{_Prefixes.py_plain_date_time.value}]{datetime}"
+                case ZoneInfo():
+                    datetime = ZonedDateTime.from_py_datetime(py_datetime)
+                    return f"[{_Prefixes.py_zoned_date_time.value}]{datetime}"
+                case _:  # pragma: no cover
+                    raise NotImplementedError
+        case dt.date() as py_date:
+            date = Date.from_py_date(py_date)
+            return f"[{_Prefixes.py_date.value}]{date}"
+        case dt.time() as py_time:
+            time = Time.from_py_time(py_time)
+            return f"[{_Prefixes.py_time.value}]{time}"
         # contains
         case Dataclass() as dataclass:
             asdict = dataclass_to_dict(
@@ -261,6 +304,7 @@ def _pre_process(
                 qualname=type(obj).__qualname__, repr=repr(obj), str=str(obj)
             )
             return pre(unserializable)
+    return None
 
 
 def _pre_process_container(
@@ -329,8 +373,12 @@ def deserialize(
     redirects: Mapping[str, type[Any]] | None = None,
 ) -> Any:
     """Deserialize an object."""
+    try:
+        obj = loads(data)
+    except JSONDecodeError:
+        raise _DeserializeInvalidJSONError(data=data) from None
     return _object_hook(
-        loads(data),
+        obj,
         data=data,
         dataclass_hook=dataclass_hook,
         objects=objects,
@@ -338,46 +386,59 @@ def deserialize(
     )
 
 
-_NONE_PATTERN = re.compile(r"^\[" + _Prefixes.none.value + r"\]$")
-_LOCAL_DATETIME_PATTERN = re.compile(
-    r"^\["
-    + _Prefixes.datetime.value
-    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)$"
-)
-_UUID_PATTERN = re.compile(r"^\[" + _Prefixes.uuid.value + r"\](" + UUID_PATTERN + ")$")
-_ZONED_DATETIME_PATTERN = re.compile(
-    r"^\["
-    + _Prefixes.datetime.value
-    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
-)
-
-
-def _make_unit_pattern(prefix: _Prefixes, /) -> Pattern[str]:
-    return re.compile(r"^\[" + prefix.value + r"\](.+)$")
+@dataclass(kw_only=True, slots=True)
+class DeerializeError(Exception):
+    obj: Any
 
 
 (
     _DATE_PATTERN,
+    _DATE_DELTA_PATTERN,
+    _DATE_PERIOD_PATTERN,
+    _DATE_TIME_DELTA_PATTERN,
     _FLOAT_PATTERN,
+    _MONTH_DAY_PATTERN,
+    _NONE_PATTERN,
     _PATH_PATTERN,
+    _PLAIN_DATE_TIME_PATTERN,
+    _PY_DATE_PATTERN,
+    _PY_PLAIN_DATE_TIME_PATTERN,
+    _PY_TIME_PATTERN,
+    _PY_ZONED_DATE_TIME_PATTERN,
     _TIME_PATTERN,
-    _TIMEDELTA_PATTERN,
+    _TIME_DELTA_PATTERN,
+    _TIME_PERIOD_PATTERN,
+    _UUID_PATTERN,
     _VERSION_PATTERN,
-) = map(
-    _make_unit_pattern,
-    [
+    _YEAR_MONTH_PATTERN,
+    _ZONED_DATE_TIME_PATTERN,
+    _ZONED_DATE_TIME_PERIOD_PATTERN,
+) = [
+    re.compile(r"^\[" + p.value + r"\](" + ".*" + ")$")
+    for p in [
         _Prefixes.date,
+        _Prefixes.date_delta,
+        _Prefixes.date_period,
+        _Prefixes.date_time_delta,
         _Prefixes.float_,
+        _Prefixes.month_day,
+        _Prefixes.none,
         _Prefixes.path,
+        _Prefixes.plain_date_time,
+        _Prefixes.py_date,
+        _Prefixes.py_plain_date_time,
+        _Prefixes.py_time,
+        _Prefixes.py_zoned_date_time,
         _Prefixes.time,
-        _Prefixes.timedelta,
+        _Prefixes.time_delta,
+        _Prefixes.time_period,
+        _Prefixes.uuid,
         _Prefixes.version,
-    ],
-)
-
-
-def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
-    return re.compile(r"^\[" + prefix.value + r"(?:\|(.+))?\]$")
+        _Prefixes.year_month,
+        _Prefixes.zoned_date_time,
+        _Prefixes.zoned_date_time_period,
+    ]
+]
 
 
 (
@@ -389,9 +450,9 @@ def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
     _LIST_PATTERN,
     _SET_PATTERN,
     _TUPLE_PATTERN,
-) = map(
-    _make_container_pattern,
-    [
+) = [
+    re.compile(r"^\[" + p.value + r"(?:\|(.+))?\]$")
+    for p in [
         _Prefixes.dataclass,
         _Prefixes.enum,
         _Prefixes.exception_class,
@@ -400,8 +461,8 @@ def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
         _Prefixes.list_,
         _Prefixes.set_,
         _Prefixes.tuple_,
-    ],
-)
+    ]
+]
 
 
 def _object_hook(
@@ -420,23 +481,50 @@ def _object_hook(
             if match := _NONE_PATTERN.search(text):
                 return None
             if match := _DATE_PATTERN.search(text):
-                return parse_date(match.group(1))
+                return Date.parse_iso(match.group(1))
+            if match := _DATE_DELTA_PATTERN.search(text):
+                return DateDelta.parse_iso(match.group(1))
+            if match := _DATE_PERIOD_PATTERN.search(text):
+                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_iso(match.group(1))
             if match := _FLOAT_PATTERN.search(text):
                 return float(match.group(1))
-            if match := _LOCAL_DATETIME_PATTERN.search(text):
-                return parse_plain_datetime(match.group(1))
+            if match := _MONTH_DAY_PATTERN.search(text):
+                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_iso(match.group(1))
+            if match := _PY_DATE_PATTERN.search(text):
+                return Date.parse_iso(match.group(1)).py_date()
+            if match := _PY_PLAIN_DATE_TIME_PATTERN.search(text):
+                return PlainDateTime.parse_iso(match.group(1)).py_datetime()
+            if match := _PY_TIME_PATTERN.search(text):
+                return Time.parse_iso(match.group(1)).py_time()
+            if match := _PY_ZONED_DATE_TIME_PATTERN.search(text):
+                return ZonedDateTime.parse_iso(match.group(1)).py_datetime()
             if match := _TIME_PATTERN.search(text):
-                return parse_time(match.group(1))
-            if match := _TIMEDELTA_PATTERN.search(text):
-                return parse_timedelta(match.group(1))
+                return Time.parse_iso(match.group(1))
+            if match := _TIME_DELTA_PATTERN.search(text):
+                return TimeDelta.parse_iso(match.group(1))
+            if match := _TIME_PERIOD_PATTERN.search(text):
+                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 := _ZONED_DATETIME_PATTERN.search(text):
-                return parse_zoned_datetime(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):
+                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_iso(end)
+                start = PlainDateTime.parse_iso(start).assume_tz(end.tz)
+                return ZonedDateTimePeriod(start, end)
             if (
                 exc_class := _object_hook_exception_class(
                     text, data=data, objects=objects, redirects=redirects
@@ -518,7 +606,7 @@ def _object_hook(
                 )
                 for k, v in mapping.items()
             }
-        case _ as never:
+        case never:
             assert_never(never)
 
 
@@ -662,11 +750,19 @@ def _object_hook_get_object(
 @dataclass(kw_only=True, slots=True)
 class DeserializeError(Exception):
     data: bytes
-    qualname: str
+
+
+@dataclass(kw_only=True, slots=True)
+class _DeserializeInvalidJSONError(DeserializeError):
+    @override
+    def __str__(self) -> str:
+        return f"Invalid JSON: {self.data!r}"
 
 
 @dataclass(kw_only=True, slots=True)
 class _DeserializeNoObjectsError(DeserializeError):
+    qualname: str
+
     @override
     def __str__(self) -> str:
         return f"Objects required to deserialize {self.qualname!r} from {self.data!r}"
@@ -674,6 +770,8 @@ class _DeserializeNoObjectsError(DeserializeError):
 
 @dataclass(kw_only=True, slots=True)
 class _DeserializeObjectNotFoundError(DeserializeError):
+    qualname: str
+
     @override
     def __str__(self) -> str:
         return (
@@ -742,8 +840,6 @@ class OrjsonFormatter(Formatter):
 
     @override
     def format(self, record: LogRecord) -> str:
-        from utilities.tzlocal import get_local_time_zone
-
         extra = {
             k: v
             for k, v in record.__dict__.items()
@@ -755,9 +851,7 @@ class OrjsonFormatter(Formatter):
             path_name=Path(record.pathname),
             line_num=record.lineno,
             message=record.getMessage(),
-            datetime=dt.datetime.fromtimestamp(
-                record.created, tz=get_local_time_zone()
-            ),
+            datetime=from_timestamp(record.created, time_zone=LOCAL_TIME_ZONE),
             func_name=record.funcName,
             extra=extra if len(extra) >= 1 else None,
         )
@@ -848,9 +942,7 @@ class GetLogRecordsOutput:
 
     @cached_property
     def dataframe(self) -> Any:
-        from polars import DataFrame, Object, String, UInt64
-
-        from utilities.polars import zoned_datetime
+        from polars import DataFrame, Datetime, Object, String, UInt64
 
         records = [
             replace(
@@ -861,11 +953,16 @@ class GetLogRecordsOutput:
             for r in self.records
         ]
         if len(records) >= 1:
-            time_zone = one_unique(ensure_time_zone(r.datetime) for r in records)
+            time_zone = one_unique(ZoneInfo(r.datetime.tz) for r in records)
         else:
-            time_zone = get_local_time_zone()
+            time_zone = LOCAL_TIME_ZONE
         return DataFrame(
-            data=[dataclass_to_dict(r, recursive=False) for r in records],
+            data=[
+                dataclass_to_dict(
+                    replace(r, datetime=r.datetime.py_datetime()), recursive=False
+                )
+                for r in records
+            ],
             schema={
                 "index": UInt64,
                 "name": String,
@@ -873,7 +970,7 @@ class GetLogRecordsOutput:
                 "level": UInt64,
                 "path_name": String,
                 "line_num": UInt64,
-                "datetime": zoned_datetime(time_zone=time_zone),
+                "datetime": Datetime(time_zone=time_zone),
                 "func_name": String,
                 "stack_info": String,
                 "extra": Object,
@@ -893,9 +990,12 @@ class GetLogRecordsOutput:
         level: LogLevel | None = None,
         min_level: LogLevel | None = None,
         max_level: LogLevel | None = None,
-        date_or_datetime: DateOrDateTime | None = None,
-        min_date_or_datetime: DateOrDateTime | None = None,
-        max_date_or_datetime: DateOrDateTime | None = None,
+        date: Date | None = None,
+        min_date: Date | None = None,
+        max_date: Date | None = None,
+        datetime: ZonedDateTime | None = None,
+        min_datetime: ZonedDateTime | None = None,
+        max_datetime: ZonedDateTime | None = None,
         func_name: bool | str | None = None,
         extra: bool | MaybeIterable[str] | None = None,
         log_file: bool | PathLike | None = None,
@@ -934,30 +1034,18 @@ class GetLogRecordsOutput:
             records = [
                 r for r in records if r.level <= get_logging_level_number(max_level)
             ]
-        if date_or_datetime is not None:
-            match date_or_datetime:
-                case dt.datetime() as datetime:
-                    records = [r for r in records if r.datetime == datetime]
-                case dt.date() as date:
-                    records = [r for r in records if r.date == date]
-                case _ as never:
-                    assert_never(never)
-        if min_date_or_datetime is not None:
-            match min_date_or_datetime:
-                case dt.datetime() as min_datetime:
-                    records = [r for r in records if r.datetime >= min_datetime]
-                case dt.date() as min_date:
-                    records = [r for r in records if r.date >= min_date]
-                case _ as never:
-                    assert_never(never)
-        if max_date_or_datetime is not None:
-            match max_date_or_datetime:
-                case dt.datetime() as max_datetime:
-                    records = [r for r in records if r.datetime <= max_datetime]
-                case dt.date() as max_date:
-                    records = [r for r in records if r.date <= max_date]
-                case _ as never:
-                    assert_never(never)
+        if date is not None:
+            records = [r for r in records if r.date == date]
+        if min_date is not None:
+            records = [r for r in records if r.date >= min_date]
+        if max_date is not None:
+            records = [r for r in records if r.date <= max_date]
+        if datetime is not None:
+            records = [r for r in records if r.datetime == datetime]
+        if min_datetime is not None:
+            records = [r for r in records if r.datetime >= min_datetime]
+        if max_datetime is not None:
+            records = [r for r in records if r.datetime <= max_datetime]
         if func_name is not None:
             match func_name:
                 case bool() as has_func_name:
@@ -970,7 +1058,7 @@ class GetLogRecordsOutput:
                         for r in records
                         if (r.func_name is not None) and search(func_name, r.func_name)
                     ]
-                case _ as never:
+                case never:
                     assert_never(never)
         if extra is not None:
             match extra:
@@ -983,7 +1071,7 @@ class GetLogRecordsOutput:
                         if (r.extra is not None)
                         and set(r.extra).issuperset(always_iterable(keys))
                     ]
-                case _ as never:
+                case never:
                     assert_never(never)
         if log_file is not None:
             match log_file:
@@ -998,7 +1086,7 @@ class GetLogRecordsOutput:
                         if (r.log_file is not None)
                         and search(str(log_file), str(r.log_file))
                     ]
-                case _ as never:
+                case never:
                     assert_never(never)
         if log_file_line_num is not None:
             match log_file_line_num:
@@ -1012,7 +1100,7 @@ class GetLogRecordsOutput:
                     records = [
                         r for r in records if r.log_file_line_num == log_file_line_num
                     ]
-                case _ as never:
+                case never:
                     assert_never(never)
         if min_log_file_line_num is not None:
             records = [
@@ -1026,7 +1114,7 @@ class GetLogRecordsOutput:
                 r
                 for r in records
                 if (r.log_file_line_num is not None)
-                and (r.log_file_line_num >= max_log_file_line_num)
+                and (r.log_file_line_num <= max_log_file_line_num)
             ]
         return replace(self, records=records)
 
@@ -1060,7 +1148,7 @@ class OrjsonLogRecord:
     level: int
     path_name: Path
     line_num: int
-    datetime: dt.datetime
+    datetime: ZonedDateTime
     func_name: str | None = None
     stack_info: str | None = None
     extra: StrMapping | None = None
@@ -1068,7 +1156,7 @@ class OrjsonLogRecord:
     log_file_line_num: int | None = None
 
     @cached_property
-    def date(self) -> dt.date:
+    def date(self) -> Date:
         return self.datetime.date()
 
 
@@ -1089,9 +1177,8 @@ def _get_log_records_one(
 ) -> _GetLogRecordsOneOutput:
     path = Path(path)
     try:
-        with path.open() as fh:
-            lines = fh.readlines()
-    except UnicodeDecodeError as error:  # skipif-ci-and-windows
+        lines = path.read_text().splitlines()
+    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()
@@ -1163,6 +1250,52 @@ class _GetLogRecordsOneOutput:
     other_errors: list[Exception] = field(default_factory=list, repr=False)
 
 
+# read/write
+
+
+def read_object(
+    path: PathLike,
+    /,
+    *,
+    decompress: bool = False,
+    dataclass_hook: _DataclassHook | None = None,
+    objects: AbstractSet[type[Any]] | None = None,
+    redirects: Mapping[str, type[Any]] | None = None,
+) -> Any:
+    """Read an object from disk."""
+    data = read_binary(path, decompress=decompress)
+    return deserialize(
+        data, dataclass_hook=dataclass_hook, objects=objects, redirects=redirects
+    )
+
+
+def write_object(
+    obj: Any,
+    path: PathLike,
+    /,
+    *,
+    before: Callable[[Any], Any] | None = None,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+    dataclass_hook: _DataclassHook | None = None,
+    dataclass_defaults: bool = False,
+    compress: bool = False,
+    overwrite: bool = False,
+) -> None:
+    """Write an object to disk."""
+    data = serialize(
+        obj,
+        before=before,
+        globalns=globalns,
+        localns=localns,
+        warn_name_errors=warn_name_errors,
+        dataclass_hook=dataclass_hook,
+        dataclass_defaults=dataclass_defaults,
+    )
+    write_formatted_json(data, path, compress=compress, overwrite=overwrite)
+
+
 __all__ = [
     "DeserializeError",
     "GetLogRecordsOutput",
@@ -1171,5 +1304,7 @@ __all__ = [
     "SerializeError",
     "deserialize",
     "get_log_records",
+    "read_object",
     "serialize",
+    "write_object",
 ]