omlish 0.0.0.dev405__py3-none-any.whl → 0.0.0.dev407__py3-none-any.whl

omlish/funcs/pipes.py

@@ -39,6 +39,7 @@ class Fn(abc.ABC, ta.Generic[T]):
 class Bind(Fn[T]):
     def __init__(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__()
+
         if Ellipsis not in args and Ellipsis not in kwargs:
             args += (Ellipsis,)
         self._fn = fn
@@ -75,6 +76,7 @@ bind = Bind
 class Pipe(Fn[T]):
     def __init__(self, lfns: ta.Sequence[ta.Callable], rfn: ta.Callable[..., T]) -> None:
         super().__init__()
+
         self._lfn, *self._rfns = [*lfns, rfn]
 
     def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
@@ -95,6 +97,7 @@ def pipe(*fns: ta.Callable) -> Pipe:
 class Apply(Fn[T]):
     def __init__(self, *fns: ta.Callable[[T], ta.Any]) -> None:
         super().__init__()
+
         self._fns = fns
 
     def __call__(self, o: T) -> T:  # noqa

omlish/graphs/trees.py

@@ -26,6 +26,7 @@ NodeGenerator: ta.TypeAlias = ta.Generator[NodeT]
 class NodeError(Exception, ta.Generic[NodeT]):
     def __init__(self, node: NodeT, msg: str, *args, **kwargs) -> None:
         super().__init__(msg, *args, **kwargs)  # noqa
+
         self._node = node
 
     @property

omlish/http/jwt.py

@@ -52,6 +52,7 @@ class Algorithm(abc.ABC):
 class HmacAlgorithm(Algorithm):
     def __init__(self, name: str, digest: ta.Any) -> None:
         super().__init__()
+
         self._name = name
         self._digest = digest
 
@@ -69,6 +70,7 @@ class HmacAlgorithm(Algorithm):
 class RsaAlgorithm(Algorithm):
     def __init__(self, name: str, digest: str) -> None:
         super().__init__()
+
         self._name = name
         self._digest = digest
 

omlish/http/multipart.py

@@ -31,6 +31,7 @@ class MultipartEncoder:
             boundary: bytes | None = None,
     ) -> None:
         super().__init__()
+
         self._fields = fields
         self._boundary = boundary or (b'----WebKitFormBoundary-' + uuid.uuid4().hex.encode('ascii'))
 

omlish/inject/impl/injector.py

@@ -111,6 +111,7 @@ class InjectorImpl(Injector, lang.Final):
     class _Request:
         def __init__(self, injector: 'InjectorImpl') -> None:
             super().__init__()
+
             self._injector = injector
             self._provisions: dict[Key, lang.Maybe] = {}
             self._seen_keys: set[Key] = set()

omlish/io/buffers.py

@@ -24,6 +24,7 @@ class DelimitingBuffer:
     class Error(Exception):
         def __init__(self, buffer: 'DelimitingBuffer') -> None:
             super().__init__(buffer)
+
             self.buffer = buffer
 
         def __repr__(self) -> str:
@@ -179,6 +180,7 @@ class ReadableListBuffer:
 
     def __init__(self) -> None:
         super().__init__()
+
         self._lst: list[bytes] = []
 
     def __len__(self) -> int:

omlish/io/compress/codecs.py

@@ -67,12 +67,12 @@ def make_compression_codec(
 
 
 def make_compression_lazy_loaded_codec(
-        mod_name: str,
-        attr_name: str,
+        module: str,
+        attr: str,
         codec: CompressionCodec,
 ) -> codecs.LazyLoadedCodec:
     return codecs.LazyLoadedCodec.new(
-        mod_name,
-        attr_name,
+        module,
+        attr,
         codec,
     )

omlish/iterators/unique.py

@@ -33,6 +33,7 @@ class UniqueIterator(ta.Iterator[UniqueItem[T]]):
             keyer: ta.Callable[[T], ta.Any] = lang.identity,
     ) -> None:
         super().__init__()
+
         self._it = enumerate(it)
         self._keyer = keyer
 

omlish/lang/classes/restrict.py

@@ -129,6 +129,7 @@ class NoBool:
 class _NoBoolDescriptor:
     def __init__(self, fn, instance=None, owner=None) -> None:
         super().__init__()
+
         self._fn = fn
         self._instance = instance
         self._owner = owner

omlish/lang/classes/simple.py

@@ -91,6 +91,7 @@ class Singleton:
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         _set_singleton_instance(super().__new__(cls))  # noqa
 
 

omlish/lang/contextmanagers.py

