omlish 0.0.0.dev402__py3-none-any.whl → 0.0.0.dev404__py3-none-any.whl

omlish/.manifests.json

@@ -311,7 +311,7 @@
     "module": ".io.compress.zstd",
     "attr": "_ZSTD_LAZY_CODEC",
     "file": "omlish/io/compress/zstd.py",
-    "line": 43,
+    "line": 51,
     "value": {
       "$.codecs.base.LazyLoadedCodec": {
         "mod_name": "omlish.io.compress.zstd",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev402'
-__revision__ = '923dbb60edd6e046587daf400ee931ae9ec619de'
+__version__ = '0.0.0.dev404'
+__revision__ = 'bd964bf904e22ab46e4d3b4f7ec3028f9aed5c9a'
 
 
 #
@@ -51,7 +51,7 @@ class Project(ProjectBase):
 
             'python-snappy ~= 0.7',
 
-            'zstandard ~= 0.24',
+            'zstandard ~= 0.24; python_version < "3.14"',
 
             'brotli ~= 1.1',
         ],

omlish/argparse/cli.py

@@ -140,6 +140,7 @@ def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
 class _ArgparseCliAnnotationBox:
     def __init__(self, annotations: ta.Mapping[str, ta.Any]) -> None:
         super().__init__()
+
         self.__annotations__ = annotations  # type: ignore
 
 

omlish/codecs/registry.py

@@ -27,6 +27,8 @@ class CodecRegistry:
     ) -> None:
         super().__init__()
 
+        if late_load_callbacks is not None:
+            late_load_callbacks = list(late_load_callbacks)
         self._late_load_callbacks = late_load_callbacks
 
         self._lock = threading.RLock()
@@ -36,8 +38,10 @@ class CodecRegistry:
 
     def _late_load(self) -> None:
         if self._late_load_callbacks:
-            for cb in self._late_load_callbacks:
+            while self._late_load_callbacks:
+                cb = self._late_load_callbacks[0]
                 cb(self)
+                self._late_load_callbacks.pop(0)
             self._late_load_callbacks = None
 
     @contextlib.contextmanager
@@ -103,7 +107,7 @@ def _install_standard_codecs(registry: CodecRegistry) -> None:
 @cached.function
 def _build_manifest_lazy_loaded_codecs() -> ta.Sequence[LazyLoadedCodec]:
     ldr = manifest_globals.GlobalManifestLoader.instance()
-    pkgs = {__package__.split('.')[0], *ldr.discover_packages()}
+    pkgs = {__package__.split('.')[0], *ldr.discover_packages()}  # FIXME
     mns = ldr.load(*pkgs, only=[LazyLoadedCodec])
     return [m.value() for m in mns]
 

omlish/dataclasses/_internals.py

@@ -1,3 +1,7 @@
+"""
+For arcane import machinery compatibility with stdlib, this must be a direct child of the 'dataclasses' package - not
+under 'impl'.
+"""
 import dataclasses as dc
 import enum
 import sys
@@ -101,7 +105,10 @@ def _self_module():
 def std_is_classvar(cls: type, ty: ta.Any) -> bool:
     return (
         dc._is_classvar(ty, ta)  # type: ignore  # noqa
-        or (isinstance(ty, str) and dc._is_type(ty, cls, ta, ta.ClassVar, dc._is_classvar))  # type: ignore  # noqa
+        or (
+            isinstance(ty, str) and
+            dc._is_type(ty, cls, ta, ta.ClassVar, dc._is_classvar)  # type: ignore  # noqa
+        )
     )
 
 
