omlish 0.0.0.dev117__py3-none-any.whl → 0.0.0.dev119__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev117'
-__revision__ = '53d3fb51abb6f481bd836efe8a32c8da91113468'
+__version__ = '0.0.0.dev119'
+__revision__ = 'abf03cc06fe1610ddf750a1392aa9c9de00acfd3'
 
 
 #

omlish/collections/hasheq.py

@@ -27,21 +27,11 @@ class HashEq(lang.Abstract, ta.Generic[K]):
         raise NotImplementedError
 
 
-@lang.unabstract_class([
-    ('hash', '_hash'),
-    ('eq', '_eq'),
-])
 @dc.dataclass(frozen=True)
 class HashEq_(ta.Generic[K]):  # noqa
     hash: ta.Callable[[K], int]
     eq: ta.Callable[[K, K], bool]
 
-    def _hash(self, k: K) -> int:
-        return self.hash(k)
-
-    def _eq(self, l: K, r: K) -> bool:
-        return self.eq(l, r)
-
 
 class hash_eq(HashEq[K], lang.NotInstantiable, lang.Final):  # noqa
     """Workaround for PEP 695 support."""

omlish/fnpairs.py

@@ -94,21 +94,12 @@ class FnPair(ta.Generic[F, T], abc.ABC):
 ##
 
 
-@lang.unabstract_class([
-    ('forward', '_forward'),
-    ('backward', 'backward'),
-])
+@lang.unabstract_class(['forward', 'backward'])
 @dc.dataclass(frozen=True)
 class Simple(FnPair[F, T]):
     forward: ta.Callable[[F], T]  # type: ignore
     backward: ta.Callable[[T], F]  # type: ignore
 
-    def _forward(self, f: F) -> T:
-        return self.forward(f)
-
-    def _backward(self, t: T) -> F:
-        return self.backward(t)
-
 
 of = Simple
 

omlish/formats/json/__init__.py

@@ -37,3 +37,8 @@ else:
     _lang.proxy_init(globals(), '.render', [
         'JsonRenderer',
     ])
+
+from .types import (  # noqa
+    SCALAR_TYPES,
+    Scalar,
+)

omlish/formats/json/literals.py