@@ -266,6 +266,7 @@ class Timer:
             clock: ta.Callable[[], float] | None = None,
     ) -> None:
         super().__init__()
+
         self._clock = clock if clock is not None else time.monotonic
 
     _start: float

omlish/lang/descriptors.py

@@ -200,6 +200,7 @@ decorator = _decorator
 class AccessForbiddenError(Exception):
     def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__(*((name,) if name is not None else ()), *args, **kwargs)  # noqa
+
         self.name = name
 
 
@@ -231,6 +232,7 @@ class _ClassOnly:
         if not isinstance(mth, classmethod):
             raise TypeError(f'must be classmethod: {mth}')
         super().__init__()
+
         self._mth = (mth,)
         functools.update_wrapper(self, mth)  # type: ignore
 

omlish/lang/objects.py

@@ -166,6 +166,7 @@ class SimpleProxy(ta.Generic[T]):
     class Descriptor:
         def __init__(self, attr: str) -> None:
             super().__init__()
+
             self._attr = attr
 
         def __get__(self, instance, owner=None):
@@ -189,6 +190,7 @@ class SimpleProxy(ta.Generic[T]):
 
     def __init__(self, wrapped: T) -> None:
         super().__init__()
+
         object.__setattr__(self, '__wrapped__', wrapped)
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:

omlish/lang/resolving.py

@@ -59,4 +59,5 @@ def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
 class Resolvable:
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         get_cls_fqcn(cls, nocheck=True)

omlish/lifecycles/contextmanagers.py

@@ -33,6 +33,7 @@ class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]
 class LifecycleContextManager(ta.Generic[LifecycleT]):
     def __init__(self, lifecycle: LifecycleT) -> None:
         super().__init__()
+
         self._lifecycle = lifecycle
         self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
 

omlish/lite/cached.py

@@ -13,6 +13,7 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
+
         self._fn = fn
         self._value = self._missing = object()
         functools.update_wrapper(self, fn)

omlish/lite/inject.py

@@ -402,6 +402,7 @@ class ContextvarInjectorScope(InjectorScope, abc.ABC):
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         check.not_in(abc.ABC, cls.__bases__)
         check.state(not hasattr(cls, '_cv'))
         cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
@@ -676,6 +677,7 @@ class _Injector(Injector):
     class _Request:
         def __init__(self, injector: '_Injector') -> None:
             super().__init__()
+
             self._injector = injector
             self._provisions: ta.Dict[InjectorKey, Maybe] = {}
             self._seen_keys: ta.Set[InjectorKey] = set()

omlish/lite/secrets.py

@@ -12,6 +12,7 @@ class Secret:
 
     def __init__(self, *, key: ta.Optional[str] = None, value: str) -> None:
         super().__init__()
+
         self._key = key
         setattr(self, self._VALUE_ATTR, lambda: value)
 

omlish/logs/handlers.py

@@ -10,6 +10,7 @@ import typing as ta
 class ListHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()
+
         self.records: ta.List[logging.LogRecord] = []
 
     def emit(self, record: logging.LogRecord) -> None:

omlish/manifests/base.py

