omlish 0.0.0.dev132__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/lite/inject.py

@@ -8,11 +8,7 @@ import types
 import typing as ta
 import weakref
 
-from .check import check_in
-from .check import check_isinstance
-from .check import check_not_in
-from .check import check_not_isinstance
-from .check import check_not_none
+from .check import check
 from .maybes import Maybe
 from .reflect import get_optional_alias_arg
 from .reflect import is_new_type
@@ -170,7 +166,7 @@ class FnInjectorProvider(InjectorProvider):
     fn: ta.Any
 
     def __post_init__(self) -> None:
-        check_not_isinstance(self.fn, type)
+        check.not_isinstance(self.fn, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -184,7 +180,7 @@ class CtorInjectorProvider(InjectorProvider):
     cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls_, type)
+        check.isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -206,7 +202,7 @@ class SingletonInjectorProvider(InjectorProvider):
     p: InjectorProvider
 
     def __post_init__(self) -> None:
-        check_isinstance(self.p, InjectorProvider)
+        check.isinstance(self.p, InjectorProvider)
 
     def provider_fn(self) -> InjectorProviderFn:
         v = not_set = object()
@@ -226,7 +222,7 @@ class LinkInjectorProvider(InjectorProvider):
     k: InjectorKey
 
     def __post_init__(self) -> None:
-        check_isinstance(self.k, InjectorKey)
+        check.isinstance(self.k, InjectorKey)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -423,7 +419,7 @@ def build_injection_kwargs_target(
 
     skip_names: ta.Set[str] = set()
     if skip_kwargs is not None:
-        skip_names.update(check_not_isinstance(skip_kwargs, str))
+        skip_names.update(check.not_isinstance(skip_kwargs, str))
 
     seen: ta.Set[InjectorKey] = set()
     kws: ta.List[InjectionKwarg] = []
@@ -484,8 +480,8 @@ class _Injector(Injector):
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
 
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+        self._bs = check.isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check.isinstance(p, (Injector, type(None)))
 
         self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
 
@@ -516,8 +512,8 @@ class _Injector(Injector):
             return Maybe.empty()
 
         def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
-            check_in(key, self._seen_keys)
-            check_not_in(key, self._provisions)
+            check.in_(key, self._seen_keys)
+            check.not_in(key, self._provisions)
             self._provisions[key] = mv
             return mv
 
@@ -614,7 +610,7 @@ class InjectorBinder:
     def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
-    _FN_TYPES: ta.Tuple[type, ...] = (
+    _FN_TYPES: ta.ClassVar[ta.Tuple[type, ...]] = (
         types.FunctionType,
         types.MethodType,
 
@@ -631,12 +627,12 @@ class InjectorBinder:
 
     @classmethod
     def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
-        check_isinstance(icls, type)
+        check.isinstance(icls, type)
         if icls not in cls._FN_TYPES:
             cls._FN_TYPES = (*cls._FN_TYPES, icls)
         return icls
 
-    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
+    _BANNED_BIND_TYPES: ta.ClassVar[ta.Tuple[type, ...]] = (
         InjectorProvider,
     )
 
@@ -688,7 +684,7 @@ class InjectorBinder:
             to_fn = obj
             if key is None:
                 insp = _injection_inspect(obj)
-                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
+                key_cls: ta.Any = check_valid_injector_key_cls(check.not_none(insp.type_hints.get('return')))
                 key = InjectorKey(key_cls)
         else:
             if to_const is not None:
@@ -815,45 +811,35 @@ def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
 ##
 
 
-class Injection:
-    def __new__(cls, *args, **kwargs):  # noqa
-        raise TypeError
-
+class InjectionApi:
     # keys
 
-    @classmethod
-    def as_key(cls, o: ta.Any) -> InjectorKey:
+    def as_key(self, o: ta.Any) -> InjectorKey:
         return as_injector_key(o)
 
-    @classmethod
-    def array(cls, o: ta.Any) -> InjectorKey:
+    def array(self, o: ta.Any) -> InjectorKey:
         return dc.replace(as_injector_key(o), array=True)
 
-    @classmethod
-    def tag(cls, o: ta.Any, t: ta.Any) -> InjectorKey:
+    def tag(self, o: ta.Any, t: ta.Any) -> InjectorKey:
         return dc.replace(as_injector_key(o), tag=t)
 
     # bindings
 
-    @classmethod
-    def as_bindings(cls, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    def as_bindings(self, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return as_injector_bindings(*args)
 
-    @classmethod
-    def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
     # injector
 
-    @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+    def create_injector(self, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
         return _Injector(as_injector_bindings(*args), parent)
 
     # binder
 
-    @classmethod
     def bind(
-            cls,
+            self,
             obj: ta.Any,
             *,
             key: ta.Any = None,
@@ -888,32 +874,29 @@ class Injection:
 
     # helpers
 
-    @classmethod
     def bind_factory(
-            cls,
+            self,
             fn: ta.Callable[..., T],
             cls_: U,
             ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_factory(fn, cls_, ann))
+        return self.bind(make_injector_factory(fn, cls_, ann))
 
-    @classmethod
     def bind_array(
-            cls,
+            self,
             obj: ta.Any = None,
             *,
             tag: ta.Any = None,
     ) -> InjectorBindingOrBindings:
         return bind_injector_array(obj, tag=tag)
 
-    @classmethod
     def bind_array_type(
-            cls,
+            self,
             ele: ta.Union[InjectorKey, InjectorKeyCls],
             cls_: U,
             ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_array_type(ele, cls_, ann))
+        return self.bind(make_injector_array_type(ele, cls_, ann))
 
 
-inj = Injection
+inj = InjectionApi()

omlish/lite/logs.py

@@ -1,274 +1,4 @@
-"""
-TODO:
- - translate json keys
- - debug
-"""
-# ruff: noqa: UP006 UP007 N802
-import contextlib
-import datetime
 import logging
-import threading
-import typing as ta
-
-from .json import json_dumps_compact
 
 
 log = logging.getLogger(__name__)
-
-
-##
-
-
-class TidLogFilter(logging.Filter):
-
-    def filter(self, record):
-        record.tid = threading.get_native_id()
-        return True
-
-
-##
-
-
-class JsonLogFormatter(logging.Formatter):
-
-    KEYS: ta.Mapping[str, bool] = {
-        'name': False,
-        'msg': False,
-        'args': False,
-        'levelname': False,
-        'levelno': False,
-        'pathname': False,
-        'filename': False,
-        'module': False,
-        'exc_info': True,
-        'exc_text': True,
-        'stack_info': True,
-        'lineno': False,
-        'funcName': False,
-        'created': False,
-        'msecs': False,
-        'relativeCreated': False,
-        'thread': False,
-        'threadName': False,
-        'processName': False,
-        'process': False,
-    }
-
-    def format(self, record: logging.LogRecord) -> str:
-        dct = {
-            k: v
-            for k, o in self.KEYS.items()
-            for v in [getattr(record, k)]
-            if not (o and v is None)
-        }
-        return json_dumps_compact(dct)
-
-
-##
-
-
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)-6s'),
-    ('thread', 'tid=%(thread)x'),
-    ('levelname', '%(levelname)s'),
-    ('name', '%(name)s'),
-    ('separator', '::'),
-    ('message', '%(message)s'),
-]
-
-
-class StandardLogFormatter(logging.Formatter):
-
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
-
-    converter = datetime.datetime.fromtimestamp  # type: ignore
-
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)  # type: ignore
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
-        else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
-
-
-##
-
-
-class ProxyLogFilterer(logging.Filterer):
-    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
-        self._underlying = underlying
-
-    @property
-    def underlying(self) -> logging.Filterer:
-        return self._underlying
-
-    @property
-    def filters(self):
-        return self._underlying.filters
-
-    @filters.setter
-    def filters(self, filters):
-        self._underlying.filters = filters
-
-    def addFilter(self, filter):  # noqa
-        self._underlying.addFilter(filter)
-
-    def removeFilter(self, filter):  # noqa
-        self._underlying.removeFilter(filter)
-
-    def filter(self, record):
-        return self._underlying.filter(record)
-
-
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
-    def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
-
-    _underlying: logging.Handler
-
-    @property
-    def underlying(self) -> logging.Handler:
-        return self._underlying
-
-    def get_name(self):
-        return self._underlying.get_name()
-
-    def set_name(self, name):
-        self._underlying.set_name(name)
-
-    @property
-    def name(self):
-        return self._underlying.name
-
-    @property
-    def level(self):
-        return self._underlying.level
-
-    @level.setter
-    def level(self, level):
-        self._underlying.level = level
-
-    @property
-    def formatter(self):
-        return self._underlying.formatter
-
-    @formatter.setter
-    def formatter(self, formatter):
-        self._underlying.formatter = formatter
-
-    def createLock(self):
-        self._underlying.createLock()
-
-    def acquire(self):
-        self._underlying.acquire()
-
-    def release(self):
-        self._underlying.release()
-
-    def setLevel(self, level):
-        self._underlying.setLevel(level)
-
-    def format(self, record):
-        return self._underlying.format(record)
-
-    def emit(self, record):
-        self._underlying.emit(record)
-
-    def handle(self, record):
-        return self._underlying.handle(record)
-
-    def setFormatter(self, fmt):
-        self._underlying.setFormatter(fmt)
-
-    def flush(self):
-        self._underlying.flush()
-
-    def close(self):
-        self._underlying.close()
-
-    def handleError(self, record):
-        self._underlying.handleError(record)
-
-
-##
-
-
-class StandardLogHandler(ProxyLogHandler):
-    pass
-
-
-##
-
-
-@contextlib.contextmanager
-def _locking_logging_module_lock() -> ta.Iterator[None]:
-    if hasattr(logging, '_acquireLock'):
-        logging._acquireLock()  # noqa
-        try:
-            yield
-        finally:
-            logging._releaseLock()  # type: ignore  # noqa
-
-    elif hasattr(logging, '_lock'):
-        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
-        with logging._lock:  # noqa
-            yield
-
-    else:
-        raise Exception("Can't find lock in logging module")
-
-
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
-
-        #
-
-        if not force:
-            if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
-                return None
-
-        #
-
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
-
-        #
-
-        formatter: logging.Formatter
-        if json:
-            formatter = JsonLogFormatter()
-        else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
-        handler.setFormatter(formatter)
-
-        #
-
-        handler.addFilter(TidLogFilter())
-
-        #
-
-        target.addHandler(handler)
-
-        #
-
-        if level is not None:
-            target.setLevel(level)
-
-        #
-
-        return StandardLogHandler(handler)