omlish 0.0.0.dev220__py3-none-any.whl → 0.0.0.dev221__py3-none-any.whl

omlish/docker/oci/media.py

@@ -8,18 +8,29 @@ from ...lite.check import check
 from ...lite.marshal import OBJ_MARSHALER_FIELD_KEY
 from ...lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
 from ...lite.marshal import unmarshal_obj
-from .data import OciDataclass
 from .data import OciImageConfig
+from .data import OciImageLayer
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class OciMediaDataclass(OciDataclass, abc.ABC):  # noqa
+OCI_MEDIA_FIELDS: ta.Collection[str] = frozenset([
+    'schema_version',
+    'media_type',
+])
+
+
+@dc.dataclass()
+class OciMediaDataclass(abc.ABC):  # noqa
     SCHEMA_VERSION: ta.ClassVar[int]
     MEDIA_TYPE: ta.ClassVar[str]
 
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        for a in OCI_MEDIA_FIELDS:
+            check.in_(a, cls.__dict__)
+
 
 _REGISTERED_OCI_MEDIA_DATACLASSES: ta.Dict[str, ta.Type[OciMediaDataclass]] = {}
 
@@ -48,11 +59,11 @@ def unmarshal_oci_media_dataclass(
     return unmarshal_obj(dct, cls)
 
 
-#
+##
 
 
-@dc.dataclass(frozen=True)
-class OciMediaDescriptor(OciDataclass):
+@dc.dataclass()
+class OciMediaDescriptor:
     """https://github.com/opencontainers/image-spec/blob/92353b0bee778725c617e7d57317b568a7796bd0/descriptor.md#properties"""  # noqa
 
     media_type: str = dc.field(metadata={OBJ_MARSHALER_FIELD_KEY: 'mediaType'})
@@ -71,8 +82,11 @@ class OciMediaDescriptor(OciDataclass):
     platform: ta.Optional[ta.Mapping[str, ta.Any]] = dc.field(default=None, metadata={OBJ_MARSHALER_OMIT_IF_NONE: True})  # noqa
 
 
+##
+
+
 @_register_oci_media_dataclass
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class OciMediaImageIndex(OciMediaDataclass):
     """https://github.com/opencontainers/image-spec/blob/92353b0bee778725c617e7d57317b568a7796bd0/image-index.md"""
 
@@ -91,18 +105,16 @@ class OciMediaImageIndex(OciMediaDataclass):
     media_type: str = dc.field(default=MEDIA_TYPE, metadata={OBJ_MARSHALER_FIELD_KEY: 'mediaType'})
 
 
+#
+
+
 @_register_oci_media_dataclass
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class OciMediaImageManifest(OciMediaDataclass):
     """https://github.com/opencontainers/image-spec/blob/92353b0bee778725c617e7d57317b568a7796bd0/manifest.md"""
 
     config: OciMediaDescriptor  # -> OciMediaImageConfig
 
-    # MEDIA_TYPES: ta.ClassVar[ta.Mapping[str, str]] = {
-    #     'TAR': 'application/vnd.oci.image.layer.v1.tar',
-    #     'TAR_GZIP': 'application/vnd.oci.image.layer.v1.tar+gzip',
-    #     'TAR_ZSTD': 'application/vnd.oci.image.layer.v1.tar+zstd',
-    # }
     layers: ta.Sequence[OciMediaDescriptor]
 
     #
@@ -114,8 +126,26 @@ class OciMediaImageManifest(OciMediaDataclass):
     media_type: str = dc.field(default=MEDIA_TYPE, metadata={OBJ_MARSHALER_FIELD_KEY: 'mediaType'})
 
 
+#
+
+
+OCI_IMAGE_LAYER_KIND_MEDIA_TYPES: ta.Mapping[OciImageLayer.Kind, str] = {
+    OciImageLayer.Kind.TAR: 'application/vnd.oci.image.layer.v1.tar',
+    OciImageLayer.Kind.TAR_GZIP: 'application/vnd.oci.image.layer.v1.tar+gzip',
+    OciImageLayer.Kind.TAR_ZSTD: 'application/vnd.oci.image.layer.v1.tar+zstd',
+}
+
+OCI_IMAGE_LAYER_KIND_MEDIA_TYPES_: ta.Mapping[str, OciImageLayer.Kind] = {
+    v: k
+    for k, v in OCI_IMAGE_LAYER_KIND_MEDIA_TYPES.items()
+}
+
+
+#
+
+
 @_register_oci_media_dataclass
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class OciMediaImageConfig(OciImageConfig, OciMediaDataclass):
     SCHEMA_VERSION: ta.ClassVar[int] = 2
     schema_version: int = dc.field(default=SCHEMA_VERSION, metadata={OBJ_MARSHALER_FIELD_KEY: 'schemaVersion'})

omlish/docker/oci/repositories.py

@@ -0,0 +1,72 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import abc
+import os.path
+import typing as ta
+
+from ...lite.check import check
+from ...os.paths import is_path_in_dir
+from .datarefs import BytesOciDataRef
+from .datarefs import FileOciDataRef
+from .datarefs import OciDataRef
+
+
+##
+
+
+class OciRepository(abc.ABC):
+    @abc.abstractmethod
+    def read_blob(self, digest: str) -> bytes:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def ref_blob(self, digest: str) -> OciDataRef:
+        raise NotImplementedError
+
+
+#
+
+
+class DirectoryOciRepository(OciRepository):
+    def __init__(self, data_dir: str) -> None:
+        super().__init__()
+
+        self._data_dir = check.non_empty_str(data_dir)
+
+    def read_file(self, path: str) -> bytes:
+        full_path = os.path.join(self._data_dir, path)
+        check.arg(is_path_in_dir(self._data_dir, full_path))
+        with open(full_path, 'rb') as f:
+            return f.read()
+
+    def blob_path(self, digest: str) -> str:
+        scheme, value = digest.split(':')
+        return os.path.join('blobs', scheme, value)
+
+    def blob_full_path(self, digest: str) -> str:
+        path = self.blob_path(digest)
+        full_path = os.path.join(self._data_dir, path)
+        check.arg(is_path_in_dir(self._data_dir, full_path))
+        return full_path
+
+    def read_blob(self, digest: str) -> bytes:
+        return self.read_file(self.blob_path(digest))
+
+    def ref_blob(self, digest: str) -> OciDataRef:
+        return FileOciDataRef(self.blob_full_path(digest))
+
+
+#
+
+
+class DictionaryOciRepository(OciRepository):
+    def __init__(self, blobs: ta.Mapping[str, bytes]) -> None:
+        super().__init__()
+
+        self._blobs = blobs
+
+    def read_blob(self, digest: str) -> bytes:
+        return self._blobs[digest]
+
+    def ref_blob(self, digest: str) -> OciDataRef:
+        return BytesOciDataRef(self._blobs[digest])

omlish/graphs/trees.py

@@ -10,6 +10,7 @@ from .. import cached
 from .. import check
 from .. import collections as col
 from .. import lang
+from ..algorithm import all as alg
 
 
 T = ta.TypeVar('T')
@@ -194,7 +195,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}
-        ts = list(col.mut_toposort(tsd))
+        ts = list(alg.mut_toposort(tsd))
         root = d(check.single(ts[0]))
 
         return cls(

omlish/http/coro/server.py

@@ -421,50 +421,59 @@ class CoroHttpServer:
     #
 
     def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], None]:
-        while True:
-            gen = self.coro_handle_one()
+        return self._coro_run_handler(self._coro_handle_one())
 
-            i: ta.Optional[bytes]
-            o: ta.Any = next(gen)
-            while True:
-                try:
-                    if isinstance(o, self.AnyLogIo):
-                        i = None
-                        yield o
+    def _coro_run_handler(
+            self,
+            gen: ta.Generator[
+                ta.Union[AnyLogIo, AnyReadIo, _Response],
+                ta.Optional[bytes],
+                None,
+            ],
+    ) -> ta.Generator[Io, ta.Optional[bytes], None]:
+        i: ta.Optional[bytes]
+        o: ta.Any = next(gen)
+        while True:
+            try:
+                if isinstance(o, self.AnyLogIo):
+                    i = None
+                    yield o
 
-                    elif isinstance(o, self.AnyReadIo):
-                        i = check.isinstance((yield o), bytes)
+                elif isinstance(o, self.AnyReadIo):
+                    i = check.isinstance((yield o), bytes)
 
-                    elif isinstance(o, self._Response):
-                        i = None
+                elif isinstance(o, self._Response):
+                    i = None
 
-                        r = self._preprocess_response(o)
-                        hb = self._build_response_head_bytes(r)
-                        check.none((yield self.WriteIo(hb)))
+                    r = self._preprocess_response(o)
+                    hb = self._build_response_head_bytes(r)
+                    check.none((yield self.WriteIo(hb)))
 
-                        for b in self._yield_response_data(r):
-                            yield self.WriteIo(b)
+                    for b in self._yield_response_data(r):
+                        yield self.WriteIo(b)
 
-                        o.close()
-                        o = None
+                    o.close()
+                    if o.close_connection:
+                        break
+                    o = None
 
-                    else:
-                        raise TypeError(o)  # noqa
+                else:
+                    raise TypeError(o)  # noqa
 
-                    try:
-                        o = gen.send(i)
-                    except EOFError:
-                        return
-                    except StopIteration:
-                        break
+                try:
+                    o = gen.send(i)
+                except EOFError:
+                    return
+                except StopIteration:
+                    break
 
-                except Exception:  # noqa
-                    if hasattr(o, 'close'):
-                        o.close()
+            except Exception:  # noqa
+                if hasattr(o, 'close'):
+                    o.close()
 
-                    raise
+                raise
 
-    def coro_handle_one(self) -> ta.Generator[
+    def _coro_handle_one(self) -> ta.Generator[
         ta.Union[AnyLogIo, AnyReadIo, _Response],
         ta.Optional[bytes],
         None,

omlish/http/{simple.py → coro/simple.py}

@@ -5,23 +5,23 @@ import contextlib
 import functools
 import typing as ta
 
-from ..lite.check import check
-from ..sockets.addresses import SocketAndAddress
-from ..sockets.bind import CanSocketBinder
-from ..sockets.bind import SocketBinder
-from ..sockets.server.handlers import ExecutorSocketServerHandler
-from ..sockets.server.handlers import SocketHandlerSocketServerHandler
-from ..sockets.server.handlers import SocketServerHandler
-from ..sockets.server.handlers import SocketWrappingSocketServerHandler
-from ..sockets.server.handlers import StandardSocketServerHandler
-from ..sockets.server.server import SocketServer
-from ..sockets.server.threading import ThreadingSocketServerHandler
-from .coro.server import CoroHttpServer
-from .coro.server import CoroHttpServerSocketHandler
-from .handlers import HttpHandler
-from .parsing import HttpRequestParser
-from .versions import HttpProtocolVersion
-from .versions import HttpProtocolVersions
+from ...lite.check import check
+from ...sockets.addresses import SocketAndAddress
+from ...sockets.bind import CanSocketBinder
+from ...sockets.bind import SocketBinder
+from ...sockets.server.handlers import ExecutorSocketServerHandler
+from ...sockets.server.handlers import SocketHandlerSocketServerHandler
+from ...sockets.server.handlers import SocketServerHandler
+from ...sockets.server.handlers import SocketWrappingSocketServerHandler
+from ...sockets.server.handlers import StandardSocketServerHandler
+from ...sockets.server.server import SocketServer
+from ...sockets.server.threading import ThreadingSocketServerHandler
+from ..handlers import HttpHandler
+from ..parsing import HttpRequestParser
+from ..versions import HttpProtocolVersion
+from ..versions import HttpProtocolVersions
+from .server import CoroHttpServer
+from .server import CoroHttpServerSocketHandler
 
 
 if ta.TYPE_CHECKING:

omlish/specs/irc/format/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2016-2021 Daniel Oaks
+Copyright (c) 2018-2021 Shivaram Lingamneni
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

omlish/specs/irc/format/__init__.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2016-2021 Daniel Oaks
+# Copyright (c) 2018-2021 Shivaram Lingamneni
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby
+# granted, provided that the above copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+# AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+#
+# https://github.com/ergochat/irc-go/blob/9beac2d29dc5f998c5a53e5db7a6426d7d083a79/ircmsg/
+from .consts import (  # noqa
+    MAX_LEN_CLIENT_TAG_DATA,
+    MAX_LEN_SERVER_TAG_DATA,
+    MAX_LEN_TAGS,
+    MAX_LEN_TAGS_FROM_CLIENT,
+    MAX_LEN_TAG_DATA,
+)
+
+from .errors import (  # noqa
+    BadCharactersError,
+    BadParamError,
+    CommandMissingError,
+    Error,
+    InvalidTagContentError,
+    LineEmptyError,
+    MalformedNuhError,
+    TagsTooLongError,
+)
+
+from .message import (  # noqa
+    Message,
+)
+
+from .nuh import (  # noqa
+    Nuh,
+)
+
+from .parsing import (  # noqa
+    ParsedLine,
+    parse_line,
+    parse_line_,
+    parse_line_strict,
+)
+
+from .rendering import (  # noqa
+    RenderedLine,
+    render_line,
+    render_line_,
+    render_line_strict,
+)
+
+from .tags import (  # noqa
+    escape_tag_value,
+    parse_tags,
+    unescape_tag_value,
+    validate_tag_name,
+    validate_tag_value,
+)

omlish/specs/irc/format/consts.py

@@ -0,0 +1,6 @@
+# Constants
+MAX_LEN_TAGS = 8191
+MAX_LEN_TAG_DATA = MAX_LEN_TAGS - 2
+MAX_LEN_CLIENT_TAG_DATA = 4094
+MAX_LEN_SERVER_TAG_DATA = 4094
+MAX_LEN_TAGS_FROM_CLIENT = MAX_LEN_CLIENT_TAG_DATA + 2

omlish/specs/irc/format/errors.py

@@ -0,0 +1,30 @@
+class Error(Exception):
+    pass
+
+
+class LineEmptyError(Error):
+    pass
+
+
+class BadCharactersError(Error):
+    pass
+
+
+class TagsTooLongError(Error):
+    pass
+
+
+class InvalidTagContentError(Error):
+    pass
+
+
+class CommandMissingError(Error):
+    pass
+
+
+class BadParamError(Error):
+    pass
+
+
+class MalformedNuhError(Error):
+    pass

omlish/specs/irc/format/message.py

@@ -0,0 +1,18 @@
+"""
+TODO:
+ - https://github.com/ergochat/irctest/blob/master/irctest/irc_utils/message_parser.py ?
+"""
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class Message:
+    source: str | None
+    command: str
+    params: ta.Sequence[str]
+
+    force_trailing: bool = False
+
+    tags: ta.Mapping[str, str] | None = None
+    client_only_tags: ta.Mapping[str, str] | None = None

omlish/specs/irc/format/nuh.py

@@ -0,0 +1,52 @@
+import dataclasses as dc
+import typing as ta
+
+from .errors import MalformedNuhError
+
+
+@dc.dataclass(frozen=True)
+class Nuh:
+    name: str | None = None
+    user: str | None = None
+    host: str | None = None
+
+    @property
+    def tuple(self) -> tuple[str | None, ...]:
+        return (self.name, self.user, self.host)
+
+    def __iter__(self) -> ta.Iterator[str | None]:
+        return iter(self.tuple)
+
+    @classmethod
+    def parse(cls, inp: str) -> 'Nuh':
+        if not inp:
+            raise MalformedNuhError
+
+        host: str | None = None
+        host_start = inp.find('@')
+        if host_start != -1:
+            host = inp[host_start + 1:]
+            inp = inp[:host_start]
+
+        user_start = inp.find('!')
+        user: str | None = None
+        if user_start != -1:
+            user = inp[user_start + 1:]
+            inp = inp[:user_start]
+
+        return cls(
+            name=inp or None,
+            user=user,
+            host=host,
+        )
+
+    @property
+    def canonical(self) -> str:
+        parts = []
+        if (n := self.name) is not None:
+            parts.append(n)
+        if (u := self.user) is not None:
+            parts.append(f'!{u}')
+        if (h := self.host) is not None:
+            parts.append(f'@{h}')
+        return ''.join(parts)

omlish/specs/irc/format/parsing.py

@@ -0,0 +1,155 @@
+import typing as ta
+
+from .consts import MAX_LEN_CLIENT_TAG_DATA
+from .consts import MAX_LEN_TAG_DATA
+from .errors import BadCharactersError
+from .errors import LineEmptyError
+from .errors import TagsTooLongError
+from .message import Message
+from .tags import parse_tags
+from .utils import is_ascii
+from .utils import trim_initial_spaces
+from .utils import truncate_utf8_safe
+
+
+class ParsedLine(ta.NamedTuple):
+    message: Message
+
+    truncated: bool = False
+
+
+def parse_line_(
+        line: str,
+        *,
+        max_tag_data_length: int | None = None,
+        truncate_len: int | None = None,
+) -> ParsedLine:
+    # Remove either \n or \r\n from the end of the line:
+    line = line.removesuffix('\n')
+    line = line.removesuffix('\r')
+
+    # Whether we removed them ourselves, or whether they were removed previously, they count against the line limit:
+    if truncate_len is not None:
+        if truncate_len <= 2:
+            raise LineEmptyError
+        truncate_len -= 2
+
+    # Now validate for the 3 forbidden bytes:
+    if any(c in line for c in '\x00\n\r'):
+        raise BadCharactersError
+
+    if not line:
+        raise LineEmptyError
+
+    #
+
+    # Handle tags
+    tags: ta.Mapping[str, str] | None = None
+    if line.startswith('@'):
+        tag_end = line.find(' ')
+        if tag_end == -1:
+            raise LineEmptyError
+        raw_tags = line[1:tag_end]
+        if max_tag_data_length is not None and len(raw_tags) > max_tag_data_length:
+            raise TagsTooLongError
+        tags = parse_tags(raw_tags)
+        # Skip over the tags and the separating space
+        line = line[tag_end + 1:]
+
+    #
+
+    # Truncate if desired
+    truncated = False
+    if truncate_len is not None and len(line) > truncate_len:
+        line = truncate_utf8_safe(line, truncate_len)
+        truncated = True
+
+    line = trim_initial_spaces(line)
+
+    # Handle source
+    source: str | None = None
+
+    if line.startswith(':'):
+        source_end = line.find(' ')
+        if source_end == -1:
+            raise LineEmptyError
+        source = line[1:source_end]
+        line = line[source_end + 1:]
+
+    # Modern: "These message parts, and parameters themselves, are separated by one or more ASCII SPACE characters"
+    line = trim_initial_spaces(line)
+
+    # Handle command
+    command_end = line.find(' ')
+    param_start = command_end + 1 if command_end != -1 else len(line)
+    base_command = line[:command_end] if command_end != -1 else line
+
+    if not base_command:
+        raise LineEmptyError
+    # Technically this must be either letters or a 3-digit numeric:
+    if not is_ascii(base_command):
+        raise BadCharactersError
+
+    # Normalize command to uppercase:
+    command = base_command.upper()
+    line = line[param_start:]
+
+    # Handle parameters
+    params: list[str] = []
+    while line:
+        line = trim_initial_spaces(line)
+        if not line:
+            break
+        # Handle trailing
+        if line.startswith(':'):
+            params.append(line[1:])
+            break
+        param_end = line.find(' ')
+        if param_end == -1:
+            params.append(line)
+            break
+        params.append(line[:param_end])
+        line = line[param_end + 1:]
+
+    #
+
+    msg = Message(
+        source=source,
+        command=command,
+        params=params,
+        tags=tags,
+    )
+
+    return ParsedLine(
+        msg,
+        truncated=truncated,
+    )
+
+
+def parse_line(
+        line: str,
+        *,
+        max_tag_data_length: int | None = None,
+        truncate_len: int | None = None,
+) -> Message:
+    return parse_line_(
+        line,
+        max_tag_data_length=max_tag_data_length,
+        truncate_len=truncate_len,
+    ).message
+
+
+def parse_line_strict(
+        line: str,
+        from_client: bool,
+        truncate_len: int | None,
+) -> ParsedLine:
+    max_tag_data_length = MAX_LEN_TAG_DATA
+    if from_client:
+        max_tag_data_length = MAX_LEN_CLIENT_TAG_DATA
+
+    return parse_line_(
+        line,
+        max_tag_data_length=max_tag_data_length,
+        truncate_len=truncate_len,
+    )