omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/logs/typed/bindings.py

@@ -16,6 +16,7 @@ from ...lite.abstract import Abstract
 from .types import TYPED_LOGGER_VALUE_OR_PROVIDER_OR_ABSENT_TYPES
 from .types import TYPED_LOGGER_VALUE_OR_PROVIDER_TYPES
 from .types import DefaultTypedLoggerValue
+from .types import MultiTypedLoggerValue
 from .types import TypedLoggerConstFieldValue
 from .types import TypedLoggerField
 from .types import TypedLoggerFieldValue
@@ -92,6 +93,9 @@ class TypedLoggerBindings(Abstract):
         accept_value: ta.Callable[[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent], None]
         accept_values: ta.Callable[[ta.Iterable[ta.Tuple[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent]]], None]  # noqa
 
+        accept_multi_value: ta.Callable[[ta.Type[MultiTypedLoggerValue], MultiTypedLoggerValue], None]  # noqa
+        accept_multi_values: ta.Callable[[ta.Iterable[ta.Tuple[ta.Type[MultiTypedLoggerValue], MultiTypedLoggerValue]]], None]  # noqa
+
         accept_const_values: ta.Callable[[ta.Iterable[ta.Tuple[ta.Type[TypedLoggerValue], TypedLoggerValueOrAbsent]]], None]  # noqa
 
         accept_value_wrapping: ta.Callable[[ta.Union['TypedLoggerValueWrapper', 'FullTypedLoggerBindings._ValueWrappingState']], None]  # noqa
@@ -110,19 +114,11 @@ class FullTypedLoggerBindings(TypedLoggerBindings):
             self,
             *items: TypedLoggerBindingItem,
             override: bool = False,
+            override_multis: bool = False,
     ) -> None:
         kd: ta.Dict[str, TypedLoggerFieldValue] = {}
         dup_kd: ta.Dict[str, ta.List[TypedLoggerFieldValue]] = {}
 
-        vd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent] = {}
-        dup_vd: ta.Dict[ta.Type[TypedLoggerValue], ta.List[TypedLoggerValueOrProviderOrAbsent]] = {}
-
-        cvd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrAbsent] = {}
-
-        vwl: ta.List[ta.Union[TypedLoggerValueWrapper, FullTypedLoggerBindings._ValueWrappingState]] = []
-
-        vst: TypedLoggerBindings._Visitor
-
         if not override:
             def add_kd(kd_k: str, kd_v: TypedLoggerFieldValue) -> None:  # noqa
                 if kd_k in kd:
@@ -130,42 +126,71 @@ class FullTypedLoggerBindings(TypedLoggerBindings):
                 else:
                     kd[kd_k] = kd_v
 
+            def add_kds(it: 'ta.Iterable[ta.Tuple[str, TypedLoggerFieldValue]]') -> None:  # noqa
+                collections.deque(itertools.starmap(add_kd, it), maxlen=0)
+
+        else:
+            add_kd = kd.__setitem__  # type: ignore[assignment]
+            add_kds = kd.update  # type: ignore[assignment]
+
+        #
+
+        vd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent] = {}
+        dup_vd: ta.Dict[ta.Type[TypedLoggerValue], ta.List[TypedLoggerValueOrProviderOrAbsent]] = {}
+
+        if not override:
             def add_vd(vd_k: 'ta.Type[TypedLoggerValue]', vd_v: TypedLoggerValueOrProviderOrAbsent) -> None:  # noqa
                 if vd_k in vd:
                     dup_vd.setdefault(vd_k, []).append(vd_v)
                 else:
                     vd[vd_k] = vd_v
 
-            def add_kds(it: 'ta.Iterable[ta.Tuple[str, TypedLoggerFieldValue]]') -> None:  # noqa
-                collections.deque(itertools.starmap(add_kd, it), maxlen=0)
-
             def add_vds(it: 'ta.Iterable[ta.Tuple[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent]]') -> None:  # noqa
                 collections.deque(itertools.starmap(add_vd, it), maxlen=0)
 
