omlish 0.0.0.dev294__py3-none-any.whl → 0.0.0.dev296__py3-none-any.whl

omlish/math/fixed.py

@@ -0,0 +1,390 @@
+import enum
+import functools
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+FixedWidthIntT = ta.TypeVar('FixedWidthIntT', bound='FixedWidthInt')
+
+
+##
+
+
+class CheckedFixedWidthIntError(ValueError):
+    pass
+
+
+class OverflowFixedWidthIntError(CheckedFixedWidthIntError):
+    pass
+
+
+class UnderflowFixedWidthIntError(CheckedFixedWidthIntError):
+    pass
+
+
+##
+
+
+def _get_exclusive_base_cls(cls: type, base_classes: ta.Iterable[type]) -> type:
+    return check.single(bcls for bcls in base_classes if issubclass(cls, bcls))
+
+
+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, lang.Abstract):
+    BITS: ta.ClassVar[int]
+
+    #
+
+    class Mode(enum.StrEnum):
+        CHECK = enum.auto()
+        CLAMP = enum.auto()
+        WRAP = enum.auto()
+
+    MODE: ta.ClassVar[Mode]
+
+    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 lang.is_abstract_class(cls):
+            return
+
+        #
+
+        bits = check.single({
+            check.isinstance(bbits, int)
+            for bcls in cls.__mro__
+            if (bbits := bcls.__dict__.get('BITS')) is not None
+        })
+
+        #
+
+        mode_base = _get_exclusive_base_cls(cls, _MODE_BASE_CLASSES)
+
+        if mode_base is CheckedInt:
+            cls.MODE = cls.Mode.CHECK
+
+        elif mode_base is ClampedInt:
+            cls.MODE = cls.Mode.CLAMP
+
+        elif mode_base is WrappedInt:
+            cls.MODE = cls.Mode.WRAP
+
+        else:
+            raise TypeError(cls)
+
+        #
+
+        sign_base = _get_exclusive_base_cls(cls, _SIGN_BASE_CLASSES)
+
+        if sign_base is SignedInt:
+            cls.SIGNED = True
+            cls.MIN = -(1 << (bits - 1))
+            cls.MAX = (1 << (bits - 1)) - 1
+
+        elif sign_base is UnsignedInt:
+            cls.SIGNED = False
+            cls.MIN = 0
+            cls.MAX = (1 << bits) - 1
+
+        else:
+            raise TypeError(cls)
+
+        #
+
+        cls.MASK = (1 << bits) - 1
+
+    #
+
+    @classmethod
+    def clamp(cls, value: int) -> int:
+        return max(min(value, cls.MAX), cls.MIN)
+
+    @classmethod
+    def check(cls, value: int) -> int:
+        if value > cls.MAX:
+            raise OverflowFixedWidthIntError(value)
+        elif value < cls.MIN:
+            raise UnderflowFixedWidthIntError(value)
+        return value
+
+    @classmethod
+    def wrap(cls, value: int) -> int:
+        return ((value - cls.MIN) & cls.MASK) + cls.MIN
+
+    #
+
+    _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 SignedInt(FixedWidthInt, lang.Abstract):
+    pass
+
+
+class UnsignedInt(FixedWidthInt, lang.Abstract):
+    pass
+
+
+_SIGN_BASE_CLASSES: tuple[type[FixedWidthInt], ...] = (
+    SignedInt,
+    UnsignedInt,
+)
+
+
+#
+
+
+class CheckedInt(FixedWidthInt, lang.Abstract):
+    def __new__(cls: type[FixedWidthIntT], value: int) -> FixedWidthIntT:
+        return super().__new__(cls, cls.check(value))  # type: ignore[misc]
+
+
+class ClampedInt(FixedWidthInt, lang.Abstract):
+    def __new__(cls: type[FixedWidthIntT], value: int) -> FixedWidthIntT:
+        return super().__new__(cls, cls.clamp(value))  # type: ignore[misc]
+
+
+class WrappedInt(FixedWidthInt, lang.Abstract):
+    def __new__(cls: type[FixedWidthIntT], value: int) -> FixedWidthIntT:
+        return super().__new__(cls, cls.wrap(value))  # type: ignore[misc]
+
+
+_MODE_BASE_CLASSES: tuple[type[FixedWidthInt], ...] = (
+    CheckedInt,
+    ClampedInt,
+    WrappedInt,
+)
+
+
+#
+
+
+class AnyInt8(FixedWidthInt, lang.Abstract):
+    BITS = 8
+
+
+class AnyInt16(FixedWidthInt, lang.Abstract):
+    BITS = 16
+
+
+class AnyInt32(FixedWidthInt, lang.Abstract):
+    BITS = 32
+
+
+class AnyInt64(FixedWidthInt, lang.Abstract):
+    BITS = 64
+
+
+class AnyInt128(FixedWidthInt, lang.Abstract):
+    BITS = 128
+
+
+##
+
+
+class CheckedInt8(CheckedInt, SignedInt, AnyInt8):
+    pass
+
+
+class CheckedInt16(CheckedInt, SignedInt, AnyInt16):
+    pass
+
+
+class CheckedInt32(CheckedInt, SignedInt, AnyInt32):
+    pass
+
+
+class CheckedInt64(CheckedInt, SignedInt, AnyInt64):
+    pass
+
+
+class CheckedInt128(CheckedInt, SignedInt, AnyInt128):
+    pass
+
+
+#
+
+
+class CheckedUInt8(CheckedInt, UnsignedInt, AnyInt8):
+    pass
+
+
+class CheckedUInt16(CheckedInt, UnsignedInt, AnyInt16):
+    pass
+
+
+class CheckedUInt32(CheckedInt, UnsignedInt, AnyInt32):
+    pass
+
+
+class CheckedUInt64(CheckedInt, UnsignedInt, AnyInt64):
+    pass
+
+
+class CheckedUInt128(CheckedInt, UnsignedInt, AnyInt128):
+    pass
+
+
+#
+
+
+class ClampedInt8(ClampedInt, SignedInt, AnyInt8):
+    pass
+
+
+class ClampedInt16(ClampedInt, SignedInt, AnyInt16):
+    pass
+
+
+class ClampedInt32(ClampedInt, SignedInt, AnyInt32):
+    pass
+
+
+class ClampedInt64(ClampedInt, SignedInt, AnyInt64):
+    pass
+
+
+class ClampedInt128(ClampedInt, SignedInt, AnyInt128):
+    pass
+
+
+#
+
+
+class ClampedUInt8(ClampedInt, UnsignedInt, AnyInt8):
+    pass
+
+
+class ClampedUInt16(ClampedInt, UnsignedInt, AnyInt16):
+    pass
+
+
+class ClampedUInt32(ClampedInt, UnsignedInt, AnyInt32):
+    pass
+
+
+class ClampedUInt64(ClampedInt, UnsignedInt, AnyInt64):
+    pass
+
+
+class ClampedUInt128(ClampedInt, UnsignedInt, AnyInt128):
+    pass
+
+
+#
+
+
+class WrappedInt8(WrappedInt, SignedInt, AnyInt8):
+    pass
+
+
+class WrappedInt16(WrappedInt, SignedInt, AnyInt16):
+    pass
+
+
+class WrappedInt32(WrappedInt, SignedInt, AnyInt32):
+    pass
+
+
+class WrappedInt64(WrappedInt, SignedInt, AnyInt64):
+    pass
+
+
+class WrappedInt128(WrappedInt, SignedInt, AnyInt128):
+    pass
+
+
+#
+
+
+class WrappedUInt8(WrappedInt, UnsignedInt, AnyInt8):
+    pass
+
+
+class WrappedUInt16(WrappedInt, UnsignedInt, AnyInt16):
+    pass
+
+
+class WrappedUInt32(WrappedInt, UnsignedInt, AnyInt32):
+    pass
+
+
+class WrappedUInt64(WrappedInt, UnsignedInt, AnyInt64):
+    pass
+
+
+class WrappedUInt128(WrappedInt, UnsignedInt, AnyInt128):
+    pass

