omdev 0.0.0.dev416__py3-none-any.whl → 0.0.0.dev500__py3-none-any.whl

omdev/dataserver/targets.py

@@ -1,8 +1,8 @@
 # ruff: noqa: UP006 UP007 UP045
-import abc
 import dataclasses as dc
 import typing as ta
 
+from omlish.lite.abstract import Abstract
 from omlish.lite.check import check
 from omlish.lite.dataclasses import dataclass_maybe_post_init
 from omlish.lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
@@ -12,7 +12,7 @@ from omlish.lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
 
 
 @dc.dataclass(frozen=True)
-class DataServerTarget(abc.ABC):  # noqa
+class DataServerTarget(Abstract):
     content_type: ta.Optional[str] = dc.field(default=None, metadata={OBJ_MARSHALER_OMIT_IF_NONE: True})
     content_length: ta.Optional[int] = dc.field(default=None, metadata={OBJ_MARSHALER_OMIT_IF_NONE: True})
 

omdev/imgur.py

@@ -130,11 +130,11 @@ def _main() -> None:
 
             print(resp.data.link)
 
-    Cli()(exit=True)
+    Cli()(exit=True)  # noqa
 
 
 # @omlish-manifest
-_FOO_CLI_MODULE = CliModule('imgur', __name__)
+_CLI_MODULE = CliModule('imgur', __name__)
 
 
 if __name__ == '__main__':

omdev/interp/cli.py

@@ -17,7 +17,7 @@ from omlish.lite.check import check
 from omlish.lite.inject import Injector
 from omlish.lite.inject import inj
 from omlish.lite.runtime import check_lite_runtime_version
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .inject import bind_interp
 from .resolvers import InterpResolver

omdev/interp/inspect.py

@@ -6,6 +6,7 @@ import sys
 import typing as ta
 
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
+from omlish.logs.protocols import LoggerLike
 
 from ..packaging.versions import Version
 from .types import InterpOpts