-            vst = TypedLoggerBindings._Visitor(  # noqa
-                add_kd,
-                add_kds,
+        else:
+            add_vd = vd.__setitem__  # type: ignore[assignment]
+            add_vds = vd.update  # type: ignore[assignment]
+
+        #
 
-                add_vd,
-                add_vds,
+        mvd: ta.Dict[ta.Type[MultiTypedLoggerValue], ta.List[MultiTypedLoggerValue]] = {}
 
-                cvd.update,
+        if override_multis:
+            def add_mvd(mvd_k: 'ta.Type[MultiTypedLoggerValue]', mvd_v: MultiTypedLoggerValue) -> None:  # noqa
+                try:
+                    mvd_l = mvd[mvd_k]
+                except KeyError:
+                    mvd_l = mvd[mvd_k] = []
+                mvd_l.append(mvd_v)
 
-                vwl.append,
-            )
+            def add_mvds(it: 'ta.Iterable[ta.Tuple[ta.Type[MultiTypedLoggerValue], MultiTypedLoggerValue]]') -> None:
+                collections.deque(itertools.starmap(add_mvd, it), maxlen=0)
 
         else:
-            vst = TypedLoggerBindings._Visitor(  # noqa
-                kd.__setitem__,
-                kd.update,
+            add_mvd = mvd.__setitem__  # type: ignore[assignment]
+            add_mvds = mvd.update  # type: ignore[assignment]
 
-                vd.__setitem__,
-                vd.update,
+        #
 
-                cvd.update,
+        cvd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrAbsent] = {}
 
-                vwl.append,
-            )
+        vwl: ta.List[ta.Union[TypedLoggerValueWrapper, FullTypedLoggerBindings._ValueWrappingState]] = []
+
+        vst = TypedLoggerBindings._Visitor(  # noqa
+            add_kd,
+            add_kds,
+
+            add_vd,
+            add_vds,
+
+            add_mvd,
+            add_mvds,
+
+            cvd.update,
+
+            vwl.append,
+        )
 
         for o in items:
             o._typed_logger_visit_bindings(vst)  # noqa
@@ -288,18 +313,22 @@ class ChainTypedLoggerBindings(TypedLoggerBindings):
         kd: ta.Dict[str, TypedLoggerFieldValue] = {}
         dup_kd: ta.Dict[str, ta.List[TypedLoggerFieldValue]] = {}
 
-        vd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent] = {}
-        dup_vd: ta.Dict[ta.Type[TypedLoggerValue], ta.List[TypedLoggerValueOrProviderOrAbsent]] = {}
-
-        pcv = dict(parent.const_value_map)
-        cvd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrAbsent] = {}
-
         def add_kd(kd_k: str, kd_v: TypedLoggerFieldValue) -> None:  # noqa
             if kd_k in kd:
                 dup_kd.setdefault(kd_k, []).append(kd_v)
             else:
                 kd[kd_k] = kd_v
 
+        def add_kds(it: 'ta.Iterable[ta.Tuple[str, TypedLoggerFieldValue]]') -> None:  # noqa
+            collections.deque(itertools.starmap(add_kd, it), maxlen=0)
+
+        #
+
+        vd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent] = {}
+        dup_vd: ta.Dict[ta.Type[TypedLoggerValue], ta.List[TypedLoggerValueOrProviderOrAbsent]] = {}
+
+        pcv = dict(parent.const_value_map)
+
         def add_vd(vd_k: 'ta.Type[TypedLoggerValue]', vd_v: TypedLoggerValueOrProviderOrAbsent) -> None:  # noqa
             if vd_k in vd:
                 dup_vd.setdefault(vd_k, []).append(vd_v)
@@ -307,12 +336,27 @@ class ChainTypedLoggerBindings(TypedLoggerBindings):
                 vd[vd_k] = vd_v
                 pcv.pop(vd_k, None)
 
-        def add_kds(it: 'ta.Iterable[ta.Tuple[str, TypedLoggerFieldValue]]') -> None:  # noqa
-            collections.deque(itertools.starmap(add_kd, it), maxlen=0)
-
         def add_vds(it: 'ta.Iterable[ta.Tuple[ta.Type[TypedLoggerValue], TypedLoggerValueOrProviderOrAbsent]]') -> None:  # noqa
             collections.deque(itertools.starmap(add_vd, it), maxlen=0)
 