@@ -0,0 +1,179 @@
+# MIT License
+# ===========
+#
+# Copyright (c) 2006 Bob Ippolito
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# https://github.com/simplejson/simplejson/blob/6932004966ab70ef47250a2b3152acd8c904e6b5/simplejson/scanner.py
+import json
+import re
+import sys
+import typing as ta
+
+
+##
+
+
+_FOUR_DIGIT_HEX_PAT = re.compile(r'^[0-9a-fA-F]{4}$')
+
+
+def _scan_four_digit_hex(
+        s: str,
+        end: int,
+):
+    """Scan a four digit hex number from s[end:end + 4]"""
+
+    msg = 'Invalid \\uXXXX escape sequence'
+    esc = s[end: end + 4]
+    if not _FOUR_DIGIT_HEX_PAT.match(esc):
+        raise json.JSONDecodeError(msg, s, end - 2)
+
+    try:
+        return int(esc, 16), end + 4
+    except ValueError:
+        raise json.JSONDecodeError(msg, s, end - 2) from None
+
+
+_STRING_CHUNK_PAT = re.compile(r'(.*?)(["\\\x00-\x1f])', re.VERBOSE | re.MULTILINE | re.DOTALL)
+
+_BACKSLASH_MAP = {
+    '"': '"',
+    '\\': '\\',
+    '/': '/',
+    'b': '\b',
+    'f': '\f',
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+}
+
+
+def parse_string(
+        s: str,
+        idx: int = 0,
+        *,
+        strict: bool = True,
+) -> tuple[str, int]:
+    """
+    Scan the string s for a JSON string. Idx is the index of the quote that starts the JSON string. Unescapes all valid
+    JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then
+    literal control characters are allowed in the string.
+
+    Returns a tuple of the decoded string and the index of the character in s after the end quote.
+    """
+
+    if s[idx] != '"':
+        raise json.JSONDecodeError('No opening string quotes at', s, idx)
+
+    chunks: list[str] = []
+    end = idx + 1
+    while True:
+        chunk = _STRING_CHUNK_PAT.match(s, end)
+        if chunk is None:
+            raise json.JSONDecodeError('Unterminated string starting at', s, idx)
+
+        prev_end = end
+        end = chunk.end()
+        content, terminator = chunk.groups()
+        # Content is contains zero or more unescaped string characters
+        if content:
+            chunks.append(content)
+
+        # Terminator is the end of string, a literal control character, or a backslash denoting that an escape sequence
+        # follows
+        if terminator == '"':
+            break
+        elif terminator != '\\':
+            if strict:
+                msg = 'Invalid control character %r at'
+                raise json.JSONDecodeError(msg, s, prev_end)
+            else:
+                chunks.append(terminator)
+                continue
+
+        try:
+            esc = s[end]
+        except IndexError:
+            raise json.JSONDecodeError('Unterminated string starting at', s, idx) from None
+
+        # If not a unicode escape sequence, must be in the lookup table
+        if esc != 'u':
+            try:
+                char = _BACKSLASH_MAP[esc]
+            except KeyError:
+                msg = 'Invalid \\X escape sequence %r'
+                raise json.JSONDecodeError(msg, s, end) from None
+            end += 1
+
+        else:
+            # Unicode escape sequence
+            uni, end = _scan_four_digit_hex(s, end + 1)
+
+            # Check for surrogate pair on UCS-4 systems Note that this will join high/low surrogate pairs but will also
+            # pass unpaired surrogates through
+            if (
+                    sys.maxunicode > 65535 and
+                    uni & 0xFC00 == 0xD800 and
+                    s[end: end + 2] == '\\u'
+            ):
+                uni2, end2 = _scan_four_digit_hex(s, end + 2)
+                if uni2 & 0xFC00 == 0xDC00:
+                    uni = 0x10000 + (((uni - 0xD800) << 10) | (uni2 - 0xDC00))
+                    end = end2
+
+            char = chr(uni)
+
+        # Append the unescaped character
+        chunks.append(char)
+
+    return ''.join(chunks), end
+
+
+def try_parse_string(
+        s: str,
+        idx: int = 0,
+        *,
+        strict: bool = True,
+) -> tuple[str, int] | None:
+    if not s or s[idx] != '"':
+        return None
+
+    return parse_string(s, idx, strict=strict)
+
+
+##
+
+
+_NUMBER_PAT = re.compile(
+    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
+    (re.VERBOSE | re.MULTILINE | re.DOTALL),
+)
+
+
+def try_parse_number(
+        s: str,
+        idx: int = 0,
+        *,
+        parse_float: ta.Callable[[str], float] = float,
+        parse_int: ta.Callable[[str], int] = int,
+) -> tuple[int | float, int] | None:
+    if (m := _NUMBER_PAT.match(s, idx)) is None:
+        return None
+
+    integer, frac, exp = m.groups()
+    if frac or exp:
+        res = parse_float(integer + (frac or '') + (exp or ''))
+    else:
+        res = parse_int(integer)
+    return res, m.end()

omlish/formats/json/render.py

@@ -6,12 +6,11 @@ import typing as ta
 
 from ... import lang
 from . import consts
+from .types import SCALAR_TYPES
+from .types import Scalar
 
 
 I = ta.TypeVar('I')
-Scalar: ta.TypeAlias = bool | int | float | str | None
-
-SCALAR_TYPES: tuple[type, ...] = (bool, int, float, str, type(None))
 
 MULTILINE_SEPARATORS = consts.Separators(',', ': ')
 

omlish/formats/json/stream/render.py