@@ -12,14 +12,14 @@ NameAliasesManifestT = ta.TypeVar('NameAliasesManifestT', bound='NameAliasesMani
 
 @dc.dataclass(frozen=True)
 class ModAttrManifest:
-    mod_name: str
-    attr_name: str
+    module: str
+    attr: str
 
     def load(self) -> ta.Any:
         import importlib  # noqa
 
-        mod = importlib.import_module(self.mod_name)
-        return getattr(mod, self.attr_name)
+        mod = importlib.import_module(self.module)
+        return getattr(mod, self.attr)
 
 
 ##

omlish/manifests/loading.py

@@ -31,35 +31,42 @@ class ManifestLoader:
         def __init__(
                 self,
                 package: 'ManifestLoader.LoadedPackage',
-                manifest: Manifest,
+                resolved: 'ManifestLoader._ResolvedManifest',
         ) -> None:
             super().__init__()
 
             self._package = package
-            self._manifest = manifest
-
-            [(cls_key, value_dct)] = self._manifest.value.items()  # noqa
-            self._cls_key = cls_key
+            self._resolved = resolved
 
         def __repr__(self) -> str:
-            return f'{self.__class__.__name__}@{id(self):x}(package={self._package!r}, class_key={self._cls_key!r})'
+            return (
+                f'{self.__class__.__name__}@{id(self):x}('
+                f'package={self._package.name!r}, '
+                f'module={self._resolved.module!r}, '
+                f'class_key={self._resolved.class_key!r}'
+                f')'
+            )
 
         @property
         def package(self) -> 'ManifestLoader.LoadedPackage':
             return self._package
 
+        @property
+        def module(self) -> str:
+            return self._resolved.module
+
+        @property
+        def class_key(self) -> str:
+            return self._resolved.class_key
+
         @property
         def manifest(self) -> Manifest:
-            return self._manifest
+            return self._resolved.manifest
 
         @property
         def loader(self) -> 'ManifestLoader':
             return self._package.loader
 
-        @property
-        def class_key(self) -> str:
-            return self._cls_key
-
         _value: ta.Any
 
         def value(self) -> ta.Any:
@@ -68,7 +75,7 @@ class ManifestLoader:
             except AttributeError:
                 pass
 
-            value = self.loader._instantiate_loaded_manifest(self)  # noqa
+            value = self.loader._instantiate_resolved_manifest(self._resolved)  # noqa
             self._value = value
             return value
 
@@ -86,7 +93,7 @@ class ManifestLoader:
         _manifests: ta.Sequence['ManifestLoader.LoadedManifest']
 
         def __repr__(self) -> str:
-            return f'{self.__class__.__name__}(name={self._name!r})'
+            return f'{self.__class__.__name__}@{id(self):x}(name={self._name!r})'
 
         @property
         def loader(self) -> 'ManifestLoader':
@@ -287,14 +294,19 @@ class ManifestLoader:
 
     ##
 
+    @dc.dataclass()
     class ClassKeyError(Exception):
-        pass
+        key: str
+        module: ta.Optional[str] = None
 
     def _load_class_uncached(self, key: str) -> type:
-        if not key.startswith('$'):
+        if not key.startswith('!'):
             raise ManifestLoader.ClassKeyError(key)
 
         parts = key[1:].split('.')
+        if '' in parts:
+            raise ManifestLoader.ClassKeyError(key)
+
         pos = next(i for i, p in enumerate(parts) if p[0].isupper())
 
         mod_name = '.'.join(parts[:pos])
@@ -330,37 +342,79 @@ class ManifestLoader:
             raise TypeError(cls)
         mod_name = cls.__module__
         mod_name = self._module_reverse_remap.get(mod_name, mod_name)
-        return f'${mod_name}.{cls.__qualname__}'
+        return f'!{mod_name}.{cls.__qualname__}'
+
+    ##
+
+    class _ResolvedManifest(ta.NamedTuple):
+        manifest: Manifest
+        package: str
+
+        module: str
+        class_key: str
+        value_dct: ta.Any
+
+    @classmethod
+    def _resolve_raw_manifest(
+            cls,
+            m: Manifest,
+            *,
+            package_name: str,
+    ) -> _ResolvedManifest:
+        # self._module = module
+        # self._class_key = class_key
+        if not m.module.startswith('.'):
+            raise NameError(m.module)
+
+        module = package_name + m.module
+
+        [(class_key, value_dct)] = m.value.items()
+
+        if not class_key.startswith('!'):
+            raise ManifestLoader.ClassKeyError(class_key, module=module)
+
+        if class_key.startswith('!.'):
+            class_key = f'!{package_name}{class_key[1:]}'
+
+        # FIXME: move to builder
+        # elif key.startswith('$.'):
+        #     if module.startswith('.'):
+        #         raise NameError(module)
+        #     kl = key[1:].split('.')
+        #     ml = module.split('.')
+        #     lvl = len(kl) - kl[::-1].index('')
+        #     if lvl >= len(ml):
+        #         raise ManifestLoader.ClassKeyError(key, module=module)
+        #     rn = '.'.join([*ml[:-lvl], *kl[lvl:]])
+        #     return f'${rn}'
+
+        return ManifestLoader._ResolvedManifest(
+            manifest=m,
+            package=package_name,
+
+            module=module,
+            class_key=class_key,
+            value_dct=value_dct,
+        )
 
     ##
 
-    def _deserialize_raw_manifests(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
+    @classmethod
+    def _deserialize_raw_manifests(cls, obj: ta.Any) -> ta.Sequence[Manifest]:
         if not isinstance(obj, (list, tuple)):
             raise TypeError(obj)
 
         lst: ta.List[Manifest] = []
         for e in obj:
-            m = Manifest(**e)
-
-            m = dc.replace(m, module=pkg_name + m.module)
-
-            [(key, value_dct)] = m.value.items()
-            if not key.startswith('$'):
-                raise ManifestLoader.ClassKeyError(key)
-            if key.startswith('$.'):
-                key = f'${pkg_name}{key[1:]}'
-                m = dc.replace(m, value={key: value_dct})
-
-            lst.append(m)
+            lst.append(Manifest(**e))
 
         return lst
 
-    #
-
-    def _read_package_file_text(self, pkg_name: str, file_name: str) -> ta.Optional[str]:
+    @classmethod
+    def _read_package_file_text(cls, package_name: str, file_name: str) -> ta.Optional[str]:
         # importlib.resources.files actually imports the package - to avoid this, if possible, the file is read straight
         # off the filesystem.
-        spec = importlib.util.find_spec(pkg_name)
+        spec = importlib.util.find_spec(package_name)
         if (
                 spec is not None and
                 isinstance(spec.loader, importlib.machinery.SourceFileLoader) and
@@ -375,17 +429,16 @@ class ManifestLoader:
                     return f.read()
 
         from importlib import resources as importlib_resources  # noqa
-        t = importlib_resources.files(pkg_name).joinpath(file_name)
+        t = importlib_resources.files(package_name).joinpath(file_name)
         if not t.is_file():
             return None
         return t.read_text('utf-8')
 
-    #
-
     MANIFESTS_FILE_NAME: ta.ClassVar[str] = '.manifests.json'
 
-    def _load_package_uncached(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
-        src = self._read_package_file_text(pkg_name, self.MANIFESTS_FILE_NAME)
+    @classmethod
+    def _read_package_raw_manifests(cls, package_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
+        src = cls._read_package_file_text(package_name, cls.MANIFESTS_FILE_NAME)
         if src is None:
             return None
 
@@ -393,13 +446,21 @@ class ManifestLoader:
         if not isinstance(obj, (list, tuple)):
             raise TypeError(obj)
 
-        raw_lst = self._deserialize_raw_manifests(obj, pkg_name)
+        return cls._deserialize_raw_manifests(obj)
+
+    ##
+
+    def _load_package_uncached(self, package_name: str) -> ta.Optional[LoadedPackage]:
+        if (raw_lst := self._read_package_raw_manifests(package_name)) is None:
+            return None
 
-        ld_pkg = ManifestLoader.LoadedPackage(self, pkg_name)
+        ld_pkg = ManifestLoader.LoadedPackage(self, package_name)
 
         ld_man_lst: ta.List[ManifestLoader.LoadedManifest] = []
         for raw in raw_lst:
-            ld_man = ManifestLoader.LoadedManifest(ld_pkg, raw)
+            rsv = self._resolve_raw_manifest(raw, package_name=package_name)
+
+            ld_man = ManifestLoader.LoadedManifest(ld_pkg, rsv)
 
             ld_man_lst.append(ld_man)
 
@@ -407,19 +468,19 @@ class ManifestLoader:
 
         return ld_pkg
 
-    def _load_package_locked(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
+    def _load_package_locked(self, package_name: str) -> ta.Optional[LoadedPackage]:
         try:
-            return self._loaded_packages[pkg_name]
+            return self._loaded_packages[package_name]
         except KeyError:
             pass
 
-        pkg = self._load_package_uncached(pkg_name)
-        self._loaded_packages[pkg_name] = pkg
+        pkg = self._load_package_uncached(package_name)
+        self._loaded_packages[package_name] = pkg
         return pkg
 
-    def load_package(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
+    def load_package(self, package_name: str) -> ta.Optional[LoadedPackage]:
         with self._lock:
-            return self._load_package_locked(pkg_name)
+            return self._load_package_locked(package_name)
 
     ##
 
@@ -429,10 +490,9 @@ class ManifestLoader:
         else:
             return cls(**kwargs)
 
-    def _instantiate_loaded_manifest(self, ld_man: LoadedManifest) -> ta.Any:
-        [(cls_key, value_dct)] = ld_man.manifest.value.items()
-        cls = self._load_class(cls_key)
-        value = self._instantiate_value(cls, **value_dct)
+    def _instantiate_resolved_manifest(self, resolved: _ResolvedManifest) -> ta.Any:
+        cls = self._load_class(resolved.class_key)
+        value = self._instantiate_value(cls, **resolved.value_dct)
         return value
 
     ##

omlish/manifests/static.py

@@ -13,8 +13,8 @@ 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__
+                'module' not in cls.__dict__
         ):
-            setattr(cls, 'mod_name', cls.__module__)
+            setattr(cls, 'module', cls.__module__)
 
         super().__init_subclass__(**kwargs)

omlish/manifests/types.py

@@ -9,7 +9,7 @@ import typing as ta
 
 @dc.dataclass(frozen=True)
 class ManifestOrigin:
-    module: str
+    module: str  # Always starts with exactly one '.'
     attr: ta.Optional[str]  # None if inline
 
     file: str
@@ -18,4 +18,4 @@ class ManifestOrigin:
 
 @dc.dataclass(frozen=True)
 class Manifest(ManifestOrigin):
-    value: ta.Any
+    value: ta.Any  # [{class_key: value_dct}], where class_key is of the form `!.foo.bar.Class` or `!baz.quz.Class`

omlish/marshal/factories.py

@@ -41,6 +41,7 @@ class TypeMapFactory(mfs.MatchFn[[C, rfl.Type], R]):
 class TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
     def __init__(self, f: mfs.MatchFn[[C, rfl.Type], R]) -> None:
         super().__init__()
+
         self._f = f
         self._dct: dict[rfl.Type, R | None] = {}
         self._mtx = threading.RLock()
@@ -90,6 +91,7 @@ class RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
             prx: ta.Callable[[], tuple[R, ta.Callable[[R], None]]],
     ) -> None:
         super().__init__()
+
         self._f = f
         self._prx = prx
         self._dct: dict[rfl.Type, R] = {}

omlish/marshal/polymorphism/metadata.py

@@ -39,6 +39,7 @@ class Impls(ta.Sequence[Impl]):
             lst: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
+
         self._lst = list(lst)
 
         by_ty: dict[type, Impl] = {}
@@ -89,6 +90,7 @@ class Polymorphism:
             impls: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
+
         self._ty = ty
         self._impls = Impls(impls)
 

omlish/marshal/registries.py

@@ -35,6 +35,7 @@ class _KeyRegistryItems:
 class Registry:
     def __init__(self) -> None:
         super().__init__()
+
         self._mtx = threading.Lock()
         self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
         self._dct: dict[ta.Any, _KeyRegistryItems] = {}

omlish/multiprocessing/spawn.py

@@ -24,6 +24,7 @@ class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
     def __init__(self, process_obj: 'ExtrasSpawnProcess', *, extras: SpawnExtras) -> None:
         self.__extras = extras
         self.__pass_fds = extras.pass_fds
+
         super().__init__(process_obj)
 
     def _launch(self, process_obj: 'ExtrasSpawnProcess') -> None:
@@ -38,6 +39,7 @@ class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
 class ExtrasSpawnProcess(mp.context.SpawnProcess):
     def __init__(self, *args: ta.Any, extras: SpawnExtras, **kwargs: ta.Any) -> None:
         self.__extras = extras
+
         super().__init__(*args, **kwargs)
 
     def _Popen(self, process_obj: 'ExtrasSpawnProcess') -> ExtrasSpawnPosixPopen:  # type: ignore  # noqa
@@ -56,6 +58,7 @@ class ExtrasSpawnProcess(mp.context.SpawnProcess):
 class ExtrasSpawnContext(mp.context.SpawnContext):
     def __init__(self, extras: SpawnExtras = SpawnExtras()) -> None:
         self.__extras = extras
+
         super().__init__()
 
     def Process(self, *args: ta.Any, **kwargs: ta.Any):  # type: ignore  # noqa

omlish/os/pidfiles/__main__.py

@@ -1,7 +1,7 @@
 # @omlish-manifest
-_CLI_MODULE = {'$omdev.cli.types.CliModule': {
-    'cmd_name': 'pidfiles',
-    'mod_name': __name__,
+_CLI_MODULE = {'!omdev.cli.types.CliModule': {
+    'name': 'pidfiles',
+    'module': __name__,
 }}
 
 

omlish/secrets/openssl.py

@@ -56,6 +56,7 @@ class OpensslAescbcCrypto(Crypto):
             iters: int = 10_000,
     ) -> None:
         super().__init__()
+
         self._iters = iters
 
     def generate_key(self, sz: int = DEFAULT_KEY_SIZE) -> bytes:
@@ -131,6 +132,7 @@ class OpensslSubprocessAescbcCrypto(Crypto):
             file_input: SubprocessFileInputMethod = temp_subprocess_file_input,
     ) -> None:
         super().__init__()
+
         self._cmd = cmd
         self._timeout = timeout
         self._file_input = file_input

omlish/secrets/pwgen.py

@@ -76,9 +76,9 @@ def _main() -> None:
 
 
 # @omlish-manifest
-_CLI_MODULE = {'$omdev.cli.types.CliModule': {
-    'cmd_name': 'pwgen',
-    'mod_name': __name__,
+_CLI_MODULE = {'!omdev.cli.types.CliModule': {
+    'name': 'pwgen',
+    'module': __name__,
 }}