omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/http/flasky/types.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+from ._compat import compat
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+@compat
+class ImmutableMultiDict(ta.Mapping[K, V]):
+    pass

omlish/http/handlers.py

@@ -7,6 +7,7 @@ import logging
 import typing as ta
 
 from ..lite.abstract import Abstract
+from ..logs.protocols import LoggerLike
 from ..sockets.addresses import SocketAddress
 from .parsing import HttpHeaders
 
@@ -70,7 +71,7 @@ class HttpHandler_(Abstract):  # noqa
 @dc.dataclass(frozen=True)
 class LoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
-    log: logging.Logger
+    log: LoggerLike
     level: int = logging.DEBUG
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
@@ -83,7 +84,7 @@ class LoggingHttpHandler(HttpHandler_):
 @dc.dataclass(frozen=True)
 class ExceptionLoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
-    log: logging.Logger
+    log: LoggerLike
     message: ta.Union[str, ta.Callable[[HttpHandlerRequest, BaseException], str]] = 'Error in http handler'
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:

omlish/http/headers.py

@@ -1,3 +1,5 @@
+# @omlish-lite
+# ruff: noqa: UP006 UP007
 """
 TODO:
  - handle secrets (but they're strs..)
@@ -5,40 +7,44 @@ TODO:
 import http.client
 import typing as ta
 
-from .. import cached
-from .. import check
-from .. import collections as col
+from ..lite.cached import cached_nullary
+from ..lite.cached import cached_property
+from ..lite.check import check
 
 
-StrOrBytes: ta.TypeAlias = str | bytes
+StrOrBytes = ta.Union[str, bytes]  # ta.TypeAlias
 
 
 ##
 
 
-CanHttpHeaders: ta.TypeAlias = ta.Union[
+CanHttpHeaders = ta.Union[  # ta.TypeAlias  # omlish-amalg-typing-no-move
     'HttpHeaders',
 
     http.client.HTTPMessage,
 
     ta.Mapping[str, str],
     ta.Mapping[str, ta.Sequence[str]],
-    ta.Mapping[str, str | ta.Sequence[str]],
+    ta.Mapping[str, ta.Union[str, ta.Sequence[str]]],
 
     ta.Mapping[bytes, bytes],
     ta.Mapping[bytes, ta.Sequence[bytes]],
-    ta.Mapping[bytes, bytes | ta.Sequence[bytes]],
+    ta.Mapping[bytes, ta.Union[bytes, ta.Sequence[bytes]]],
 
     ta.Mapping[StrOrBytes, StrOrBytes],
     ta.Mapping[StrOrBytes, ta.Sequence[StrOrBytes]],
-    ta.Mapping[StrOrBytes, StrOrBytes | ta.Sequence[StrOrBytes]],
+    ta.Mapping[StrOrBytes, ta.Union[StrOrBytes, ta.Sequence[StrOrBytes]]],
 
-    ta.Sequence[tuple[str, str]],
-    ta.Sequence[tuple[bytes, bytes]],
-    ta.Sequence[tuple[StrOrBytes, StrOrBytes]],
+    ta.Sequence[ta.Tuple[str, str]],
+    ta.Sequence[ta.Tuple[bytes, bytes]],
+    ta.Sequence[ta.Tuple[StrOrBytes, StrOrBytes]],
 ]
 
 
+class DuplicateHttpHeaderError(Exception):
+    pass
+
+
 class HttpHeaders:
     def __init__(self, src: CanHttpHeaders) -> None:
         super().__init__()
@@ -48,7 +54,7 @@ class HttpHeaders:
             return
 
         # TODO: optimized storage, 'use-whats-given'
-        lst: list[tuple[bytes, bytes]] = []
+        lst: ta.List[ta.Tuple[bytes, bytes]] = []
         if isinstance(src, http.client.HTTPMessage):
             lst = [(self._as_bytes(k), self._as_bytes(v)) for k, v in src.items()]
 
@@ -98,55 +104,83 @@ class HttpHeaders:
 
     #
 
-    @cached.function
+    @cached_nullary
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({{{", ".join(repr(k) for k in self.single_str_dct)}}})'
 
     #
 
     @property
-    def raw(self) -> ta.Sequence[tuple[bytes, bytes]]:
+    def raw(self) -> ta.Sequence[ta.Tuple[bytes, bytes]]:
         return self._lst
 
     @classmethod
     def _as_key(cls, o: StrOrBytes) -> bytes:
         return cls._as_bytes(o).lower()
 
-    @cached.property
-    def normalized(self) -> ta.Sequence[tuple[bytes, bytes]]:
+    @cached_property
+    def normalized(self) -> ta.Sequence[ta.Tuple[bytes, bytes]]:
         return [(self._as_key(k), v) for k, v in self._lst]
 
     #
 
-    @cached.property
+    @cached_property
     def multi_dct(self) -> ta.Mapping[bytes, ta.Sequence[bytes]]:
-        return col.multi_map(self.normalized)
-
-    @cached.property
+        d: ta.Dict[bytes, ta.List[bytes]] = {}
+        for k, v in self.normalized:
+            try:
+                l = d[k]
+            except KeyError:
+                l = d[k] = []
+            l.append(v)
+        return d
+
+    @cached_property
     def single_dct(self) -> ta.Mapping[bytes, bytes]:
         return {k: v[0] for k, v in self.multi_dct.items() if len(v) == 1}
 
-    @cached.property
+    @cached_property
     def strict_dct(self) -> ta.Mapping[bytes, bytes]:
-        return col.make_map(self.normalized, strict=True)
+        d: ta.Dict[bytes, bytes] = {}
+        for k, v in self.normalized:
+            if k in d:
+                if True:
+                    raise DuplicateHttpHeaderError(k)
+            else:
+                d[k] = v
+        return d
 
     #
 
-    @cached.property
-    def strs(self) -> ta.Sequence[tuple[str, str]]:
+    @cached_property
+    def strs(self) -> ta.Sequence[ta.Tuple[str, str]]:
         return tuple((k.decode(self.ENCODING), v.decode(self.ENCODING)) for k, v in self.normalized)
 
-    @cached.property
+    @cached_property
     def multi_str_dct(self) -> ta.Mapping[str, ta.Sequence[str]]:
-        return col.multi_map(self.strs)
-
-    @cached.property
+        d: ta.Dict[str, ta.List[str]] = {}
+        for k, v in self.strs:
+            try:
+                l = d[k]
+            except KeyError:
+                l = d[k] = []
+            l.append(v)
+        return d
+
+    @cached_property
     def single_str_dct(self) -> ta.Mapping[str, str]:
         return {k: v[0] for k, v in self.multi_str_dct.items() if len(v) == 1}
 
-    @cached.property
+    @cached_property
     def strict_str_dct(self) -> ta.Mapping[str, str]:
-        return col.make_map(self.strs, strict=True)
+        d: ta.Dict[str, str] = {}
+        for k, v in self.strs:
+            if k in d:
+                if True:
+                    raise DuplicateHttpHeaderError(k)
+            else:
+                d[k] = v
+        return d
 
     #
 
@@ -156,7 +190,7 @@ class HttpHeaders:
     def __len__(self) -> int:
         return len(self._lst)
 
-    def __iter__(self) -> ta.Iterator[tuple[bytes, bytes]]:
+    def __iter__(self) -> ta.Iterator[ta.Tuple[bytes, bytes]]:
         return iter(self._lst)
 
     @ta.overload
@@ -168,11 +202,11 @@ class HttpHeaders:
         ...
 
     @ta.overload
-    def __getitem__(self, item: int) -> tuple[StrOrBytes, StrOrBytes]:
+    def __getitem__(self, item: int) -> ta.Tuple[StrOrBytes, StrOrBytes]:
         ...
 
     @ta.overload
-    def __getitem__(self, item: slice) -> ta.Sequence[tuple[StrOrBytes, StrOrBytes]]:
+    def __getitem__(self, item: slice) -> ta.Sequence[ta.Tuple[StrOrBytes, StrOrBytes]]:
         ...
 
     def __getitem__(self, item):
@@ -188,14 +222,14 @@ class HttpHeaders:
     def keys(self) -> ta.Iterable[bytes]:
         return self.multi_dct.keys()
 
-    def items(self) -> ta.Iterable[tuple[bytes, bytes]]:
+    def items(self) -> ta.Iterable[ta.Tuple[bytes, bytes]]:
         return self._lst
 
     #
 
     def update(
             self,
-            *items: tuple[bytes, bytes],  # FIXME: all arg types
+            *items: ta.Tuple[bytes, bytes],  # FIXME: all arg types
             override: bool = False,
     ) -> 'HttpHeaders':
         if override:

omlish/http/sse.py

@@ -82,7 +82,7 @@ class SseDecoder:
 
         return e
 
-    def process_line(self, line: bytes) -> ta.Iterable[SseDecoderOutput]:
+    def process_line(self, line: bytes) -> ta.Iterator[SseDecoderOutput]:
         if b'\r' in line or b'\n' in line:
             raise ValueError(line)
 

omlish/http/urls.py

@@ -0,0 +1,67 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+import re
+import typing as ta
+import urllib.parse
+
+from ..lite.cached import cached_nullary
+
+
+##
+
+
+@cached_nullary
+def _url_split_host_pat() -> re.Pattern:
+    return re.compile('//([^/#?]*)(.*)', re.DOTALL)
+
+
+def url_split_host(url: str) -> ta.Tuple[ta.Optional[str], str]:
+    """splithost('//host[:port]/path') --> 'host[:port]', '/path'."""
+
+    # https://github.com/python/cpython/blob/364ae607d8035db8ba92486ebebd8225446c1a90/Lib/urllib/parse.py#L1143
+    if not (m := _url_split_host_pat().match(url)):
+        return None, url
+
+    host_port, path = m.groups()
+    if path and path[0] != '/':
+        path = '/' + path
+    return host_port, path
+
+
+##
+
+
+def unparse_url_request_path(url: ta.Union[str, urllib.parse.ParseResult]) -> str:
+    if isinstance(url, urllib.parse.ParseResult):
+        ups = url
+    else:
+        ups = urllib.parse.urlparse(url)
+
+    return urllib.parse.urlunparse((
+        '',
+        '',
+        ups.path,
+        ups.params,
+        ups.query,
+        ups.fragment,
+    ))
+
+
+def parsed_url_replace(
+        url: urllib.parse.ParseResult,
+        *,
+        scheme: ta.Optional[str] = None,
+        netloc: ta.Optional[str] = None,
+        path: ta.Optional[str] = None,
+        params: ta.Optional[str] = None,
+        query: ta.Optional[str] = None,
+        fragment: ta.Optional[str] = None,
+) -> urllib.parse.ParseResult:
+    return urllib.parse.ParseResult(
+        scheme if scheme is not None else url.scheme,
+        netloc if netloc is not None else url.netloc,
+        path if path is not None else url.path,
+        params if params is not None else url.params,
+        query if query is not None else url.query,
+        fragment if fragment is not None else url.fragment,
+    )

omlish/inject/__init__.py

@@ -13,129 +13,176 @@ _dc.init_package(
 ##
 
 
-from .binder import (  # noqa
-    bind,
-    bind_as_fn,
-    bind_map_entry_const,
-    bind_set_entry_const,
-)
-
-from .bindings import (  # noqa
-    Binding,
-)
-
-from .eagers import (  # noqa
-    Eager,
-)
-
-from .elements import (  # noqa
-    Element,
-    Elemental,
-    Elements,
-    as_elements,
-)
-
-from .errors import (  # noqa
-    BaseKeyError,
-    ConflictingKeyError,
-    CyclicDependencyError,
-    ScopeAlreadyOpenError,
-    ScopeError,
-    ScopeNotOpenError,
-    UnboundKeyError,
-)
-
-from .injector import (  # noqa
-    create_injector,
-    Injector,
-)
-
-from .inspect import (  # noqa
-    Kwarg,
-    KwargsTarget,
-    build_kwargs_target,
-    tag,
-)
-
-from .keys import (  # noqa
-    Key,
-    as_key,
-)
-
-from .listeners import (  # noqa
-    ProvisionListener,
-    ProvisionListenerBinding,
-    bind_provision_listener,
-)
-
-from .managed import (  # noqa
-    create_async_managed_injector,
-    create_managed_injector,
-    make_async_managed_provider,
-    make_managed_provider,
-)
-
-from .multis import (  # noqa
-    MapBinding,
-    MapProvider,
-    SetBinding,
-    SetProvider,
-    MapBinder,
-    SetBinder,
-
-    MapBinder as map_binder,  # noqa
-    SetBinder as set_binder,  # noqa
-)
-
-
-from .overrides import (  # noqa
-    Overrides,
-    override,
-)
-
-from .origins import (  # noqa
-    HasOrigins,
-    Origin,
-    Origins,
-)
-
-from .privates import (  # noqa
-    Expose,
-    Private,
-    private,
-
-    Expose as expose,  # noqa
-)
-
-from .providers import (  # noqa
-    ConstProvider,
-    CtorProvider,
-    FnProvider,
-    LinkProvider,
-    Provider,
-)
-
-from .scopes import (  # noqa
-    ScopeBinding,
-    ScopeSeededProvider,
-    SeededScope,
-    Singleton,
-    ThreadScope,
-    bind_scope,
-    bind_scope_seed,
-    enter_seeded_scope,
-)
-
-from .tags import (  # noqa
-    Id,
-)
-
-from .types import (  # noqa
-    Scope,
-    Tag,
-    Unscoped,
-)
-
-from .utils import (  # noqa
-    ConstFn,
-)
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .helpers.constfn import (  # noqa
+        ConstFn,
+    )
+
+    from .helpers.id import (  # noqa
+        Id,
+    )
+
+    from .helpers.multis import (  # noqa
+        bind_map_entry_const,
+        bind_set_entry_const,
+
+        ItemsBinderHelper,
+        items_binder_helper,
+    )
+
+    from .helpers.wrappers import (  # noqa
+        WrapperBinderHelper,
+        wrapper_binder_helper,
+    )
+
+    from .binder import (  # noqa
+        bind,
+        bind_as_fn,
+    )
+
+    from .bindings import (  # noqa
+        Binding,
+    )
+
+    from .eagers import (  # noqa
+        Eager,
+    )
+
+    from .elements import (  # noqa
+        Element,
+        Elements,
+        Elemental,
+
+        as_elements,
+        iter_elements,
+
+        CollectedElements,
+        collect_elements,
+    )
+
+    from .errors import (  # noqa
+        BaseKeyError,
+        ConflictingKeyError,
+        CyclicDependencyError,
+        ScopeAlreadyOpenError,
+        ScopeError,
+        ScopeNotOpenError,
+        UnboundKeyError,
+    )
+
+    from .injector import (  # noqa
+        AsyncInjector,
+        create_async_injector,
+    )
+
+    from .inspect import (  # noqa
+        Kwarg,
+        KwargsTarget,
+        build_kwargs_target,
+        tag,
+    )
+
+    from .keys import (  # noqa
+        Key,
+        as_key,
+    )
+
+    from .listeners import (  # noqa
+        ProvisionListener,
+        ProvisionListenerBinding,
+        bind_provision_listener,
+    )
+
+    from .managed import (  # noqa
+        create_async_managed_injector,
+        make_async_managed_provider,
+
+        create_managed_injector,
+        make_managed_provider,
+
+        create_maysync_managed_injector,
+        make_maysync_managed_provider,
+    )
+
+    from .maysync import (  # noqa
+        MaysyncInjector,
+        create_maysync_injector,
+    )
+
+    from .multis import (  # noqa
+        is_set_multi_key,
+        SetBinding,
+        SetProvider,
+
+        is_map_multi_key,
+        MapBinding,
+        MapProvider,
+
+        SetBinder,
+        set_binder,
+
+        MapBinder,
+        map_binder,
+    )
+
+
+    from .overrides import (  # noqa
+        Overrides,
+        override,
+    )
+
+    from .origins import (  # noqa
+        HasOrigins,
+        Origin,
+        Origins,
+    )
+
+    from .privates import (  # noqa
+        Expose,
+        expose,
+
+        Private,
+        private,
+    )
+
+    from .providers import (  # noqa
+        AsyncFnProvider,
+        ConstProvider,
+        CtorProvider,
+        FnProvider,
+        LinkProvider,
+        Provider,
+    )
+
+    from .scopes import (  # noqa
+        ScopeBinding,
+        bind_scope,
+
+        Singleton,
+
+        ThreadScope,
+
+        SeededScope,
+        ScopeSeededProvider,
+        bind_scope_seed,
+
+        async_enter_seeded_scope,
+        enter_seeded_scope,
+        maysync_enter_seeded_scope,
+    )
+
+    from .sync import (  # noqa
+        Injector,
+        create_injector,
+    )
+
+    from .types import (  # noqa
+        Scope,
+        Tag,
+        Unscoped,
+    )