@@ -1,8 +1,8 @@
 import io
 import typing as ta
 
-from ..render import SCALAR_TYPES
 from ..render import AbstractJsonRenderer
+from ..types import SCALAR_TYPES
 from .parse import BeginArray
 from .parse import BeginObject
 from .parse import EndArray

omlish/formats/json/types.py

@@ -0,0 +1,6 @@
+import typing as ta
+
+
+Scalar: ta.TypeAlias = bool | int | float | str | None
+
+SCALAR_TYPES: tuple[type, ...] = (bool, int, float, str, type(None))

omlish/lang/classes/abstract.py

@@ -7,6 +7,10 @@ T = ta.TypeVar('T')
 
 _DISABLE_CHECKS = False
 
+_ABSTRACT_METHODS_ATTR = '__abstractmethods__'
+_IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
+_FORCE_ABSTRACT_ATTR = '__forceabstract__'
+
 
 def make_abstract(obj: T) -> T:
     if callable(obj):
@@ -29,13 +33,13 @@ class Abstract(abc.ABC):  # noqa
     def __forceabstract__(self):
         raise TypeError
 
-    setattr(__forceabstract__, '__isabstractmethod__', True)
+    setattr(__forceabstract__, _IS_ABSTRACT_METHOD_ATTR, True)
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         if Abstract in cls.__bases__:
-            cls.__forceabstract__ = Abstract.__forceabstract__  # type: ignore
+            setattr(cls, _FORCE_ABSTRACT_ATTR, getattr(Abstract, _FORCE_ABSTRACT_ATTR))
         else:
-            cls.__forceabstract__ = False  # type: ignore
+            setattr(cls, _FORCE_ABSTRACT_ATTR, False)
 
         super().__init_subclass__(**kwargs)
 
@@ -43,7 +47,7 @@ class Abstract(abc.ABC):  # noqa
             ams = {a for a, o in cls.__dict__.items() if is_abstract_method(o)}
             seen = set(cls.__dict__)
             for b in cls.__bases__:
-                ams.update(set(getattr(b, '__abstractmethods__', [])) - seen)
+                ams.update(set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen)
                 seen.update(dir(b))
             if ams:
                 raise TypeError(
@@ -53,18 +57,18 @@ class Abstract(abc.ABC):  # noqa
 
 
 def is_abstract_method(obj: ta.Any) -> bool:
-    return bool(getattr(obj, '__isabstractmethod__', False))
+    return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
 def is_abstract_class(obj: ta.Any) -> bool:
-    if bool(getattr(obj, '__abstractmethods__', [])):
+    if bool(getattr(obj, _ABSTRACT_METHODS_ATTR, [])):
         return True
     if isinstance(obj, type):
         if Abstract in obj.__bases__:
             return True
         if (
                 Abstract in obj.__mro__
-                and getattr(obj.__dict__.get('__forceabstract__', None), '__isabstractmethod__', False)
+                and getattr(obj.__dict__.get(_FORCE_ABSTRACT_ATTR, None), _IS_ABSTRACT_METHOD_ATTR, False)
         ):
             return True
     return False
@@ -75,13 +79,32 @@ def is_abstract(obj: ta.Any) -> bool:
 
 
 def unabstract_class(
-        impls: ta.Iterable[tuple[str, ta.Any]],
-) -> ta.Callable[[type[T]], type[T]]:
+        members: ta.Iterable[str | tuple[str, ta.Any]],
+):  # -> ta.Callable[[type[T]], type[T]]:
     def inner(cls):