+        #
+
+        mvd: ta.Dict[ta.Type[MultiTypedLoggerValue], ta.List[MultiTypedLoggerValue]] = {}
+
+        def add_mvd(mvd_k: 'ta.Type[MultiTypedLoggerValue]', mvd_v: MultiTypedLoggerValue) -> None:  # noqa
+            try:
+                mvd_l = mvd[mvd_k]
+            except KeyError:
+                mvd_l = mvd[mvd_k] = []
+            mvd_l.append(mvd_v)
+
+        def add_mvds(it: 'ta.Iterable[ta.Tuple[ta.Type[MultiTypedLoggerValue], MultiTypedLoggerValue]]') -> None:
+            collections.deque(itertools.starmap(add_mvd, it), maxlen=0)
+
+        #
+
+        cvd: ta.Dict[ta.Type[TypedLoggerValue], TypedLoggerValueOrAbsent] = {}
+
         def bad_type(*args, **kwargs):  # noqa
             raise ChainTypedLoggerBindingsUnhandledItemError
 
@@ -323,6 +367,9 @@ class ChainTypedLoggerBindings(TypedLoggerBindings):
             add_vd,
             add_vds,
 
+            add_mvd,
+            add_mvds,
+
             cvd.update,
 
             bad_type,
@@ -448,6 +495,30 @@ _AS_TYPED_LOGGER_BINDINGS_FIELD_VALUE_DIRECT_TYPES: ta.Tuple[type, ...] = (
 )
 
 
