omlish 0.0.0.dev133__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/collections/cache/impl.py

@@ -51,63 +51,56 @@ class CacheImpl(Cache[K, V]):
     https://google.github.io/guava/releases/16.0/api/docs/com/google/common/cache/CacheBuilder.html
     """
 
-    try:
-        if not ta.TYPE_CHECKING:
-            from ..._ext.cy.collections.cache import CacheLink as Link
-        else:
-            raise ImportError  # noqa
-
-    except ImportError:
-        class Link:
-            __slots__ = [
-                'seq',
-                'ins_prev',
-                'ins_next',
-                'lru_prev',
-                'lru_next',
-                'lfu_prev',
-                'lfu_next',
-                'key',
-                'value',
-                'weight',
-                'written',
-                'accessed',
-                'hits',
-                'unlinked',
-            ]
-
-            seq: int
-            ins_prev: 'CacheImpl.Link'
-            ins_next: 'CacheImpl.Link'
-            lru_prev: 'CacheImpl.Link'
-            lru_next: 'CacheImpl.Link'
-            lfu_prev: 'CacheImpl.Link'
-            lfu_next: 'CacheImpl.Link'
-            key: ta.Any | weakref.ref
-            value: ta.Any | weakref.ref
-            weight: float
-            written: float
-            accessed: float
-            hits: int
-            unlinked: bool
-
-            def __repr__(self) -> str:
-                return (
-                    f'Link@{self.seq!s}('
-                    f'ins_prev={("@" + str(self.ins_prev.seq)) if self.ins_prev is not None else None}, '
-                    f'ins_next={("@" + str(self.ins_next.seq)) if self.ins_next is not None else None}, '
-                    f'lru_prev={("@" + str(self.lru_prev.seq)) if self.lru_prev is not None else None}, '
-                    f'lru_next={("@" + str(self.lru_next.seq)) if self.lru_next is not None else None}, '
-                    f'lfu_prev={("@" + str(self.lfu_prev.seq)) if self.lfu_prev is not None else None}, '
-                    f'lfu_next={("@" + str(self.lfu_next.seq)) if self.lfu_next is not None else None}, '
-                    f'key={self.key!r}, '
-                    f'value={self.value!r}, '
-                    f'weight={self.weight}, '
-                    f'written={self.written}, '
-                    f'accessed={self.accessed}, '
-                    f'hits={self.hits}, '
-                    f'unlinked={self.unlinked})'
-                )
+    class Link:
+        __slots__ = [
+            'seq',
+            'ins_prev',
+            'ins_next',
+            'lru_prev',
+            'lru_next',
+            'lfu_prev',
+            'lfu_next',
+            'key',
+            'value',
+            'weight',
+            'written',
+            'accessed',
+            'hits',
+            'unlinked',
+        ]
+
+        seq: int
+        ins_prev: 'CacheImpl.Link'
+        ins_next: 'CacheImpl.Link'
+        lru_prev: 'CacheImpl.Link'
+        lru_next: 'CacheImpl.Link'
+        lfu_prev: 'CacheImpl.Link'
+        lfu_next: 'CacheImpl.Link'
+        key: ta.Any | weakref.ref
+        value: ta.Any | weakref.ref
+        weight: float
+        written: float
+        accessed: float
+        hits: int
+        unlinked: bool
+
+        def __repr__(self) -> str:
+            return (
+                f'Link@{self.seq!s}('
+                f'ins_prev={("@" + str(self.ins_prev.seq)) if self.ins_prev is not None else None}, '
+                f'ins_next={("@" + str(self.ins_next.seq)) if self.ins_next is not None else None}, '
+                f'lru_prev={("@" + str(self.lru_prev.seq)) if self.lru_prev is not None else None}, '
+                f'lru_next={("@" + str(self.lru_next.seq)) if self.lru_next is not None else None}, '
+                f'lfu_prev={("@" + str(self.lfu_prev.seq)) if self.lfu_prev is not None else None}, '
+                f'lfu_next={("@" + str(self.lfu_next.seq)) if self.lfu_next is not None else None}, '
+                f'key={self.key!r}, '
+                f'value={self.value!r}, '
+                f'weight={self.weight}, '
+                f'written={self.written}, '
+                f'accessed={self.accessed}, '
+                f'hits={self.hits}, '
+                f'unlinked={self.unlinked})'
+            )
 
     _cache: ta.MutableMapping[ta.Any, Link]
 

omlish/collections/coerce.py

@@ -334,4 +334,5 @@ def map_of_or_none(
     value_fn = _unpack_fn(value_fn)
     return inner
 
+
 # endregion

omlish/collections/mappings.py

@@ -86,7 +86,7 @@ class DynamicTypeMap(ta.Generic[V]):
         self._items = list(items)
         self._weak = bool(weak)
 
-        self._cache: ta.MutableMapping[type, ta.Any] = weakref.WeakKeyDictionary()
+        self._cache: ta.MutableMapping[type, ta.Any] = weakref.WeakKeyDictionary() if weak else {}
 
     @property
     def items(self) -> ta.Sequence[V]:

omlish/configs/flattening.py

@@ -130,7 +130,7 @@ class Flattening:
                             .split(self._index_close + self._index_open):
                         yield int(p)
                 else:
-                    check.state(')' not in part)
+                    check.state(self._index_close not in part)
                     yield part
 
         for fk, v in flattened.items():

omlish/defs.py

@@ -199,7 +199,7 @@ def abstract_method(cls_dct, *names):
 
 @lang.cls_dct_fn()
 def abstract_property(cls_dct, *names):
-    return not_implemented(cls_dct, *names, wrapper=abc.abstractmethod)
+    return not_implemented(cls_dct, *names, wrapper=lambda o: property(abc.abstractmethod(o)))
 
 
 @lang.cls_dct_fn()

omlish/diag/_pycharm/runhack.py

@@ -3,7 +3,10 @@
 .venv/bin/python $(curl -LsSf https://raw.githubusercontent.com/wrmsr/omlish/master/omlish/diag/_pycharm/runhack.py -o $(mktemp) && echo "$_") install
 
 ==
+TODO:
+ - check for existing files - can't run regular dep entrypoints now
 
+==
 See:
  - https://github.com/JetBrains/intellij-community/blob/6400f70dde6f743e39a257a5a78cc51b644c835e/python/helpers/pycharm/_jb_pytest_runner.py
  - https://github.com/JetBrains/intellij-community/blob/5a4e584aa59767f2e7cf4bd377adfaaf7503984b/python/helpers/pycharm/_jb_runner_tools.py
@@ -1278,7 +1281,7 @@ class HackRunner:
     def run(self) -> None:
         # breakpoint()
 
-        env = self._env()
+        env = self._env()  # type: RunEnv
         self._debug(env.as_json())
 
         if not self._is_enabled:
@@ -1292,6 +1295,10 @@ class HackRunner:
             self._debug('not pycharm hosted')
             return
 
+        if len(env.orig_argv) < 2:
+            self._debug('no enough interpreter arguments')
+            return
+
         exe = self._exe()
         dec = self._decider().decide(exe.target)
         if dec is None:
@@ -1301,7 +1308,6 @@ class HackRunner:
         self._debug(dec.as_json())
         self._apply(dec)
 
-
 ##
 
 

omlish/diag/procfs.py

@@ -13,8 +13,8 @@ import typing as ta
 
 from .. import iterators as it
 from .. import lang
-from .. import os as oos
 from ..formats import json
+from ..os.sizes import PAGE_SIZE
 from .procstats import ProcStats
 
 
@@ -239,8 +239,8 @@ def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> t
     """https://www.kernel.org/doc/Documentation/vm/pagemap.txt"""
 
     _check_linux()