-        for name, impl in impls:
-            if isinstance(impl, str):
-                impl = getattr(cls, impl)
-            setattr(cls, name, impl)
-        setattr(cls, '__abstractmethods__', frozenset())
+        if isinstance(members, str):
+            raise TypeError(members)
+
+        ams = getattr(cls, _ABSTRACT_METHODS_ATTR)
+
+        names: set[str] = set()
+        for m in members:
+            if isinstance(m, str):
+                if m not in ams:
+                    raise NameError(m)
+                getattr(cls, m)
+                names.add(m)
+
+            elif isinstance(m, tuple):
+                name, impl = m
+                if name not in ams:
+                    raise NameError(name)
+                if isinstance(impl, str):
+                    impl = getattr(cls, impl)
+                setattr(cls, name, impl)
+                names.add(name)
+
+        setattr(cls, _ABSTRACT_METHODS_ATTR, ams - names)
         return cls
+
     return inner

omlish/lang/imports.py

@@ -312,7 +312,7 @@ class _ProxyInit:
         try:
             mod = self._mods_by_pkgs[pkg]
         except KeyError:
-            mod = importlib.import_module(pkg, package=self.name_package.package)
+            mod = importlib.import_module(pkg, package=self._name_package.package)
 
         val = getattr(mod, attr)
 

omlish/lang/maybes.py

