omlish 0.0.0.dev433__py3-none-any.whl → 0.0.0.dev435__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev433'
-__revision__ = '8b1520428b44d4d75317513a61d17c5e6f0c7711'
+__version__ = '0.0.0.dev435'
+__revision__ = 'deaaa1ce6258184eff437ebf09b0eea7fc2ca758'
 
 
 #

omlish/asyncs/all.py

@@ -1,12 +1,3 @@
-from .bridge import (  # noqa
-    a_to_s,
-    is_in_bridge,
-    s_to_a,
-    s_to_a_await,
-    trivial_a_to_s,
-    trivial_s_to_a,
-)
-
 from .flavors import (  # noqa
     ContextManagerAdapter,
     Flavor,
@@ -25,7 +16,3 @@ from .flavors import (  # noqa
     mark_trio,
     with_adapter_loop,
 )
-
-from .utils import (  # noqa
-    call_with_async_exit_stack,
-)

omlish/concurrent/__init__.py

@@ -1,17 +0,0 @@
-from .. import lang as _lang
-
-
-with _lang.auto_proxy_init(globals()):
-    ##
-
-    from .executors import (  # noqa
-        ImmediateExecutor,
-        new_executor,
-    )
-
-    from .futures import (  # noqa
-        FutureError,
-        FutureTimeoutError,
-        wait_futures,
-        wait_dependent_futures,
-    )

omlish/concurrent/all.py

@@ -0,0 +1,17 @@
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .executors import (  # noqa
+        ImmediateExecutor,
+        new_executor,
+    )
+
+    from .futures import (  # noqa
+        FutureError,
+        FutureTimeoutError,
+        wait_futures,
+        wait_dependent_futures,
+    )

omlish/configs/types.py

@@ -3,7 +3,7 @@
 import typing as ta
 
 
-ConfigMap = ta.Mapping[str, ta.Any]
+ConfigMap = ta.Mapping[str, ta.Any]  # ta.TypeAlias
 
 
 ##

omlish/daemons/__init__.py

@@ -0,0 +1,70 @@
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .daemon import (  # noqa
+        Daemon,
+    )
+
+    from .launching import (  # noqa
+        Launcher,
+    )
+
+    from .services import (  # noqa
+        Service,
+
+        ServiceTarget,
+        ServiceTargetRunner,
+
+        ServiceConfigTarget,
+        ServiceConfigTargetRunner,
+    )
+
+    from .spawning import (  # noqa
+        Spawning,
+        Spawn,
+        Spawner,
+        InProcessSpawner,
+        spawner_for,
+
+        MultiprocessingSpawning,
+        MultiprocessingSpawner,
+
+        ForkSpawning,
+        ForkSpawner,
+
+        ThreadSpawning,
+        ThreadSpawner,
+    )
+
+    from .targets import (  # noqa
+        Target,
+        TargetRunner,
+        target_runner_for,
+
+        FnTarget,
+        FnTargetRunner,
+
+        NameTarget,
+        NameTargetRunner,
+
+        ExecTarget,
+        ExecTargetRunner,
+    )
+
+    from .waiting import (  # noqa
+        Wait,
+        Waiter,
+        waiter_for,
+
+        SequentialWait,
+        SequentialWaiter,
+
+        FnWait,
+        FnWaiter,
+
+        ConnectWait,
+        ConnectWaiter,
+    )

omlish/dataclasses/errors.py

@@ -6,7 +6,7 @@ import typing as ta
 
 
 def _hands_off_repr(obj: ta.Any) -> str:
-    return f'{obj.__class__.__qualname__}@{hex(id(obj))[2:]}'
+    return f'{obj.__class__.__qualname__}@{id(obj):x}'
 
 
 def _fn_repr(fn: ta.Callable) -> str:

omlish/formats/json/stream/lexing.py

@@ -122,11 +122,17 @@ class JsonStreamLexer(GenMachine[str, Token]):
             include_space: bool = False,
             allow_comments: bool = False,
             include_comments: bool = False,
+            allow_single_quotes: bool = False,
+            string_literal_parser: ta.Callable[[str], str] | None = None,
     ) -> None:
         self._include_raw = include_raw
         self._include_space = include_space
         self._allow_comments = allow_comments
         self._include_comments = include_comments
