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

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

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

build/lib/moat/src/_templates/pyproject.default.yaml

@@ -0,0 +1,146 @@
+project:
+  authors:
+  - email: matthias@urlichs.de
+    name: Matthias Urlichs
+  classifiers:
+  - 'Intended Audience :: Developers'
+  - 'Programming Language :: Python :: 3'
+  - 'Framework :: AsyncIO'
+  - 'Framework :: Trio'
+  - 'Framework :: Trio'
+  - 'Intended Audience :: Developers'
+  - 'License :: OSI Approved'
+  - 'Development Status :: 4 - Beta'
+  dependencies:
+  - anyio ~= 3.0
+  description: REPLACE ME
+  dynamic:
+  - version
+  keywords:
+  - MoaT
+  license:
+    file: LICENSE.txt
+  name: SUBUNDER
+  readme: README.rst
+  requires-python: '>=3.8'
+  urls:
+    homepage: https://m-o-a-t.org
+    repository: https://github.com/M-o-a-T/SUBNAME
+tool:
+  pytest:
+    ini_options:
+      log_cli_level: DEBUG
+  ruff:
+    lint:
+      select:
+      - ALL
+      ignore:
+      - ANN
+      - PTH
+      - PERF
+      - D105
+      - D107
+      - A003
+      - S101
+      - RUF001
+      - RUF002
+      - PLW1514
+      - D2
+      - D3
+      - D4
+      - T2
+      - FBT
+      - TRY003
+      - EM10
+      - PLR
+      - C
+      - RET50
+      - TD
+      - FIX
+      - N
+      - ERA
+      - BLE001
+      explicit-preview-rules: true
+      flake8-comprehensions:
+        allow-dict-calls-with-keyword-arguments: true
+      flake8-builtins:
+        builtins-ignorelist:
+        - id
+        - help
+      isort:
+        no-lines-before:
+        - future
+        required-imports:
+        - "from __future__ import annotations"
+        section-order:
+        - future
+        - typing
+        - standard-library
+        - first-party
+        - upy
+        - moat
+        - local-folder
+        - third-party
+        extra-standard-library:
+        - pytest
+        - anyio
+        force-to-top:
+        - moat.util
+        sections:
+          moat:
+          - moat
+          upy:
+          - micropython
+          - machine
+          - esp
+          typing:
+          - typing
+    preview: true
+    line-length: 99
+  black:
+    line-length: 99
+  flake8:
+    max-line-length: 99
+    ignore:
+    - E123
+    - E127
+    - E203
+    - E231
+    - E402
+    - E502
+    - E731
+    - F401  # covered by pylint
+    - F841  # covered by pylint
+    - W503
+  setuptools:
+    packages:
+    - SUBDOT
+    package-data:
+      "*": [ "*.yaml" ]
+  setuptools_scm: {}
+  pylint:
+    messages_control:
+      disable:
+      - fixme
+      - invalid-name
+      - no-else-continue
+      - no-else-return
+      - superfluous-parens
+      - too-few-public-methods
+      - too-many-arguments
+      - too-many-branches
+      - too-many-instance-attributes
+      - too-many-locals
+      - too-many-nested-blocks
+      - too-many-return-statements
+      - too-many-statements
+      - ungrouped-imports
+      - unspecified-encoding
+      - use-dict-literal
+      - wrong-import-order
+  tox:
+    tox:
+      isolated_build: True
+      envlist:
+      - check
+

build/lib/moat/src/_templates/pyproject.forced.yaml

@@ -0,0 +1,77 @@
+build-system:
+  build-backend: setuptools.build_meta
+  requires:
+  - setuptools
+  - wheel
+  - setuptools-scm
+project:
+  classifiers:
+  - 'Intended Audience :: Developers'
+  - 'Programming Language :: Python :: 3'
+  - 'Framework :: AsyncIO'
+  - 'Framework :: Trio'
+  - 'Framework :: AnyIO'
+  - 'Intended Audience :: Developers'
+  - 'License :: OSI Approved'
+  - 'Development Status :: 4 - Beta'
+  dependencies:
+  - anyio ~= 3.0
+  dynamic:
+  - version
+  keywords:
+  - MoaT
+  license:
+    file: LICENSE.txt
+  requires-python: '>=3.8'
+  urls:
+    homepage: https://m-o-a-t.org
+  name: SUBNAME
+tool:
+  moat:
+    fixup: |
+        try:
+            toml["tool"]["tox"]["tox"]["envlist"].remove("py39")
+        except(KeyError,ValueError):
+            pass
+  flake8:
+    max-line-length: 99
+    ignore:
+    - W503
+    - E231
+    - E203
+
+  isort:
+    line_length: 99
+    multi_line_output: 3
+    trailing_comma: DELETE
+    profile: black
+  setuptools_scm: {}
+
+  tox:
+    tox:
+      isolated_build: True
+      envlist:
+      - check
+      - py310
+
+    testenv:
+      setenv:
+      - "PYTHONPATH = {env:PYTHONPATH}{:}{toxinidir}"
+      deps:
+      - pytest
+      - trio
+      commands:
+      - python3 -mpytest tests/
+
+    "testenv:check":
+      commands:
+      - black --check moat tests
+      - flake8p moat tests
+      - pylint moat tests
+      deps:
+      - flake8
+      - flake8-pyproject
+      - black
+      - pylint
+      - pytest
+

build/lib/moat/src/inspect.py

@@ -0,0 +1,65 @@
+"""
+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

@@ -0,0 +1,89 @@
+"""
+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)