@@ -50,15 +50,15 @@ class Maybe(abc.ABC, ta.Generic[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else(self, other: T) -> 'Maybe[T]':
+    def or_else(self, other: T) -> T:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else_get(self, supplier: ta.Callable[[], T]) -> 'Maybe[T]':
+    def or_else_get(self, supplier: ta.Callable[[], T]) -> T:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> 'Maybe[T]':
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
         raise NotImplementedError
 
 
@@ -98,9 +98,7 @@ class _Maybe(Maybe[T], tuple):
 
     def map(self, mapper: ta.Callable[[T], U]) -> Maybe[U]:
         if self:
-            value = mapper(self[0])
-            if value is not None:
-                return just(value)
+            return just(mapper(self[0]))
         return _empty  # noqa
 
     def flat_map(self, mapper: ta.Callable[[T], Maybe[U]]) -> Maybe[U]:
@@ -111,15 +109,15 @@ class _Maybe(Maybe[T], tuple):
             return value
         return _empty  # noqa
 
-    def or_else(self, other: T) -> Maybe[T]:
-        return self if self else just(other)
+    def or_else(self, other: T) -> T:
+        return self.must() if self else other
 
-    def or_else_get(self, supplier: ta.Callable[[], T]) -> Maybe[T]:
-        return self if self else just(supplier())
+    def or_else_get(self, supplier: ta.Callable[[], T]) -> T:
+        return self.must() if self else supplier()
 
-    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> Maybe[T]:
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
         if self:
-            return self
+            return self.must()
         raise exception_supplier()
 
 

omlish/lite/journald.py

@@ -0,0 +1,163 @@
+# ruff: noqa: UP007 UP012
+import ctypes as ct
+import logging
+import sys
+import syslog
+import threading
+import typing as ta
+
+from .cached import cached_nullary
+
+
+##
+
+
+class sd_iovec(ct.Structure):  # noqa
+    pass
+
+
+sd_iovec._fields_ = [
+    ('iov_base', ct.c_void_p),  # Pointer to data.
+    ('iov_len', ct.c_size_t),  # Length of data.
+]
+
+
+##
+
+
+@cached_nullary
+def sd_libsystemd() -> ta.Any:
+    lib = ct.CDLL('libsystemd.so.0')
+
+    lib.sd_journal_sendv = lib['sd_journal_sendv']  # type: ignore
+    lib.sd_journal_sendv.restype = ct.c_int
+    lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
+
+    return lib
+
+
+@cached_nullary
+def sd_try_libsystemd() -> ta.Optional[ta.Any]:
+    try:
+        return sd_libsystemd()
+    except OSError:  # noqa
+        return None
+
+
+##
+
+
+def sd_journald_send(**fields: str) -> int:
+    lib = sd_libsystemd()
+
+    msgs = [
+        f'{k.upper()}={v}\0'.encode('utf-8')
+        for k, v in fields.items()
+    ]
+
+    vec = (sd_iovec * len(msgs))()
+    cl = (ct.c_char_p * len(msgs))()  # noqa
+    for i in range(len(msgs)):
+        vec[i].iov_base = ct.cast(ct.c_char_p(msgs[i]), ct.c_void_p)
+        vec[i].iov_len = len(msgs[i]) - 1
+
+    return lib.sd_journal_sendv(vec, len(msgs))
+
+
+##
+
+
+SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
+    logging.FATAL: syslog.LOG_EMERG,  # system is unusable
+    # LOG_ALERT ?  # action must be taken immediately
+    logging.CRITICAL: syslog.LOG_CRIT,
+    logging.ERROR: syslog.LOG_ERR,
+    logging.WARNING: syslog.LOG_WARNING,
+    # LOG_NOTICE ?  # normal but significant condition
+    logging.INFO: syslog.LOG_INFO,
+    logging.DEBUG: syslog.LOG_DEBUG,
+}
+
+
+class JournaldLogHandler(logging.Handler):
+    """
+    TODO:
+     - fallback handler for when this barfs
+    """
+
+    def __init__(
+            self,
+            *,
+            use_formatter_output: bool = False,
+    ) -> None:
+        super().__init__()
+
+        sd_libsystemd()
+
+        self._use_formatter_output = use_formatter_output
+
+    #
+
+    EXTRA_RECORD_ATTRS_BY_JOURNALD_FIELD: ta.ClassVar[ta.Mapping[str, str]] = {
+        'name': 'name',
+        'module': 'module',
+        'exception': 'exc_text',
+        'thread_name': 'threadName',
+        'task_name': 'taskName',
+    }
+
+    def make_fields(self, record: logging.LogRecord) -> ta.Mapping[str, str]:
+        formatter_message = self.format(record)
+        if self._use_formatter_output:
+            message = formatter_message
+        else:
+            message = record.message
+
+        fields: dict[str, str] = {
+            'message': message,
+            'priority': str(SD_LOG_LEVEL_MAP[record.levelno]),
+            'tid': str(threading.get_ident()),
+        }
+
+        if (pathname := record.pathname) is not None:
+            fields['code_file'] = pathname
+        if (lineno := record.lineno) is not None:
+            fields['code_lineno'] = str(lineno)
+        if (func_name := record.funcName) is not None:
+            fields['code_func'] = func_name
+
+        for f, a in self.EXTRA_RECORD_ATTRS_BY_JOURNALD_FIELD.items():
+            if (v := getattr(record, a, None)) is not None:
+                fields[f] = str(v)
+
+        return fields
+
+    #
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            fields = self.make_fields(record)
+
+            if rc := sd_journald_send(**fields):
+                raise RuntimeError(f'{self.__class__.__name__}.emit failed: {rc=}')  # noqa
+
+        except RecursionError:  # See issue 36272
+            raise
+
+        except Exception:  # noqa
+            self.handleError(record)
+
+
+def journald_log_handler_factory(
+        *,
+        no_tty_check: bool = False,
+        no_fallback: bool = False,
+) -> logging.Handler:
+    if (
+            sys.platform == 'linux' and
+            (no_tty_check or not sys.stderr.isatty()) and
+            (no_fallback or sd_try_libsystemd() is not None)
+    ):
+        return JournaldLogHandler()
+
+    return logging.StreamHandler()

omlish/lite/logs.py

@@ -91,7 +91,7 @@ class StandardLogFormatter(logging.Formatter):
         if datefmt:
             return ct.strftime(datefmt)  # noqa
         else:
-            t = ct.strftime("%Y-%m-%d %H:%M:%S")  # noqa
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
             return '%s.%03d' % (t, record.msecs)
 
 
@@ -228,6 +228,7 @@ def configure_standard_logging(
         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:
@@ -241,7 +242,10 @@ def configure_standard_logging(
 
         #
 
-        handler = logging.StreamHandler()
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
 
         #