omlish 0.0.0.dev295__py3-none-any.whl → 0.0.0.dev297__py3-none-any.whl

omlish/dom/rendering.py

@@ -0,0 +1,184 @@
+import io
+import textwrap
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import dispatch
+from .. import lang
+from .content import Dom
+from .content import iter_content
+
+
+if ta.TYPE_CHECKING:
+    import markupsafe as ms
+
+    _HAS_MARKUPSAFE = True
+
+else:
+    ms = lang.proxy_import('markupsafe')
+
+    _HAS_MARKUPSAFE = lang.can_import('markupsafe')
+
+
+##
+
+
+@dc.dataclass()
+class InvalidTagError(Exception):
+    pass
+
+
+@dc.dataclass()
+class StrForbiddenError(Exception):
+    pass
+
+
+class Renderer:
+    def __init__(
+            self,
+            sb: io.StringIO | None,
+            *,
+            forbid_str: bool = False,
+            escape: ta.Callable[[str], str] | None = None,
+            indent: str | int | None = None,
+            indent_string_content: bool = False,
+    ) -> None:
+        super().__init__()
+
+        if sb is None:
+            sb = io.StringIO()
+        self._sb = sb
+
+        self._forbid_str = forbid_str
+        self._escape_fn = escape
+        if isinstance(indent, int):
+            indent = ' ' * indent
+        self._indent_unit: str | None = indent
+        self._indent_string_content = indent_string_content
+
+        self._level = 0
+        self._indent_cache: dict[int, str] = {}
+
+    @classmethod
+    def render_to_str(cls, o: ta.Any, **kwargs: ta.Any) -> str:
+        sb = io.StringIO()
+        cls(sb, **kwargs).render(o)
+        return sb.getvalue()
+
+    #
+
+    def _escape(self, s: str) -> str:
+        if _HAS_MARKUPSAFE and isinstance(s, ms.Markup):
+            return s
+        if type(s) is not str:
+            raise TypeError(s)
+        if (fn := self._escape_fn) is None:
+            return s
+        return fn(s)
+
+    def _check_tag(self, s: str) -> str:
+        if self._escape(s) != s:
+            raise InvalidTagError(s)
+        return s
+
+    #
+
+    def _indent_str(self) -> str | None:
+        if not (s := self._indent_unit):
+            return None
+        try:
+            return self._indent_cache[self._level]
+        except KeyError:
+            pass
+        ls = self._indent_cache[self._level] = s * self._level
+        return ls
+
+    def _write_indent(self) -> None:
+        if (s := self._indent_str()):
+            self._sb.write(s)
+
+    #
+
+    @dispatch.method
+    def render(self, o: ta.Any) -> None:
+        raise TypeError(o)
+
+    #
+
+    def _write_string_content(self, s: str) -> None:
+        if self._indent_string_content and (ls := self._indent_str()):
+            s = textwrap.indent(s, ls)
+        self._sb.write(s)
+
+    @render.register  # noqa
+    def _render_str(self, s: str) -> None:
+        if self._forbid_str:
+            raise StrForbiddenError(s)
+        self._write_string_content(s)
+
+    @render.register  # noqa
+    def _render_sequence(self, l: ta.Sequence) -> None:
+        for e in l:
+            self.render(e)
+
+    #
+
+    if _HAS_MARKUPSAFE:
+        @render.register
+        def _render_markup(self, m: ms.Markup) -> None:
+            self._write_string_content(m)
+
+    #
+
+    def _render_tag(self, tag: str) -> None:
+        self._sb.write(self._check_tag(tag))
+
+    def _render_attr_key(self, k: str) -> None:
+        self._sb.write(self._check_tag(k))
+
+    def _render_attr_value(self, v: ta.Any) -> None:
+        self._sb.write('"')
+        self._sb.write(check.isinstance(v, str))  # FIXME
+        self._sb.write('"')
+
+    @render.register  # noqa
+    def _render_dom(self, n: Dom) -> None:
+        self._write_indent()
+
+        self._sb.write('<')
+        self._render_tag(n.tag)
+
+        for k, v in (n.attrs or {}).items():
+            self._sb.write(' ')
+            self._render_attr_key(k)
+            if v is not None:
+                self._sb.write('=')
+                self._render_attr_value(v)
+
+        i = -1
+        for i, c in enumerate(iter_content(n.body)):
+            if not i:
+                self._sb.write('>')
+
+            if self._indent_unit:
+                self._sb.write('\n')
+
+            self._level += 1
+            self.render(c)
+            self._level -= 1
+
+        if i >= 0:
+            if self._indent_unit:
+                self._sb.write('\n')
+                self._write_indent()
+
+            self._sb.write('</')
+            self._render_tag(n.tag)
+            self._sb.write('>')
+
+        else:
+            self._sb.write(' />')
+
+
+render = Renderer.render_to_str

omlish/math/__init__.py

@@ -0,0 +1,83 @@
+from .bits import (  # noqa
+    get_bit,
+    get_bits,
+    set_bit,
+    set_bits,
+)
+
+from .c import (  # noqa
+    cdiv,
+    cmod,
+)
+
+from .fixed import (  # noqa
+    CheckedFixedWidthIntError,
+    OverflowFixedWidthIntError,
+    UnderflowFixedWidthIntError,
+
+    FixedWidthInt,
+
+    SignedInt,
+    UnsignedInt,
+
+    CheckedInt,
+    ClampedInt,
+
+    AnyInt8,
+    AnyInt16,
+    AnyInt32,
+    AnyInt64,
+    AnyInt128,
+
+    CheckedInt8,
+    CheckedInt16,
+    CheckedInt32,
+    CheckedInt64,
+    CheckedInt128,
+
+    CheckedUInt8,
+    CheckedUInt16,
+    CheckedUInt32,
+    CheckedUInt64,
+    CheckedUInt128,
+
+    ClampedInt8,
+    ClampedInt16,
+    ClampedInt32,
+    ClampedInt64,
+    ClampedInt128,
+
+    ClampedUInt8,
+    ClampedUInt16,
+    ClampedUInt32,
+    ClampedUInt64,
+    ClampedUInt128,
+
+    WrappedInt8,
+    WrappedInt16,
+    WrappedInt32,
+    WrappedInt64,
+    WrappedInt128,
+
+    WrappedUInt8,
+    WrappedUInt16,
+    WrappedUInt32,
+    WrappedUInt64,
+    WrappedUInt128,
+)
+
+from .floats import (  # noqa
+    isclose,
+    float_to_bytes,
+    bytes_to_float,
+)
+
+from .stats import (  # noqa
+    get_quantile,
+
+    Stats,
+)
+
+from .histogram import (  # noqa
+    SamplingHistogram,
+)

omlish/math/bits.py

@@ -1,10 +1,3 @@
-import functools
-import typing as ta
-
-
-##
-
-
 def get_bit(bit: int, value: int) -> int:
     return (value >> bit) & 1
 
@@ -22,149 +15,3 @@ def set_bit(bit: int, bit_value: int, value: int) -> int:
 
 def set_bits(bits_from: int, num_bits: int, bits_value: int, value: int) -> int:
     return value & ~(((1 << num_bits) - 1) << bits_from) | (bits_value << bits_from)
-
-
-##
-
-
-def _gen_scalar_proxy_method(name):
-    def inner(self, *args, **kwargs):
-        return self.__class__(orig(self, *args, **kwargs))
-
-    orig = getattr(int, name)
-    return functools.wraps(orig)(inner)
-
-
-def _gen_tuple_proxy_method(name):
-    def inner(self, *args, **kwargs):
-        return tuple(map(self.__class__, orig(self, *args, **kwargs)))
-
-    orig = getattr(int, name)
-    return functools.wraps(orig)(inner)
-
-
-class FixedWidthInt(int):
-    BITS: ta.ClassVar[int]
-    SIGNED: ta.ClassVar[bool]
-
-    MIN: ta.ClassVar[int]
-    MAX: ta.ClassVar[int]
-
-    MASK: ta.ClassVar[int]
-
-    def __init_subclass__(cls) -> None:
-        super().__init_subclass__()
-
-        if not isinstance(cls.BITS, int):
-            raise TypeError(cls.BITS)
-
-        if cls.SIGNED:
-            cls.MIN = -(1 << (cls.BITS - 1))
-            cls.MAX = (1 << (cls.BITS - 1)) - 1
-        else:
-            cls.MIN = 0
-            cls.MAX = (1 << cls.BITS) - 1
-
-        cls.MASK = (1 << cls.BITS) - 1
-
-    @classmethod
-    def clamp(cls, value: int) -> int:
-        return ((value - cls.MIN) & cls.MASK) + cls.MIN
-
-    def __new__(cls, value: int) -> 'FixedWidthInt':
-        return super().__new__(cls, cls.clamp(value))  # noqa
-
-    SCALAR_PROXY_METHODS = frozenset([
-        '__abs__',
-        '__add__',
-        '__and__',
-        '__floordiv__',
-        '__invert__',
-        '__lshift__',
-        '__mod__',
-        '__mul__',
-        '__neg__',
-        '__or__',
-        '__pos__',
-        '__pow__',
-        '__radd__',
-        '__rand__',
-        '__rfloordiv__',
-        '__rlshift__',
-        '__rmod__',
-        '__rmul__',
-        '__ror__',
-        '__rpow__',
-        '__rrshift__',
-        '__rshift__',
-        '__rsub__',
-        '__rtruediv__',
-        '__rxor__',
-        '__sub__',
-        '__truediv__',
-        '__xor__',
-    ])
-
-    TUPLE_PROXY_METHODS = frozenset([
-        '__divmod__',
-        '__rdivmod__',
-    ])
-
-    for _proxy_name in SCALAR_PROXY_METHODS:
-        locals()[_proxy_name] = _gen_scalar_proxy_method(_proxy_name)
-    for _proxy_name in TUPLE_PROXY_METHODS:
-        locals()[_proxy_name] = _gen_tuple_proxy_method(_proxy_name)
-    del _proxy_name
-
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}({int(self)})'
-
-
-class Int8(FixedWidthInt):
-    BITS = 8
-    SIGNED = True
-
-
-class Int16(FixedWidthInt):
-    BITS = 16
-    SIGNED = True
-
-
-class Int32(FixedWidthInt):
-    BITS = 32
-    SIGNED = True
-
-
-class Int64(FixedWidthInt):
-    BITS = 64
-    SIGNED = True
-
-
-class Int128(FixedWidthInt):
-    BITS = 128
-    SIGNED = True
-
-
-class Uint8(FixedWidthInt):
-    BITS = 8
-    SIGNED = False
-
-
-class Uint16(FixedWidthInt):
-    BITS = 16
-    SIGNED = False
-
-
-class Uint32(FixedWidthInt):
-    BITS = 32
-    SIGNED = False
-
-
-class Uint64(FixedWidthInt):
-    BITS = 64
-    SIGNED = False
-
-
-class Uint128(FixedWidthInt):
-    BITS = 128
-    SIGNED = False

omlish/math/c.py

@@ -0,0 +1,13 @@
+def cdiv(x: int, y: int) -> int:
+    """https://python-history.blogspot.com/2010/08/why-pythons-integer-division-floors.html"""
+
+    if y == 0:
+        return 0
+    u = abs(x) // abs(y)
+    if (x < 0) ^ (y < 0):
+        u *= -1
+    return u
+
+
+def cmod(x: int, y: int) -> int:
+    return x - (cdiv(x, y) * y)