omlish/math/floats.py

@@ -1,6 +1,9 @@
 import struct
 
 
+##
+
+
 def isclose(a: float, b: float, *, rel_tol: float = 1e-09, abs_tol: float = 0.0) -> float:
     return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
 

omlish/math/histogram.py

@@ -0,0 +1,127 @@
+"""
+TODO:
+ - reservoir
+ - dep tdigest?
+ - struct-of-arrays - array.array('f', ...) - backed SamplingHistogram
+ - https://docs.python.org/3/library/statistics.html
+"""
+import contextlib
+import dataclasses as dc
+import operator
+import random
+import time
+import typing as ta
+
+from .. import check
+
+
+##
+
+
+class SamplingHistogram:
+    @dc.dataclass(frozen=True)
+    class Entry:
+        value: float
+        timestamp: float
+
+    @dc.dataclass(frozen=True)
+    class Percentile:
+        p: float
+        value: float
+
+    @dc.dataclass(frozen=True)
+    class Stats:
+        count: int
+        min: float
+        max: float
+        last_percentiles: list['SamplingHistogram.Percentile']
+        sample_percentiles: list['SamplingHistogram.Percentile']
+
+    DEFAULT_SIZE = 1000
+    DEFAULT_PERCENTILES = (0.5, 0.75, 0.9, 0.95, 0.99)
+
+    def __init__(
+            self,
+            *,
+            size: int = DEFAULT_SIZE,
+            percentiles: ta.Iterable[float] | None = None,
+    ) -> None:
+        check.arg(size > 0)
+
+        super().__init__()
+
+        self._size = size
+        self._percentiles = list(percentiles if percentiles is not None else self.DEFAULT_PERCENTILES)
+
+        self._count = 0
+        self._min = float('inf')
+        self._max = float('-inf')
+
+        self._percentile_pos_list = [self._calc_percentile_pos(p, self._size) for p in self._percentiles]
+
+        self._ring: list[SamplingHistogram.Entry | None] = [None] * size
+        self._ring_pos = 0
+
+        self._sample: list[SamplingHistogram.Entry | None] = [None] * size
+        self._sample_pos_queue = list(reversed(range(size)))
+
+    def add(self, value: float) -> None:
+        self._count += 1
+        self._min = min(self._min, value)
+        self._max = max(self._max, value)
+
+        entry = self.Entry(value, time.time())
+
+        self._ring[self._ring_pos] = entry
+        next_ring_pos = self._ring_pos + 1
+        self._ring_pos = 0 if next_ring_pos >= self._size else next_ring_pos
+
+        sample_pos = None
+        if self._sample_pos_queue:
+            with contextlib.suppress(IndexError):
+                sample_pos = self._sample_pos_queue.pop()
+        if sample_pos is None:
+            sample_pos = random.randrange(0, self._size)
+        self._sample[sample_pos] = entry
+
+    @staticmethod
+    def _calc_percentile_pos(p: float, sz: int) -> int:
+        return round((p * sz) - 1)
+
+    def _calc_percentiles(self, entries: list[Entry | None]) -> list[Percentile]:
+        entries = list(filter(None, entries))
+        sz = len(entries)
+        if not sz:
+            return []
+        elif sz == self._size:
+            pos_list = self._percentile_pos_list
+        else:
+            pos_list = [self._calc_percentile_pos(p, sz) for p in self._percentiles]
+        entries.sort(key=operator.attrgetter('value'))
+        return [
+            self.Percentile(p, check.not_none(entries[pos]).value)
+            for p, pos in zip(self._percentiles, pos_list)
+        ]
+
+    def get(self) -> Stats:
+        return self.Stats(
+            count=self._count,
+            min=self._min,
+            max=self._max,
+            last_percentiles=self._calc_percentiles(self._ring),
+            sample_percentiles=self._calc_percentiles(self._sample),
+        )
+
+    def get_filtered(self, entry_filter: ta.Callable[[Entry], bool]) -> Stats:
+        def filter_entries(l):
+            return [e for e in list(l) if e is not None and entry_filter(e)]
+        return self.Stats(
+            count=self._count,
+            min=self._min,
+            max=self._max,
+            last_percentiles=self._calc_percentiles(filter_entries(self._ring)),
+            sample_percentiles=self._calc_percentiles(filter_entries(self._sample)),
+        )
+
+    def get_since(self, min_timestamp: float) -> Stats:
+        return self.get_filtered(lambda e: e.timestamp >= min_timestamp)

omlish/math/stats.py

@@ -1,18 +1,6 @@
-"""
-TODO:
- - reservoir
- - dep tdigest?
- - struct-of-arrays - array.array('f', ...) - backed SamplingHistogram
- - https://docs.python.org/3/library/statistics.html
-"""
 import bisect
 import collections
-import contextlib
-import dataclasses as dc
 import math
-import operator
-import random
-import time
 import typing as ta
 
 from .. import cached
@@ -228,115 +216,3 @@ class Stats(ta.Sequence[float]):
         count_map = collections.Counter(idxs)
         bin_counts = [(b, count_map.get(i, 0)) for i, b in enumerate(bins)]
         return bin_counts
-
-
-##
-
-
-class SamplingHistogram:
-    @dc.dataclass(frozen=True)
-    class Entry:
-        value: float
-        timestamp: float
-
-    @dc.dataclass(frozen=True)
-    class Percentile:
-        p: float
-        value: float
-
-    @dc.dataclass(frozen=True)
-    class Stats:
-        count: int
-        min: float
-        max: float
-        last_percentiles: list['SamplingHistogram.Percentile']
-        sample_percentiles: list['SamplingHistogram.Percentile']
-
-    DEFAULT_SIZE = 1000
-    DEFAULT_PERCENTILES = (0.5, 0.75, 0.9, 0.95, 0.99)
-
-    def __init__(
-            self,
-            *,
-            size: int = DEFAULT_SIZE,
-            percentiles: ta.Iterable[float] | None = None,
-    ) -> None:
-        check.arg(size > 0)
-
-        super().__init__()
-
-        self._size = size
-        self._percentiles = list(percentiles if percentiles is not None else self.DEFAULT_PERCENTILES)
-
-        self._count = 0
-        self._min = float('inf')
-        self._max = float('-inf')
-
-        self._percentile_pos_list = [self._calc_percentile_pos(p, self._size) for p in self._percentiles]
-
-        self._ring: list[SamplingHistogram.Entry | None] = [None] * size
-        self._ring_pos = 0
-
-        self._sample: list[SamplingHistogram.Entry | None] = [None] * size
-        self._sample_pos_queue = list(reversed(range(size)))
-
-    def add(self, value: float) -> None:
-        self._count += 1
-        self._min = min(self._min, value)
-        self._max = max(self._max, value)
-
-        entry = self.Entry(value, time.time())
-
-        self._ring[self._ring_pos] = entry
-        next_ring_pos = self._ring_pos + 1
-        self._ring_pos = 0 if next_ring_pos >= self._size else next_ring_pos
-
-        sample_pos = None
-        if self._sample_pos_queue:
-            with contextlib.suppress(IndexError):
-                sample_pos = self._sample_pos_queue.pop()
-        if sample_pos is None:
-            sample_pos = random.randrange(0, self._size)
-        self._sample[sample_pos] = entry
-
-    @staticmethod
-    def _calc_percentile_pos(p: float, sz: int) -> int:
-        return round((p * sz) - 1)
-
-    def _calc_percentiles(self, entries: list[Entry | None]) -> list[Percentile]:
-        entries = list(filter(None, entries))
-        sz = len(entries)
-        if not sz:
-            return []
-        elif sz == self._size:
-            pos_list = self._percentile_pos_list
-        else:
-            pos_list = [self._calc_percentile_pos(p, sz) for p in self._percentiles]
-        entries.sort(key=operator.attrgetter('value'))
-        return [
-            self.Percentile(p, check.not_none(entries[pos]).value)
-            for p, pos in zip(self._percentiles, pos_list)
-        ]
-
-    def get(self) -> Stats:
-        return self.Stats(
-            count=self._count,
-            min=self._min,
-            max=self._max,
-            last_percentiles=self._calc_percentiles(self._ring),
-            sample_percentiles=self._calc_percentiles(self._sample),
-        )
-
-    def get_filtered(self, entry_filter: ta.Callable[[Entry], bool]) -> Stats:
-        def filter_entries(l):
-            return [e for e in list(l) if e is not None and entry_filter(e)]
-        return self.Stats(
-            count=self._count,
-            min=self._min,
-            max=self._max,
-            last_percentiles=self._calc_percentiles(filter_entries(self._ring)),
-            sample_percentiles=self._calc_percentiles(filter_entries(self._sample)),
-        )
-
-    def get_since(self, min_timestamp: float) -> Stats:
-        return self.get_filtered(lambda e: e.timestamp >= min_timestamp)

omlish/sql/__init__.py

@@ -1,3 +1,14 @@
+# ruff: noqa: I001
+import typing as _ta
+
+from .. import lang as _lang
+
+
+if _ta.TYPE_CHECKING:
+    from . import api
+else:
+    api = _lang.proxy_import('.api', __package__)
+
 from .dbs import (  # noqa
     DbLoc,
     DbSpec,
@@ -11,3 +22,8 @@ from .qualifiedname import (  # noqa
     QualifiedName,
     qn,
 )
+
+if _ta.TYPE_CHECKING:
+    from . import queries
+else:
+    queries = _lang.proxy_import('.queries', __package__)

omlish/sql/api/__init__.py

@@ -14,6 +14,13 @@ from .columns import (  # noqa
     Columns,
 )
 
+from .dbapi import (  # noqa
+    DbapiRows,
+    DbapiConn,
+    DbapiDb,
+    DbapiAdapter,
+)
+
 from .errors import (  # noqa
     Error,