+# @ta.final
+# class TypedLoggerBindingsBuilder:
+#     def __init__(
+#             self,
+#             *,
+#             add_default_keys: bool = False,
+#             default_key_filter: ta.Optional[ta.Callable[[str], bool]] = None,
+#
+#             add_default_values: bool = False,
+#             default_value_filter: ta.Optional[ta.Callable[[ta.Type[DefaultTypedLoggerValue]], bool]] = None,
+#
+#             value_wrapper: ta.Optional[TypedLoggerValueWrapperFn] = None,
+#     ) -> None:
+#         self._add_default_keys = add_default_keys
+#         self._default_key_filter = default_key_filter
+#
+#         self._add_default_values = add_default_values
+#         self._default_value_filter = default_value_filter
+#
+#         self._value_wrapper = value_wrapper
+#
+#         self._lst: ta.List[TypedLoggerBindingItem] = []
+
+
 def as_typed_logger_bindings(
         *objs: CanTypedLoggerBinding,
 

omlish/logs/typed/types.py

@@ -86,6 +86,7 @@ class TypedLoggerValue(Abstract, ta.Generic[T]):
     def of(cls: ta.Type[TypedLoggerValueT], v: ta.Any) -> ta.Union[TypedLoggerValueT, AbsentTypedLoggerValue]:
         return cls(v) if v is not ABSENT_TYPED_LOGGER_VALUE else ABSENT_TYPED_LOGGER_VALUE
 
+    @ta.final
     @property
     def v(self) -> T:
         return self._v
@@ -180,7 +181,6 @@ class TypedLoggerValue(Abstract, ta.Generic[T]):
     def _typed_logger_unwrap_field_value(self, ctx: 'TypedLoggerContext') -> UnwrappedTypedLoggerFieldValue:  # noqa
         return self._v
 
-    @ta.final
     def _typed_logger_visit_bindings(self, vst: 'TypedLoggerBindings._Visitor') -> None:  # noqa
         vst.accept_values(((type(self), self),))
         vst.accept_const_values(((type(self), self),))
@@ -232,6 +232,22 @@ class DefaultTypedLoggerValue(TypedLoggerValue[T], Abstract):
         return (cls.default_provider().provide_value(ctx),)
 
 
+class MultiTypedLoggerValue(TypedLoggerValue[T], Abstract):
+    """
+    Note: There is no DefaultMultiTypedLoggerValue.
+    """
+
+    @classmethod
+    @abc.abstractmethod
+    def merge_values(cls, *values: T) -> T:
+        raise NotImplementedError
+
+    #
+
+    def _typed_logger_visit_bindings(self, vst: 'TypedLoggerBindings._Visitor') -> None:  # noqa
+        vst.accept_multi_values(((type(self), self),))
+
+
 ##
 
 

omlish/logs/typed/values.py

@@ -7,7 +7,7 @@ import threading
 import time
 import typing as ta
 
-from ...logs.callers import LoggingCaller
+from ...logs.infos import LoggingContextInfos
 from ...logs.levels import LogLevel
 from .types import ABSENT_TYPED_LOGGER_VALUE
 from .types import AbsentTypedLoggerValue
@@ -57,7 +57,7 @@ class StandardTypedLoggerValues:
 
     #
 
-    class Caller(TypedLoggerValue[LoggingCaller]):
+    class Caller(TypedLoggerValue[LoggingContextInfos.Caller]):
         pass
 
     #

omlish/logs/utils.py

@@ -1,14 +1,17 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
 import functools
 import logging
+import time
+import typing as ta
 
-
-##
+from .protocols import LoggerLike
 
 
-_log = logging.getLogger(__name__)
+##
 
 
-def error_logging(log=_log):  # noqa
+def exception_logging(log):  # noqa
     def outer(fn):
         @functools.wraps(fn)
         def inner(*args, **kwargs):
@@ -21,3 +24,56 @@ def error_logging(log=_log):  # noqa
         return inner
 
     return outer
+
+
+##
+
+
+class LogTimingContext:
+    DEFAULT_LOG: ta.ClassVar[ta.Optional[LoggerLike]] = None
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    def __init__(
+            self,
+            description: str,
+            *,
+            log: ta.Union[LoggerLike, ta.Type[_NOT_SPECIFIED], None] = _NOT_SPECIFIED,  # noqa
+            level: int = logging.DEBUG,
+    ) -> None:
+        super().__init__()
+
+        self._description = description
+        if log is self._NOT_SPECIFIED:
+            log = self.DEFAULT_LOG  # noqa
+        self._log: ta.Optional[LoggerLike] = log  # type: ignore
+        self._level = level
+
+    def set_description(self, description: str) -> 'LogTimingContext':
+        self._description = description
+        return self
+
+    _begin_time: float
+    _end_time: float
+
+    def __enter__(self) -> 'LogTimingContext':
+        self._begin_time = time.time()
+
+        if self._log is not None:
+            self._log.log(self._level, f'Begin : {self._description}')  # noqa
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._end_time = time.time()
+
+        if self._log is not None:
+            self._log.log(
+                self._level,
+                f'End : {self._description} - {self._end_time - self._begin_time:0.2f} s elapsed',
+            )
+
+
+log_timing_context = LogTimingContext

omlish/logs/warnings.py

@@ -0,0 +1,8 @@
+# @omlish-lite
+
+
+##
+
+
+class LoggingSetupWarning(Warning):
+    pass

omlish/manifests/loading.py

@@ -8,6 +8,12 @@ TODO:
  - TypeMap style weak cache of issubclass queries
   - wait.. lazily load the class for virtual subclass queries? xor support virtual bases?
  - weakref class dict keys?
+ - cheap_discover_package_root_dirs: Seq[str] | None = None or smth
+ - maaaybe.. add an EnvVar? OMLISH_MANIFEST_ROOT_DIRS? if set to : delimited, turns off package disco and overrides
+   scan_root_dirs
+  - currently the cli cant subprocess itself and keep manifests working
+  - EnvVar cls is already lite
+ - can discover_packages deadlock with concurrent / multithreaded imports?
 """
 import dataclasses as dc
 import importlib.machinery
@@ -411,6 +417,7 @@ class ManifestLoader:
     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.
+        # FIXME: find_spec *still* imports the parent package to get __path__ to feed to _find_spec...
         spec = importlib.util.find_spec(package_name)
         if (
                 spec is not None and
@@ -432,7 +439,7 @@ class ManifestLoader:
             return None
         return t.read_text('utf-8')
 
-    MANIFESTS_FILE_NAME: ta.ClassVar[str] = '.manifests.json'
+    MANIFESTS_FILE_NAME: ta.ClassVar[str] = '.omlish-manifests.json'
 
     @classmethod
     def _read_package_raw_manifests(cls, package_name: str) -> ta.Optional[ta.Sequence[Manifest]]:

omlish/marshal/__init__.py

@@ -1,14 +1,24 @@
 # ruff: noqa: I001
 """
 TODO:
- - redacted
- - strongly typed MarshalerFactory base class?
- - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
- - streaming? Start/EndObject, etc..
- - lang.Marker - class name, handle type[Foo]
-  - can't disambiguate from str - can't coexist in bare union
- - factories being free MatchFns does more harm than good - in practice these are such big guns you want to write a
-   class body if only ceremonially
+ - streaming?
+ - datatypes
+  - redacted
+  - lang.Marker - class name, handle type[Foo]
+  - pathlib.Path
+  - decimal.Decimal
+  - datetime.date, datetime.time
+  - ipaddress
+  - numpy types
+ - jackson switches
+  - accept_case_insensitive_enums
+  - accept_case_insensitive_properties
+  - accept_case_insensitive_values
+  - allow_coercion_of_scalars
+  - use_base_type_as_default_impl
+ - codegen
+ - context-local switches
+  - mutable_collections
  - simple lite interop like inj - alt ObjMarshalerManager impl for Context
 
 See:
@@ -16,6 +26,8 @@ See:
  - https://github.com/jcrist/msgspec
  - https://github.com/Fatal1ty/mashumaro
  - https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers
+ - https://github.com/yukinarit/pyserde
+ - https://github.com/FasterXML/jackson
 """
 from .. import dataclasses as _dc  # noqa
 
@@ -32,16 +44,22 @@ _dc.init_package(
 from .. import lang as _lang  # noqa
 
 
-with _lang.auto_proxy_init(globals()) as _api_cap:
+with _lang.auto_proxy_init(globals()):
     ##
 
     from .base.configs import (  # noqa
         Config,
+        Configs,
+
         ConfigRegistry,
     )
 
     from .base.contexts import (  # noqa
         BaseContext,
+
+        MarshalFactoryContext,
+        UnmarshalFactoryContext,
+
         MarshalContext,
         UnmarshalContext,
     )
@@ -96,19 +114,35 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         IterableUnmarshaler,
     )
 
+    from .composite.optionals import (  # noqa
+        OptionalMarshaler,
+        OptionalUnmarshaler,
+    )
+
+    from .composite.unions.literals import (  # noqa
+        LITERAL_UNION_TYPES,
+        LiteralUnionMarshaler,
+        LiteralUnionMarshalerFactory,
+        LiteralUnionUnmarshaler,
+        LiteralUnionUnmarshalerFactory,
+    )
+
+    from .composite.unions.primitives import (  # noqa
+        PRIMITIVE_UNION_TYPES,
+        PrimitiveUnionMarshaler,
+        PrimitiveUnionMarshalerFactory,
+        PrimitiveUnionUnmarshaler,
+        PrimitiveUnionUnmarshalerFactory,
+    )
+
     from .composite.wrapped import (  # noqa
         WrappedMarshaler,
         WrappedUnmarshaler,
     )
 
-    from .factories.simple import (  # noqa
-        SimpleMarshalerFactory,
-        SimpleUnmarshalerFactory,
-    )
-
-    from .factories.match import (  # noqa
-        MarshalerFactoryMatchClass,
-        UnmarshalerFactoryMatchClass,
+    from .factories.method import (  # noqa
+        MarshalerFactoryMethodClass,
+        UnmarshalerFactoryMethodClass,
     )
 
     from .factories.moduleimport.configs import (  # noqa
@@ -180,6 +214,7 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
     )
 
     from .polymorphism.metadata import (  # noqa
+        AutoStripSuffix,
         FieldTypeTagging,
         Impl,
         Impls,
@@ -195,13 +230,8 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
     )
 
     from .polymorphism.unions import (  # noqa
-        PRIMITIVE_UNION_TYPES,
         PolymorphismUnionMarshalerFactory,
         PolymorphismUnionUnmarshalerFactory,
-        PrimitiveUnionMarshaler,
-        PrimitiveUnionMarshalerFactory,
-        PrimitiveUnionUnmarshaler,
-        PrimitiveUnionUnmarshalerFactory,
     )
 
     from .polymorphism.unmarshal import (  # noqa
@@ -213,6 +243,7 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
     from .singular.base64 import (  # noqa
         BASE64_MARSHALER_FACTORY,
         BASE64_UNMARSHALER_FACTORY,
+        Base64MarshalerUnmarshaler,
     )
 
     from .singular.primitives import (  # noqa
@@ -221,6 +252,7 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
 
     from .trivial.forbidden import (  # noqa
         ForbiddenTypeMarshalerFactory,
+        ForbiddenTypeMarshalerFactoryUnmarshalerFactory,
         ForbiddenTypeUnmarshalerFactory,
     )