omlish 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/marshal/registries.py

@@ -1,13 +1,13 @@
-import abc
 import dataclasses as dc
 import threading
 import typing as ta
 
 from .. import check
+from .. import lang
 from .. import reflect as rfl
 
 
-class RegistryItem(abc.ABC):
+class RegistryItem(lang.Abstract):
     pass
 
 
@@ -31,7 +31,7 @@ class Registry:
         super().__init__()
         self._mtx = threading.Lock()
         self._dct: dict[rfl.Type, _TypeRegistry] = {}
-        self._ps: ta.Sequence['Registry'] = []
+        self._ps: ta.Sequence[Registry] = []
 
     def register(self, rty: rfl.Type, *items: RegistryItem) -> 'Registry':
         check.isinstance(rty, rfl.TYPES)

omlish/marshal/standard.py

@@ -47,9 +47,9 @@ def new_standard_marshaler_factory() -> MarshalerFactory:
     return TypeCacheFactory(  # noqa
         RecursiveMarshalerFactory(
             CompositeFactory(
-                *STANDARD_MARSHALER_FACTORIES
-            )
-        )
+                *STANDARD_MARSHALER_FACTORIES,
+            ),
+        ),
     )
 
 
@@ -74,7 +74,7 @@ def new_standard_unmarshaler_factory() -> UnmarshalerFactory:
     return TypeCacheFactory(  # noqa
         RecursiveUnmarshalerFactory(
             CompositeFactory(
-                *STANDARD_UNMARSHALER_FACTORIES
-            )
-        )
+                *STANDARD_UNMARSHALER_FACTORIES,
+            ),
+        ),
     )

omlish/marshal/utils.py

@@ -5,7 +5,7 @@ T = ta.TypeVar('T')
 
 
 class _Proxy(ta.Generic[T]):
-    __obj: ta.Optional[T] = None
+    __obj: T | None = None
 
     @property
     def _obj(self) -> T:
@@ -19,5 +19,5 @@ class _Proxy(ta.Generic[T]):
         self.__obj = obj
 
     @classmethod
-    def _new(cls):
-        return (p := cls()), p._set_obj
+    def _new(cls) -> tuple[ta.Any, ta.Callable[[ta.Any], None]]:
+        return (p := cls()), p._set_obj  # noqa

omlish/marshal/values.py

@@ -13,7 +13,7 @@ Any
 import typing as ta
 
 
