omdev 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev495__py3-none-any.whl

omdev/interp/uv/provider.py

@@ -4,7 +4,10 @@ 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 dataclasses as dc
 import typing as ta
 
 from omlish.logs.protocols import LoggerLike
@@ -20,6 +23,34 @@ 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,
@@ -39,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/venvs.py

@@ -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
 
 

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,
+        )