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

omlish/lite/reflect.py

@@ -7,6 +7,9 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
+##
+
+
 _GENERIC_ALIAS_TYPES = (
     ta._GenericAlias,  # type: ignore  # noqa
     *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
@@ -24,6 +27,9 @@ is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
 is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
 
 
+##
+
+
 def is_optional_alias(spec: ta.Any) -> bool:
     return (
         isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
@@ -38,6 +44,9 @@ def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
     return it
 
 
+##
+
+
 def is_new_type(spec: ta.Any) -> bool:
     if isinstance(ta.NewType, type):
         return isinstance(spec, ta.NewType)
@@ -46,6 +55,30 @@ def is_new_type(spec: ta.Any) -> bool:
         return isinstance(spec, types.FunctionType) and spec.__code__ is ta.NewType.__code__.co_consts[1]  # type: ignore  # noqa
 
 
+def get_new_type_supertype(spec: ta.Any) -> ta.Any:
+    return spec.__supertype__
+
+
+##
+
+
+def is_literal_type(spec: ta.Any) -> bool:
+    if hasattr(ta, '_LiteralGenericAlias'):
+        return isinstance(spec, ta._LiteralGenericAlias)  # noqa
+    else:
+        return (
+            isinstance(spec, ta._GenericAlias) and  # type: ignore  # noqa
+            spec.__origin__ is ta.Literal
+        )
+
+
+def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
+    return spec.__args__
+
+
+##
+
+
 def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
     seen = set()
     todo = list(reversed(cls.__subclasses__()))

omlish/lite/resources.py

@@ -0,0 +1,8 @@
+def read_package_resource_binary(package: str, resource: str) -> bytes:
+    import importlib.resources
+    return importlib.resources.read_binary(package, resource)
+
+
+def read_package_resource_text(package: str, resource: str) -> str:
+    import importlib.resources
+    return importlib.resources.read_text(package, resource)

omlish/lite/runtime.py

@@ -9,9 +9,9 @@ def is_debugger_attached() -> bool:
     return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
 
 
-REQUIRED_PYTHON_VERSION = (3, 8)
+LITE_REQUIRED_PYTHON_VERSION = (3, 8)
 
 
-def check_runtime_version() -> None:
-    if sys.version_info < REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+def check_lite_runtime_version() -> None:
+    if sys.version_info < LITE_REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa

omlish/lite/shlex.py

@@ -0,0 +1,12 @@
+import shlex
+
+
+def shlex_needs_quote(s: str) -> bool:
+    return bool(s) and len(list(shlex.shlex(s))) > 1
+
+
+def shlex_maybe_quote(s: str) -> str:
+    if shlex_needs_quote(s):
+        return shlex.quote(s)
+    else:
+        return s

omlish/lite/socketserver.py

@@ -3,7 +3,7 @@ import socket
 import socketserver
 import typing as ta
 
-from omlish.lite.check import check_not_none
+from omlish.lite.check import check
 
 from .socket import SocketAddress
 from .socket import SocketHandlerFactory
@@ -58,7 +58,7 @@ class SocketHandlerSocketServerStreamRequestHandler(  # type: ignore[misc]
         )
 
     def handle(self) -> None:
-        target = check_not_none(self.socket_handler_factory)(
+        target = check.not_none(self.socket_handler_factory)(
             self.client_address,
             self.rfile,  # type: ignore[arg-type]
             self.wfile,  # type: ignore[arg-type]

omlish/lite/strings.py

@@ -21,6 +21,37 @@ def snake_case(name: str) -> str:
 ##
 
 
+def strip_with_newline(s: str) -> str:
+    if not s:
+        return ''
+    return s.strip() + '\n'
+
+
+@ta.overload
+def split_keep_delimiter(s: str, d: str) -> str:
+    ...
+
+
+@ta.overload
+def split_keep_delimiter(s: bytes, d: bytes) -> bytes:
+    ...
+
+
+def split_keep_delimiter(s, d):
+    ps = []
+    i = 0
+    while i < len(s):
+        if (n := s.find(d, i)) < i:
+            ps.append(s[i:])
+            break
+        ps.append(s[i:n + 1])
+        i = n + 1
+    return ps
+
+
+##
+
+
 def is_dunder(name: str) -> bool:
     return (
         name[:2] == name[-2:] == '__' and

omlish/logs/__init__.py

@@ -1,32 +0,0 @@
-from .configs import (  # noqa
-    configure_standard_logging,
-)
-
-from .formatters import (  # noqa
-    ColorLogFormatter,
-)
-
-from .handlers import (  # noqa
-    ListHandler,
-)
-
-from .utils import (  # noqa
-    error_logging,
-)
-
-
-##
-
-
-from ..lite.logs import (  # noqa
-    TidLogFilter,
-    JsonLogFormatter,
-
-    STANDARD_LOG_FORMAT_PARTS,
-    StandardLogFormatter,
-
-    ProxyLogFilterer,
-    ProxyLogHandler,
-
-    StandardLogHandler,
-)

omlish/logs/{_abc.py → abc.py}

@@ -1,7 +1,6 @@
 # ruff: noqa: A002
 # ruff: noqa: N802
 # ruff: noqa: N815
-
 import types
 import typing as ta
 

omlish/logs/all.py

@@ -0,0 +1,37 @@
+from .color import (  # noqa
+    ColorLogFormatter,
+)
+
+from .filters import (  # noqa
+    TidLogFilter,
+)
+
+from .handlers import (  # noqa
+    ListHandler,
+)
+
+from .json import (  # noqa
+    JsonLogFormatter,
+)
+
+from .noisy import (  # noqa
+    silence_noisy_loggers,
+)
+
+from .proxy import (  # noqa
+    ProxyLogFilterer,
+    ProxyLogHandler,
+)
+
+from .standard import (  # noqa
+    STANDARD_LOG_FORMAT_PARTS,
+    StandardLogFormatter,
+
+    StandardConfiguredLogHandler,
+
+    configure_standard_logging,
+)
+
+from .utils import (  # noqa
+    error_logging,
+)

omlish/logs/{formatters.py → color.py}

@@ -3,11 +3,10 @@ import logging
 import typing as ta
 
 from .. import term
-from ..lite.logs import StandardLogFormatter
+from .standard import StandardLogFormatter
 
 
 class ColorLogFormatter(StandardLogFormatter):
-
     LEVEL_COLORS: ta.Mapping[int, term.SGRs.FG] = {
         logging.WARNING: term.SGRs.FG.BRIGHT_YELLOW,
         logging.ERROR: term.SGRs.FG.BRIGHT_RED,

omlish/logs/configs.py

@@ -1,19 +1,17 @@
+"""
+https://docs.python.org/3/howto/logging.html#configuring-logging
+"""
 import dataclasses as dc
-import logging
 import typing as ta
 
-from ..lite.logs import StandardLogHandler
-from ..lite.logs import configure_standard_logging as configure_lite_standard_logging
-from .noisy import silence_noisy_loggers
-
 
 ##
 
 
-FilterConfig = dict[str, ta.Any]
-FormatterConfig = dict[str, ta.Any]
-HandlerConfig = dict[str, ta.Any]
-LoggerConfig = dict[str, ta.Any]
+FilterConfig: ta.TypeAlias = dict[str, ta.Any]
+FormatterConfig: ta.TypeAlias = dict[str, ta.Any]
+HandlerConfig: ta.TypeAlias = dict[str, ta.Any]
+LoggerConfig: ta.TypeAlias = dict[str, ta.Any]
 
 
 @dc.dataclass()
@@ -26,32 +24,3 @@ class DictConfig:
     handlers: dict[str, HandlerConfig] = dc.field(default_factory=dict)
     loggers: dict[str, LoggerConfig] = dc.field(default_factory=dict)
     root: LoggerConfig | None = None
-
-
-##
-
-
-def configure_standard_logging(
-        level: ta.Any = None,
-        *,
-        json: bool = False,
-        target: logging.Logger | None = None,
-        force: bool = False,
-) -> StandardLogHandler | None:
-    handler = configure_lite_standard_logging(
-        level,
-        json=json,
-        target=target,
-        force=force,
-    )
-
-    if handler is None:
-        return None
-
-    #
-
-    silence_noisy_loggers()
-
-    #
-
-    return handler

omlish/logs/filters.py

@@ -0,0 +1,10 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import logging
+import threading
+
+
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        record.tid = threading.get_native_id()
+        return True

omlish/logs/handlers.py

@@ -1,10 +1,13 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import logging
+import typing as ta
 
 
 class ListHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()
-        self.records: list[logging.LogRecord] = []
+        self.records: ta.List[logging.LogRecord] = []
 
     def emit(self, record: logging.LogRecord) -> None:
         self.records.append(record)

omlish/logs/json.py

@@ -0,0 +1,56 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - translate json keys
+"""
+import logging
+import typing as ta
+
+from ..lite.json import json_dumps_compact
+
+
+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 __init__(
+            self,
+            *args: ta.Any,
+            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if json_dumps is None:
+            json_dumps = json_dumps_compact
+        self._json_dumps = json_dumps
+
+    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 self._json_dumps(dct)

omlish/logs/proxy.py

@@ -0,0 +1,99 @@
+# ruff: noqa: N802 UP006 UP007
+# @omlish-lite
+import logging
+
+
+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)

omlish/logs/standard.py

@@ -0,0 +1,128 @@
+# ruff: noqa: N802 UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - structured
+ - prefixed
+ - debug
+ - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
+"""
+import contextlib
+import datetime
+import logging
+import typing as ta
+
+from .filters import TidLogFilter
+from .json import JsonLogFormatter
+from .proxy import ProxyLogHandler
+
+
+##
+
+
+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 StandardConfiguredLogHandler(ProxyLogHandler):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('This class serves only as a marker and should not be subclassed.')
+
+
+##
+
+
+@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[StandardConfiguredLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
+
+        #
+
+        if not force:
+            if any(isinstance(h, StandardConfiguredLogHandler) 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 StandardConfiguredLogHandler(handler)

omlish/logs/utils.py

@@ -2,10 +2,10 @@ import functools
 import logging
 
 
-log = logging.getLogger(__name__)
+_log = logging.getLogger(__name__)
 
 
-def error_logging(log=log):  # noqa
+def error_logging(log=_log):  # noqa
     def outer(fn):
         @functools.wraps(fn)
         def inner(*args, **kwargs):

omlish/manifests/__init__.py

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