omlish 0.0.0.dev470__py3-none-any.whl → 0.0.0.dev471__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev470'
-__revision__ = '967906fd30a40d061ede9f7aeda9dad0ec608508'
+__version__ = '0.0.0.dev471'
+__revision__ = '2a1fe39e9894efdf0e28923ddd0067f441d9d964'
 
 
 #

omlish/inject/__init__.py

@@ -57,8 +57,12 @@ with _lang.auto_proxy_init(globals()):
         Element,
         Elements,
         Elemental,
+
         as_elements,
         iter_elements,
+
+        CollectedElements,
+        collect_elements,
     )
 
     from .errors import (  # noqa

omlish/inject/elements.py

@@ -6,6 +6,12 @@ from .. import lang
 from .impl.origins import HasOriginsImpl
 
 
+if ta.TYPE_CHECKING:
+    from .impl import elements as _elements
+else:
+    _elements = lang.proxy_import('.impl.elements', __package__)
+
+
 ##
 
 
@@ -74,3 +80,14 @@ def iter_elements(*args: Elemental) -> ta.Iterator[Element]:
             yield from a
         else:
             raise TypeError(a)
+
+
+##
+
+
+class CollectedElements(lang.PackageSealed, lang.Abstract):
+    pass
+
+
+def collect_elements(es: Elements | CollectedElements) -> CollectedElements:
+    return _elements.collect_elements(es)

omlish/inject/impl/elements.py

@@ -27,6 +27,7 @@ from ... import collections as col
 from ... import lang
 from ..bindings import Binding
 from ..eagers import Eager
+from ..elements import CollectedElements
 from ..elements import Element
 from ..elements import Elements
 from ..errors import ConflictingKeyError
@@ -47,7 +48,7 @@ from .multis import make_multi_provider_impl
 from .origins import Origins
 from .origins import set_origins
 from .providers import ProviderImpl
-from .providers2 import make_provider_impl
+from .providersmap import make_provider_impl
 from .scopes import make_scope_impl
 
 
@@ -80,7 +81,7 @@ _NON_BINDING_ELEMENT_TYPES: tuple[type[Element], ...] = (
 )
 
 
-class ElementCollection(lang.Final):
+class ElementCollection(CollectedElements, lang.Final):
     def __init__(self, es: Elements) -> None:
         super().__init__()
 
@@ -208,6 +209,10 @@ class ElementCollection(lang.Final):
 
     ##
 
+    @lang.cached_function
+    def scope_binding_scopes(self) -> ta.Sequence[Scope]:
+        return [sb.scope for sb in self.elements_of_type(ScopeBinding)]
+
     @lang.cached_function
     def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
         bim = self.binding_impl_map()
@@ -216,3 +221,13 @@ class ElementCollection(lang.Final):
             bi = bim[e.key]
             ret.setdefault(bi.scope, []).append(e.key)
         return ret
+
+
+##
+
+
+def collect_elements(es: Elements | CollectedElements) -> ElementCollection:
+    if isinstance(es, CollectedElements):
+        return check.isinstance(es, ElementCollection)
+    else:
+        return ElementCollection(es)

omlish/inject/impl/injector.py

@@ -2,14 +2,12 @@
 TODO:
  - ** can currently bind in a child/private scope shadowing an external parent binding **
  - better source tracking
- - cache/export ElementCollections lol
  - scope bindings, auto in root
  - injector-internal / blacklisted bindings (Injector itself, default scopes) without rebuilding ElementCollection
  - config - proxies, impl select, etc
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** eagers in any scope, on scope init/open
- - injection listeners
  - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
  - multiple live request scopes on single injector - use private injectors?
  - more listeners - UnboundKeyListener
@@ -24,7 +22,7 @@ import weakref
 from ... import check
 from ... import lang
 from ...logs import all as logs
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..errors import CyclicDependencyError
 from ..errors import UnboundKeyError
 from ..injector import AsyncInjector
@@ -33,7 +31,6 @@ from ..keys import Key
 from ..keys import as_key
 from ..listeners import ProvisionListener
 from ..listeners import ProvisionListenerBinding
-from ..scopes import ScopeBinding
 from ..scopes import Singleton
 from ..scopes import ThreadScope
 from ..types import Scope
@@ -61,14 +58,12 @@ DEFAULT_SCOPES: list[Scope] = [
 class AsyncInjectorImpl(AsyncInjector, lang.Final):
     def __init__(
             self,
-            ec: ElementCollection,
+            ec: CollectedElements,
             p: ta.Optional['AsyncInjectorImpl'] = None,
             *,
             internal_consts: dict[Key, ta.Any] | None = None,
     ) -> None:
-        super().__init__()
-
-        self._ec = check.isinstance(ec, ElementCollection)
+        self._ec = (ec := check.isinstance(ec, ElementCollection))
         self._p: AsyncInjectorImpl | None = check.isinstance(p, (AsyncInjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
@@ -77,28 +72,31 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
+
         self._ekbs = ec.eager_keys_by_scope()
+
         self._pls: tuple[ProvisionListener, ...] = tuple(
             b.listener  # type: ignore[attr-defined]
             for b in itertools.chain(
                 ec.elements_of_type(ProvisionListenerBinding),
-                (p._pls if p is not None else ()),  # noqa
+                p._pls if p is not None else (),  # noqa
             )
         )
 
-        self._cs: weakref.WeakSet[AsyncInjectorImpl] | None = None  # noqa
         self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
 
-        self.__cur_req: AsyncInjectorImpl._Request | None = None
-
-        ss = [
-            *DEFAULT_SCOPES,
-            *[sb.scope for sb in ec.elements_of_type(ScopeBinding)],
-        ]
         self._scopes: dict[Scope, ScopeImpl] = {
-            s: make_scope_impl(s) for s in ss
+            s: make_scope_impl(s)
+            for s in itertools.chain(
+                DEFAULT_SCOPES,
+                ec.scope_binding_scopes(),
+            )
         }
 
+    _cs: weakref.WeakSet['AsyncInjectorImpl'] | None = None  # noqa
+
+    __cur_req: ta.Optional['AsyncInjectorImpl._Request'] = None
+
     #
 
     _has_run_init: bool = False
@@ -259,7 +257,7 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         return obj(**kws)
 
 
-async def create_async_injector(es: Elements) -> AsyncInjector:
-    i = AsyncInjectorImpl(ElementCollection(es))
+async def create_async_injector(ce: CollectedElements) -> AsyncInjector:
+    i = AsyncInjectorImpl(ce)
     await i._init()  # noqa
     return i

omlish/inject/impl/maysync.py

@@ -1,13 +1,12 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..maysync import MaysyncInjector
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -30,10 +29,10 @@ class MaysyncInjectorImpl(MaysyncInjector, lang.Final):
         return lang.run_maysync(self._ai.inject(obj))
 
 
-def create_maysync_injector(es: Elements) -> MaysyncInjector:
+def create_maysync_injector(ce: CollectedElements) -> MaysyncInjector:
     si = MaysyncInjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(MaysyncInjector): si,
             Key(Injector): si,

omlish/inject/impl/sync.py

@@ -1,12 +1,11 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -29,10 +28,10 @@ class InjectorImpl(Injector, lang.Final):
         return lang.sync_await(self._ai.inject(obj))
 
 
-def create_injector(es: Elements) -> Injector:
+def create_injector(ce: CollectedElements) -> Injector:
     si = InjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(Injector): si,
         },

omlish/inject/injector.py

@@ -1,9 +1,12 @@
 import abc
 import typing as ta
 
+from .. import check
 from .. import lang
+from .elements import CollectedElements
 from .elements import Elemental
 from .elements import as_elements
+from .elements import collect_elements
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -44,5 +47,31 @@ class AsyncInjector(lang.Abstract):
         return self.provide(target)
 
 
-def create_async_injector(*args: Elemental) -> ta.Awaitable[AsyncInjector]:
-    return _injector.create_async_injector(as_elements(*args))
+##
+
+
+@ta.final
+class _InjectorCreator(ta.Generic[T]):
+    def __init__(self, fac: ta.Callable[[CollectedElements], T]) -> None:
+        self._fac = fac
+
+    @ta.overload
+    def __call__(self, es: CollectedElements, /) -> T: ...
+
+    @ta.overload
+    def __call__(self, *es: Elemental) -> T: ...
+
+    def __call__(self, arg0, *argv):
+        ce: CollectedElements
+        if isinstance(arg0, CollectedElements):
+            check.arg(not argv)
+            ce = arg0
+        else:
+            ce = collect_elements(as_elements(arg0, *argv))
+        return self._fac(ce)
+
+
+##
+
+
+create_async_injector = _InjectorCreator[ta.Awaitable[AsyncInjector]](lambda ce: _injector.create_async_injector(ce))

omlish/inject/maysync.py

@@ -1,8 +1,7 @@
 import typing as ta
 
 from .. import lang
-from .elements import Elemental
-from .elements import as_elements
+from .injector import _InjectorCreator
 from .sync import Injector
 
 
@@ -25,5 +24,4 @@ class MaysyncInjector(Injector, lang.Abstract):
 ##
 
 
-def create_maysync_injector(*args: Elemental) -> MaysyncInjector:
-    return _maysync.create_maysync_injector(as_elements(*args))
+create_maysync_injector = _InjectorCreator[MaysyncInjector](lambda ce: _maysync.create_maysync_injector(ce))

omlish/inject/sync.py

@@ -2,8 +2,7 @@ import abc
 import typing as ta
 
 from .. import lang
-from .elements import Elemental
-from .elements import as_elements
+from .injector import _InjectorCreator
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -44,5 +43,7 @@ class Injector(lang.Abstract):
         return self.provide(target)
 
 
-def create_injector(*args: Elemental) -> Injector:
-    return _sync.create_injector(as_elements(*args))
+##
+
+
+create_injector = _InjectorCreator[Injector](lambda ce: _sync.create_injector(ce))

omlish/lang/imports/proxy.py

@@ -342,6 +342,8 @@ def proxy_import(
         spec: str,
         package: str | None = None,
         extras: ta.Iterable[str] | None = None,
+        *,
+        no_cache: bool = False,
 ) -> types.ModuleType:
     """'Legacy' proxy import mechanism."""
 
@@ -352,12 +354,19 @@ def proxy_import(
 
     def __getattr__(att):  # noqa
         nonlocal omod
+
         if omod is None:
             omod = importlib.import_module(spec, package=package)
             if extras:
                 for x in extras:
                     importlib.import_module(f'{spec}.{x}', package=package)
-        return getattr(omod, att)
+
+        v = getattr(omod, att)
+
+        if not no_cache:
+            setattr(lmod, att, v)
+
+        return v
 
     lmod = types.ModuleType(spec)
     lmod.__getattr__ = __getattr__  # type: ignore[method-assign]

omlish/term/pager.py

@@ -0,0 +1,235 @@
+# ruff: noqa: S602 S605
+#
+#   Copyright 2000-2008 Michael Hudson-Doyle <micahel@gmail.com>
+#                       Armin Rigo
+#
+#                   All Rights Reserved
+#
+#
+# Permission to use, copy, modify, and distribute this software and its documentation for any purpose is hereby granted
+# without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and
+# this permission notice appear in supporting documentation.
+#
+# THE AUTHOR MICHAEL HUDSON 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, 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/python/cpython/tree/bcced02604f845b2b71d0a1dd95f95366bd7774d/Lib/_pyrepl
+import io
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import termios
+import tty
+import typing as ta
+
+from .. import check
+
+
+##
+
+
+class Pager(ta.Protocol):
+    def __call__(self, text: str, title: str = '') -> None:
+        ...
+
+
+def get_pager() -> Pager:
+    """Decide what method to use for paging through text."""
+
+    if not hasattr(sys.stdin, 'isatty'):
+        return plain_pager
+
+    if not hasattr(sys.stdout, 'isatty'):
+        return plain_pager
+
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return plain_pager
+
+    if sys.platform == 'emscripten':
+        return plain_pager
+
+    use_pager = os.environ.get('MANPAGER') or os.environ.get('PAGER')
+    if use_pager:
+        if sys.platform == 'win32':  # pipes completely broken in Windows
+            raise OSError
+
+        elif os.environ.get('TERM') in ('dumb', 'emacs'):
+            return lambda text, title='': pipe_pager(plain(text), use_pager, title)
+
+        else:
+            return lambda text, title='': pipe_pager(text, use_pager, title)
+
+    if os.environ.get('TERM') in ('dumb', 'emacs'):
+        return plain_pager
+
+    if sys.platform == 'win32':
+        return lambda text, title='': tempfile_pager(plain(text), 'more <')
+
+    if hasattr(os, 'system') and os.system('(pager) 2>/dev/null') == 0:
+        return lambda text, title='': pipe_pager(text, 'pager', title)
+
+    if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
+        return lambda text, title='': pipe_pager(text, 'less', title)
+
+    import tempfile
+    (fd, filename) = tempfile.mkstemp()
+    os.close(fd)
+    try:
+        if hasattr(os, 'system') and os.system(f'more "{filename}"') == 0:
+            return lambda text, title='': pipe_pager(text, 'more', title)
+
+        else:
+            return tty_pager
+
+    finally:
+        os.unlink(filename)
+
+
+def escape_stdout(text: str) -> str:
+    # Escape non-encodable characters to avoid encoding errors later
+    encoding = getattr(sys.stdout, 'encoding', None) or 'utf-8'
+    return text.encode(encoding, 'backslashreplace').decode(encoding)
+
+
+def escape_less(s: str) -> str:
+    return re.sub(r'([?:.%\\])', r'\\\1', s)
+
+
+def plain(text: str) -> str:
+    """Remove boldface formatting from text."""
+
+    return re.sub('.\b', '', text)
+
+
+def tty_pager(text: str, title: str = '') -> None:
+    """Page through text on a text terminal."""
+
+    lines = plain(escape_stdout(text)).split('\n')
+    has_tty = False
+    try:
+        fd = sys.stdin.fileno()
+        old = termios.tcgetattr(fd)
+        tty.setcbreak(fd)
+        has_tty = True
+
+        def getchar() -> str:
+            return sys.stdin.read(1)
+
+    except (ImportError, AttributeError, io.UnsupportedOperation):
+        def getchar() -> str:
+            return sys.stdin.readline()[:-1][:1]
+
+    try:
+        try:
+            h = int(os.environ.get('LINES', '0'))
+        except ValueError:
+            h = 0
+        if h <= 1:
+            h = 25
+        r = inc = h - 1
+
+        sys.stdout.write('\n'.join(lines[:inc]) + '\n')
+        while lines[r:]:
+            sys.stdout.write('-- more --')
+            sys.stdout.flush()
+            c = getchar()
+
+            if c in ('q', 'Q'):
+                sys.stdout.write('\r          \r')
+                break
+
+            elif c in ('\r', '\n'):
+                sys.stdout.write('\r          \r' + lines[r] + '\n')
+                r = r + 1
+                continue
+
+            if c in ('b', 'B', '\x1b'):
+                r = r - inc - inc
+                if r < 0:
+                    r = 0
+
+            sys.stdout.write('\n' + '\n'.join(lines[r:r + inc]) + '\n')
+            r = r + inc
+
+    finally:
+        if has_tty:
+            termios.tcsetattr(fd, termios.TCSAFLUSH, old)  # noqa
+
+
+def plain_pager(text: str, title: str = '') -> None:
+    """Simply print unformatted text. This is the ultimate fallback."""
+
+    sys.stdout.write(plain(escape_stdout(text)))
+
+
+def pipe_pager(text: str, cmd: str, title: str = '') -> None:
+    """Page through text by feeding it to another program."""
+
+    env = os.environ.copy()
+
+    if title:
+        title += ' '
+    esc_title = escape_less(title)
+
+    prompt_string = (
+        f' {esc_title}'
+        '?ltline %lt?L/%L.'
+        ':byte %bB?s/%s.'
+        '.'
+        '?e (END):?pB %pB\\%..'
+        ' (press h for help or q to quit)'
+    )
+
+    env['LESS'] = f'-RmPm{prompt_string}$PM{prompt_string}$'
+
+    proc = subprocess.Popen(
+        cmd,
+        shell=True,
+        stdin=subprocess.PIPE,
+        errors='backslashreplace',
+        env=env,
+    )
+
+    try:
+        with check.not_none(proc.stdin) as pipe:
+            try:
+                pipe.write(text)
+
+            except KeyboardInterrupt:
+                # We've hereby abandoned whatever text hasn't been written, but the pager is still in control of the
+                # terminal.
+                pass
+
+    except OSError:
+        pass  # Ignore broken pipes caused by quitting the pager program.
+
+    while True:
+        try:
+            proc.wait()
+            break
+
+        except KeyboardInterrupt:
+            # Ignore ctl-c like the pager itself does. Otherwise the pager is left running and the terminal is in raw
+            # mode and unusable.
+            pass
+
+
+def tempfile_pager(text: str, cmd: str, title: str = '') -> None:
+    """Page through text by invoking a program on a temporary file."""
+
+    with tempfile.TemporaryDirectory() as tempdir:
+        filename = os.path.join(tempdir, 'pydoc.out')
+
+        with open(
+                filename,
+                'w',
+                errors='backslashreplace',
+                encoding=os.device_encoding(0) if sys.platform == 'win32' else None,
+        ) as file:
+            file.write(text)
+
+        os.system(cmd + ' "' + filename + '"')