moat-src 0.3.1__tar.gz → 0.5.2__tar.gz

{moat-src-0.3.1/moat_src.egg-info → moat-src-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moat-src
-Version: 0.3.1
+Version: 0.5.2
 Summary: Tools for managing the MoaT sources
 Author-email: Matthias Urlichs <matthias@urlichs.de>
 Project-URL: homepage, https://m-o-a-t.org

{moat-src-0.3.1 → moat-src-0.5.2}/moat/src/_main.py

@@ -38,27 +38,26 @@ class Repo(git.Repo):
         mi = p.parts.index("moat")
         self.moat_name = "-".join(p.parts[mi:])
 
-    def subrepos(self, recurse=True, depth=True):
+    def subrepos(self, recurse=True, depth=True, same=True):
         """List subrepositories (and cache them)."""
 
-        if recurse and not depth:
+        if same and recurse and not depth:
             yield self
 
-        if "/lib/" in self.working_dir:
-            return
-        for r in self.submodules:
-            try:
-                res = self._subrepo_cache[r.path]
-            except KeyError:
-                p = Path(self.working_dir) / r.path
-                self._subrepo_cache[r.path] = res = Repo(p)
-                res.submod = r
-            if recurse:
-                yield from res.subrepos(depth=depth)
-            else:
-                yield res
+        if "/lib/" not in self.working_dir:
+            for r in self.submodules:
+                try:
+                    res = self._subrepo_cache[r.path]
+                except KeyError:
+                    p = Path(self.working_dir) / r.path
+                    self._subrepo_cache[r.path] = res = Repo(p)
+                    res.submod = r
+                if recurse:
+                    yield from res.subrepos(depth=depth)
+                else:
+                    yield res
 
-        if recurse and depth:
+        if same and recurse and depth:
             yield self
 
     def commits(self, ref=None):
@@ -444,10 +443,10 @@ async def setup(no_dirty, no_commit, skip, only, message, amend, no_amend):
 
     Default: amend if the text is identical and the prev head isn't tagged.
     """
-    repo = Repo(None)
+    repo = Repo()
     skip = set(skip)
     if only:
-        repos = (Repo(repo, x) for x in only)
+        repos = (Repo(x) for x in only)
     else:
         repos = (x for x in repo.subrepos(depth=True) if x.moat_name[5:] not in skip)
 
@@ -547,10 +546,13 @@ async def fix_main(repo):
 
     async def _fix(r):
         if not r.head.is_detached:
-            if r.head.ref.name != "main":
+            if r.head.ref.name not in {"main", "moat"}:
                 print(f"{r.working_dir}: Head is {r.head.ref.name !r}", file=sys.stderr)
             return
-        m = r.refs["main"]
+        if "moat" in r.refs:
+            m = r.refs["moat"]
+        else:
+            m = r.refs["main"]
         if m.commit != r.head.commit:
             ch = await run_process(
                 ["git", "-C", r.working_dir, "merge-base", m.commit.hexsha, r.head.commit.hexsha],
@@ -564,7 +566,6 @@ async def fix_main(repo):
             m.set_reference(ref=r.head.commit, logmsg="fix_main")
         r.head.set_reference(ref=m, logmsg="fix_main 2")
 
-    await _fix(repo)
     for r in repo.subrepos():
         await _fix(r)
 
@@ -608,7 +609,7 @@ async def push(obj, remote):
 
 @cli.command()
 @click.option("-r", "--remote", type=str, help="Remote to fetch. Default: probably 'origin'.")
-@click.option("-b", "--branch", type=str, default="main", help="Branch to merge.")
+@click.option("-b", "--branch", type=str, default=None, help="Branch to merge.")
 @click.pass_obj
 async def pull(obj, remote, branch):
     """Fetch updates"""
@@ -631,7 +632,9 @@ async def pull(obj, remote, branch):
             elif obj.debug > 1:
                 cmd.append("-v")
             if remote is not None:
-                cmd.append(remote if branch is None else f"{remote}/{branch}")
+                if branch is None:
+                    branch = "moat" if "moat" in r.refs else "main"
+                cmd.append(f"{remote}/{branch}")
             await run_process(cmd, input=None, stdout=sys.stdout, stderr=sys.stderr)
 
         except subprocess.CalledProcessError as exc:
@@ -692,6 +695,10 @@ async def build(version, no_test, no_commit, no_dirty, cache):
 
         heads[r.moat_name] = r.commit().hexsha
         t = r.tagged(r.head.commit)
+        if t is not None:
+            if r.is_dirty(index=False, working_tree=False, untracked_files=False, submodules=True):
+                t = None
+
         if t is None:
             for c in r.commits():
                 t = r.tagged(c)
@@ -720,7 +727,7 @@ async def build(version, no_test, no_commit, no_dirty, cache):
 
     dirty = set()
 
-    check = check1 = True
+    check = True
 
     while check:
         check = False
@@ -752,17 +759,10 @@ async def build(version, no_test, no_commit, no_dirty, cache):
                 for v in deps.values():
                     work = fix_deps(v, tags) | work
 
-            if check1:
-                if r.is_dirty(
-                    index=True, working_tree=True, untracked_files=False, submodules=True
-                ):
-                    for rr in r.subrepos(recurse=False):
-                        r.git.add(rr.working_dir)
-                    work = True
-
             if work:
                 p.write_text(pr.as_string())
                 r.index.add(p)
+            if work or r.is_dirty(index=False, working_tree=False, submodules=True):
                 dirty.add(r)
                 t = tags[r.moat_name]
                 if not isinstance(t, str):
@@ -771,41 +771,27 @@ async def build(version, no_test, no_commit, no_dirty, cache):
                     tags[r.moat_name] = t
                 check = True
 
-        check1 = False
-
     if bad:
         print("Partial work done. Fix and try again.")
         return
 
     if not no_commit:
-        for r in dirty:
-            r.index.commit("Update MoaT requirements")
-
-        if repo.is_dirty(index=True, working_tree=True, untracked_files=False, submodules=True):
-            for r in repo.subrepos():
-                if r is repo:
-                    continue
-                t = tags[r.moat_name]
-                if isinstance(t, str):
-                    r.create_tag(t)
+        for r in repo.subrepos(depth=True):
+            if not r.is_dirty(
+                index=True, working_tree=True, untracked_files=False, submodules=True
+            ):
+                continue
 
-            for r in repo.subrepos(recurse=False):
-                repo.git.add(r.working_dir)
-            repo.index.commit("Update")
+            if r in dirty:
+                r.index.commit("Update MoaT requirements")
 
-        for c in repo.commits():
-            t = repo.tagged(c)
-            if t is not None:
-                break
-        else:
-            print("NO TAG", repo.moat_name)
-            return
-
-        xt, t = t.name.rsplit(".", 1)
-        t = f"{xt}.{int(t)+1}"
+            for rr in r.subrepos(recurse=False):
+                r.git.add(rr.working_dir)
+            r.index.commit("Submodule Update")
 
-        print("New:", t)
-        repo.create_tag(t)
+            t = tags[r.moat_name]
+            if isinstance(t, str):
+                r.create_tag(t)
 
 
 add_repr(tomlkit.items.String)

{moat-src-0.3.1 → moat-src-0.5.2}/moat/src/_templates/make/py

@@ -15,6 +15,8 @@ CODE ?= $(subst -,/,$(PACKAGE))
 BUILD_DIR ?= build
 INPUT_DIR ?= docs/source
 
+RQ := grep -qs tool.ruff pyproject.toml
+
 # Sphinx options (are passed to build_docs, which passes them to sphinx-build)
 #   -W       : turn warning into errors
 #   -a       : write all files
@@ -60,16 +62,21 @@ cov:
 
 test: statictest pytest
 statictest:
-	black --check $(CODE) $(TESTS) $(SETUP)
-	python3 -misort --check $(CODE) $(TESTS) $(SETUP)
-	flake8p $(CODE) $(TESTS) $(SETUP)
-	pylint $(CODE) $(TESTS) $(SETUP)
+	${RQ} || black --check $(CODE) $(TESTS) $(SETUP)
+	${RQ} || python3 -misort --check $(CODE) $(TESTS) $(SETUP)
+	${RQ} || flake8p $(CODE) $(TESTS) $(SETUP)
+	${RQ} || pylint $(CODE) $(TESTS) $(SETUP)
+	${RQ} && ruff format $(CODE) $(TESTS) $(SETUP)
+	${RQ} && ruff check $(CODE) $(TESTS) $(SETUP)
+
 pytest:
 	$(PYTEST) $(PYTEST_OPTIONS) $(TESTS)
 
 format:
-	black $(CODE) $(TESTS) $(SETUP)
-	python3 -misort $(CODE) $(TESTS) $(SETUP)
+	${RQ} || black $(CODE) $(TESTS) $(SETUP)
+	${RQ} || python3 -misort $(CODE) $(TESTS) $(SETUP)
+	${RQ} && ruff format $(CODE) $(TESTS) $(SETUP)
+	${RQ} && ruff check --fix $(CODE) $(TESTS) $(SETUP)
 
 precommit: format test
 

{moat-src-0.3.1 → moat-src-0.5.2}/moat/src/_templates/pyproject.default.yaml

@@ -27,6 +27,75 @@ project:
     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:
+    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
+    preview: true
+    explicit-preview-rules: true
+    line-length: 99
+    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
   black:
     line-length: 99
   flake8:

{moat-src-0.3.1 → moat-src-0.5.2}/moat/src/test.py

@@ -5,6 +5,7 @@ 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
@@ -41,6 +42,10 @@ async def run(*args, expect_exit=0, do_stdout=True):
         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
@@ -48,6 +53,35 @@ async def run(*args, expect_exit=0, do_stdout=True):
         assert expect_exit == 0
         return res
     finally:
+        if res is None:
+            res = attrdict()
         if do_stdout:
             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
+        pass
+    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)

{moat-src-0.3.1 → moat-src-0.5.2/moat_src.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moat-src
-Version: 0.3.1
+Version: 0.5.2
 Summary: Tools for managing the MoaT sources
 Author-email: Matthias Urlichs <matthias@urlichs.de>
 Project-URL: homepage, https://m-o-a-t.org

{moat-src-0.3.1 → moat-src-0.5.2}/tests/test_basic.py

@@ -3,6 +3,7 @@ Empty test file
 """
 
 import moat.src  # pylint: disable=unused-import
+from moat.src.test import raises
 
 
 def test_nothing():
@@ -10,3 +11,7 @@ def test_nothing():
     Empty test
     """
     pass  # pylint: disable=unnecessary-pass
+    with raises(SyntaxError):
+        raise SyntaxError("foo")
+
+