-    offset = (start // oos.PAGE_SIZE) * 8
-    npages = ((end - start) // oos.PAGE_SIZE)
+    offset = (start // PAGE_SIZE) * 8
+    npages = ((end - start) // PAGE_SIZE)
     size = npages * 8
     with open(f'/proc/{pid}/pagemap', 'rb') as pagemap_file:
         pagemap_file.seek(offset)
@@ -251,7 +251,7 @@ def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> t
     for pagenum in range(npages):
         [packed] = _struct_unpack('Q', pagemap_buf[pagenum * 8:(pagenum + 1) * 8])
         yield {
-            'address': start + (pagenum * oos.PAGE_SIZE),
+            'address': start + (pagenum * PAGE_SIZE),
             'pfn': (packed & ((1 << (54 + 1)) - 1)),
             'swap_type': (packed & ((1 << (4 + 1)) - 1)),
             'swap_offset': (packed & ((1 << (54 + 1)) - 1)) >> 5,
@@ -280,7 +280,7 @@ def _dump_cmd(args: ta.Any) -> None:
         sys.stdout.write('\n')
         for pm in get_process_range_pagemaps(m['address'], m['end_address'], args.pid):
             if pm['pte_soft_dirty']:
-                dirty_total += oos.PAGE_SIZE
+                dirty_total += PAGE_SIZE
             sys.stdout.write(json.dumps({'page': tuple(pm[k] for k in PAGEMAP_KEYS)}))
             sys.stdout.write('\n')
     dct = {
@@ -326,11 +326,11 @@ def _cmp_cmd(args: ta.Any) -> None:
     r_pages += c_pages
     dct = {
         'l_pages': l_pages,
-        'l_bytes': l_pages * oos.PAGE_SIZE,
+        'l_bytes': l_pages * PAGE_SIZE,
         'r_pages': r_pages,
-        'r_bytes': r_pages * oos.PAGE_SIZE,
+        'r_bytes': r_pages * PAGE_SIZE,
         'c_pages': c_pages,
-        'c_bytes': c_pages * oos.PAGE_SIZE,
+        'c_bytes': c_pages * PAGE_SIZE,
     }
     sys.stdout.write(json.dumps(dct))
     sys.stdout.write('\n')

omlish/docker/__init__.py

@@ -1,36 +0,0 @@
-from .cli import (  # noqa
-    Inspect,
-    Port,
-    PsItem,
-    cli_inspect,
-    cli_ps,
-    has_cli,
-    parse_port,
-)
-
-from .compose import (  # noqa
-    ComposeConfig,
-    get_compose_port,
-)
-
-from .helpers import (  # noqa
-    DOCKER_FOR_MAC_HOSTNAME,
-    DOCKER_HOST_PLATFORM_KEY,
-    get_docker_host_platform,
-    timebomb_payload,
-)
-
-from .hub import (  # noqa
-    HubRepoInfo,
-    get_hub_repo_info,
-    select_latest_tag,
-    split_tag_suffix,
-)
-
-
-##
-
-
-from ..lite.docker import (  # noqa
-    is_likely_in_docker,
-)

omlish/docker/all.py

@@ -0,0 +1,31 @@
+from .cli import (  # noqa
+    Inspect,
+    Port,
+    PsItem,
+    cli_inspect,
+    cli_ps,
+    has_cli,
+    parse_port,
+)
+
+from .compose import (  # noqa
+    ComposeConfig,
+    get_compose_port,
+)
+
+from .detect import (  # noqa
+    DOCKER_HOST_PLATFORM_KEY,
+    get_docker_host_platform,
+    is_likely_in_docker,
+)
+
+from .hub import (  # noqa
+    HubRepoInfo,
+    get_hub_repo_info,
+    select_latest_tag,
+    split_tag_suffix,
+)
+
+from .timebomb import (  # noqa
+    timebomb_payload,
+)

omlish/docker/consts.py

@@ -0,0 +1,4 @@
+# @omlish-lite
+
+
+DOCKER_FOR_MAC_HOSTNAME = 'docker.for.mac.localhost'

omlish/{lite/docker.py → docker/detect.py}

@@ -1,5 +1,23 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import os
 import re
 import sys
+import typing as ta
+
+
+##
+
+
+# Set by pyproject, docker-dev script
+DOCKER_HOST_PLATFORM_KEY = 'DOCKER_HOST_PLATFORM'
+
+
+def get_docker_host_platform() -> ta.Optional[str]:
+    return os.environ.get(DOCKER_HOST_PLATFORM_KEY)
+
+
+##
 
 
 _LIKELY_IN_DOCKER_PATTERN = re.compile(r'^overlay / .*/(docker|desktop-containerd)/')

omlish/docker/{helpers.py → timebomb.py}

@@ -1,10 +1,6 @@
-import os
 import shlex
 
 
-##
-
-
 _DEFAULT_TIMEBOMB_NAME = '-'.join([*__name__.split('.'), 'timebomb'])
 
 
@@ -16,20 +12,3 @@ def timebomb_payload(delay_s: float, name: str = _DEFAULT_TIMEBOMB_NAME) -> str:
         'sh -c \'killall5 -9 -o $PPID -o $$ ; kill 1\''
         ') &'
     )
-
-
-##
-
-
-DOCKER_FOR_MAC_HOSTNAME = 'docker.for.mac.localhost'
-
-
-##
-
-
-# Set by pyproject, docker-dev script
-DOCKER_HOST_PLATFORM_KEY = 'DOCKER_HOST_PLATFORM'
-
-
-def get_docker_host_platform() -> str | None:
-    return os.environ.get(DOCKER_HOST_PLATFORM_KEY)

omlish/formats/cbor.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from .. import lang
+from .codecs import make_bytes_object_codec
+from .codecs import make_object_lazy_loaded_codec
+
+
+if ta.TYPE_CHECKING:
+    import cbor2
+else:
+    cbor2 = lang.proxy_import('cbor2')
+
+
+##
+
+
+def dump(obj: ta.Any) -> bytes:
+    return cbor2.dumps(obj)
+
+
+def load(s: bytes) -> ta.Any:
+    return cbor2.loads(s)
+
+
+##
+
+
+CBOR_CODEC = make_bytes_object_codec('cbor', dump, load)
+
+# @omlish-manifest
+_CBOR_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'CBOR_CODEC', CBOR_CODEC)

omlish/formats/cloudpickle.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from .. import lang
+from .codecs import make_bytes_object_codec
+from .codecs import make_object_lazy_loaded_codec
+
+
+if ta.TYPE_CHECKING:
+    import cloudpickle
+else:
+    cloudpickle = lang.proxy_import('cloudpickle')
+
+
+##
+
+
+def dump(obj: ta.Any) -> bytes:
+    return cloudpickle.dumps(obj)
+
+
+def load(s: bytes) -> ta.Any:
+    return cloudpickle.loads(s)
+
+
+##
+
+
+CLOUDPICKLE_CODEC = make_bytes_object_codec('cloudpickle', dump, load)
+
+# @omlish-manifest
+_CLOUDPICKLE_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'CLOUDPICKLE_CODEC', CLOUDPICKLE_CODEC)

omlish/formats/codecs.py

@@ -0,0 +1,93 @@
+import typing as ta
+
+from .. import codecs
+from .. import reflect as rfl
+
+
+ObjectCodecT = ta.TypeVar('ObjectCodecT', bound='ObjectCodec')
+
+
+##
+
+
+class ObjectCodec(codecs.Codec):
+    pass
+
+
+def make_object_codec(
+        cls: type[ObjectCodecT],
+        name: str,
+        dumps: ta.Callable,
+        loads: ta.Callable,
+        *,
+        input: rfl.Type = rfl.type_(ta.Any),  # noqa
+        aliases: ta.Collection[str] | None = None,
+) -> ObjectCodecT:
+    return cls(
+        name=name,
+        aliases=aliases,
+
+        input=input,
+        output=bytes,
+
+        new=lambda: codecs.FnPairEagerCodec.of(dumps, loads),
+    )
+
+
+##
+
+
+class BytesObjectCodec(ObjectCodec):
+    pass
+
+
+def make_bytes_object_codec(
+        name: str,
+        dumps: ta.Callable[[ta.Any], bytes],
+        loads: ta.Callable[[bytes], ta.Any],
+        **kwargs: ta.Any,
+) -> BytesObjectCodec:
+    return make_object_codec(
+        BytesObjectCodec,
+        name,
+        dumps,
+        loads,
+        **kwargs,
+    )
+
+
+##
+
+
+class StrObjectCodec(ObjectCodec):
+    pass
+
+
+def make_str_object_codec(
+        name: str,
+        dumps: ta.Callable[[ta.Any], str],
+        loads: ta.Callable[[str], ta.Any],
+        **kwargs: ta.Any,
+) -> StrObjectCodec:
+    return make_object_codec(
+        StrObjectCodec,
+        name,
+        dumps,
+        loads,
+        **kwargs,
+    )
+
+
+##
+
+
+def make_object_lazy_loaded_codec(
+        mod_name: str,
+        attr_name: str,
+        codec: ObjectCodec,
+) -> codecs.LazyLoadedCodec:
+    return codecs.LazyLoadedCodec.new(
+        mod_name,
+        attr_name,
+        codec,
+    )

omlish/formats/json/codecs.py

@@ -0,0 +1,29 @@
+from ..codecs import make_object_lazy_loaded_codec
+from ..codecs import make_str_object_codec
+from .json import dumps
+from .json import dumps_compact
+from .json import dumps_pretty
+from .json import loads
+
+
+##
+
+
+JSON_CODEC = make_str_object_codec('json', dumps, loads)
+
+# @omlish-manifest
+_JSON_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON_CODEC', JSON_CODEC)
+
+#
+
+JSON_COMPACT_CODEC = make_str_object_codec('json-compact', dumps_compact, loads)
+
+# @omlish-manifest
+_JSON_COMPACT_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON_COMPACT_CODEC', JSON_COMPACT_CODEC)
+
+#
+
+JSON_PRETTY_CODEC = make_str_object_codec('json-pretty', dumps_pretty, loads)
+
+# @omlish-manifest
+_JSON_PRETTY_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON_PRETTY_CODEC', JSON_PRETTY_CODEC)

omlish/formats/json/delimted.py

@@ -0,0 +1,4 @@
+"""
+TODO:
+ - jsonl codec
+"""

omlish/formats/json/stream/errors.py

@@ -0,0 +1,2 @@
+class JsonStreamError(Exception):
+    pass

omlish/formats/json/stream/lex.py

@@ -3,6 +3,7 @@ TODO:
  - max buf size
  - max recursion depth
  - mark start pos of tokens, currently returning end
+ - _do_string inner loop optimization somehow
 """
 import dataclasses as dc
 import io
@@ -11,7 +12,8 @@ import re
 import typing as ta
 
 from .... import check
-from ....genmachine import GenMachine
+from ....funcs.genmachine import GenMachine
+from .errors import JsonStreamError
 
 
 ##
@@ -95,7 +97,7 @@ CONST_TOKENS: ta.Mapping[str, tuple[TokenKind, str | float | None]] = {
 
 
 @dc.dataclass()
-class JsonLexError(Exception):
+class JsonStreamLexError(JsonStreamError):
     message: str
 
     pos: Position
@@ -160,8 +162,8 @@ class JsonStreamLexer(GenMachine[str, Token]):
         self._buf.truncate()
         return raw
 
-    def _raise(self, msg: str) -> ta.NoReturn:
-        raise JsonLexError(msg, self.pos)
+    def _raise(self, msg: str, src: Exception | None = None) -> ta.NoReturn:
+        raise JsonStreamLexError(msg, self.pos) from src
 
     def _do_main(self):
         while True:
@@ -202,7 +204,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 self._raise('Unexpected end of input')
 
             if not c:
-                raise NotImplementedError
+                self._raise(f'Unterminated string literal: {self._buf.getvalue()}')
 
             self._buf.write(c)
             if c == '"' and last != '\\':
@@ -210,7 +212,11 @@ class JsonStreamLexer(GenMachine[str, Token]):
             last = c
 
         raw = self._flip_buf()
-        sv = json.loads(raw)
+        try:
+            sv = json.loads(raw)
+        except json.JSONDecodeError as e:
+            self._raise(f'Invalid string literal: {raw!r}', e)
+
         yield self._make_tok('STRING', sv, raw, pos)
 
         return self._do_main()