omlish 0.0.0.dev23__tar.gz → 0.0.0.dev25__tar.gz

{omlish-0.0.0.dev23/omlish.egg-info → omlish-0.0.0.dev25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev23
+Version: 0.0.0.dev25
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/README.rst

@@ -8,3 +8,6 @@ Core packages installable from git via:
 .. code-block::
 
   pip install 'git+https://github.com/wrmsr/omlish@master#subdirectory=.pkg/<pkg>'
+
+Core packages have no required dependencies, but numerous optional ones - see their respective ``pyproject.toml`` files
+for details.

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev23'
-__revision__ = '1d019b6879a9552ea31622e40f50d260d6b08824'
+__version__ = '0.0.0.dev25'
+__revision__ = '123812c0156cbb06af42b6e2ee3b7912d5bf5fc8'
 
 
 #
@@ -111,8 +111,6 @@ class SetuptoolsBase:
         'global-exclude **/conftest.py',
     ]
 
-    include_package_data = False
-
     find_packages = {
         'exclude': [
             '*.tests',
@@ -120,6 +118,20 @@ class SetuptoolsBase:
         ],
     }
 
+    package_data = {
+        '*': [
+            '*.c',
+            '*.cc',
+            '*.h',
+
+            '*.json',
+
+            '*.sql',
+
+            'LICENSE',
+        ],
+    }
+
 
 class Setuptools(SetuptoolsBase):
     find_packages = {

omlish-0.0.0.dev25/omlish/_manifests.json

@@ -0,0 +1 @@
+[]

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/bootstrap/diag.py

@@ -166,12 +166,12 @@ class PycharmBootstrap(SimpleBootstrap['PycharmBootstrap.Config']):
     class Config(Bootstrap.Config):
         debug_host: ta.Optional[str] = None
         debug_port: ta.Optional[int] = None
-        debug_version: ta.Optional[str] = None
+        version: ta.Optional[str] = None
 
     def run(self) -> None:
         if self._config.debug_port is not None:
             diagpc.pycharm_remote_debugger_attach(
                 self._config.debug_host,
                 self._config.debug_port,
-                version=self._config.debug_version,
+                version=self._config.version,
             )

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/check.py

@@ -75,6 +75,9 @@ def enable_args_rendering() -> bool:
         return True
 
 
+enable_args_rendering()
+
+
 #
 
 
@@ -142,7 +145,14 @@ def _unpack_isinstance_spec(spec: ta.Any) -> tuple:
 
 def isinstance(v: ta.Any, spec: type[T] | tuple, msg: Message = None) -> T:  # noqa
     if not _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(TypeError, 'Must be instance', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must be instance',
+            msg,
+            _Args(v, spec),
+            render_fmt='not isinstance(%s, %s)',
+        )
+
     return v
 
 
@@ -155,7 +165,13 @@ def of_isinstance(spec: type[T] | tuple, msg: Message = None) -> ta.Callable[[ta
 
 def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:  # noqa
     if not _isinstance(v, cls):
-        _raise(TypeError, 'Must be instance', msg, _Args(v, cls))
+        _raise(
+            TypeError,
+            'Must be instance',
+            msg,
+            _Args(v, cls),
+        )
+
     return v
 
 
@@ -168,7 +184,14 @@ def of_cast(cls: type[T], msg: Message = None) -> ta.Callable[[T], T]:
 
 def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:  # noqa
     if _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(TypeError, 'Must not be instance', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must not be instance',
+            msg,
+            _Args(v, spec),
+            render_fmt='isinstance(%s, %s)',
+        )
+
     return v
 
 
@@ -184,13 +207,27 @@ def of_not_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[T], T]:
 
 def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
     if not _issubclass(v, spec):
-        _raise(TypeError, 'Must be subclass', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must be subclass',
+            msg,
+            _Args(v, spec),
+            render_fmt='not issubclass(%s, %s)',
+        )
+
     return v
 
 
 def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
     if _issubclass(v, spec):
-        _raise(TypeError, 'Must not be subclass', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must not be subclass',
+            msg,
+            _Args(v, spec),
+            render_fmt='issubclass(%s, %s)',
+        )
+
     return v
 
 
@@ -199,19 +236,40 @@ def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  #
 
 def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
     if v not in c:
-        _raise(ValueError, 'Must be in', msg, _Args(v, c))
+        _raise(
+            ValueError,
+            'Must be in',
+            msg,
+            _Args(v, c),
+            render_fmt='%s not in %s',
+        )
+
     return v
 
 
 def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
     if v in c:
-        _raise(ValueError, 'Must not be in', msg, _Args(v, c))
+        _raise(
+            ValueError,
+            'Must not be in',
+            msg,
+            _Args(v, c),
+            render_fmt='%s in %s',
+        )
+
     return v
 
 
 def empty(v: SizedT, msg: Message = None) -> SizedT:
     if len(v) != 0:
-        _raise(ValueError, 'Must be empty', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
@@ -222,20 +280,40 @@ def iterempty(v: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
     except StopIteration:
         pass
     else:
-        _raise(ValueError, 'Must be empty', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 def not_empty(v: SizedT, msg: Message = None) -> SizedT:
     if len(v) == 0:
-        _raise(ValueError, 'Must not be empty', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must not be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
     dupes = [e for e, c in collections.Counter(it).items() if c > 1]
     if dupes:
-        _raise(ValueError, 'Must be unique', msg, _Args(it, dupes))
+        _raise(
+            ValueError,
+            'Must be unique',
+            msg,
+            _Args(it, dupes),
+        )
+
     return it
 
 
@@ -243,9 +321,15 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
     try:
         [value] = obj
     except ValueError:
-        _raise(ValueError, 'Must be single', message, _Args(obj))
-    else:
-        return value
+        _raise(
+            ValueError,
+            'Must be single',
+            message,
+            _Args(obj),
+            render_fmt='%s',
+        )
+
+    return value
 
 
 def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
@@ -254,11 +338,19 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
         value = next(it)
     except StopIteration:
         return None
+
     try:
         next(it)
     except StopIteration:
         return value  # noqa
-    _raise(ValueError, 'Must be empty or single', message, _Args(obj))
+
+    _raise(
+        ValueError,
+        'Must be empty or single',
+        message,
+        _Args(obj),
+        render_fmt='%s',
+    )
 
 
 ##
@@ -266,12 +358,25 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
 
 def none(v: ta.Any, msg: Message = None) -> None:
     if v is not None:
-        _raise(ValueError, 'Must be None', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be None',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
 
 
 def not_none(v: T | None, msg: Message = None) -> T:
     if v is None:
-        _raise(ValueError, 'Must not be None', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must not be None',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
@@ -280,42 +385,115 @@ def not_none(v: T | None, msg: Message = None) -> T:
 
 def equal(v: T, o: ta.Any, msg: Message = None) -> T:
     if o != v:
-        _raise(ValueError, 'Must be equal', msg, _Args(v, o), render_fmt='%s != %s')
+        _raise(
+            ValueError,
+            'Must be equal',
+            msg,
+            _Args(v, o),
+            render_fmt='%s != %s',
+        )
+
     return v
 
 
 def is_(v: T, o: ta.Any, msg: Message = None) -> T:
     if o is not v:
-        _raise(ValueError, 'Must be the same', msg, _Args(v, o), render_fmt='%s is not %s')
+        _raise(
+            ValueError,
+            'Must be the same',
+            msg,
+            _Args(v, o),
+            render_fmt='%s is not %s',
+        )
+
     return v
 
 
 def is_not(v: T, o: ta.Any, msg: Message = None) -> T:
     if o is v:
-        _raise(ValueError, 'Must not be the same', msg, _Args(v, o), render_fmt='%s is %s')
+        _raise(
+            ValueError,
+            'Must not be the same',
+            msg,
+            _Args(v, o),
+            render_fmt='%s is %s',
+        )
+
     return v
 
 
 def callable(v: T, msg: Message = None) -> T:  # noqa
     if not _callable(v):
-        _raise(TypeError, 'Must be callable', msg, _Args(v))
+        _raise(
+            TypeError,
+            'Must be callable',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v  # type: ignore
 
 
 def non_empty_str(v: str | None, msg: Message = None) -> str:
     if not _isinstance(v, str) or not v:
-        _raise(ValueError, 'Must be non-empty str', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be non-empty str',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
+def replacing(expected: ta.Any, old: ta.Any, new: T, msg: Message = None) -> T:
+    if old != expected:
+        _raise(
+            ValueError,
+            'Must be replacing',
+            msg,
+            _Args(expected, old, new),
+            render_fmt='%s -> %s -> %s',
+        )
+
+    return new
+
+
+def replacing_none(old: ta.Any, new: T, msg: Message = None) -> T:
+    if old is not None:
+        _raise(
+            ValueError,
+            'Must be replacing None',
+            msg,
+            _Args(old, new),
+            render_fmt='%s -> %s',
+        )
+
+    return new
+
+
 ##
 
 
 def arg(v: bool, msg: Message = None) -> None:
     if not v:
-        _raise(RuntimeError, 'Argument condition not met', msg)
+        _raise(
+            RuntimeError,
+            'Argument condition not met',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
 
 
 def state(v: bool, msg: Message = None) -> None:
     if not v:
-        _raise(RuntimeError, 'State condition not met', msg)
+        _raise(
+            RuntimeError,
+            'State condition not met',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/collections/__init__.py

@@ -95,12 +95,12 @@ from .utils import (  # noqa
     all_not_equal,
     indexes,
     key_cmp,
+    make_map,
+    make_map_by,
     multi_map,
     multi_map_by,
     mut_toposort,
     partition,
     toposort,
     unique,
-    unique_map,
-    unique_map_by,
 )

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/collections/utils.py

@@ -72,7 +72,7 @@ def unique(
     return ret
 
 
-def unique_map(
+def make_map(
         kvs: ta.Iterable[tuple[K, V]],
         *,
         identity: bool = False,
@@ -88,14 +88,14 @@ def unique_map(
     return d
 
 
-def unique_map_by(
+def make_map_by(
         fn: ta.Callable[[V], K],
         vs: ta.Iterable[V],
         *,
         identity: bool = False,
         strict: bool = False,
 ) -> ta.MutableMapping[K, V]:
-    return unique_map(
+    return make_map(
         ((fn(v), v) for v in vs),
         identity=identity,
         strict=strict,

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/concurrent/threadlets.py

@@ -1,3 +1,8 @@
+"""
+An abstraction over greenlet's api. Greenlet doesn't currently support nogil but its functionality is needed for async
+bridge code (both here and in sqlalchemy). This can be implemented with real threads at the expense of overhead, but
+this code is only intended to be used in already fairly heavy situations (bootstrap, db calls).
+"""
 import abc
 import dataclasses as dc
 import typing as ta

{omlish-0.0.0.dev23 → omlish-0.0.0.dev25}/omlish/dataclasses/__init__.py

@@ -94,6 +94,7 @@ from .utils import (  # noqa
     field_modifier,
     maybe_post_init,
     opt_repr,
+    update_class_metadata,
     update_field_extras,
     update_field_metadata,
     update_fields,