+        self._allow_single_quotes = allow_single_quotes
+        if string_literal_parser is None:
+            string_literal_parser = json.loads
+        self._string_literal_parser = string_literal_parser
 
         self._ofs = 0
         self._line = 1
@@ -202,8 +208,8 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 yield self._make_tok(CONTROL_TOKENS[c], c, c, self.pos)
                 continue
 
-            if c == '"':
-                return self._do_string()
+            if c == '"' or (self._allow_single_quotes and c == "'"):
+                return self._do_string(c)
 
             if c.isdigit() or c == '-':
                 return self._do_number(c)
@@ -217,9 +223,9 @@ class JsonStreamLexer(GenMachine[str, Token]):
 
             self._raise(f'Unexpected character: {c}')
 
-    def _do_string(self):
+    def _do_string(self, q: str):
         check.state(self._buf.tell() == 0)
-        self._buf.write('"')
+        self._buf.write(q)
 
         pos = self.pos
 
@@ -234,13 +240,13 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 self._raise(f'Unterminated string literal: {self._buf.getvalue()}')
 
             self._buf.write(c)
-            if c == '"' and last != '\\':
+            if c == q and last != '\\':
                 break
             last = c
 
         raw = self._flip_buf()
         try:
-            sv = json.loads(raw)
+            sv = self._string_literal_parser(raw)
         except json.JSONDecodeError as e:
             self._raise(f'Invalid string literal: {raw!r}', e)
 

omlish/formats/json/stream/utils.py

@@ -1,3 +1,28 @@
+r"""
+TODO:
+ - gson switches
+  - Strictness.LEGACY_STRICT
+   - JsonReader allows the literals true, false and null to have any capitalization, for example fAlSe or NULL
+   - JsonReader supports the escape sequence \', representing a ' (single-quote)
+   - JsonReader supports the escape sequence \LF (with LF being the Unicode character U+000A), resulting in a LF within
+     the read JSON string
+   - JsonReader allows unescaped control characters (U+0000 through U+001F)
+  - Strictness.LENIENT
+   - In lenient mode, all input that is accepted in legacy strict mode is accepted in addition to the following
+     departures from RFC 8259:
+   - Streams that start with the non-execute prefix, ")]'\n"}
+   - Streams that include multiple top-level values. With legacy strict or strict parsing, each stream must contain
+     exactly one top-level value.
+   - Numbers may be NaNs or infinities represented by NaN and (-)Infinity respectively.
+   - End of line comments starting with // or # and ending with a newline character.
+   - C-style comments starting with /* and ending with */. Such comments may not be nested.
+   - Names that are unquoted or 'single quoted'.
+   - Strings that are unquoted or 'single quoted'.
+   - Array elements separated by ; instead of ,.
+   - Unnecessary array separators. These are interpreted as if null was the omitted value.
+   - Names and values separated by = or => instead of :.
+   - Name/value pairs separated by ; instead of ,.
+"""
 import dataclasses as dc
 import typing as ta
 
@@ -15,7 +40,7 @@ class JsonStreamValueParser(lang.ExitStacked):
     include_raw: bool = False
     yield_object_lists: bool = False
 
-    allow_comments: bool = False
+    json5: bool = False
 
     #
 
@@ -26,7 +51,8 @@ class JsonStreamValueParser(lang.ExitStacked):
     def _enter_contexts(self) -> None:
         self._lex = JsonStreamLexer(
             include_raw=self.include_raw,
-            allow_comments=self.allow_comments,
+            allow_comments=self.json5,
+            allow_single_quotes=self.json5,
         )
 
         self._parse = JsonStreamParser()

omlish/formats/json5/stream.py

@@ -0,0 +1,82 @@
+"""
+TODO:
+
+Objects:
+ - Object keys may be an ECMAScript 5.1 IdentifierName.
+ - Objects may have a single trailing comma.
+Arrays:
+ - Arrays may have a single trailing comma.
+Strings:
+ - Strings may be single quoted.
+ - Strings may span multiple lines by escaping new line characters.
+ - Strings may include character escapes.
+Numbers:
+ - Numbers may be hexadecimal.
+ - Numbers may have a leading or trailing decimal point.
+ - Numbers may be IEEE 754 positive infinity, negative infinity, and NaN.
+ - Numbers may begin with an explicit plus sign.
+Comments:
+ + Single and multi-line comments are allowed.
+White Space:
+ - Additional white space characters are allowed.
+"""
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from ..json.stream.building import JsonValueBuilder
+from ..json.stream.lexing import JsonStreamLexer
+from ..json.stream.parsing import JsonStreamParser
+from .literals import parse_string_literal
+
+
+##
+
+
+@dc.dataclass(kw_only=True)
+class JsonStreamValueParser(lang.ExitStacked):
+    include_raw: bool = False
+    yield_object_lists: bool = False
+
+    #
+
+    _lex: JsonStreamLexer = dc.field(init=False)
+    _parse: JsonStreamParser = dc.field(init=False)
+    _build: JsonValueBuilder = dc.field(init=False)
+
+    def _enter_contexts(self) -> None:
+        self._lex = JsonStreamLexer(
+            include_raw=self.include_raw,
+            allow_comments=True,
+            allow_single_quotes=True,
+            string_literal_parser=parse_string_literal,
+        )
+
+        self._parse = JsonStreamParser()
+
+        self._build = JsonValueBuilder(
+            yield_object_lists=self.yield_object_lists,
+        )
+
+    def feed(self, i: ta.Iterable[str]) -> ta.Iterator[ta.Any]:
+        for c in i:
+            for t in self._lex(c):
+                for e in self._parse(t):
+                    for v in self._build(e):  # noqa
+                        yield v
+
+
+def stream_parse_values(
+        i: ta.Iterable[str],
+        **kwargs: ta.Any,
+) -> ta.Generator[ta.Any]:
+    with JsonStreamValueParser(**kwargs) as p:
+        yield from p.feed(i)
+
+
+def stream_parse_one_value(
+        i: ta.Iterable[str],
+        **kwargs: ta.Any,
+) -> ta.Any:
+    with JsonStreamValueParser(**kwargs) as p:
+        return next(p.feed(i))

omlish/funcs/genmachine.py

@@ -45,7 +45,7 @@ class GenMachine(ta.Generic[I, O]):
     _gen: MachineGen | None
 
     def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{hex(id(self))[2:]}<{self.state}>'
+        return f'{self.__class__.__name__}@{id(self):x}<{self.state}>'
 
     #
 

omlish/http/coro/server/server.py

@@ -77,7 +77,7 @@ from ...versions import HttpProtocolVersion
 from ...versions import HttpProtocolVersions
 
 
-CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
+CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']  # ta.TypeAlias
 
 
 ##

omlish/inject/__init__.py

@@ -13,129 +13,155 @@ _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 .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
+        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
+        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,
+        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 .tags import (  # noqa
+        Id,
+    )
+
+    from .types import (  # noqa
+        Scope,
+        Tag,
+        Unscoped,
+    )
+
+    from .utils import (  # noqa
+        ConstFn,
+    )

omlish/inject/binder.py

@@ -19,6 +19,7 @@ from .multis import SetBinding
 from .multis import is_map_multi_key
 from .multis import is_set_multi_key
 from .privates import Expose
+from .providers import AsyncFnProvider
 from .providers import ConstProvider
 from .providers import CtorProvider
 from .providers import FnProvider
@@ -31,10 +32,8 @@ from .types import Scope
 from .types import Unscoped
 
 
-if ta.TYPE_CHECKING:
-    from .impl.inspect import inspect as _inspect
-else:
-    _inspect = lang.proxy_import('.impl.inspect', __package__)
+with lang.auto_proxy_import(globals()):
+    from .impl import inspect as _inspect
 
 
 T = ta.TypeVar('T')
@@ -83,6 +82,7 @@ def bind(
         *,
         tag: ta.Any = None,
 
+        to_async_fn: ta.Any = None,
         to_fn: ta.Any = None,
         to_ctor: ta.Any = None,
         to_const: ta.Any = None,
@@ -102,6 +102,7 @@ def bind(
     ##
 
     has_to = (
+        to_async_fn is not None or
         to_fn is not None or
         to_ctor is not None or
         to_const is not None or
@@ -137,6 +138,8 @@ def bind(
     ##
 
     providers: list[Provider] = []
+    if to_async_fn is not None:
+        providers.append(AsyncFnProvider(to_async_fn))
     if to_fn is not None:
         providers.append(FnProvider(to_fn))
     if to_ctor is not None: