moat-src 0.8.4__py3-none-any.whl → 0.8.10__py3-none-any.whl

build/lib/moat/src/_templates/moat/__init__.py

@@ -1,3 +0,0 @@
-from __future__ import annotations
-
-__path__ = __import__("pkgutil").extend_path(__path__, __name__)

build/lib/moat/src/inspect.py

@@ -1,65 +0,0 @@
-"""
-This Trio inspector is geared towards figuring out why the *censored* a
-task is cancelled when no exception shows up.
-
-"""
-
-from __future__ import annotations
-
-import inspect
-import logging
-
-from asyncscope import scope as sc
-
-logger = logging.getLogger("trio.inspect")
-
-
-def debug(*a):
-    "logging helper"
-    s = sc.get()
-    (logger if s is None else s.logger).debug(*a)
-
-
-class CancelTracer:
-    """A Trio inspect module that helps tracking cancel scopes"""
-
-    # pylint: disable=missing-function-docstring,protected-access
-    def __init__(self):
-        pass
-
-    def skip(self, scope):
-        if scope._stack is None:
-            return True
-        if scope._stack[5].f_code.co_name == "connect_tcp":
-            return True
-        return False
-
-    def scope_entered(self, scope):
-        scope._stack = s = []
-        f = inspect.currentframe().f_back
-        while f:
-            s.append(f)
-            f = f.f_back
-
-        if self.skip(scope):
-            return
-
-        debug("EnterCS %r", scope)
-
-    def scope_exited(self, scope):
-        if self.skip(scope):
-            return
-        debug("ExitCS %r", scope)
-
-    def scope_cancelled(self, scope, reason):
-        if self.skip(scope):
-            return
-        #       if reason.value == 0:
-        #           breakpoint()
-        debug("KillCS %r %s", scope, reason.name)
-
-    def task_spawned(self, task):
-        debug("EnterT %r", task)
-
-    def task_exited(self, task):
-        debug("ExitT %r", task)

build/lib/moat/src/test.py

@@ -1,89 +0,0 @@
-"""
-MoaT test support
-"""
-
-from __future__ import annotations
-
-import io
-import logging
-import shlex
-import sys
-from contextlib import contextmanager
-
-from asyncscope import main_scope, scope
-from moat.util import OptCtx, attrdict, wrap_main  # pylint:disable=no-name-in-module
-
-logger = logging.getLogger(__name__)
-
-
-async def run(*args, expect_exit=0, do_stdout=True):
-    """Call a MoaT command handler"""
-    args = ("-c", "/dev/null", *args)
-    CFG = {}  # load_cfg("moat")
-
-    if do_stdout:
-        CFG["_stdout"] = out = io.StringIO()
-    logger.debug(" moat %s", " ".join(shlex.quote(str(x)) for x in args))
-    try:
-        res = None
-        async with (
-            OptCtx(main_scope(name="run") if scope.get() is None else None),
-            scope.using_scope(),
-        ):
-            res = await wrap_main(
-                args=args,
-                wrap=True,
-                CFG=CFG,
-                cfg=False,
-                name="moat",
-                sub_pre="moat",
-                sub_post="_main.cli",
-            )
-        if res is None:
-            res = attrdict()
-        return res
-    except SystemExit as exc:
-        res = exc
-        assert exc.code == expect_exit, exc.code
-        return exc
-    except Exception as exc:
-        while isinstance(exc, ExceptionGroup) and len(exc.exceptions) == 1:
-            exc = exc.exceptions[0]
-        raise exc
-    except BaseException as exc:
-        res = exc
-        raise
-    else:
-        assert expect_exit == 0
-        return res
-    finally:
-        if do_stdout:
-            if res is not None:
-                res.stdout = out.getvalue()
-            CFG["_stdout"] = sys.stdout
-
-
-class DidNotRaise(Exception):
-    pass
-
-
-@contextmanager
-def raises(*exc):
-    """
-    Like pytest.raises, but handles exception groups
-    """
-    res = attrdict()
-    try:
-        yield res
-    except exc as e:
-        res.value = e
-    except ExceptionGroup as e:
-        while isinstance(e, ExceptionGroup) and len(e.exceptions) == 1:
-            e = e.exceptions[0]
-        res.value = e
-        if isinstance(e, exc):
-            return
-        raise
-    else:
-        res.value = None
-        raise DidNotRaise(exc)