@@ -109,8 +116,8 @@ def std_is_initvar(cls: type, ty: ta.Any) -> bool:
     return (
         dc._is_initvar(ty, dc)  # type: ignore  # noqa
         or (
-            isinstance(ty, str)
-            and any(
+            isinstance(ty, str) and
+            any(
                 dc._is_type(ty, cls, mod, dc.InitVar, dc._is_initvar)  # type: ignore  # noqa
                 for mod in (dc, _self_module())
             )
@@ -122,8 +129,8 @@ def std_is_kw_only(cls: type, ty: ta.Any) -> bool:
     return (
         dc._is_kw_only(ty, dc)  # type: ignore  # noqa
         or (
-            isinstance(ty, str)
-            and any(
+            isinstance(ty, str) and
+            any(
                 dc._is_type(ty, cls, mod, dc.KW_ONLY, dc._is_kw_only)  # type: ignore  # noqa
                 for mod in (dc, _self_module())
             )

omlish/dataclasses/impl/api/classes/make.py

@@ -10,6 +10,14 @@ from .decorator import dataclass
 ##
 
 
+_IS_PY_3_14 = sys.version_info >= (3, 14)
+
+if _IS_PY_3_14:
+    import annotationlib  # noqa
+
+    _ANY_MARKER = object()
+
+
 def make_dataclass(  # noqa
         cls_name,
         fields,
@@ -31,6 +39,8 @@ def make_dataclass(  # noqa
 
         module=None,
 
+        decorator=dataclass,
+
         #
 
         metadata: ta.Sequence[ta.Any] | None = None,
@@ -46,6 +56,12 @@ def make_dataclass(  # noqa
 
         allow_redundant_decorator: bool | None = None,
 ):
+    if decorator is not dataclass:
+        raise TypeError(
+            f'The `decorator` kwarg, as added in https://github.com/python/cpython/pull/122723, is not supported. '
+            f'{decorator=}',
+        )
+
     if namespace is None:
         namespace = {}
 
@@ -55,7 +71,10 @@ def make_dataclass(  # noqa
     for item in fields:
         if isinstance(item, str):
             name = item
-            tp = 'typing.Any'
+            if _IS_PY_3_14:
+                tp = _ANY_MARKER
+            else:
+                tp = 'typing.Any'
         elif len(item) == 2:
             name, tp, = item
         elif len(item) == 3:
@@ -73,13 +92,52 @@ def make_dataclass(  # noqa
         seen.add(name)
         annotations[name] = tp
 
+    if _IS_PY_3_14:
+        # We initially block the VALUE format, because inside dataclass() we'll call get_annotations(), which will try
+        # the VALUE format first. If we don't block, that means we'd always end up eagerly importing typing here, which
+        # is what we're trying to avoid.
+        value_blocked = True
+
+        def annotate_method(format):  # noqa
+            def get_any():
+                match format:
+                    case annotationlib.Format.STRING:
+                        return 'typing.Any'
+                    case annotationlib.Format.FORWARDREF:
+                        typing = sys.modules.get('typing')
+                        if typing is None:
+                            return annotationlib.ForwardRef('Any', module='typing')
+                        else:
+                            return typing.Any
+                    case annotationlib.Format.VALUE:
+                        if value_blocked:
+                            raise NotImplementedError
+                        from typing import Any
+                        return Any
+                    case _:
+                        raise NotImplementedError
+
+            annos = {
+                ann: get_any() if t is _ANY_MARKER else t
+                for ann, t in annotations.items()
+            }
+            if format == annotationlib.Format.STRING:
+                return annotationlib.annotations_to_string(annos)
+            else:
+                return annos
+
     def exec_body_callback(ns):
         ns.update(namespace)
         ns.update(defaults)
-        ns['__annotations__'] = annotations
+        if not _IS_PY_3_14:
+            ns['__annotations__'] = annotations
 
     cls = types.new_class(cls_name, bases, {}, exec_body_callback)
 
+    if _IS_PY_3_14:
+        # For now, set annotations including the _ANY_MARKER.
+        cls.__annotate__ = annotate_method  # type: ignore
+
     if module is None:
         try:
             module = sys._getframemodulename(1) or '__main__'  # type: ignore  # noqa
@@ -89,7 +147,7 @@ def make_dataclass(  # noqa
     if module is not None:
         cls.__module__ = module
 
-    return dataclass(
+    cls = decorator(
         cls,
         init=init,
         repr=repr,
@@ -117,3 +175,9 @@ def make_dataclass(  # noqa
 
         allow_redundant_decorator=allow_redundant_decorator,
     )
+
+    if _IS_PY_3_14:
+        # Now that the class is ready, allow the VALUE format.
+        value_blocked = False
+
+    return cls

omlish/dataclasses/impl/api/fields/constructor.py

@@ -1,5 +1,6 @@
 import collections
 import dataclasses as dc
+import sys
 import typing as ta
 
 from ..... import lang
@@ -13,6 +14,9 @@ from .metadata import extra_field_params
 ##
 
 
+_IS_PY_3_14 = sys.version_info >= (3, 14)
+
+
 def field(
         default=dc.MISSING,
         *,
@@ -23,6 +27,7 @@ def field(
         compare=True,
         metadata=None,
         kw_only=dc.MISSING,
+        doc=None,
 
         coerce: bool | CoerceFn | None = None,
         validate: ValidateFn | None = None,  # noqa
@@ -40,6 +45,7 @@ def field(
             override=override,
             repr_fn=repr_fn,
             repr_priority=repr_priority,
+            doc=doc,
         ),
     })
 
@@ -58,4 +64,5 @@ def field(
         compare=compare,
         metadata=md,
         kw_only=kw_only,
+        **(dict(doc=doc) if _IS_PY_3_14 else {}),
     )

omlish/dataclasses/impl/api/fields/conversion.py

@@ -1,4 +1,5 @@
 import dataclasses as dc
+import sys
 import typing as ta
 
 from ..... import check
@@ -16,6 +17,12 @@ from .metadata import set_field_spec_metadata
 ##
 
 
+_IS_PY_3_14 = sys.version_info >= (3, 14)
+
+
+##
+
+
 STD_FIELD_TYPE_BY_SPEC_FIELD_TYPE: ta.Mapping[FieldType, StdFieldType] = {
     FieldType.INSTANCE: StdFieldType.INSTANCE,
     FieldType.CLASS_VAR: StdFieldType.CLASS_VAR,
@@ -99,6 +106,10 @@ def std_field_to_field_spec(
         metadata=f.metadata,
         kw_only=None if f.kw_only is dc.MISSING else (check.isinstance(f.kw_only, bool) if DEBUG else f.kw_only),
 
+        **lang.opt_kw(
+            doc=extra_params.get('doc', f.doc if _IS_PY_3_14 else None),  # type: ignore[attr-defined]  # noqa
+        ),
+
         **lang.opt_kw(
             coerce=extra_params.get('coerce'),
             validate=extra_params.get('validate'),
@@ -133,6 +144,7 @@ def field_spec_to_std_field(fs: FieldSpec) -> dc.Field:
         compare=fs.compare,
         **lang.opt_kw(metadata=fs.metadata),
         kw_only=dc.MISSING if fs.kw_only is None else fs.kw_only,  # type: ignore[arg-type]
+        **(dict(doc=fs.doc) if _IS_PY_3_14 else {}),
     )
 
     f.name = fs.name
@@ -162,6 +174,7 @@ def check_field_spec_against_field(f: dc.Field, fs: FieldSpec) -> None:
         'compare': f.compare,
         # f.metadata,
         'kw_only': f.kw_only if f.kw_only is not dc.MISSING else None,
+        **({'doc': f.doc} if _IS_PY_3_14 else {}),  # type: ignore[attr-defined]  # noqa
 
         'std_field_type': f._field_type,  # type: ignore[attr-defined]  # noqa
     }
@@ -178,6 +191,7 @@ def check_field_spec_against_field(f: dc.Field, fs: FieldSpec) -> None:
         'compare': fs.compare,
         # fs.metadata,
         'kw_only': fs.kw_only,
+        **({'doc': fs.doc} if _IS_PY_3_14 else {}),
 
         'std_field_type': STD_FIELD_TYPE_BY_SPEC_FIELD_TYPE[fs.field_type].value,
     }

omlish/dataclasses/impl/concerns/doc.py

@@ -1,4 +1,5 @@
 import inspect
+import sys
 
 from ..processing.base import ProcessingContext
 from ..processing.base import Processor
@@ -9,14 +10,31 @@ from ..processing.registry import register_processor_type
 ##
 
 
+if sys.version_info >= (3, 14):
+    import annotationlib  # noqa
+
+    def _raw_build_cls_sig(cls: type) -> str:
+        return str(inspect.signature(
+            cls,
+            annotation_format=annotationlib.Format.FORWARDREF,  # noqa
+        )).replace(' -> None', '')
+
+else:
+    def _raw_build_cls_sig(cls: type) -> str:
+        return str(inspect.signature(cls)).replace(' -> None', '')
+
+
 def _build_cls_doc(cls: type) -> str:
     try:
-        text_sig = str(inspect.signature(cls)).replace(' -> None', '')
+        text_sig = _raw_build_cls_sig(cls)
     except (TypeError, ValueError):
         text_sig = ''
     return cls.__name__ + text_sig
 
 
+##
+
+
 class _LazyClsDocDescriptor:
     def __get__(self, instance, owner):
         if instance is not None:

omlish/dataclasses/impl/concerns/slots.py

@@ -2,6 +2,7 @@ import dataclasses as dc
 import inspect
 import itertools
 import types
+import typing as ta
 
 from ..processing.base import Processor
 from ..processing.priority import ProcessorPriority
@@ -63,11 +64,41 @@ def _update_func_cell_for__class__(f, oldcls, newcls):
     return False
 
 
+def _create_slots(
+        defined_fields,
+        inherited_slots,
+        field_names,
+        weakref_slot,
+):
+    # The slots for our class.  Remove slots from our base classes.  Add '__weakref__' if weakref_slot was given, unless
+    # it is already present.
+    seen_docs = False
+    slots = {}
+    for slot in itertools.filterfalse(
+        inherited_slots.__contains__,
+        itertools.chain(
+            # gh-93521: '__weakref__' also needs to be filtered out if already present in inherited_slots
+            field_names, ('__weakref__',) if weakref_slot else (),
+        ),
+    ):
+        doc = getattr(defined_fields.get(slot), 'doc', None)
+        if doc is not None:
+            seen_docs = True
+        slots[slot] = doc
+
+    # We only return dict if there's at least one doc member, otherwise we return tuple, which is the old default
+    # format.
+    if seen_docs:
+        return slots
+    return tuple(slots)
+
+
 def add_slots(
         cls: type,
         *,
         is_frozen: bool,
         weakref_slot: bool,
+        defined_fields: ta.Mapping[str, ta.Any],
 ) -> 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.
@@ -83,17 +114,11 @@ def add_slots(
     # 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 (),
-            ),
-        ),
+    cls_dict['__slots__'] = _create_slots(
+        defined_fields,
+        inherited_slots,
+        field_names,
+        weakref_slot,
     )
 
     for field_name in field_names:
@@ -156,4 +181,5 @@ class SlotsProcessor(Processor):
             cls,
             is_frozen=self._ctx.cs.frozen,
             weakref_slot=self._ctx.cs.weakref_slot,
+            defined_fields=self._ctx.cs.fields_by_name,
         )

omlish/dataclasses/metaclass/meta.py

@@ -5,6 +5,7 @@ TODO:
 """
 import abc
 import dataclasses as dc
+import sys
 import typing as ta
 
 from ... import lang
@@ -21,6 +22,26 @@ T = ta.TypeVar('T')
 ##
 
 
+if sys.version_info >= (3, 14):
+    annotationlib = __import__('annotationlib')  # noqa
+
+    # See:
+    #  - https://github.com/python/cpython/pull/132345
+    #  - https://github.com/python/cpython/pull/132490
+    def _get_ns_annotation_names(ns: ta.Mapping[str, ta.Any]) -> ta.Sequence[str]:
+        if (fn := annotationlib.get_annotate_from_class_namespace(ns)) is not None:  # noqa
+            return list(annotationlib.call_annotate_function(fn, annotationlib.Format.FORWARDREF))  # noqa
+        else:
+            return []
+
+else:
+    def _get_ns_annotation_names(ns: ta.Mapping[str, ta.Any]) -> ta.Sequence[str]:
+        return list(ns.get('__annotations__', []))
+
+
+##
+
+
 class DataMeta(abc.ABCMeta):
     def __new__(
             mcls,
@@ -88,7 +109,7 @@ class DataMeta(abc.ABCMeta):
 
         ofs: set[str] = set()
         if any(issubclass(b, lang.Abstract) for b in bases) and nkw.get('override'):
-            ofs.update(a for a in namespace.get('__annotations__', []) if a not in namespace)
+            ofs.update(a for a in _get_ns_annotation_names(namespace) if a not in namespace)
             namespace.update((a, dc.MISSING) for a in ofs)
 
         #

omlish/dataclasses/specs.py

@@ -65,7 +65,7 @@ class FieldSpec(lang.Final):
 
     kw_only: bool | None = None
 
-    # doc: ta.Any = None
+    doc: ta.Any = None
 
     ##
     # ext

omlish/dataclasses/tools/static.py

@@ -155,6 +155,7 @@ class Static(lang.Abstract):
                 if k not in new_anns
             })
 
+            # FIXME: 3.14
             cls.__annotations__ = new_anns
 
         else:

omlish/dispatch/impls.py

@@ -20,8 +20,7 @@ T = ta.TypeVar('T')
 
 
 def get_impl_func_cls_set(func: ta.Callable, *, arg_offset: int = 0) -> frozenset[type]:
-    ann = getattr(func, '__annotations__', {})
-    if not ann:
+    if not rfl.has_annotations(func):
         raise TypeError(f'Invalid impl func: {func!r}')
 
     def erase(a):

omlish/dispatch/methods.py

@@ -101,12 +101,6 @@ class Method(ta.Generic[P, R]):
         return wrapper
 
     def register(self, impl: T, cls_set: frozenset[type] | None = None) -> T:
-        # bpo-39679: in Python <= 3.9, classmethods and staticmethods don't inherit __annotations__ of the wrapped
-        # function (fixed in 3.10+ as a side-effect of bpo-43682) but we need that for annotation-derived
-        # singledispatches. So we add that just-in-time here.
-        if isinstance(impl, (staticmethod, classmethod)):
-            impl.__annotations__ = getattr(impl.__func__, '__annotations__', {})
-
         check.callable(impl)
         if impl not in self._impls:
             self._impls[impl] = cls_set  # type: ignore

omlish/inject/impl/proxy.py

@@ -15,6 +15,7 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
 
         def __init__(self, cls: ta.Any) -> None:
             super().__init__()
+
             self.__cls = cls
 
         def __repr__(self) -> str:
@@ -24,6 +25,7 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
 
         def __init__(self, cls):
             super().__init__(_CyclicDependencyPlaceholder(cls))
+
             if isinstance(cls, type):
                 self._self__class__ = cls  # noqa
 

omlish/inject/impl/scopes.py

@@ -67,6 +67,7 @@ class UnscopedScopeImpl(ScopeImpl, lang.Final):
 class SingletonScopeImpl(ScopeImpl, lang.Final):
     def __init__(self) -> None:
         super().__init__()
+
         self._dct: dict[BindingImpl, ta.Any] = {}
 
     @property
@@ -86,6 +87,7 @@ class SingletonScopeImpl(ScopeImpl, lang.Final):
 class ThreadScopeImpl(ScopeImpl, lang.Final):
     def __init__(self) -> None:
         super().__init__()
+
         self._local = threading.local()
 
     @property
@@ -135,6 +137,7 @@ class SeededScopeImpl(ScopeImpl):
 
     def __init__(self, ss: SeededScope) -> None:
         super().__init__()
+
         self._ss = check.isinstance(ss, SeededScope)
         self._st: SeededScopeImpl.State | None = None
 
@@ -150,6 +153,7 @@ class SeededScopeImpl(ScopeImpl):
     class Manager(SeededScope.Manager, lang.Final):
         def __init__(self, ss: SeededScope, i: Injector) -> None:
             super().__init__()
+
             self._ss = check.isinstance(ss, SeededScope)
             self._ii = check.isinstance(i, injector_.InjectorImpl)
             self._ssi = check.isinstance(self._ii.get_scope_impl(self._ss), SeededScopeImpl)

omlish/io/compress/zstd.py

@@ -1,4 +1,5 @@
 import dataclasses as dc
+import sys
 import typing as ta
 
 from ... import lang
@@ -7,10 +8,17 @@ from .codecs import make_compression_codec
 from .codecs import make_compression_lazy_loaded_codec
 
 
-if ta.TYPE_CHECKING:
-    import zstandard
-else:
-    zstandard = lang.proxy_import('zstandard')
+if sys.version_info >= (3, 14):
+    if ta.TYPE_CHECKING:
+        from compression import zstd  # noqa
+    else:
+        zstd = lang.proxy_import('compression.zstd')
+
+else:  # noqa
+    if ta.TYPE_CHECKING:
+        import zstandard as zstd
+    else:
+        zstd = lang.proxy_import('zstandard')
 
 
 ##
@@ -20,18 +28,18 @@ else:
 class ZstdCompression(Compression):
     level: int | None = None
 
-    max_output_size: int = 0
+    # max_output_size: int = 0
 
     def compress(self, d: bytes) -> bytes:
-        return zstandard.compress(
+        return zstd.compress(
             d,
             **(dict(level=self.level) if self.level is not None else {}),
         )
 
     def decompress(self, d: bytes) -> bytes:
-        return zstandard.decompress(
+        return zstd.decompress(
             d,
-            max_output_size=self.max_output_size,
+            # max_output_size=self.max_output_size,
         )
 
 

omlish/lang/__init__.py

@@ -446,4 +446,6 @@ from ..lite.typing import (  # noqa
     Func1,
     Func2,
     Func3,
+
+    typing_annotations_attr,
 )

omlish/lang/objects.py

@@ -72,6 +72,7 @@ def super_meta(
         **kwargs: ta.Any,
 ) -> type:
     """Per types.new_class"""
+
     resolved_bases = types.resolve_bases(bases)
     if resolved_bases is not bases:
         if '__orig_bases__' in namespace: