omlish 0.0.0.dev236__py3-none-any.whl → 0.0.0.dev238__py3-none-any.whl

omlish/dataclasses/static.py

@@ -0,0 +1,176 @@
+import abc
+import copy
+import dataclasses as dc
+import typing as ta
+
+from .. import lang
+from ..lite.dataclasses import is_immediate_dataclass
+from .impl.api import dataclass
+
+
+##
+
+
+class Static(lang.Abstract):
+    __static_dataclass_class__: ta.ClassVar[type]
+    __static_dataclass_instance__: ta.ClassVar[ta.Any]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__new__', '__init__'):
+            if a in cls.__dict__ and not (cls.__dict__[a] == getattr(Static, a)):
+                raise TypeError(f'Static base class {cls} must not implement {a}')
+
+        if cls.__init__ is not Static.__init__:
+            # This is necessary to make type-checking work (by allowing it to accept zero). This isn't strictly
+            # necessary, but since it's useful to do sometimes it might as well be done everywhere to prevent clashing.
+            raise TypeError(f'Static.__init__ should be first in mro of {cls}')
+
+        #
+
+        b_dc_lst = []
+
+        def b_dc_rec(b_cls: type) -> None:  # noqa
+            if issubclass(b_cls, Static):
+                return
+            elif is_immediate_dataclass(b_cls):
+                b_dc_lst.append(b_cls)
+            elif dc.is_dataclass(b_cls):
+                for sb_cls in b_cls.__bases__:
+                    b_dc_rec(sb_cls)
+
+        for b_cls in cls.__bases__:
+            b_dc_rec(b_cls)
+
+        b_sdc_dc_lst = [
+            b_cls.__static_dataclass_class__
+            for b_cls in cls.__bases__
+            if issubclass(b_cls, Static)
+            and b_cls is not Static
+        ]
+
+        sdc_dc_set = {*b_dc_lst, *b_sdc_dc_lst}
+        if not sdc_dc_set:
+            raise TypeError(f'Static dataclass {cls} inherits from no dataclass')
+
+        # Base static dataclasses of various types are allowed as long as there is exactly one final subclass involved.
+        # For example, a ModAttrManifest dataclass with an abstract StaticModAttrManifest subclass which sets a default
+        # mod_name may be mixed in with a further down use-case specific Manifest subclass.
+        sdc_dc_set -= {
+            m_cls
+            for s_cls in sdc_dc_set
+            for m_cls in s_cls.__mro__
+            if m_cls is not s_cls
+        }
+
+        if len(sdc_dc_set) > 1:
+            raise TypeError(f'Static dataclass {cls} inherits from multiple dataclasses: {sdc_dc_set!r}')
+        [sdc_cls] = sdc_dc_set
+
+        if '__static_dataclass_class__' in cls.__dict__:
+            raise AttributeError
+        setattr(cls, '__static_dataclass_class__', sdc_cls)
+
+        #
+
+        expected_fld_order: ta.Sequence[str] | None = None
+        is_abstract = lang.is_abstract_class(cls) or abc.ABC in cls.__bases__
+        if not is_abstract:
+            if is_immediate_dataclass(cls):
+                raise TypeError(cls)
+
+            flds_dct = {}
+            for b_cls in cls.__mro__:
+                if not dc.is_dataclass(b_cls):
+                    continue
+                b_flds = dc.fields(b_cls)  # noqa
+                for fld in b_flds:
+                    if fld.name in flds_dct:
+                        continue
+                    flds_dct[fld.name] = fld
+
+            # Annotations are the authoritative source of field order.
+            new_anns = {}
+
+            for fld in flds_dct.values():
+                new_fld = copy.copy(fld)
+
+                try:
+                    v = cls.__dict__[fld.name]
+                except KeyError:
+                    if fld.default is dc.MISSING and fld.default_factory is dc.MISSING:
+                        raise TypeError(f'Field {fld.name!r} of class {cls} is not set and has no default') from None
+                else:
+                    if isinstance(v, dc.Field):
+                        raise TypeError(f'Static dataclass {cls} may not introduce new fields: {fld.name}: {v}')
+
+                    new_fld.default = dc.MISSING
+                    # Use a default_factory to allow unsafe (mutable) values.
+                    new_fld.default_factory = (lambda v2: lambda: v2)(v)  # noqa
+
+                setattr(cls, fld.name, new_fld)
+                new_anns[fld.name] = fld.type
+
+            # Non-abstract static dataclasses may not introduce new fields.
+            expected_fld_order = list(flds_dct)
+
+            new_anns.update({
+                k: v
+                for k, v in getattr(cls, '__annotations__', {}).items()
+                if k not in new_anns
+            })
+
+            cls.__annotations__ = new_anns
+
+        else:
+            for b_cls in cls.__bases__:
+                if hasattr(b_cls, '__static_dataclass_instance__'):
+                    raise TypeError(
+                        f'Abstract static dataclass {cls} may not inherit from non-abstract static dataclass {b_cls}',
+                    )
+
+        # Explicitly forbid dc transforms that rebuild the class, such as slots.
+        if (dc_cls := dataclass(cls, frozen=True)) is not cls:
+            raise TypeError(dc_cls)
+
+        dc_flds = dc.fields(cls)  # type: ignore[arg-type]  # noqa
+
+        if expected_fld_order is not None:
+            dc_fld_order = [f.name for f in dc_flds]
+            if dc_fld_order != expected_fld_order:
+                raise TypeError(
+                    f'Static dataclass field order {dc_fld_order!r} != expected field order {expected_fld_order!r}',
+                )
+
+        if not is_abstract:
+            # This is the only time the Statices are ever actually instantiated, and it's only to produce the
+            # kwargs passed to the underlying dataclass.
+            tmp_inst = cls()
+            inst_kw = dc.asdict(tmp_inst)  # type: ignore[call-overload]  # noqa
+            inst = sdc_cls(**inst_kw)
+
+            cls.__static_dataclass_instance__ = inst
+
+            # Make all field values available via static `Class.field` access, even those created via a factory. Note
+            # that further inheritance of this non-abstract Static will continue to inherit dc.Field instances
+            # (including things like their metadata) via dc.fields() access, which does not reference `cls.__dict__`.
+            for fld in dc_flds:
+                v = getattr(inst, fld.name)
+                setattr(cls, fld.name, v)
+
+            def __new__(new_cls, *new_args, **new_kwargs):  # noqa
+                try:
+                    return new_cls.__dict__['__static_dataclass_instance__']
+                except KeyError:
+                    return super().__new__(new_cls)
+
+            cls.__new__ = __new__  # type: ignore
+
+        cls.__init__ = Static.__init__  # type: ignore
+
+    @ta.final
+    def __init__(self) -> None:
+        # This stub serves to allow `StaticSubclass()` to typecheck by allowing it to accept only zero arguments. Note
+        # that this is only the case when `Static` is first in mro.
+        raise TypeError('May not instantiate static dataclasses')

omlish/dataclasses/utils.py

@@ -4,7 +4,6 @@ import types
 import typing as ta
 
 from .. import check
-from .impl.internals import FIELDS_ATTR
 from .impl.metadata import METADATA_ATTR
 from .impl.metadata import UserMetadata
 from .impl.params import DEFAULT_FIELD_EXTRAS
@@ -18,14 +17,6 @@ T = ta.TypeVar('T')
 ##
 
 
-def is_immediate_dataclass(cls: type) -> bool:
-    check.isinstance(cls, type)
-    return FIELDS_ATTR in cls.__dict__
-
-
-##
-
-
 def opt_repr(o: ta.Any) -> str | None:
     return repr(o) if o is not None else None
 

omlish/graphs/trees.py

@@ -56,7 +56,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         self._set_fac: ta.Callable[..., ta.MutableSet[NodeT]] = col.IdentitySet if identity else set
         self._dict_fac: ta.Callable[..., ta.MutableMapping[NodeT, ta.Any]] = col.IdentityKeyDict if identity else dict
-        self._idx_seq_fac: ta.Callable[..., col.IndexedSeq[NodeT]] = functools.partial(col.IndexedSeq, identity=identity)  # type: ignore  # noqa
+        self._rank_seq_fac: ta.Callable[..., col.RankedSeq[NodeT]] = functools.partial(col.RankedSeq, identity=identity)  # type: ignore  # noqa
 
         def walk(cur: NodeT, parent: NodeT | None) -> None:
             check.not_none(cur)
@@ -88,10 +88,10 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         walk(root, None)
 
-        self._nodes = self._idx_seq_fac(nodes)
+        self._nodes = self._rank_seq_fac(nodes)
         self._node_set: ta.AbstractSet[NodeT] = node_set
-        self._children_by_node: ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]] = self._dict_fac(
-            [(n, self._idx_seq_fac(cs)) for n, cs in children_by_node.items()])
+        self._children_by_node: ta.Mapping[NodeT | None, col.RankedSeq[NodeT]] = self._dict_fac(
+            [(n, self._rank_seq_fac(cs)) for n, cs in children_by_node.items()])
         self._child_sets_by_node: ta.Mapping[NodeT | None, ta.AbstractSet[NodeT]] = child_sets_by_node
         self._parents_by_node: ta.Mapping[NodeT, NodeT | None] = parents_by_node
 
@@ -100,7 +100,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         return self._root
 
     @property
-    def nodes(self) -> col.IndexedSeq[NodeT]:
+    def nodes(self) -> col.RankedSeq[NodeT]:
         return self._nodes
 
     @property
@@ -116,7 +116,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         return self._node_set
 
     @property
-    def children_by_node(self) -> ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]]:
+    def children_by_node(self) -> ta.Mapping[NodeT | None, col.RankedSeq[NodeT]]:
         return self._children_by_node
 
     @property
@@ -224,8 +224,8 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
                 break
             yield cur
 
-    def get_lineage(self, node: NodeT) -> col.IndexedSeq[NodeT]:
-        return self._idx_seq_fac(reversed([node, *self.iter_ancestors(node)]))
+    def get_lineage(self, node: NodeT) -> col.RankedSeq[NodeT]:
+        return self._rank_seq_fac(reversed([node, *self.iter_ancestors(node)]))
 
     def get_first_parent_of_type(self, node: NodeT, ty: type[T]) -> T | None:
         for cur in self.iter_ancestors(node):

omlish/lang/__init__.py

@@ -135,6 +135,7 @@ from .generators import (  # noqa
 
 from .imports import (  # noqa
     can_import,
+    get_real_module_name,
     import_all,
     import_attr,
     import_module,

omlish/lang/descriptors.py

@@ -48,25 +48,26 @@ def _has_method_descriptor(obj: ta.Any) -> bool:
                 return False
 
 
-def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
+def unwrap_method_descriptors(fn: ta.Any) -> ta.Any:
     while is_method_descriptor(fn):
-        fn = fn.__func__  # type: ignore  # noqa
+        fn = fn.__func__
     return fn
 
 
 ##
 
 
-def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
+def unwrap_func_with_partials(fn: ta.Any) -> tuple[ta.Any, list[functools.partial]]:
     ps = []
     while True:
         if is_method_descriptor(fn) or isinstance(fn, types.MethodType):
-            fn = fn.__func__  # type: ignore
+            fn = fn.__func__
 
         elif hasattr(fn, '__wrapped__'):
             nxt = fn.__wrapped__
-            if not callable(nxt):
-                raise TypeError(nxt)
+            # FIXME: ?
+            # if not callable(nxt):
+            #     raise TypeError(nxt)
             if nxt is fn:
                 raise TypeError(fn)
             fn = nxt
@@ -83,7 +84,7 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
     return fn, ps
 
 
-def unwrap_func(fn: ta.Callable) -> ta.Callable:
+def unwrap_func(fn: ta.Any) -> ta.Any:
     uw, _ = unwrap_func_with_partials(fn)
     return uw
 

omlish/lang/imports.py

@@ -384,3 +384,18 @@ def proxy_init(
             raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')
 
     pi.add(package, attrs)
+
+
+##
+
+
+def get_real_module_name(globals: ta.Mapping[str, ta.Any]) -> str:  # noqa
+    module = sys.modules[globals['__name__']]
+
+    if module.__spec__ and module.__spec__.name:
+        return module.__spec__.name
+
+    if module.__package__:
+        return module.__package__
+
+    raise RuntimeError("Can't determine real module name")

omlish/lite/dataclasses.py

@@ -3,6 +3,18 @@ import dataclasses as dc
 import typing as ta
 
 
+##
+
+
+def is_immediate_dataclass(cls: type) -> bool:
+    if not isinstance(cls, type):
+        raise TypeError(cls)
+    return dc._FIELDS in cls.__dict__  # type: ignore[attr-defined]  # noqa
+
+
+##
+
+
 def dataclass_cache_hash(
         *,
         cached_hash_attr: str = '__dataclass_hash__',
@@ -33,6 +45,9 @@ def dataclass_cache_hash(
     return inner
 
 
+##
+
+
 def dataclass_maybe_post_init(sup: ta.Any) -> bool:
     if not isinstance(sup, super):
         raise TypeError(sup)
@@ -44,6 +59,9 @@ def dataclass_maybe_post_init(sup: ta.Any) -> bool:
     return True
 
 
+##
+
+
 def dataclass_repr_filtered(
         obj: ta.Any,
         fn: ta.Callable[[ta.Any, dc.Field, ta.Any], bool],

omlish/manifests/__init__.py

@@ -1,2 +0,0 @@
-# @omlish-lite
-from .types import Manifest  # noqa

omlish/manifests/base.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import typing as ta
 

omlish/manifests/load.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 Should be kept somewhat lightweight - used in cli entrypoints.
 

omlish/manifests/static.py

@@ -0,0 +1,20 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .base import ModAttrManifest
+
+
+##
+
+
+class StaticModAttrManifest(dc.Static, ModAttrManifest, abc.ABC):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        if (
+                not (lang.is_abstract_class(cls) or abc.ABC in cls.__bases__) and
+                'mod_name' not in cls.__dict__
+        ):
+            setattr(cls, 'mod_name', cls.__module__)
+
+        super().__init_subclass__(**kwargs)

omlish/manifests/types.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import typing as ta
 

omlish/metadata.py

@@ -0,0 +1,153 @@
+"""
+These attempt to punch through *all* wrappers. The the usecases involve having things like bound methods, classmethods,
+functools.partial instances, and needing to get the metadata of the underlying thing the end-user wrote.
+
+TODO:
+ - re type targets:
+  - unwrap instances of objects to their types?
+  - merge mro?
+  - are these better left up to callers? too usecase-specific to favor either way?
+"""
+import types
+import typing as ta
+
+from . import check
+from . import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class ObjectMetadata(lang.Abstract):
+    pass
+
+
+class ObjectMetadataTarget(lang.Abstract):
+    pass
+
+
+##
+
+
+_VALID_OBJECT_METADATA_TARGET_TYPES: tuple[type, ...] = (
+    type,
+
+    types.FunctionType,
+    # *not* types.MethodType - must unwrap to unbound class func
+    # *not* functools.partial - must unwrap to underlying func
+
+    ObjectMetadataTarget,
+)
+
+
+class ObjectMetadataTargetTypeError(TypeError):
+    pass
+
+
+def _unwrap_object_metadata_target(obj: ta.Any) -> ta.Any:
+    tgt: ta.Any = obj
+    tgt = lang.unwrap_func(tgt)
+
+    if not isinstance(tgt, _VALID_OBJECT_METADATA_TARGET_TYPES):
+        raise ObjectMetadataTargetTypeError(tgt)
+
+    return tgt
+
+
+##
+
+
+_OBJECT_METADATA_ATTR = '__' + __name__.replace('.', '_') + '__metadata__'
+
+
+def append_object_metadata(obj: T, *mds: ObjectMetadata) -> T:
+    for md in mds:
+        check.isinstance(md, ObjectMetadata)
+
+    tgt = _unwrap_object_metadata_target(obj)
+    dct = tgt.__dict__
+
+    if isinstance(dct, types.MappingProxyType):
+        for _ in range(2):
+            try:
+                lst = dct[_OBJECT_METADATA_ATTR]
+            except KeyError:
+                setattr(tgt, _OBJECT_METADATA_ATTR, [])
+            else:
+                break
+        else:
+            raise RuntimeError
+
+    else:
+        lst = dct.setdefault(_OBJECT_METADATA_ATTR, [])
+
+    lst.extend(mds)
+    return obj
+
+
+def get_object_metadata(obj: ta.Any, *, strict: bool = False) -> ta.Sequence[ObjectMetadata]:
+    try:
+        tgt = _unwrap_object_metadata_target(obj)
+    except ObjectMetadataTargetTypeError:
+        if not strict:
+            return ()
+        raise
+
+    try:
+        dct = tgt.__dict__
+    except AttributeError:
+        return ()
+
+    return dct.get(_OBJECT_METADATA_ATTR, ())
+
+
+##
+
+
+class DecoratorObjectMetadata(ObjectMetadata, lang.Abstract):
+    _OBJECT_METADATA_TARGET_TYPES: ta.ClassVar[tuple[type, ...] | None] = None
+
+    def __init_subclass__(
+            cls,
+            *,
+            object_metadata_target_types: ta.Iterable[type] | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if object_metadata_target_types is not None:
+            tts = tuple(object_metadata_target_types)
+            for tt in tts:
+                check.issubclass(tt, _VALID_OBJECT_METADATA_TARGET_TYPES)
+            setattr(cls, '_OBJECT_METADATA_TARGET_TYPES', tts)
+
+    def __call__(self, obj: T) -> T:
+        tgt: ta.Any = obj
+        if (tts := type(self)._OBJECT_METADATA_TARGET_TYPES) is not None:  # noqa
+            tgt = _unwrap_object_metadata_target(tgt)
+            check.isinstance(tgt, tts)
+
+        append_object_metadata(tgt, self)
+        return obj
+
+
+#
+
+
+class ClassDecoratorObjectMetadata(
+    DecoratorObjectMetadata,
+    lang.Abstract,
+    object_metadata_target_types=[type],
+):
+    pass
+
+
+class FunctionDecoratorObjectMetadata(
+    DecoratorObjectMetadata,
+    lang.Abstract,
+    object_metadata_target_types=[types.FunctionType],
+):
+    pass

omlish/os/filemodes.py

@@ -77,6 +77,48 @@ class FileMode:
             )
         )
 
+    @classmethod
+    def from_flags(cls, i: int) -> 'FileMode':
+        if i & os.O_RDWR:
+            i &= ~os.O_RDWR
+            read = write = True
+        elif i & os.O_WRONLY:
+            i &= ~os.O_WRONLY
+            write = True
+            read = False
+        else:
+            read = True
+            write = False
+
+        create = False
+        if i & os.O_CREAT:
+            i &= ~os.O_CREAT
+            create = True
+
+        exists: str | None = None
+        if i & os.O_TRUNC:
+            i &= ~os.O_TRUNC
+            exists = check.replacing_none(exists, 'truncate')
+        if i & os.O_EXCL:
+            i &= ~os.O_EXCL
+            exists = check.replacing_none(exists, 'fail')
+        if i & os.O_APPEND:
+            i &= ~os.O_APPEND
+            exists = check.replacing_none(exists, 'append')
+        if exists is None:
+            exists = 'beginning'
+
+        if i:
+            raise ValueError(i)
+
+        return FileMode(
+            read=read,
+            write=write,
+            create=create,
+            exists=exists,  # type: ignore
+            binary=True,
+        )
+
     #
 
     def render(self) -> str:

{omlish-0.0.0.dev236.dist-info → omlish-0.0.0.dev238.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev236
+Version: 0.0.0.dev238
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause