omlish 0.0.0.dev80__tar.gz → 0.0.0.dev82__tar.gz

{omlish-0.0.0.dev80/omlish.egg-info → omlish-0.0.0.dev82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev80
+Version: 0.0.0.dev82
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -19,7 +19,7 @@ Requires-Dist: greenlet~=3.1; extra == "all"
 Requires-Dist: trio~=0.27; extra == "all"
 Requires-Dist: trio-asyncio~=0.15; extra == "all"
 Requires-Dist: lz4~=4.3; extra == "all"
-Requires-Dist: python-snappy~=0.7; python_version < "3.13" and extra == "all"
+Requires-Dist: python-snappy~=0.7; extra == "all"
 Requires-Dist: zstd~=1.5; extra == "all"
 Requires-Dist: asttokens~=2.4; extra == "all"
 Requires-Dist: executing~=2.1; extra == "all"
@@ -38,7 +38,7 @@ Requires-Dist: pg8000~=1.31; extra == "all"
 Requires-Dist: pymysql~=1.1; extra == "all"
 Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.20; extra == "all"
-Requires-Dist: asyncpg~=0.30; python_version < "3.13" and extra == "all"
+Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.46; extra == "all"
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
@@ -58,7 +58,7 @@ Requires-Dist: trio~=0.27; extra == "async"
 Requires-Dist: trio-asyncio~=0.15; extra == "async"
 Provides-Extra: compress
 Requires-Dist: lz4~=4.3; extra == "compress"
-Requires-Dist: python-snappy~=0.7; python_version < "3.13" and extra == "compress"
+Requires-Dist: python-snappy~=0.7; extra == "compress"
 Requires-Dist: zstd~=1.5; extra == "compress"
 Provides-Extra: diag
 Requires-Dist: asttokens~=2.4; extra == "diag"
@@ -84,7 +84,7 @@ Requires-Dist: pg8000~=1.31; extra == "sqldrivers"
 Requires-Dist: pymysql~=1.1; extra == "sqldrivers"
 Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.20; extra == "sqldrivers"
-Requires-Dist: asyncpg~=0.30; python_version < "3.13" and extra == "sqldrivers"
+Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.46; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "sqldrivers"
 Requires-Dist: duckdb~=1.1; extra == "sqldrivers"

{omlish-0.0.0.dev80 → omlish-0.0.0.dev82}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev80'
-__revision__ = '7640968fc4c06ed0d54ea53c36daae3574c9071f'
+__version__ = '0.0.0.dev82'
+__revision__ = '025f44593a2c0c59d06340e1d7dbcd15b1ab7684'
 
 
 #
@@ -45,7 +45,7 @@ class Project(ProjectBase):
             'lz4 ~= 4.3',
             # 'lz4 @ git+https://github.com/wrmsr/python-lz4@wrmsr_20240830_GIL_NOT_USED'
 
-            'python-snappy ~= 0.7; python_version < "3.13"',
+            'python-snappy ~= 0.7',
 
             'zstd ~= 1.5',
         ],
@@ -97,7 +97,7 @@ class Project(ProjectBase):
 
             'aiomysql ~= 0.2',
             'aiosqlite ~= 0.20',
-            'asyncpg ~= 0.30; python_version < "3.13"',
+            'asyncpg ~= 0.30',
 
             'apsw ~= 3.46',
 

{omlish-0.0.0.dev80 → omlish-0.0.0.dev82}/omlish/dataclasses/impl/__init__.py

@@ -22,4 +22,12 @@ TODO:
  - enums
  - nodal
  - embedding? forward kwargs in general? or only for replace?
+
+TODO refs:
+ - batch up exec calls
+  - https://github.com/python/cpython/commit/8945b7ff55b87d11c747af2dad0e3e4d631e62d6
+ - add doc parameter to dataclasses.field
+  - https://github.com/python/cpython/commit/9c7657f09914254724683d91177aed7947637be5
+ - add decorator argument to make_dataclass
+  - https://github.com/python/cpython/commit/3e3a4d231518f91ff2f3c5a085b3849e32f1d548
 """

{omlish-0.0.0.dev80 → omlish-0.0.0.dev82}/omlish/dataclasses/impl/params.py

@@ -12,6 +12,9 @@ class Field_:
     metadata: Metadata | None = None
     kw_only: bool | MISSING = MISSING
 
+    if sys.version_info >= (3, 13):
+        doc: str | None = None
+
     _field_type: Any = None
 
 

omlish-0.0.0.dev82/omlish/dataclasses/impl/slots.py

@@ -0,0 +1,134 @@
+import dataclasses as dc
+import inspect
+import itertools
+import types
+
+
+MISSING = dc.MISSING
+
+
+def _dataclass_getstate(self):
+    return [getattr(self, f.name) for f in dc.fields(self)]
+
+
+def _dataclass_setstate(self, state):
+    for field, value in zip(dc.fields(self), state):
+        object.__setattr__(self, field.name, value)
+
+
+def _get_slots(cls):
+    match cls.__dict__.get('__slots__'):
+        # A class which does not define __slots__ at all is equivalent to a class defining
+        #   __slots__ = ('__dict__', '__weakref__')
+        # `__dictoffset__` and `__weakrefoffset__` can tell us whether the base type has dict/weakref slots, in a way
+        # that works correctly for both Python classes and C extension types. Extension types don't use `__slots__` for
+        # slot creation
+        case None:
+            slots = []
+            if getattr(cls, '__weakrefoffset__', -1) != 0:
+                slots.append('__weakref__')
+            if getattr(cls, '__dictoffset__', -1) != 0:
+                slots.append('__dict__')
+            yield from slots
+        case str(slot):
+            yield slot
+        # Slots may be any iterable, but we cannot handle an iterator because it will already be (partially) consumed.
+        case iterable if not hasattr(iterable, '__next__'):
+            yield from iterable
+        case _:
+            raise TypeError(f"Slots of '{cls.__name__}' cannot be determined")
+
+
+def _update_func_cell_for__class__(f, oldcls, newcls):
+    # Returns True if we update a cell, else False.
+    if f is None:
+        # f will be None in the case of a property where not all of fget, fset, and fdel are used.  Nothing to do in
+        # that case.
+        return False
+    try:
+        idx = f.__code__.co_freevars.index('__class__')
+    except ValueError:
+        # This function doesn't reference __class__, so nothing to do.
+        return False
+    # Fix the cell to point to the new class, if it's already pointing at the old class.  I'm not convinced that the "is
+    # oldcls" test is needed, but other than performance can't hurt.
+    closure = f.__closure__[idx]
+    if closure.cell_contents is oldcls:
+        closure.cell_contents = newcls
+        return True
+    return False
+
+
+def add_slots(
+        cls: type,
+        is_frozen: bool,
+        weakref_slot: bool,
+) -> type:
+    # Need to create a new class, since we can't set __slots__ after a class has been created, and the @dataclass
+    # decorator is called after the class is created.
+
+    # Make sure __slots__ isn't already set.
+    if '__slots__' in cls.__dict__:
+        raise TypeError(f'{cls.__name__} already specifies __slots__')
+
+    # Create a new dict for our new class.
+    cls_dict = dict(cls.__dict__)
+    field_names = tuple(f.name for f in dc.fields(cls))  # noqa
+
+    # Make sure slots don't overlap with those in base classes.
+    inherited_slots = set(itertools.chain.from_iterable(map(_get_slots, cls.__mro__[1:-1])))
+
+    # The slots for our class.  Remove slots from our base classes.  Add '__weakref__' if weakref_slot was given, unless
+    # it is already present.
+    cls_dict['__slots__'] = tuple(
+        itertools.filterfalse(
+            inherited_slots.__contains__,
+            itertools.chain(
+                field_names,
+                # gh-93521: '__weakref__' also needs to be filtered out if already present in inherited_slots
+                ('__weakref__',) if weakref_slot else (),
+            ),
+        ),
+    )
+
+    for field_name in field_names:
+        # Remove our attributes, if present. They'll still be available in _MARKER.
+        cls_dict.pop(field_name, None)
+
+    # Remove __dict__ itself.
+    cls_dict.pop('__dict__', None)
+
+    # Clear existing `__weakref__` descriptor, it belongs to a previous type:
+    cls_dict.pop('__weakref__', None)
+
+    qualname = getattr(cls, '__qualname__', None)
+    newcls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
+    if qualname is not None:
+        newcls.__qualname__ = qualname
+
+    if is_frozen:
+        # Need this for pickling frozen classes with slots.
+        if '__getstate__' not in cls_dict:
+            newcls.__getstate__ = _dataclass_getstate  # type: ignore
+        if '__setstate__' not in cls_dict:
+            newcls.__setstate__ = _dataclass_setstate  # type: ignore
+
+    # Fix up any closures which reference __class__.  This is used to fix zero argument super so that it points to the
+    # correct class (the newly created one, which we're returning) and not the original class.  We can break out of this
+    # loop as soon as we make an update, since all closures for a class will share a given cell.
+    for member in newcls.__dict__.values():
+        # If this is a wrapped function, unwrap it.
+        member = inspect.unwrap(member)
+        if isinstance(member, types.FunctionType):
+            if _update_func_cell_for__class__(member, cls, newcls):
+                break
+
+        elif isinstance(member, property):
+            if (
+                    _update_func_cell_for__class__(member.fget, cls, newcls) or
+                    _update_func_cell_for__class__(member.fset, cls, newcls) or
+                    _update_func_cell_for__class__(member.fdel, cls, newcls)
+            ):
+                break
+
+    return newcls

{omlish-0.0.0.dev80 → omlish-0.0.0.dev82}/omlish/formats/json/__init__.py

@@ -1,9 +1,16 @@
-from .json import (  # noqa
+from .consts import (  # noqa
     COMPACT_KWARGS,
     COMPACT_SEPARATORS,
     PRETTY_INDENT,
     PRETTY_KWARGS,
+)
+
+from .encoding import (  # noqa
+    decodes,
     detect_encoding,
+)
+
+from .json import (  # noqa
     dump,
     dump_compact,
     dump_pretty,

omlish-0.0.0.dev82/omlish/formats/json/backends/__init__.py

@@ -0,0 +1,7 @@
+from .base import (  # noqa
+    Backend,
+)
+
+from .default import (  # noqa
+    DEFAULT_BACKED,
+)

omlish-0.0.0.dev82/omlish/formats/json/backends/base.py

@@ -0,0 +1,38 @@
+import abc
+import typing as ta
+
+from .... import lang
+
+
+class Backend(lang.Abstract):
+    @abc.abstractmethod
+    def dump(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dumps(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def load(self, fp: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def loads(self, s: str | bytes | bytearray, **kwargs: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dump_pretty(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dumps_pretty(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dump_compact(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dumps_compact(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        raise NotImplementedError

omlish-0.0.0.dev82/omlish/formats/json/backends/default.py

@@ -0,0 +1,10 @@
+from .base import Backend
+from .std import STD_BACKEND
+from .ujson import UJSON_BACKEND
+
+
+DEFAULT_BACKED: Backend
+if UJSON_BACKEND is not None:
+    DEFAULT_BACKED = UJSON_BACKEND
+else:
+    DEFAULT_BACKED = STD_BACKEND

omlish-0.0.0.dev82/omlish/formats/json/backends/jiter.py

@@ -0,0 +1,25 @@
+"""
+from_json(
+    json_data: bytes,
+    /,
+    *,
+    allow_inf_nan: bool = True,
+    cache_mode: Literal[True, False, "all", "keys", "none"] = "all",
+    partial_mode: Literal[True, False, "off", "on", "trailing-strings"] = False,
+    catch_duplicate_keys: bool = False,
+    lossless_floats: bool = False,
+) -> Any:
+    json_data: The JSON data to parse
+    allow_inf_nan: Whether to allow infinity (`Infinity` an `-Infinity`) and `NaN` values to float fields.
+    Defaults to True.
+    cache_mode: cache Python strings to improve performance at the cost of some memory usage
+    - True / 'all' - cache all strings
+    - 'keys' - cache only object keys
+    - False / 'none' - cache nothing
+    partial_mode: How to handle incomplete strings:
+    - False / 'off' - raise an exception if the input is incomplete
+    - True / 'on' - allow incomplete JSON but discard the last string if it is incomplete
+    - 'trailing-strings' - allow incomplete JSON, and include the last incomplete string in the output
+    catch_duplicate_keys: if True, raise an exception if objects contain the same key multiple times
+    lossless_floats: if True, preserve full detail on floats using `LosslessFloat`
+"""

{omlish-0.0.0.dev80 → omlish-0.0.0.dev82}/omlish/formats/json/backends/orjson.py

@@ -1,11 +1,16 @@
 """
-def loads(obj: str | bytes | bytearray | memoryview) -> ta.Any | oj.JSONDEcodeError
-def dumps(obj: ta.Any, **DumpOpts) -> bytes
+loads(obj: str | bytes | bytearray | memoryview) -> ta.Any | oj.JSONDEcodeError
+dumps(
+    obj: ta.Any,
+    default: ta.Callable[[ta.Any], Ata.ny] | None = ...,
+    option: int | None = ...,
+) -> bytes
 """
 import dataclasses as dc
 import typing as ta
 
 from .... import lang
+from .base import Backend
 
 
 if ta.TYPE_CHECKING:
@@ -14,6 +19,9 @@ else:
     oj = lang.proxy_import('orjson')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class Options:
     append_newline: bool = False  # append \n to the output
@@ -70,3 +78,39 @@ class Options:
 class DumpOpts:
     default: ta.Callable[[ta.Any], ta.Any] | None = None
     option: Options = Options()
+
+
+##
+
+
+class OrjsonBackend(Backend):
+    def dump(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        fp.write(self.dumps(obj, **kwargs))
+
+    def dumps(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return oj.dumps(obj, **kwargs).decode('utf-8')
+
+    def load(self, fp: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        return oj.loads(fp.read(), **kwargs)
+
+    def loads(self, s: str | bytes | bytearray, **kwargs: ta.Any) -> ta.Any:
+        return oj.loads(s, **kwargs)
+
+    def dump_pretty(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        fp.write(self.dumps_pretty(obj, **kwargs))
+
+    def dumps_pretty(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return self.dumps(obj, option=kwargs.pop('option', 0) | oj.OPT_INDENT_2, **kwargs)
+
+    def dump_compact(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        return self.dump(obj, fp, **kwargs)
+
+    def dumps_compact(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return self.dumps(obj, **kwargs)
+
+
+ORJSON_BACKEND: OrjsonBackend | None
+if lang.can_import('orjson'):
+    ORJSON_BACKEND = OrjsonBackend()
+else:
+    ORJSON_BACKEND = None

{omlish-0.0.0.dev80 → omlish-0.0.0.dev82}/omlish/formats/json/backends/std.py

@@ -8,6 +8,13 @@ import dataclasses as dc
 import json
 import typing as ta
 
+from ..consts import COMPACT_KWARGS
+from ..consts import PRETTY_KWARGS
+from .base import Backend
+
+
+##
+
 
 @dc.dataclass(frozen=True, kw_only=True)
 class DumpOpts:
@@ -35,3 +42,35 @@ class LoadOpts:
 
     # called with the result of any object literal decoded with an ordered list of pairs, by default dict  # noqa
     object_pairs_hook: ta.Callable[[list[tuple[str, ta.Any]]], ta.Any] | None = None
+
+
+##
+
+
+class StdBackend(Backend):
+    def dump(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        json.dump(obj, fp, **kwargs)
+
+    def dumps(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return json.dumps(obj, **kwargs)
+
+    def load(self, fp: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        return json.load(fp, **kwargs)
+
+    def loads(self, s: str | bytes | bytearray, **kwargs: ta.Any) -> ta.Any:
+        return json.loads(s, **kwargs)
+
+    def dump_pretty(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        json.dump(obj, fp, **PRETTY_KWARGS, **kwargs)
+
+    def dumps_pretty(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return json.dumps(obj, **PRETTY_KWARGS, **kwargs)
+
+    def dump_compact(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        json.dump(obj, fp, **COMPACT_KWARGS, **kwargs)
+
+    def dumps_compact(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return json.dumps(obj, **COMPACT_KWARGS, **kwargs)
+
+
+STD_BACKEND = StdBackend()

omlish-0.0.0.dev82/omlish/formats/json/backends/ujson.py

@@ -0,0 +1,74 @@
+"""
+load(fp: File) -> ta.Any | uj.JSONDecodeError
+loads(s: str | bytes | bytearray) -> ta.Any | uj.JSONDecodeError
+dump(obj: ta.Any, fp: File, **DumpOpts) -> None
+dumps(obj: ta.Any, **DumpOpts) -> None
+"""
+import dataclasses as dc
+import typing as ta
+
+from .... import lang
+from ..consts import PRETTY_INDENT
+from .base import Backend
+
+
+if ta.TYPE_CHECKING:
+    import ujson as uj
+else:
+    uj = lang.proxy_import('ujson')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DumpOpts:
+    """
+    https://github.com/ultrajson/ultrajson/blob/2e4aba339b0ab08f893590aaa989d12846afc5d6/python/objToJSON.c#L662
+    """
+
+    ensure_ascii: bool = True  # limits output to ASCII and escapes all extended characters above 127.
+    encode_html_chars: bool = False  # enables special encoding of "unsafe" HTML characters into safer Unicode sequences
+    escape_forward_slashes: bool = True  # whether forward slashes (/) are escaped
+    indent: int = 0
+    sort_keys: bool = False
+    allow_nan: bool = True
+    reject_bytes: bool = True
+    default: ta.Callable[[ta.Any], ta.Any] | None = None  # should return a serializable version of obj or raise TypeError  # noqa
+    separators: tuple[str, str] | None = None
+
+
+##
+
+
+class UjsonBackend(Backend):
+    def dump(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        uj.dump(obj, fp, **kwargs)
+
+    def dumps(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return uj.dumps(obj, **kwargs)
+
+    def load(self, fp: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        return uj.load(fp, **kwargs)
+
+    def loads(self, s: str | bytes | bytearray, **kwargs: ta.Any) -> ta.Any:
+        return uj.loads(s, **kwargs)
+
+    def dump_pretty(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        uj.dump(obj, fp, indent=PRETTY_INDENT, **kwargs)
+
+    def dumps_pretty(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return uj.dumps(obj, indent=PRETTY_INDENT, **kwargs)
+
+    def dump_compact(self, obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+        uj.dump(obj, fp, **kwargs)
+
+    def dumps_compact(self, obj: ta.Any, **kwargs: ta.Any) -> str:
+        return uj.dumps(obj, **kwargs)
+
+
+UJSON_BACKEND: UjsonBackend | None
+if lang.can_import('ujson'):
+    UJSON_BACKEND = UjsonBackend()
+else:
+    UJSON_BACKEND = None