@@ -48,7 +49,7 @@ class InterpInspector:
     def __init__(
             self,
             *,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omdev/interp/providers/base.py

@@ -9,6 +9,7 @@ TODO:
 import abc
 import typing as ta
 
+from omlish.lite.abstract import Abstract
 from omlish.lite.strings import snake_case
 
 from ..types import Interp
@@ -19,13 +20,13 @@ from ..types import InterpVersion
 ##
 
 
-class InterpProvider(abc.ABC):
+class InterpProvider(Abstract):
     name: ta.ClassVar[str]
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
-        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
+        if Abstract not in cls.__bases__ and 'name' not in cls.__dict__:
             sfx = 'InterpProvider'
             if not cls.__name__.endswith(sfx):
                 raise NameError(cls)

omdev/interp/providers/standalone.py

@@ -33,7 +33,10 @@ import urllib.request
 
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
-from omlish.lite.logs import log
+from omlish.logs.modules import get_module_logger
+
+
+log = get_module_logger(globals())  # noqa
 
 
 ##

omdev/interp/providers/system.py

@@ -5,13 +5,13 @@ TODO:
  - check if path py's are venvs: sys.prefix != sys.base_prefix
 """
 import dataclasses as dc
-import logging
 import os
 import re
 import typing as ta
 
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
+from omlish.logs.protocols import LoggerLike
 
 from ...packaging.versions import InvalidVersion
 from ..inspect import InterpInspector
@@ -37,7 +37,7 @@ class SystemInterpProvider(InterpProvider):
             options: Options = Options(),
             *,
             inspector: ta.Optional[InterpInspector] = None,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omdev/interp/pyenv/install.py

@@ -8,6 +8,7 @@ import sys
 import typing as ta
 
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
+from omlish.lite.abstract import Abstract
 from omlish.lite.cached import async_cached_nullary
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
@@ -89,7 +90,7 @@ THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 #
 
 
-class PyenvInstallOptsProvider(abc.ABC):
+class PyenvInstallOptsProvider(Abstract):
     @abc.abstractmethod
     def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
         raise NotImplementedError

omdev/interp/pyenv/provider.py

@@ -1,9 +1,9 @@
 # ruff: noqa: UP006 UP007 UP045
 import dataclasses as dc
-import logging
 import typing as ta
 
 from omlish.lite.check import check
+from omlish.logs.protocols import LoggerLike
 
 from ...packaging.versions import InvalidVersion
 from ...packaging.versions import Version
@@ -33,7 +33,7 @@ class PyenvInterpProvider(InterpProvider):
             *,
             pyenv: Pyenv,
             inspector: InterpInspector,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omdev/interp/types.py

@@ -85,9 +85,10 @@ class InterpSpecifier:
     def parse(cls, s: str) -> 'InterpSpecifier':
         s, o = InterpOpts.parse_suffix(s)
         if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
             if s.count('.') < 2:
-                s += '.0'
+                s = '~=' + s + '.0'
+            else:
+                s = '==' + s
         return cls(
             specifier=Specifier(s),
             opts=o,

omdev/interp/uv/provider.py

@@ -4,10 +4,14 @@ uv run pip
 uv run --python 3.11.6 pip
 uv venv --python 3.11.6 --seed barf
 python3 -m venv barf && barf/bin/pip install uv && barf/bin/uv venv --python 3.11.6 --seed barf2
+uv python find '3.13.10'
+uv python list --output-format=json
 """
-import logging
+import dataclasses as dc
 import typing as ta
 
+from omlish.logs.protocols import LoggerLike
+
 from ..inspect import InterpInspector
 from ..providers.base import InterpProvider
 from ..types import Interp
@@ -19,13 +23,41 @@ from .uv import Uv
 ##
 
 
+@dc.dataclass(frozen=True)
+class UvPythonListOutput:
+    key: str
+    version: str
+
+    @dc.dataclass(frozen=True)
+    class VersionParts:
+        major: int
+        minor: int
+        patch: int
+
+    version_parts: VersionParts
+
+    path: ta.Optional[str]
+    symlink: ta.Optional[str]
+
+    url: str
+
+    os: str  # emscripten linux macos
+    variant: str  # default freethreaded
+    implementation: str  # cpython graalpy pyodide pypy
+    arch: str  # aarch64 wasm32 x86_64
+    libc: str  # gnu musl none
+
+
+##
+
+
 class UvInterpProvider(InterpProvider):
     def __init__(
             self,
             *,
             pyenv: Uv,
             inspector: InterpInspector,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 
@@ -38,3 +70,9 @@ class UvInterpProvider(InterpProvider):
 
     async def get_installed_version(self, version: InterpVersion) -> Interp:
         raise NotImplementedError
+
+    # async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    #     return []
+
+    # async def install_version(self, version: InterpVersion) -> Interp:
+    #     raise TypeError

omdev/interp/uv/uv.py

@@ -1,6 +1,5 @@
 # ruff: noqa: UP006 UP007 UP045
 import dataclasses as dc
-import logging
 import os.path
 import shutil
 import sys
@@ -10,6 +9,7 @@ import typing as ta
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.cached import async_cached_nullary
 from omlish.lite.check import check
+from omlish.logs.protocols import LoggerLike
 
 
 ##
@@ -26,7 +26,7 @@ class Uv:
             self,
             config: UvConfig = UvConfig(),
             *,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omdev/interp/venvs.py

@@ -1,6 +1,5 @@
 # ruff: noqa: UP006 UP007 UP045
 import dataclasses as dc
-import logging
 import os.path
 import typing as ta
 
@@ -9,6 +8,7 @@ from omlish.lite.cached import async_cached_nullary
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.lite.typing import Func2
+from omlish.logs.protocols import LoggerLike
 
 from .default import get_default_interp_resolver
 from .types import InterpSpecifier
@@ -21,6 +21,7 @@ from .types import InterpSpecifier
 class InterpVenvConfig:
     interp: ta.Optional[str] = None
     requires: ta.Optional[ta.Sequence[str]] = None
+    requires_pats: ta.Optional[ta.Sequence[str]] = None
     use_uv: ta.Optional[bool] = None
 
 
@@ -35,7 +36,7 @@ class InterpVenv:
             cfg: InterpVenvConfig,
             *,
             requirements_processor: ta.Optional[InterpVenvRequirementsProcessor] = None,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omdev/irc/messages/base.py

@@ -0,0 +1,50 @@
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish.funcs import pairs as fps
+
+from ..numerics import numerics as nr
+from .formats import MessageFormat
+from .formats import MessageParamsUnpacker
+
+
+##
+
+
+class Message(dc.Case):
+    FORMAT: ta.ClassVar[MessageFormat]
+    REPLIES: ta.ClassVar[ta.Collection[nr.NumericReply]] = ()
+
+
+##
+
+
+def list_pair_params_unpacker(
+        kwarg: str,
+        key_param: str,
+        value_param: str,
+) -> MessageParamsUnpacker:
+    def forward(params: ta.Mapping[str, str]) -> ta.Mapping[str, ta.Any]:
+        out: dict = dict(params)
+        ks = out.pop(key_param)
+        vs = out.pop(value_param, None)
+        if vs is not None:
+            out[kwarg] = list(zip(ks, vs, strict=True))
+        else:
+            out[kwarg] = ks
+        return out
+
+    def backward(kwargs: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, str]:
+        out: dict = dict(kwargs)
+        ts = out.pop(kwarg)
+        is_ts = check.single({isinstance(e, tuple) for e in ts})
+        if is_ts:
+            ks, vs = zip(*ts)
+            out[key_param] = ks
+            out[value_param] = vs
+        else:
+            out[key_param] = ts
+        return out
+
+    return fps.of(forward, backward)

omdev/irc/messages/formats.py

@@ -0,0 +1,92 @@
+import enum
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish.funcs import pairs as fps
+
+
+MessageParamsUnpacker: ta.TypeAlias = fps.FnPair[
+    ta.Mapping[str, str],  # params
+    ta.Mapping[str, ta.Any],  # kwargs
+]
+
+
+##
+
+
+class MessageFormat(dc.Frozen, final=True):
+    name: str
+
+    class Param(dc.Case):
+        @classmethod
+        def of(cls, obj: ta.Any) -> 'MessageFormat.Param':
+            if isinstance(obj, MessageFormat.Param):
+                return obj
+
+            elif isinstance(obj, str):
+                s = check.non_empty_str(obj)
+
+                optional = False
+                if s.startswith('?'):
+                    optional = True
+                    s = s[1:]
+
+                arity = MessageFormat.KwargParam.Arity.SINGLE
+                if s.startswith('*'):
+                    arity = MessageFormat.KwargParam.Arity.VARIADIC
+                    s = s[1:]
+
+                elif s.startswith(','):
+                    arity = MessageFormat.KwargParam.Arity.COMMA_LIST
+                    s = s[1:]
+
+                return MessageFormat.KwargParam(
+                    s,
+                    optional=optional,
+                    arity=arity,
+                )
+
+            else:
+                raise TypeError(obj)
+
+    class KwargParam(Param):
+        name: str = dc.xfield(validate=lang.is_ident)
+
+        optional: bool = False
+
+        class Arity(enum.Enum):
+            SINGLE = enum.auto()  # <foo>
+            VARIADIC = enum.auto()  # <foo>{ <foo>}
+            COMMA_LIST = enum.auto()  # <foo>{,<foo>}
+
+        arity: Arity = Arity.SINGLE
+
+    class LiteralParam(Param):
+        text: str
+
+    params: ta.Sequence[Param]
+
+    _: dc.KW_ONLY
+
+    unpack_params: MessageParamsUnpacker | None = None
+
+    @dc.init
+    def _validate_params(self) -> None:
+        kws = [p for p in self.params if isinstance(p, MessageFormat.KwargParam)]
+        check.unique(p.name for p in kws)
+        check.state(all(p.arity is not MessageFormat.KwargParam.Arity.VARIADIC for p in kws[:-1]))
+
+    @classmethod
+    def of(
+            cls,
+            name: str,
+            *params: ta.Any,
+            **kwargs: ta.Any,
+    ) -> 'MessageFormat':
+        return cls(
+            name,
+            [MessageFormat.Param.of(p) for p in params],
+            **kwargs,
+        )