omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/http/flasky/api.py

@@ -0,0 +1,82 @@
+import threading
+import typing as ta
+
+from ... import lang
+from ._compat import compat
+from .app import App
+from .cvs import Cvs
+from .requests import Request
+from .responses import Response
+
+
+##
+
+
+class Api:
+    def __init__(
+            self,
+            *,
+            base_app_cls: type[App] = App,
+    ) -> None:
+        super().__init__()
+
+        self._base_app_cls = base_app_cls
+
+        self._lock = threading.RLock()
+
+    @property
+    def _cls_name_repr(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}'
+
+    def __repr__(self) -> str:
+        return f'{self._cls_name_repr}()'
+
+    ##
+    # app cls
+
+    _app_cls: type[App]
+
+    @property
+    def app_cls(self) -> type[App]:
+        try:
+            return self._app_cls
+        except AttributeError:
+            pass
+
+        with self._lock:
+            try:
+                return self._app_cls
+            except AttributeError:
+                pass
+
+            self._app_cls = lang.new_type(  # noqa
+                f'{self._base_app_cls.__name__}<{self._cls_name_repr}>',
+                (self._base_app_cls,),
+                {'_api': self},
+            )
+
+            return self._app_cls
+
+    @property
+    @compat
+    def Flask(self) -> type[App]:  # noqa
+        return self.app_cls
+
+    ##
+    # helpers
+
+    def abort(self, code: int | Response, *args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
+        raise NotImplementedError
+
+    ##
+    # cv's
+
+    @property
+    @compat
+    def request(self) -> Request:
+        return Cvs.REQUEST.get()
+
+    ##
+    # type aliases - must be last
+
+    Response = Response

omlish/http/flasky/app.py

@@ -0,0 +1,203 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ._compat import compat
+from .cvs import Cvs
+from .responses import Response
+from .routes import Route
+from .routes import RouteKey
+
+
+if ta.TYPE_CHECKING:
+    from .api import Api
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class AppRunParams:
+    app: 'App'
+
+    port: int | None = None
+
+
+AppRunner: ta.TypeAlias = ta.Callable[[AppRunParams], None]
+
+
+##
+
+
+ViewFunc: ta.TypeAlias = ta.Callable[[], str]
+
+BeforeRequestFunc: ta.TypeAlias = ta.Callable[[], Response | None]
+AfterRequestFunc: ta.TypeAlias = ta.Callable[[ta.Any], ta.Any]
+
+
+#
+
+
+class App:
+    _api: ta.ClassVar['Api']
+
+    def __init__(
+            self,
+            import_name: str,
+    ) -> None:
+        check.not_none(self._api)
+
+        super().__init__()
+
+        self._import_name = check.non_empty_str(import_name)
+
+        self._routes: set[Route] = set()
+        self._routes_by_key: dict[RouteKey, Route] = {}
+
+        self._view_funcs_by_endpoint: dict[str, ViewFunc] = {}
+
+        self._before_request_funcs: list[BeforeRequestFunc] = []
+        self._after_request_funcs: list[AfterRequestFunc] = []
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._import_name!r})'
+
+    @property
+    def import_name(self) -> str:
+        return self._import_name
+
+    ##
+    # routing
+
+    @property
+    def routes(self) -> ta.AbstractSet[Route]:
+        return self._routes
+
+    @property
+    def routes_by_key(self) -> ta.Mapping[RouteKey, Route]:
+        return self._routes_by_key
+
+    @property
+    def view_funcs_by_endpoint(self) -> ta.Mapping[str, ViewFunc]:
+        return self._view_funcs_by_endpoint
+
+    @compat
+    def get(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('GET', rule, **options)
+
+    @compat
+    def post(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('POST', rule, **options)
+
+    @compat
+    def put(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('PUT', rule, **options)
+
+    @compat
+    def delete(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('DELETE', rule, **options)
+
+    @compat
+    def patch(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('PATCH', rule, **options)
+
+    def _method_route(
+            self,
+            method: str,
+            rule: str,
+            **options: ta.Any,
+    ) -> ta.Callable[[T], T]:
+        return self.route(
+            rule,
+            methods=[method],
+            **options,
+        )
+
+    @compat
+    def route(
+            self,
+            rule: str,
+            **options: ta.Any,
+    ) -> ta.Callable[[T], T]:
+        def inner(fn):
+            endpoint = options.pop('endpoint', None)
+            self.add_url_rule(rule, endpoint, fn, **options)
+            return fn
+
+        return inner
+
+    @compat
+    def add_url_rule(
+            self,
+            rule: str,
+            endpoint: str | None = None,
+            view_func: ViewFunc | None = None,
+            *,
+            methods: ta.Iterable[str] | None = None,
+    ) -> None:
+        check.arg(check.non_empty_str(rule).startswith('/'))
+
+        if endpoint is None:
+            endpoint = check.not_none(view_func).__name__
+
+        if methods is None:
+            methods = ['GET']
+        else:
+            methods = [check.non_empty_str(m) for m in check.not_isinstance(methods, str)]
+        methods = check.not_empty([s.upper() for s in methods])
+
+        #
+
+        route = Route(
+            rule=rule,
+            endpoint=endpoint,
+            methods=frozenset(methods),
+        )
+
+        #
+
+        for rk in route.keys:
+            check.not_in(rk, self._routes_by_key)
+
+        if view_func is not None:
+            check.not_in(endpoint, self._view_funcs_by_endpoint)
+
+        #
+
+        self._routes.add(route)
+        for rk in route.keys:
+            self._routes_by_key[rk] = route
+
+        if view_func is not None:
+            self._view_funcs_by_endpoint[endpoint] = view_func
+
+    ##
+    # hooks
+
+    @property
+    def before_request_funcs(self) -> ta.Sequence[BeforeRequestFunc]:
+        return self._before_request_funcs
+
+    @property
+    def after_request_funcs(self) -> ta.Sequence[AfterRequestFunc]:
+        return self._after_request_funcs
+
+    def before_request(self, func: T) -> T:  # BeforeRequestFunc
+        self._before_request_funcs.append(ta.cast(BeforeRequestFunc, check.callable(func)))
+        return func
+
+    def after_request(self, func: T) -> T:  # AfterRequestFunc
+        self._after_request_funcs.append(ta.cast(AfterRequestFunc, check.callable(func)))
+        return func
+
+    ##
+    # running
+
+    @compat
+    def run(self, **kwargs: ta.Any) -> None:
+        params = AppRunParams(app=self, **kwargs)
+        runner = Cvs.APP_RUNNER.get()
+        check.not_none(runner)(params)

omlish/http/flasky/cvs.py

@@ -0,0 +1,59 @@
+import contextlib
+import contextvars
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+
+
+if ta.TYPE_CHECKING:
+    from .app import AppRunner
+    from .requests import Request
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass()
+class CvLookupError(LookupError):
+    cv: 'Cv'
+
+
+@ta.final
+class Cv(ta.Generic[T]):
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._var: contextvars.ContextVar[T] = contextvars.ContextVar(name)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._name!r})'
+
+    def get(self) -> T:
+        try:
+            return self._var.get()
+        except LookupError:
+            raise CvLookupError(self) from None
+
+    @contextlib.contextmanager
+    def set(self, new: T) -> ta.Iterator[None]:
+        tok = self._var.set(new)
+        try:
+            yield
+        finally:
+            self._var.reset(tok)
+
+
+##
+
+
+def _cv(name: str) -> Cv:
+    return Cv(f'{__name__}.Cvs.{name}')
+
+
+class Cvs(lang.Namespace, lang.Final):
+    APP_RUNNER: Cv['AppRunner'] = _cv('APP_RUNNER')
+
+    REQUEST: Cv['Request'] = _cv('REQUEST')

omlish/http/flasky/requests.py

@@ -0,0 +1,20 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ._compat import compat
+from .types import ImmutableMultiDict
+
+
+##
+
+
+@compat
+@dc.dataclass(frozen=True, kw_only=True)
+class Request:
+    path: str
+    method: str
+
+    form: ImmutableMultiDict[str, str] | None = None
+
+    def get_json(self) -> ta.Any:
+        raise NotImplementedError

omlish/http/flasky/responses.py

@@ -0,0 +1,23 @@
+import http
+import typing as ta
+
+from ... import dataclasses as dc
+from ._compat import compat
+
+
+ResponseData: ta.TypeAlias = str | ta.Iterable[str] | bytes | ta.Iterable[bytes]
+ResponseStatus: ta.TypeAlias = int | str | http.HTTPStatus
+ResponseHeaders: ta.TypeAlias = ta.Mapping[str, str | ta.Iterable[str]] | ta.Iterable[tuple[str, str]]
+
+
+##
+
+
+@compat
+@dc.dataclass(frozen=True)
+class Response:
+    response: ResponseData | None = None
+    status: ResponseStatus | None = None
+    headers: ResponseHeaders | None = None
+    mimetype: str | None = None
+    content_type: str | None = None

omlish/http/flasky/routes.py

@@ -0,0 +1,23 @@
+import typing as ta
+
+from ... import cached
+from ... import dataclasses as dc
+
+
+##
+
+
+class RouteKey(ta.NamedTuple):
+    rule: str
+    method: str
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Route:
+    rule: str
+    endpoint: str
+    methods: frozenset[str]
+
+    @cached.property
+    def keys(self) -> frozenset[RouteKey]:
+        return frozenset(RouteKey(self.rule, m) for m in self.methods)

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

@@ -19,11 +19,49 @@ 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.late import (  # noqa
+        Late,
+        AsyncLate,
+
+        bind_late,
+        bind_async_late,
+    )
+
+    from .helpers.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 .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,
-        bind_map_entry_const,
-        bind_set_entry_const,
     )
 
     from .bindings import (  # noqa
@@ -36,9 +74,14 @@ with _lang.auto_proxy_init(globals()):
 
     from .elements import (  # noqa
         Element,
-        Elemental,
         Elements,
+        Elemental,
+
         as_elements,
+        iter_elements,
+
+        CollectedElements,
+        collect_elements,
     )
 
     from .errors import (  # noqa
@@ -74,32 +117,25 @@ with _lang.auto_proxy_init(globals()):
         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
-        MapBinding,
-        MapProvider,
+        is_set_multi_key,
         SetBinding,
         SetProvider,
-        MapBinder,
+
+        is_map_multi_key,
+        MapBinding,
+        MapProvider,
+
         SetBinder,
+        set_binder,
 
-        MapBinder as map_binder,  # noqa
-        SetBinder as set_binder,  # noqa
+        MapBinder,
+        map_binder,
     )
 
 
@@ -116,10 +152,10 @@ with _lang.auto_proxy_init(globals()):
 
     from .privates import (  # noqa
         Expose,
+        expose,
+
         Private,
         private,
-
-        Expose as expose,  # noqa
     )
 
     from .providers import (  # noqa
@@ -153,16 +189,8 @@ with _lang.auto_proxy_init(globals()):
         create_injector,
     )
 
-    from .tags import (  # noqa
-        Id,
-    )
-
     from .types import (  # noqa
         Scope,
         Tag,
         Unscoped,
     )
-
-    from .utils import (  # noqa
-        ConstFn,
-    )