omlish 0.0.0.dev315__tar.gz → 0.0.0.dev316__tar.gz

{omlish-0.0.0.dev315/omlish.egg-info → omlish-0.0.0.dev316}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev315
+Version: 0.0.0.dev316
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev315'
-__revision__ = '9f4bb119f0561532694288dd8bb808ce67ebb43d'
+__version__ = '0.0.0.dev316'
+__revision__ = 'c32f4122c29baf0486a328e8d6e54beb8c47b3fc'
 
 
 #

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/formats/json/encoding.py

@@ -1,6 +1,9 @@
 import json
 
 
+##
+
+
 detect_encoding = json.detect_encoding
 
 

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/formats/json/literals.py

@@ -15,6 +15,7 @@
 # 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/encoder.py
 # https://github.com/simplejson/simplejson/blob/6932004966ab70ef47250a2b3152acd8c904e6b5/simplejson/scanner.py
 import json
 import re
@@ -25,6 +26,75 @@ import typing as ta
 ##
 
 
+_ESCAPE_PAT = re.compile(r'[\x00-\x1f\\"]')
+_ESCAPE_ASCII_PAT = re.compile(r'([\\"]|[^\ -~])')
+
+_ESCAPE_DCT = {
+    **{
+        chr(i): f'\\u{i:04x}'
+        for i in range(0x20)
+    },
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+
+
+def _convert_to_string(s: str | bytes) -> str:
+    if isinstance(s, bytes):
+        return str(s, 'utf-8')
+
+    elif type(s) is not str:
+        # Convert a str subclass instance to exact str. Raise a TypeError otherwise.
+        return str.__str__(s)
+
+    else:
+        return s
+
+
+def encode_string(s: str | bytes, q: str = '"') -> str:
+    """Return a JSON representation of a Python string"""
+
+    s = _convert_to_string(s)
+
+    def replace(m):
+        return _ESCAPE_DCT[m.group(0)]
+
+    return q + _ESCAPE_PAT.sub(replace, s) + q
+
+
+def encode_string_ascii(s: str | bytes, q: str = '"') -> str:
+    """Return an ASCII-only JSON representation of a Python string"""
+
+    s = _convert_to_string(s)
+
+    def replace(m):
+        s = m.group(0)
+
+        try:
+            return _ESCAPE_DCT[s]
+
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                return f'\\u{n:04x}'
+
+            # surrogate pair
+            n -= 0x10000
+            s1 = 0xD800 | ((n >> 10) & 0x3FF)
+            s2 = 0xDC00 | (n & 0x3FF)
+            return f'\\u{s1:04x}\\u{s2:04x}'
+
+    return q + str(_ESCAPE_ASCII_PAT.sub(replace, s)) + q
+
+
+##
+
+
 _FOUR_DIGIT_HEX_PAT = re.compile(r'^[0-9a-fA-F]{4}$')
 
 
@@ -86,7 +156,7 @@ def parse_string(
         prev_end = end
         end = chunk.end()
         content, terminator = chunk.groups()
-        # Content is contains zero or more unescaped string characters
+        # Content contains zero or more unescaped string characters
         if content:
             chunks.append(content)
 

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/formats/json/rendering.py

@@ -12,12 +12,13 @@ from .types import Scalar
 
 I = ta.TypeVar('I')
 
-MULTILINE_SEPARATORS = consts.Separators(',', ': ')
-
 
 ##
 
 
+MULTILINE_SEPARATORS = consts.Separators(',', ': ')
+
+
 class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
     class State(enum.Enum):
         VALUE = enum.auto()

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/http/coro/server.py

@@ -56,8 +56,7 @@ import abc
 import dataclasses as dc
 import email.utils
 import html
-import http.client
-import http.server
+import http
 import io
 import textwrap
 import time

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/lang/__init__.py

@@ -225,13 +225,6 @@ from .iterables import (  # noqa
     take,
 )
 
-from .maybes import (  # noqa
-    Maybe,
-    empty,
-    just,
-    maybe,
-)
-
 from .objects import (  # noqa
     Identity,
     SimpleProxy,
@@ -341,6 +334,13 @@ from ..lite.imports import (  # noqa
     import_module_attr,
 )
 
+from ..lite.maybes import (  # noqa
+    Maybe,
+)
+
+empty = Maybe.empty
+just = Maybe.just
+
 from ..lite.reprs import (  # noqa
     AttrRepr,
     attr_repr,

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/lang/generators.py

@@ -2,10 +2,8 @@ import abc
 import functools
 import typing as ta
 
+from ..lite.maybes import Maybe
 from .classes.restrict import Abstract
-from .maybes import Maybe
-from .maybes import empty
-from .maybes import just
 
 
 T = ta.TypeVar('T')
@@ -203,7 +201,7 @@ class GeneratorMappedIterator(ta.Generic[O, I, R]):
 
         self._g = g
         self._it = it
-        self._value: Maybe[R] = empty()
+        self._value: Maybe[R] = Maybe.empty()
 
     @property
     def g(self) -> ta.Generator[O, I, R]:
@@ -225,7 +223,7 @@ class GeneratorMappedIterator(ta.Generic[O, I, R]):
         try:
             o = self._g.send(i)
         except StopIteration as e:
-            self._value = just(e.value)
+            self._value = Maybe.just(e.value)
             raise StopIteration from e
         return o
 

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/lang/params.py

@@ -7,12 +7,10 @@ import enum
 import inspect
 import typing as ta
 
+from ..lite.maybes import Maybe
 from .classes.abstract import Abstract
 from .classes.restrict import Final
 from .classes.restrict import Sealed
-from .maybes import Maybe
-from .maybes import empty
-from .maybes import just
 
 
 T = ta.TypeVar('T')
@@ -25,7 +23,7 @@ T = ta.TypeVar('T')
 class Param(Sealed, Abstract):
     name: str
 
-    annotation: Maybe = empty()
+    annotation: Maybe = Maybe.empty()
 
     prefix: ta.ClassVar[str] = ''
 
@@ -57,7 +55,7 @@ class KwargsParam(VarParam, Final):
 
 @dc.dataclass(frozen=True, unsafe_hash=True)
 class ValParam(Param):
-    default: Maybe = empty()
+    default: Maybe = Maybe.empty()
 
 
 @dc.dataclass(frozen=True, unsafe_hash=True)
@@ -83,9 +81,9 @@ class ParamSeparator(enum.Enum):
 
 def _inspect_empty_to_maybe(o: T) -> Maybe[T]:
     if o is inspect.Parameter.empty:
-        return empty()
+        return Maybe.empty()
     else:
-        return just(o)
+        return Maybe.just(o)
 
 
 class ParamSpec(ta.Sequence[Param], Final):
@@ -119,8 +117,8 @@ class ParamSpec(ta.Sequence[Param], Final):
             if i < offset:
                 continue
 
-            ann = _inspect_empty_to_maybe(ip.annotation) if not strip_annotations else empty()
-            dfl = _inspect_empty_to_maybe(ip.default) if not strip_defaults else empty()
+            ann = _inspect_empty_to_maybe(ip.annotation) if not strip_annotations else Maybe.empty()
+            dfl = _inspect_empty_to_maybe(ip.default) if not strip_defaults else Maybe.empty()
 
             if ip.kind == inspect.Parameter.POSITIONAL_ONLY:
                 ps.append(PosOnlyParam(ip.name, ann, dfl))

omlish-0.0.0.dev316/omlish/lite/maybes.py

@@ -0,0 +1,206 @@
+# ruff: noqa: UP007
+import abc
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+
+
+##
+
+
+@functools.total_ordering
+class Maybe(ta.Generic[T]):
+    class ValueNotPresentError(BaseException):
+        pass
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def present(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def must(self) -> T:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def __repr__(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __eq__(self, other) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __lt__(self, other) -> bool:
+        raise NotImplementedError
+
+    #
+
+    @ta.final
+    def __ne__(self, other):
+        return not (self == other)
+
+    @ta.final
+    def __iter__(self) -> ta.Iterator[T]:
+        if self.present:
+            yield self.must()
+
+    @ta.final
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError
+
+    #
+
+    @ta.final
+    def if_present(self, consumer: ta.Callable[[T], None]) -> None:
+        if self.present:
+            consumer(self.must())
+
+    @ta.final
+    def filter(self, predicate: ta.Callable[[T], bool]) -> 'Maybe[T]':
+        if self.present and predicate(self.must()):
+            return self
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def map(self, mapper: ta.Callable[[T], U]) -> 'Maybe[U]':
+        if self.present:
+            return Maybe.just(mapper(self.must()))
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def flat_map(self, mapper: ta.Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
+        if self.present:
+            if not isinstance(v := mapper(self.must()), Maybe):
+                raise TypeError(v)
+            return v
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def or_else(self, other: ta.Union[T, U]) -> ta.Union[T, U]:
+        if self.present:
+            return self.must()
+        else:
+            return other
+
+    @ta.final
+    def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
+        if self.present:
+            return self.must()
+        else:
+            return supplier()
+
+    @ta.final
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
+        if self.present:
+            return self.must()
+        else:
+            raise exception_supplier()
+
+    #
+
+    @classmethod
+    def of_optional(cls, v: ta.Optional[T]) -> 'Maybe[T]':
+        if v is not None:
+            return cls.just(v)
+        else:
+            return cls.empty()
+
+    @classmethod
+    def just(cls, v: T) -> 'Maybe[T]':
+        return _JustMaybe(v)
+
+    _empty: ta.ClassVar['Maybe']
+
+    @classmethod
+    def empty(cls) -> 'Maybe[T]':
+        return Maybe._empty
+
+
+##
+
+
+class _Maybe(Maybe[T], abc.ABC):
+    def __lt__(self, other):
+        if not isinstance(other, _Maybe):
+            return NotImplemented
+        sp = self.present
+        op = other.present
+        if self.present and other.present:
+            return self.must() < other.must()
+        else:
+            return op and not sp
+
+
+class _JustMaybe(_Maybe[T]):
+    __slots__ = ('_v', '_hash')
+
+    def __init__(self, v: T) -> None:
+        super().__init__()
+
+        self._v = v
+
+    @property
+    def present(self) -> bool:
+        return True
+
+    def must(self) -> T:
+        return self._v
+
+    #
+
+    def __repr__(self) -> str:
+        return f'just({self._v!r})'
+
+    def __hash__(self) -> int:
+        try:
+            return self._hash  # type: ignore[has-type]
+        except AttributeError:
+            pass
+        h = self._hash = hash((_JustMaybe, self._v))
+        return h
+
+    def __eq__(self, other):
+        return (
+            self.__class__ is other.__class__ and
+            self._v == other._v  # noqa
+        )
+
+
+class _EmptyMaybe(_Maybe[T]):
+    __slots__ = ()
+
+    @property
+    def present(self) -> bool:
+        return False
+
+    def must(self) -> T:
+        raise Maybe.ValueNotPresentError
+
+    #
+
+    def __repr__(self) -> str:
+        return 'empty()'
+
+    def __hash__(self) -> int:
+        return hash(_EmptyMaybe)
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__
+
+
+Maybe._empty = _EmptyMaybe()  # noqa

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/callers.py

@@ -7,6 +7,9 @@ import types
 import typing as ta
 
 
+##
+
+
 class LoggingCaller(ta.NamedTuple):
     filename: str
     lineno: int

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/color.py

@@ -6,6 +6,9 @@ from ..term import codes as tc
 from .standard import StandardLogFormatter
 
 
+##
+
+
 class ColorLogFormatter(StandardLogFormatter):
     LEVEL_COLORS: ta.Mapping[int, tc.SGRs.FG] = {
         logging.WARNING: tc.SGRs.FG.BRIGHT_YELLOW,

omlish-0.0.0.dev316/omlish/logs/filters.py

@@ -0,0 +1,17 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import logging
+import threading
+
+
+##
+
+
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        # FIXME: handle better - missing from wasm and cosmos
+        if hasattr(threading, 'get_native_id'):
+            record.tid = threading.get_native_id()
+        else:
+            record.tid = '?'
+        return True

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/handlers.py

@@ -4,6 +4,9 @@ import logging
 import typing as ta
 
 
+##
+
+
 class ListHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/json.py

@@ -10,6 +10,9 @@ import typing as ta
 from ..lite.json import json_dumps_compact
 
 
+##
+
+
 class JsonLogFormatter(logging.Formatter):
     KEYS: ta.Mapping[str, bool] = {
         'name': False,

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/noisy.py

@@ -1,6 +1,9 @@
 import logging
 
 
+##
+
+
 NOISY_LOGGERS: set[str] = {
     'boto3.resources.action',
     'datadog.dogstatsd',

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/proxy.py

@@ -3,6 +3,9 @@
 import logging
 
 
+##
+
+
 class ProxyLogFilterer(logging.Filterer):
     def __init__(self, underlying: logging.Filterer) -> None:  # noqa
         self._underlying = underlying

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish/logs/utils.py

@@ -2,6 +2,9 @@ import functools
 import logging
 
 
+##
+
+
 _log = logging.getLogger(__name__)
 
 

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev315
+Version: 0.0.0.dev316
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/omlish.egg-info/SOURCES.txt

@@ -426,7 +426,6 @@ omlish/lang/functions.py
 omlish/lang/generators.py
 omlish/lang/imports.py
 omlish/lang/iterables.py
-omlish/lang/maybes.py
 omlish/lang/objects.py
 omlish/lang/outcomes.py
 omlish/lang/params.py

{omlish-0.0.0.dev315 → omlish-0.0.0.dev316}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev315'
+version = '0.0.0.dev316'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',