-Value = ta.Union[
+Value = ta.Union[  # noqa
     None,
 
     bool,

omlish/math.py

@@ -66,7 +66,7 @@ class FixedWidthInt(int):
 
     MASK: ta.ClassVar[int]
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls) -> None:
         super().__init_subclass__()
 
         if not isinstance(cls.BITS, int):
@@ -82,13 +82,13 @@ class FixedWidthInt(int):
         cls.MASK = (1 << cls.BITS) - 1
 
     @classmethod
-    def clamp(cls, value):
+    def clamp(cls, value: int) -> int:
         return ((value - cls.MIN) & cls.MASK) + cls.MIN
 
-    def __new__(cls, value, *args, **kwargs):
-        return super().__new__(cls, cls.clamp(value))
+    def __new__(cls, value: int) -> 'FixedWidthInt':
+        return super().__new__(cls, cls.clamp(value))  # noqa
 
-    SCALAR_PROXY_METHODS = {
+    SCALAR_PROXY_METHODS = frozenset([
         '__abs__',
         '__add__',
         '__and__',
@@ -117,12 +117,12 @@ class FixedWidthInt(int):
         '__sub__',
         '__truediv__',
         '__xor__',
-    }
+    ])
 
-    TUPLE_PROXY_METHODS = {
+    TUPLE_PROXY_METHODS = frozenset([
         '__divmod__',
         '__rdivmod__',
-    }
+    ])
 
     for _proxy_name in SCALAR_PROXY_METHODS:
         locals()[_proxy_name] = _gen_scalar_proxy_method(_proxy_name)
@@ -130,7 +130,7 @@ class FixedWidthInt(int):
         locals()[_proxy_name] = _gen_tuple_proxy_method(_proxy_name)
     del _proxy_name
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'{self.__class__.__name__}({int(self)})'
 
 

omlish/os.py

@@ -1,14 +1,23 @@
 import contextlib
+import resource
 import shutil
 import tempfile
 import typing as ta
 
 
+PAGE_SIZE = resource.getpagesize()
+
+
+def round_to_page_size(sz: int) -> int:
+    sz += PAGE_SIZE - 1
+    return sz - (sz % PAGE_SIZE)
+
+
 @contextlib.contextmanager
 def tmp_dir(
-        root_dir: ta.Optional[str] = None,
+        root_dir: str | None = None,
         cleanup: bool = True,
-        **kwargs: ta.Any
+        **kwargs: ta.Any,
 ) -> ta.Iterator[str]:
     path = tempfile.mkdtemp(dir=root_dir, **kwargs)
     try:
@@ -20,9 +29,9 @@ def tmp_dir(
 
 @contextlib.contextmanager
 def tmp_file(
-        root_dir: ta.Optional[str] = None,
+        root_dir: str | None = None,
         cleanup: bool = True,
-        **kwargs: ta.Any
+        **kwargs: ta.Any,
 ) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
     with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
         try:

omlish/reflect.py

@@ -21,7 +21,7 @@ else:
 
 _NoneType = types.NoneType  # type: ignore
 
-_NONE_TYPE_FROZENSET: ta.FrozenSet['Type'] = frozenset([_NoneType])
+_NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
 _GenericAlias = ta._GenericAlias  # type: ignore  # noqa
@@ -63,16 +63,6 @@ _KNOWN_SPECIAL_TYPE_VARS = tuple(
 ##
 
 
-try:
-    from types import get_original_bases  # type: ignore
-except ImportError:
-    def get_original_bases(cls, /):
-        try:
-            return cls.__dict__.get('__orig_bases__', cls.__bases__)
-        except AttributeError:
-            raise TypeError(f'Expected an instance of type, not {type(cls).__name__!r}') from None
-
-
 def get_params(obj: ta.Any) -> tuple[ta.TypeVar, ...]:
     if isinstance(obj, type):
         if issubclass(obj, ta.Generic):  # type: ignore
@@ -109,7 +99,7 @@ Type = ta.Union[
 
 
 class Union(ta.NamedTuple):
-    args: ta.FrozenSet[Type]
+    args: frozenset[Type]
 
     @property
     def is_optional(self) -> bool:
@@ -131,7 +121,7 @@ class Generic(ta.NamedTuple):
     # params2: tuple[ta.TypeVar, ...]  # map[int, V] = (V,)     | map[T, T] = (T,)
     obj: ta.Any
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return (
             f'{self.__class__.__name__}('
             f'cls={self.cls.__name__}, '
@@ -218,7 +208,7 @@ def get_underlying(nt: NewType) -> Type:
     return type_(nt.obj.__supertype__)  # noqa
 
 
-def get_concrete_type(ty: Type) -> ta.Optional[type]:
+def get_concrete_type(ty: Type) -> type | None:
     if isinstance(ty, type):
         return ty
     if isinstance(ty, Generic):
@@ -299,7 +289,7 @@ class GenericSubstitution:
         if (cty := get_concrete_type(ty)) is not None:
             rpl = get_type_var_replacements(ty)
             ret: list[Type] = []
-            for b in get_original_bases(cty):
+            for b in types.get_original_bases(cty):
                 bty = type_(b)
                 if isinstance(bty, Generic) and isinstance(b, type):
                     # FIXME: throws away relative types, but can't use original vars as they're class-contextual

omlish/sql/_abc.py

@@ -0,0 +1,65 @@
+import typing as ta
+
+
+DBAPITypeCode: ta.TypeAlias = ta.Any | None
+
+DBAPIColumnDescription: ta.TypeAlias = tuple[
+    str,
+    DBAPITypeCode,
+    int | None,
+    int | None,
+    int | None,
+    int | None,
+    bool | None,
+]
+
+
+class DBAPIConnection(ta.Protocol):
+    def close(self) -> object: ...
+
+    def commit(self) -> object: ...
+
+    # optional:
+    # def rollback(self) -> ta.Any: ...
+
+    def cursor(self) -> 'DBAPICursor': ...
+
+
+class DBAPICursor(ta.Protocol):
+    @property
+    def description(self) -> ta.Sequence[DBAPIColumnDescription] | None: ...
+
+    @property
+    def rowcount(self) -> int: ...
+
+    # optional:
+    # def callproc(self, procname: str, parameters: Sequence[ta.Any] = ...) -> Sequence[ta.Any]: ...
+
+    def close(self) -> object: ...
+
+    def execute(
+        self,
+        operation: str,
+        parameters: ta.Sequence[ta.Any] | ta.Mapping[str, ta.Any] = ...,
+    ) -> object: ...
+
+    def executemany(
+        self,
+        operation: str,
+        seq_of_parameters: ta.Sequence[ta.Sequence[ta.Any]],
+    ) -> object: ...
+
+    def fetchone(self) -> ta.Sequence[ta.Any] | None: ...
+
+    def fetchmany(self, size: int = ...) -> ta.Sequence[ta.Sequence[ta.Any]]: ...
+
+    def fetchall(self) -> ta.Sequence[ta.Sequence[ta.Any]]: ...
+
+    # optional:
+    # def nextset(self) -> None | Literal[True]: ...
+
+    arraysize: int
+
+    def setinputsizes(self, sizes: ta.Sequence[DBAPITypeCode | int | None]) -> object: ...
+
+    def setoutputsize(self, size: int, column: int = ...) -> object: ...

omlish/sql/dbs.py

@@ -0,0 +1,90 @@
+import typing as ta
+import urllib.parse
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DbType:
+    name: str
+    dialect_name: str
+
+    default_port: int | None = None
+
+
+class DbTypes(lang.Namespace):
+    MYSQL = DbType(
+        name='mysql',
+        dialect_name='mysql',
+        default_port=3306,
+    )
+
+    POSTGRES = DbType(
+        name='postgres',
+        dialect_name='postgresql',
+        default_port=5432,
+    )
+
+    SQLITE = DbType(
+        name='sqlite',
+        dialect_name='sqlite',
+    )
+
+
+##
+
+
+class DbLoc(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class UrlDbLoc(DbLoc, lang.Final):
+    url: str
+
+
+@dc.dataclass(frozen=True)
+class HostDbLoc(DbLoc, lang.Final):
+    host: str
+    port: int | None = None
+
+    username: str | None = None
+    password: str | None = dc.xfield(default=None, repr_fn=lambda pw: '...' if pw is not None else None)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DbSpec:
+    name: str
+    type: DbType
+    loc: DbLoc
+
+
+##
+
+
+def rebuild_url(url: str, fn: ta.Callable[[urllib.parse.ParseResult], urllib.parse.ParseResult]) -> str:
+    if '://' in url:
+        engine, _, url = url.partition('://')
+        url = 'sql://' + url
+    else:
+        engine = None
+    parsed = urllib.parse.urlparse(url)
+    parsed = fn(parsed)
+    if engine is not None and parsed.scheme == 'sql':
+        parsed = parsed._replace(scheme=engine)
+    return urllib.parse.urlunparse(parsed)  # noqa
+
+
+def set_url_engine(url: str, engine: str) -> str:
+    return rebuild_url(url, lambda parsed: parsed._replace(scheme=engine))  # noqa
+
+
+def set_url_database(url: str, database: str) -> str:
+    return rebuild_url(url, lambda parsed: parsed._replace(path='/' + database))  # noqa

omlish/stats.py

@@ -5,6 +5,7 @@ TODO:
 """
 import bisect
 import collections
+import contextlib
 import dataclasses as dc
 import math
 import operator
@@ -215,7 +216,7 @@ class Stats(ta.Sequence[float]):
         else:
             bins = [float(x) for x in bins]
             if self.min < bins[0]:
-                bins = [self.min] + bins
+                bins = [self.min, *bins]
 
         round_factor = 10.0 ** bin_digits
         bins = [math.floor(b * round_factor) / round_factor for b in bins]
@@ -251,7 +252,7 @@ class SamplingHistogram:
         sample_percentiles: list['SamplingHistogram.Percentile']
 
     DEFAULT_SIZE = 1000
-    DEFAULT_PERCENTILES = [0.5, 0.75, 0.9, 0.95, 0.99]
+    DEFAULT_PERCENTILES = (0.5, 0.75, 0.9, 0.95, 0.99)
 
     def __init__(
             self,
@@ -272,10 +273,10 @@ class SamplingHistogram:
 
         self._percentile_pos_list = [self._calc_percentile_pos(p, self._size) for p in self._percentiles]
 
-        self._ring: list[ta.Optional[SamplingHistogram.Entry]] = [None] * size
+        self._ring: list[SamplingHistogram.Entry | None] = [None] * size
         self._ring_pos = 0
 
-        self._sample: list[ta.Optional[SamplingHistogram.Entry]] = [None] * size
+        self._sample: list[SamplingHistogram.Entry | None] = [None] * size
         self._sample_pos_queue = list(reversed(range(size)))
 
     def add(self, value: float) -> None:
@@ -291,10 +292,8 @@ class SamplingHistogram:
 
         sample_pos = None
         if self._sample_pos_queue:
-            try:
+            with contextlib.suppress(IndexError):
                 sample_pos = self._sample_pos_queue.pop()
-            except IndexError:
-                pass
         if sample_pos is None:
             sample_pos = random.randrange(0, self._size)
         self._sample[sample_pos] = entry
@@ -303,7 +302,7 @@ class SamplingHistogram:
     def _calc_percentile_pos(p: float, sz: int) -> int:
         return int(round((p * sz) - 1))
 
-    def _calc_percentiles(self, entries: list[ta.Optional[Entry]]) -> list[Percentile]:
+    def _calc_percentiles(self, entries: list[Entry | None]) -> list[Percentile]:
         entries = list(filter(None, entries))
         sz = len(entries)
         if not sz:

omlish/term.py

@@ -208,7 +208,7 @@ BG24_RGB = ControlSequence(
     '24-Bit Background Color (RGB)')
 
 
-def main():
+def main() -> None:
     import sys
 
     sys.stdout.write(SGR(SGRs.RESET))

omlish/testing/pydevd.py

@@ -5,8 +5,27 @@ an already-debugging PyCharm instance to debug PySpark jobs.
 
 TODO:
  - https://www.jetbrains.com/help/pycharm/remote-debugging-with-product.html#
- - move to dev?
- - cython help? or in cython.py
+ - PyCharm.app/Contents/plugins/python/helpers/pydev/_pydevd_bundle/pydevd_constants.py -> USE_LOW_IMPACT_MONITORING
+
+==
+
+https://www.jetbrains.com/help/pycharm/remote-debugging-with-product.html#remote-debug-config ->
+
+pycharm_port = 43251
+pycharm_version = '241.18034.82'
+buf = textwrap.dedent(f'''
+    import subprocess
+    import sys
+    subprocess.check_call([sys.executable, '-mpip', 'install', f'pydevd-pycharm~={pycharm_version}'])
+
+    import pydevd_pycharm  # noqa
+    pydevd_pycharm.settrace(
+        'docker.for.mac.localhost',
+         port={pycharm_port},
+          stdoutToServer=True,
+           stderrToServer=True,
+       )
+''') + '\n' * 2 + buf
 """
 import json
 import os
@@ -40,14 +59,14 @@ def is_debugger_call(hoist: int = 0, walk: int = 2) -> bool:
     return False
 
 
-class DebuggerCallForbiddenException(Exception):
+class DebuggerCallForbiddenError(Exception):
     pass
 
 
 def forbid_debugger_call(hoist: int = 0) -> None:
     # FIXME: only reentrant?
     if not ALLOW_DEBUGGER_CALLS and is_debugger_call(hoist + 1):
-        raise DebuggerCallForbiddenException
+        raise DebuggerCallForbiddenError
 
 
 ##
@@ -62,7 +81,7 @@ def silence_subprocess_check() -> None:
         return
 
     new_tb = lang.proxy_import('traceback')
-    new_tb.print_exc = lambda *a, **k: None  # type: ignore
+    new_tb.print_exc = lambda *a, **k: None  # type: ignore  # noqa
     pydev_monkey.traceback = new_tb
 
 
@@ -87,7 +106,7 @@ def patch_for_trio_asyncio() -> None:
 
 
 @lang.cached_function
-def _pydevd() -> ta.Optional[types.ModuleType]:
+def _pydevd() -> types.ModuleType | None:
     try:
         return __import__('pydevd')
     except ImportError:
@@ -98,7 +117,7 @@ def is_present() -> bool:
     return _pydevd() is not None
 
 
-def get_setup() -> ta.Optional[dict]:
+def get_setup() -> dict | None:
     if is_present():
         return _pydevd().SetupHolder.setup
     else:
@@ -154,8 +173,8 @@ def save_args() -> None:
 
 def maybe_reexec(
         *,
-        file: ta.Optional[str] = None,
-        module: ta.Optional[str] = None,
+        file: str | None = None,
+        module: str | None = None,
         silence: bool = False,
 ) -> None:
     if ARGS_ENV_VAR not in os.environ:
@@ -188,9 +207,8 @@ def maybe_reexec(
             """))
         file = bootstrap_path
 
-    else:
-        if file is None:
-            raise ValueError
+    elif file is None:
+        raise ValueError
 
     args = [sys.executable]
     args.extend(json.loads(os.environ[ARGS_ENV_VAR]))

omlish/testing/pytest/inject/__init__.py

@@ -1 +1,8 @@
 from . import harness  # noqa
+
+from .harness import (  # noqa
+    PytestScope,
+    Scopes,
+    bind,
+    register,
+)

omlish/testing/pytest/inject/harness.py

@@ -81,7 +81,7 @@ class Harness:
 
     def __getitem__(
             self,
-            target: ta.Union[inj.Key[T], type[T]],
+            target: inj.Key[T] | type[T],
     ) -> T:
         return check.not_none(self._inj)[target]
 
@@ -141,7 +141,7 @@ class HarnessPlugin:
         with harness._pytest_scope_manager(PytestScope.CLASS, request):  # noqa
             yield
 
-    @pytest.fixture(scope='function', autouse=True)
+    @pytest.fixture(scope='function', autouse=True)  # noqa
     def _harness_scope_listener_function(self, harness, request):
         with harness._pytest_scope_manager(PytestScope.FUNCTION, request):  # noqa
             yield
@@ -153,6 +153,28 @@ class HarnessPlugin:
 _HARNESS_ELEMENTS_LIST: list[inj.Elements] = []
 
 
+def register(*args: inj.Element | inj.Elements) -> None:
+    _HARNESS_ELEMENTS_LIST.append(inj.as_elements(*args))
+
+
+TypeT = ta.TypeVar('TypeT', bound=type)
+
+
+def bind(
+        scope: PytestScope | str = PytestScope.SESSION,
+        *,
+        eager: bool = False,
+) -> ta.Callable[[TypeT], TypeT]:
+    def inner(cls):
+        pts = scope if isinstance(scope, PytestScope) else PytestScope[check.isinstance(scope, str).upper()]
+        check.isinstance(cls, type)
+        register(inj.as_elements(
+            inj.in_(cls, _SCOPES_BY_PYTEST_SCOPE[pts]),
+        ))
+        return cls
+    return inner
+
+
 @pytest.fixture(scope='session', autouse=True)
 def harness() -> ta.Generator[Harness, None, None]:
     with Harness(inj.as_elements(*_HARNESS_ELEMENTS_LIST)).activate() as h:

omlish/testing/pytest/plugins/__init__.py

@@ -1,6 +1,6 @@
 from . import (  # noqa
     logging,
-    pycharm,
+    pydevd,
     repeat,
     skips,
     spacing,

omlish/testing/pytest/plugins/pydevd.py

@@ -0,0 +1,12 @@
+from ... import pydevd as opd
+from ._registry import register
+
+
+@register
+class PydevdPlugin:
+
+    def pytest_collection(self, session):
+        setup = opd.get_setup()
+        if setup is not None:
+            if hasattr(session.config, '_env_timeout'):
+                session.config._env_timeout = None  # noqa

omlish/testing/pytest/plugins/switches.py

@@ -13,7 +13,7 @@ from .... import collections as col
 from ._registry import register
 
 
-Configable = ta.Union[pytest.FixtureRequest, pytest.Config]
+Configable = pytest.FixtureRequest | pytest.Config
 
 
 SWITCHES = col.OrderedSet([
@@ -31,13 +31,13 @@ def _get_obj_config(obj: Configable) -> pytest.Config:
         raise TypeError(obj)
 
 
-def is_disabled(obj: ta.Optional[Configable], name: str) -> bool:
+def is_disabled(obj: Configable | None, name: str) -> bool:
     check.isinstance(name, str)
     check.in_(name, SWITCHES)
     return obj is not None and _get_obj_config(obj).getoption(f'--no-{name}')
 
 
-def skip_if_disabled(obj: ta.Optional[Configable], name: str) -> None:
+def skip_if_disabled(obj: Configable | None, name: str) -> None:
     if is_disabled(obj, name):
         pytest.skip(f'{name} disabled')