moat-src 0.8.5__py3-none-any.whl → 0.8.11__py3-none-any.whl

moat/src/_main.py

@@ -13,33 +13,34 @@ from pathlib import Path
 import asyncclick as click
 import git
 import tomlkit
-from anyio import run_process
 from moat.util import P, add_repr, attrdict, make_proc, yload, yprint
 from packaging.requirements import Requirement
-from attrs import define,field
-from shutil import rmtree,copyfile,copytree
+from attrs import define, field
+from shutil import rmtree, copyfile, copytree
 from contextlib import suppress
 
 logger = logging.getLogger(__name__)
 
-PACK=Path("packaging")
-ARCH=subprocess.check_output(["dpkg","--print-architecture"]).decode("utf-8").strip()
+PACK = Path("packaging")
+ARCH = subprocess.check_output(["dpkg", "--print-architecture"]).decode("utf-8").strip()
 
-def dash(n:str) -> str:
+
+def dash(n: str) -> str:
     """
     moat.foo.bar > foo-bar
     foo.bar > ext-foo-bar
     """
-    if n in ("main","moat"):
+    if n in ("main", "moat"):
         return "main"
     if "." not in n:  # also applies to single-name packages
         return n
 
     if not n.startswith("moat."):
-        return "ext-"+n.replace("-",".")
-    return n.replace(".","-")[5:]
+        return "ext-" + n.replace("-", ".")
+    return n.replace(".", "-")[5:]
+
 
-def undash(n:str) -> str:
+def undash(n: str) -> str:
     """
     foo-bar > moat.foo.bar
     ext-foo-bar > foo.bar
@@ -47,85 +48,97 @@ def undash(n:str) -> str:
     if "." in n:
         return n
 
-    if n in ("main","moat"):
+    if n in ("main", "moat"):
         return "moat"
     if n.startswith("ext-"):
-        return n.replace("-",".")[4:]
-    return "moat."+n.replace("-",".")
+        return n.replace("-", ".")[4:]
+    return "moat." + n.replace("-", ".")
+
 
 class ChangedError(RuntimeError):
-    def __init__(subsys,tag,head):
+    def __init__(subsys, tag, head):
         self.subsys = subsys
         self.tag = tag
         self.head = head
+
     def __str__(self):
         s = self.subsys or "Something"
         if head is None:
-            head="HEAD"
+            head = "HEAD"
         else:
             head = head.hexsha[:9]
         return f"{s} changed between {tag.name} and {head}"
 
-class _Common:
 
-    def next_tag(self,major:bool=False,minor:bool=False):
+class _Common:
+    def next_tag(self, major: bool = False, minor: bool = False):
         tag = self.last_tag
         try:
-            n = [ int(x) for x in tag.split('.') ]
+            n = [int(x) for x in tag.split(".")]
             if len(n) != 3:
                 raise ValueError(n)
         except ValueError:
             raise ValueError(f"Tag {tag} not in major#.minor#.patch# form.") from None
 
         if major:
-            n = [n[0]+1,0,0]
+            n = [n[0] + 1, 0, 0]
         elif minor:
-            n = [n[0],n[1]+1,0]
+            n = [n[0], n[1] + 1, 0]
         else:
-            n = [n[0],n[1],n[2]+1]
+            n = [n[0], n[1], n[2] + 1]
         return ".".join(str(x) for x in n)
 
+
 @define
 class Package(_Common):
-    _repo:Repo = field(repr=False)
-    name:str = field()
-    under:str = field(init=False,repr=False)
-    path:Path = field(init=False,repr=False)
-    files:set(Path) = field(init=False,factory=set,repr=False)
-    subs:dict[str,Package] = field(factory=dict,init=False,repr=False)
-    hidden:bool = field(init=False,repr=False)
+    _repo: Repo = field(repr=False)
+    name: str = field()
+    under: str = field(init=False, repr=False)
+    path: Path = field(init=False, repr=False)
+    files: set(Path) = field(init=False, factory=set, repr=False)
+    subs: dict[str, Package] = field(factory=dict, init=False, repr=False)
+    hidden: bool = field(init=False, repr=False)
 
     def __init__(self, repo, name):
-        self.__attrs_init__(repo,name)
-        self.under = name.replace(".","_")
+        self.__attrs_init__(repo, name)
+        self.under = name.replace(".", "_")
         self.path = Path(*name.split("."))
-        self.hidden = not (PACK/self.dash).exists()
+        self.hidden = not (PACK / self.dash).exists()
 
     @property
     def dash(self):
         return dash(self.name)
 
     def __eq__(self, other):
-        return self.name==other.name
+        return self.name == other.name
 
     def __hash__(self):
         return hash(self.name)
 
+    @property
+    def verstr(self):
+        v=self.vers
+        return f"{v.tag}-{v.pkg}"
+
     @property
     def vers(self):
-        v = self._repo.versions[self.dash]
-        if not isinstance(v,dict):
-            tag,commit = v
-            v = attrdict(
-                tag=tag,
-                pkg=1,
-                rev=commit,
-            )
-            self._repo.versions[self.dash] = v
+        try:
+            v = self._repo.versions[self.dash]
+        except KeyError:
+            self._repo.versions[self.dash] = v = attrdict()
+        else:
+            if not isinstance(v, dict):
+                tag, commit = v
+                v = attrdict(
+                    tag=tag,
+                    pkg=1,
+                    rev=commit,
+                )
+                self._repo.versions[self.dash] = v
         return v
 
     @vers.setter
-    def vers(self,d):
+    def vers(self, d):
         v = self.vers
         v.update(d)
         return v
@@ -140,13 +153,13 @@ class Package(_Common):
 
     @property
     def mdash(self):
-        d=dash(self.name)
+        d = dash(self.name)
         if d.startswith("ext-"):
             return d[4:]
         else:
-            return "moat-"+d
+            return "moat-" + d
 
-    def populate(self, path:Path, real=None):
+    def populate(self, path: Path, real=None):
         """
         Collect this package's file names.
         """
@@ -154,7 +167,7 @@ class Package(_Common):
         for fn in path.iterdir():
             if fn.name == "__pycache__":
                 continue
-            if (sb := self.subs.get(fn.name,None)) is not None:
+            if (sb := self.subs.get(fn.name, None)) is not None:
                 sb.populate(fn, real=self if sb.hidden else None)
             else:
                 (real or self).files.add(fn)
@@ -165,41 +178,49 @@ class Package(_Common):
         """
         if not self.files:
             raise ValueError(f"No files in {self.name}?")
-        p = Path("packaging")/self.dash
+        p = Path("packaging") / self.dash / "src"
         with suppress(FileNotFoundError):
-            rmtree(p/"moat")
-        dest = p/self.path
+            rmtree(p / "moat")
+        dest = p / self.path
         dest.mkdir(parents=True)
         for f in self.files:
-            pf=p/f
-            pf.parent.mkdir(parents=True,exist_ok=True)
+            pf = p / f
+            pf.parent.mkdir(parents=True, exist_ok=True)
             if f.is_dir():
                 copytree(f, pf, symlinks=False)
             else:
                 copyfile(f, pf, follow_symlinks=True)
-        licd = p/"LICENSE.txt"
+
+        p = Path("packaging") / self.dash
+        licd = p / "LICENSE.txt"
         if not licd.exists():
             copyfile("LICENSE.txt", licd)
 
-    def has_changes(self, main:bool|None=None) -> bool:
+    def has_changes(self, main: bool | None = None) -> bool:
         """
         Test whether the given subsystem changed
         between the head and the @tag commit
         """
-        commit = self.last_commit
         head = self._repo.head.commit
+        try:
+            lc = self.last_commit
+        except AttributeError:
+            return True
         for d in head.diff(self.last_commit):
-            if self._repo.repo_for(d.a_path, main) != self.name and self._repo.repo_for(d.b_path, main) != self.name:
+            if (
+                self._repo.repo_for(d.a_path, main) != self.name
+                and self._repo.repo_for(d.b_path, main) != self.name
+            ):
                 continue
             return True
         return False
 
 
-class Repo(git.Repo,_Common):
+class Repo(git.Repo, _Common):
     """Amend git.Repo with tag caching and pseudo-submodule splitting"""
 
     moat_tag = None
-    _last_tag=None
+    _last_tag = None
 
     def __init__(self, *a, **k):
         super().__init__(*a, **k)
@@ -219,13 +240,12 @@ class Repo(git.Repo,_Common):
             self.versions = yload(f, attr=True)
 
     def write_tags(self):
-        with open("versions.yaml","w") as f:
-            yprint(self.versions,f)
+        with open("versions.yaml", "w") as f:
+            yprint(self.versions, f)
         self.index.add("versions.yaml")
 
-
     @property
-    def last_tag(self) -> Tag|None:
+    def last_tag(self) -> Tag | None:
         """
         Return the most-recent tag for this repo
         """
@@ -240,7 +260,7 @@ class Repo(git.Repo,_Common):
             self._last_tag = t
             return t
 
-        raise ValueError(f"No tags found")
+        raise ValueError("No tags found")
 
     @property
     def last_commit(self) -> str:
@@ -259,7 +279,7 @@ class Repo(git.Repo,_Common):
     def parts(self):
         return self._repos.values()
 
-    def tags_of(self, c:Commit) -> Sequence[Tag]:
+    def tags_of(self, c: Commit) -> Sequence[Tag]:
         return self._commit_tags[c]
 
     def _add_repo(self, name):
@@ -268,10 +288,10 @@ class Repo(git.Repo,_Common):
         if dn in self._repos:
             return self._repos[dn]
 
-        p = Package(self,pn)
+        p = Package(self, pn)
         self._repos[dn] = p
         if "." in pn:
-            par,nam = pn.rsplit(".",1)
+            par, nam = pn.rsplit(".", 1)
             pp = self._add_repo(par)
             pp.subs[nam] = p
         return p
@@ -287,18 +307,18 @@ class Repo(git.Repo,_Common):
 
         self._repos["main"].populate(Path("moat"))
 
-    def repo_for(self, path:Path|str, main:bool|None) -> str:
+    def repo_for(self, path: Path | str, main: bool | None) -> str:
         """
         Given a file path, returns the subrepo in question
         """
         sc = self._repos["main"]
-        path=Path(path)
+        path = Path(path)
 
         if main is not False and path.parts[0] == "moat":
             name = "moat"
             for p in path.parts[1:]:
                 if p in sc.subs:
-                    name += "."+p
+                    name += "." + p
                     sc = sc.subs[p]
                 else:
                     break
@@ -312,7 +332,6 @@ class Repo(git.Repo,_Common):
 
         return None
 
-
     def commits(self, ref=None):
         """Iterate over topo sort of commits following @ref, or HEAD.
 
@@ -334,7 +353,7 @@ class Repo(git.Repo,_Common):
             yield ref
             work.extend(ref.parents)
 
-    def has_changes(self, main:bool|None=None) -> bool:
+    def has_changes(self, main: bool | None = None) -> bool:
         """
         Test whether any subsystem changed since the "tagged" commit
 
@@ -348,8 +367,7 @@ class Repo(git.Repo,_Common):
             return True
         return False
 
-
-    def tagged(self, c:Commit=None) -> Tag|None:
+    def tagged(self, c: Commit = None) -> Tag | None:
         """Return a commit's tag name.
         Defaults to the head commit.
         Returns None if no tag, raises ValueError if more than one is found.
@@ -371,7 +389,6 @@ class Repo(git.Repo,_Common):
         return tt[0].name
 
 
-
 @click.group(short_help="Manage MoaT itself")
 async def cli():
     """
@@ -393,22 +410,27 @@ def fix_deps(deps: list[str], tags: dict[str, str]) -> bool:
     return work
 
 
-def run_tests(pkg: str|None, *opts) -> bool:
+def run_tests(pkg: str | None, *opts) -> bool:
     """Run subtests for subpackage @pkg."""
 
     if pkg is None:
         tests = Path("tests")
     else:
-        tests = dash(pkg).replace("-","_")
-        tests = Path("tests")/tests
+        tests = dash(pkg).replace("-", "_")
+        tests = Path("tests") / tests
 
     if not Path(tests):
         # No tests. Assume it's OK.
         return True
     try:
         print("\n*** Testing:", pkg)
-        # subprocess.run(["python3", "-mtox"], cwd=repo.working_dir, check=True)
-        subprocess.run(["python3","-mpytest", *opts, tests], stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr, check=True)
+        subprocess.run(
+            ["python3", "-mpytest", *opts, tests],
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+            check=True,
+        )
     except subprocess.CalledProcessError:
         return False
     else:
@@ -550,18 +572,32 @@ def apply_hooks(repo, force=False):
 
     pt = Path(__file__).parent / "_hooks"
     for f in pt.iterdir():
-        if not force:
-            if f.name in seen:
-                continue
+        if not force and f.name in seen:
+            continue
         t = h / f.name
         d = f.read_text()
         t.write_text(d)
         t.chmod(0o755)
 
 
-def apply_templates(repo):
+@cli.command
+@click.argument("part", type=str)
+def setup(part):
     """
-    Apply templates to this repo.
+    Create a new MoaT subcommand.
+    """
+    repo = Repo(None)
+    if "-" in part:
+        part = undash(part)
+
+    (Path("packaging") / dash(part)).mkdir()
+    (Path("packaging") / dash(part)).mkdir()
+    apply_templates(repo, part)
+
+
+def apply_templates(repo: Repo, part):
+    """
+    Apply template files to this component.
     """
     commas = (
         P("tool.tox.tox.envlist"),
@@ -569,14 +605,11 @@ def apply_templates(repo):
         P("tool.pylint.messages_control.disable"),
     )
 
-    rpath = Path(repo.working_dir)
-    mti = rpath.parts.index("moat")
-    mtp = rpath.parts[mti:]
-
-    rname = "-".join(mtp)
-    rdot = ".".join(mtp)
-    rpath = "/".join(mtp)
-    runder = "_".join(mtp)
+    pt = part.split(".")
+    rname = dash(part)
+    rdot = part
+    rpath = "/".join(pt)
+    runder = "_".join(pt)
     repl = Replace(
         SUBNAME=rname,
         SUBDOT=rdot,
@@ -584,7 +617,7 @@ def apply_templates(repo):
         SUBUNDER=runder,
     )
     pt = (Path(__file__).parent / "_templates").joinpath
-    pr = Path(repo.working_dir).joinpath
+    pr = Path.cwd().joinpath
     with pt("pyproject.forced.yaml").open("r") as f:
         t1 = yload(f)
     with pt("pyproject.default.yaml").open("r") as f:
@@ -592,27 +625,13 @@ def apply_templates(repo):
     try:
         with pr("pyproject.toml").open("r") as f:
             proj = tomlkit.load(f)
-        try:
-            tx = proj["tool"]["tox"]["legacy_tox_ini"]
-        except KeyError:
-            pass
-        else:
-            txp = RawConfigParser()
-            txp.read_string(tx)
-            td = {}
-            for k, v in txp.items():
-                td[k] = ttd = dict()
-                for kk, vv in v.items():
-                    if isinstance(vv, str) and vv[0] == "\n":
-                        vv = [x.strip() for x in vv.strip().split("\n")]
-                    ttd[kk] = vv
-            proj["tool"]["tox"] = td
 
         for p in commas:
             decomma(proj, p)
 
     except FileNotFoundError:
         proj = tomlkit.TOMLDocument()
+
     mod = default_dict(t1, proj, t2, repl=repl, cls=tomlkit.items.Table)
     try:
         proc = proj["tool"]["moat"]["fixup"]
@@ -630,31 +649,7 @@ def apply_templates(repo):
         for p in commas:
             encomma(proj, p)
 
-        try:
-            tx = proj["tool"]["tox"]
-        except KeyError:
-            pass
-        else:
-            txi = io.StringIO()
-            txp = RawConfigParser()
-            for k, v in tx.items():
-                if k != "DEFAULT":
-                    txp.add_section(k)
-                for kk, vv in v.items():
-                    if isinstance(vv, (tuple, list)):
-                        vv = "\n   " + "\n   ".join(str(x) for x in vv)
-                    txp.set(k, kk, vv)
-            txp.write(txi)
-            txi = txi.getvalue()
-            txi = "\n" + txi.replace("\n\t", "\n ")
-            proj["tool"]["tox"] = dict(
-                legacy_tox_ini=tomlkit.items.String.from_raw(
-                    txi,
-                    type_=tomlkit.items.StringType.MLB,
-                ),
-            )
-
-        projp = Path(repo.working_dir) / "pyproject.toml"
+        projp = Path("packaging") / rname / "pyproject.toml"
         projp.write_text(proj.as_string())
         repo.index.add(projp)
 
@@ -678,6 +673,11 @@ def apply_templates(repo):
         pr("moat", "__init__.py").write_text(init)
         repo.index.add(pr("moat", "__init__.py"))
 
+    if not pr("moat", "_main.py").exists():
+        main = repl(pt("moat", "_main.py").read_text())
+        pr("moat", "_main.py").write_text(main)
+        repo.index.add(pr("moat", "_main.py"))
+
     tst = pr("tests")
     if not tst.is_dir():
         tst.mkdir()
@@ -732,16 +732,17 @@ def tags():
         else:
             print(f"{r.dash} {tag}")
 
+
 @cli.command()
 @click.option("-r", "--run", is_flag=True, help="actually do the tagging")
 @click.option("-m", "--minor", is_flag=True, help="create a new minor version")
 @click.option("-M", "--major", is_flag=True, help="create a new major version")
 @click.option("-s", "--subtree", type=str, help="Tag this partial module")
 @click.option("-v", "--tag", "force", type=str, help="Use this explicit tag value")
-@click.option("-q", "--query","--show","show", is_flag=True, help="Show the latest tag")
-@click.option("-f", "--force","FORCE", is_flag=True, help="replace an existing tag")
+@click.option("-q", "--query", "--show", "show", is_flag=True, help="Show the latest tag")
+@click.option("-f", "--force", "FORCE", is_flag=True, help="replace an existing tag")
 @click.option("-b", "--build", is_flag=True, help="set/increment the build number")
-def tag(run,minor,major,subtree,force,FORCE,show,build):
+def tag(run, minor, major, subtree, force, FORCE, show, build):
     """
     Tag the repository (or a subtree).
 
@@ -782,48 +783,56 @@ def tag(run,minor,major,subtree,force,FORCE,show,build):
     elif FORCE or build:
         tag = r.last_tag
     else:
-        tag = r.next_tag(major,minor)
+        tag = r.next_tag(major, minor)
 
     if run or subtree:
         if subtree:
             sb = repo.part(r.dash)
             if build:
                 sb.vers.pkg += 1
-                sb.vers.rev=repo.head.commit.hexsha
+                sb.vers.rev = repo.head.commit.hexsha
             else:
                 sb.vers = attrdict(
                     tag=tag,
                     pkg=1,
                     rev=repo.head.commit.hexsha,
-                    )
+                )
             repo.write_tags()
         else:
-            git.TagReference.create(repo,tag, force=FORCE)
+            git.TagReference.create(repo, tag, force=FORCE)
         print(f"{tag}")
     else:
         print(f"{tag} DRY_RUN")
 
 
-@cli.command(epilog="""
+@cli.command(
+    epilog="""
 The default for building Debian packages is '--no-sign --build=binary'.
 '--no-sign' is dropped when you use '--deb'.
 The binary-only build is currently unconditional.
 
 The default for uploading to Debian via 'dput' is '--unchecked ext';
 it is dropped when you use '--dput'.
-""")
+""",
+)
 @click.option("-f", "--no-dirty", is_flag=True, help="don't check for dirtiness (DANGER)")
 @click.option("-F", "--no-tag", is_flag=True, help="don't check for tag uptodate-ness (DANGER)")
 @click.option("-D", "--no-deb", is_flag=True, help="don't build Debian packages")
 @click.option("-C", "--no-commit", is_flag=True, help="don't commit the result")
-@click.option("-V", "--no-version", is_flag=True, help="don't update dependency versions in pyproject files")
+@click.option(
+    "-V",
+    "--no-version",
+    is_flag=True,
+    help="don't update dependency versions in pyproject files",
+)
 @click.option("-P", "--no-pypi", is_flag=True, help="don't push to PyPI")
 @click.option("-T", "--no-test", is_flag=True, help="don't run tests")
-@click.option("-o", "--pytest", "pytest_opts", type=str,multiple=True, help="Options for pytest")
-@click.option("-d", "--deb", "deb_opts", type=str,multiple=True, help="Options for debuild")
-@click.option("-p", "--dput", "dput_opts", type=str,multiple=True, help="Options for dput")
+@click.option("-G", "--test-chg", is_flag=True, help="rebuild if changes file doesn't exist")
+@click.option("-o", "--pytest", "pytest_opts", type=str, multiple=True, help="Options for pytest")
+@click.option("-d", "--deb", "deb_opts", type=str, multiple=True, help="Options for debuild")
+@click.option("-p", "--dput", "dput_opts", type=str, multiple=True, help="Options for dput")
 @click.option("-r", "--run", is_flag=True, help="actually do the tagging")
-@click.option("-s", "--skip", "skip_", type=str,multiple=True, help="skip these repos")
+@click.option("-s", "--skip", "skip_", type=str, multiple=True, help="skip these repos")
 @click.option("-m", "--minor", is_flag=True, help="create a new minor version")
 @click.option("-M", "--major", is_flag=True, help="create a new major version")
 @click.option("-t", "--tag", "forcetag", type=str, help="Use this explicit tag value")
@@ -836,10 +845,38 @@ it is dropped when you use '--dput'.
     help="Update external dependency",
 )
 @click.argument("parts", nargs=-1)
-async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts, pytest_opts, deb_opts, run, version, no_version, no_deb, skip_, major,minor,forcetag,autotag):
+@click.pass_obj
+async def build(
+    obj,
+    no_commit,
+    no_dirty,
+    no_test,
+    no_tag,
+    no_pypi,
+    parts,
+    dput_opts,
+    pytest_opts,
+    deb_opts,
+    run,
+    test_chg,
+    version,
+    no_version,
+    no_deb,
+    skip_,
+    major,
+    minor,
+    forcetag,
+    autotag,
+):
     """
     Rebuild all modified packages.
     """
+    cfg = obj.cfg
+    g_done = cfg.get("src", {}).get("done")
+    if g_done is not None:
+        g_done = Path(g_done)
+    else:
+        g_done = Path("/tmp/nonexistent")
     repo = Repo(None)
 
     tags = dict(version)
@@ -848,7 +885,7 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
         for sn in s.split(","):
             skip.add(dash(sn))
     parts = set(dash(s) for s in parts)
-    debversion={}
+    debversion = {}
 
     if no_tag and not no_version:
         print("Warning: not updating moat versions in pyproject files", file=sys.stderr)
@@ -860,28 +897,30 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
         raise click.UsageError("Can't use an explicit tag with changing minor or major!")
 
     if forcetag is None:
-        forcetag = repo.next_tag(major,minor)
+        forcetag = repo.next_tag(major, minor)
 
-    full = False
     if parts:
-        repos = [ repo.part(x) for x in parts ]
+        repos = [repo.part(x) for x in parts]
     else:
         if not skip:
-            full = True
-        repos = [ x for x in repo.parts if not x.hidden and x.dash not in skip and not (PACK/x.dash/"SKIP").exists() ]
+            pass
+        repos = [
+            x
+            for x in repo.parts
+            if not x.hidden and x.dash not in skip and not (PACK / x.dash / "SKIP").exists()
+        ]
 
     for name in PACK.iterdir():
         if name.suffix != ".changes":
             continue
-        name=name.stem
-        name,vers,_ = name.split("_")
+        name = name.stem
+        name, vers, _ = name.split("_")
         if name.startswith("moat-"):
             name = name[5:]
         else:
-            name = "ext-"+name
-        debversion[name]=vers.rsplit("-",1)[0]
+            name = "ext-" + name
+        debversion[name] = vers.rsplit("-", 1)[0]
 
-    
     # Step 0: basic check
     if not no_dirty:
         if repo.is_dirty(index=False, working_tree=True, untracked_files=True, submodules=False):
@@ -895,14 +934,22 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
     if autotag:
         for r in repos:
             if r.has_changes(True):
+                try:
+                    nt = r.next_tag()
+                except AttributeError:
+                    nt = "1.0.0" if major else "0.1.0" if minor else "0.0.1"
                 r.vers = attrdict(
-                    tag=r.next_tag(),
+                    tag=nt,
                     pkg=1,
                     rev=repo.head.commit.hexsha,
-                    )
+                )
+                logger.debug("Changes: %s %s",r.name,r.verstr)
             elif r.has_changes(False):
                 r.vers.pkg += 1
-                r.vers.rev=repo.head.commit.hexsha
+                r.vers.rev = repo.head.commit.hexsha
+                logger.debug("Build Changes: %s %s",r.name,r.verstr)
+            else:
+                logger.debug("No Changes: %s %s",r.name,r.verstr)
 
     elif not no_tag:
         err = set()
@@ -910,7 +957,7 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
             try:
                 tag = r.last_tag
             except KeyError:
-                rd = PACK/r.dash
+                rd = PACK / r.dash
                 p = rd / "pyproject.toml"
                 if not p.is_file():
                     continue
@@ -936,15 +983,15 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
                 fails.add(p.name)
         if fails:
             if not run:
-                print(f"*** Tests failed:", *fails, file=sys.stderr)
+                print("*** Tests failed:", *fails, file=sys.stderr)
             else:
-                print(f"Failed tests:", *fails, file=sys.stderr)
-                print(f"Fix and try again.", file=sys.stderr)
+                print("Failed tests:", *fails, file=sys.stderr)
+                print("Fix and try again.", file=sys.stderr)
                 return
 
     # Step 3: set version and fix versioned dependencies
     for r in repos:
-        rd = PACK/r.dash
+        rd = PACK / r.dash
         p = rd / "pyproject.toml"
         if not p.is_file():
             # bad=True
@@ -975,52 +1022,89 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
     # Step 3: copy to packaging dir
     for r in repos:
         r.copy()
-        
+
     # Step 4: build Debian package
     if not no_deb:
         if not deb_opts:
             deb_opts = ["--no-sign"]
 
         for r in repos:
-            rd=PACK/r.dash
+            rd = PACK / r.dash
             p = rd / "debian"
             if not p.is_dir():
                 continue
+            if not (rd/"debian"/"changelog").exists():
+                subprocess.run(
+                    [
+                        "debchange",
+                        "--create",
+                        "--newversion", f"{r.last_tag}-{r.vers.pkg}",
+                        "--package", r.mdash,
+                        f"Initial release for {forcetag}",
+                     ],
+                    cwd=rd,
+                    check=True,
+                    stdout=sys.stdout,
+                    stderr=sys.stderr,
+                )
+
             try:
-                res = subprocess.run(["dpkg-parsechangelog","-l","debian/changelog","-S","version"], cwd=rd, check=True, stdout=subprocess.PIPE)
-                tag = res.stdout.strip().decode("utf-8").rsplit("-",1)[0]
+                res = subprocess.run(
+                    ["dpkg-parsechangelog", "-l", "debian/changelog", "-S", "version"],
+                    cwd=rd,
+                    check=True,
+                    stdout=subprocess.PIPE,
+                )
+                tag,ptag = res.stdout.strip().decode("utf-8").rsplit("-", 1)
+                ptag = int(ptag)
                 ltag = r.last_tag
-                if tag != ltag:
-                    subprocess.run(["debchange", "--distribution","unstable", "--newversion",f"{ltag}-{r.vers.pkg}",f"New release for {forcetag}"] , cwd=rd, check=True)
-                    repo.index.add(p/"changelog")
+                if tag != ltag or r.vers.pkg != ptag:
+                    subprocess.run(
+                        [
+                            "debchange",
+                            "--distribution",
+                            "unstable",
+                            "--newversion",
+                            f"{ltag}-{r.vers.pkg}",
+                            f"New release for {forcetag}",
+                        ],
+                        cwd=rd,
+                        check=True,
+                    )
+                    repo.index.add(p / "changelog")
+
+                changes = PACK / f"{r.mdash}_{ltag}-{r.vers.pkg}_{ARCH}.changes"
+                if debversion.get(r.dash, "") != ltag or r.vers.pkg != ptag or test_chg and not changes.exists():
 
-                if debversion.get(r.dash,"") != ltag:
                     subprocess.run(["debuild", "--build=binary"] + deb_opts, cwd=rd, check=True)
             except subprocess.CalledProcessError:
                 if not run:
-                    print("*** Failure packaging",r.name,file=sys.stderr)
+                    print("*** Failure packaging", r.name, file=sys.stderr)
                 else:
-                    print("Failure packaging",r.name,file=sys.stderr)
-                    return
+                    print("Failure packaging", r.name, file=sys.stderr)
+                    no_commit=True
+                    no_deb=True
+                    no_pypi=True
 
     # Step 5: build PyPI package
     if not no_pypi:
-        err=set()
-        up=set()
+        err = set()
+        up = set()
         for r in repos:
-            rd=PACK/r.dash
+            rd = PACK / r.dash
             p = rd / "pyproject.toml"
             if not p.is_file():
                 continue
             tag = r.last_tag
             name = r.dash
             if name.startswith("ext-"):
-                name=name[4:]
+                name = name[4:]
             else:
-                name="moat-"+r.dash
+                name = "moat-" + r.dash
+
+            targz = rd / "dist" / f"{r.under}-{tag}.tar.gz"
+            done = rd / "dist" / f"{r.under}-{tag}.done"
 
-            targz = rd/"dist"/f"{r.under}-{tag}.tar.gz"
-            done = rd/"dist"/f"{r.under}-{tag}.done"
             if targz.is_file():
                 if not done.exists():
                     up.add(r)
@@ -1039,50 +1123,60 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
                 print("Build errors:", file=sys.stderr)
                 print(*err, file=sys.stderr)
                 print("Please fix and try again.", file=sys.stderr)
-                return
-        
+                no_commit=True
+                no_deb=True
+
         # Step 6: upload PyPI package
-        if run:
-            err=set()
+        elif run:
+            err = set()
             for r in up:
-                rd=PACK/r.dash
+                rd = PACK / r.dash
                 p = rd / "pyproject.toml"
                 if not p.is_file():
                     continue
                 tag = r.last_tag
                 name = r.dash
                 if name.startswith("ext-"):
-                    name=name[4:]
+                    name = name[4:]
                 else:
-                    name="moat-"+r.dash
-                targz = Path("dist")/f"{r.under}-{tag}.tar.gz"
-                whl = Path("dist")/f"{r.under}-{tag}-py3-none-any.whl"
+                    name = "moat-" + r.dash
+                targz = Path("dist") / f"{r.under}-{tag}.tar.gz"
+                whl = Path("dist") / f"{r.under}-{tag}-py3-none-any.whl"
                 try:
-                    res = subprocess.run(["twine", "upload", str(targz), str(whl)], cwd=rd, check=True)
+                    res = subprocess.run(
+                        ["twine", "upload", str(targz), str(whl)],
+                        cwd=rd,
+                        check=True,
+                    )
                 except subprocess.CalledProcessError:
                     err.add(r.name)
                 else:
-                    done = rd/"dist"/f"{r.under}-{tag}.done"
+                    done = rd / "dist" / f"{r.under}-{tag}.done"
                     done.touch()
             if err:
                 print("Upload errors:", file=sys.stderr)
                 print(*err, file=sys.stderr)
                 print("Please fix(?) and try again.", file=sys.stderr)
-                return
+                no_commit=True
+                no_deb=True
 
     # Step 7: upload Debian package
     if run and not no_deb:
         err = set()
         if not dput_opts:
-            dput_opts = ["-u","ext"]
+            dput_opts = ["-u", "ext"]
         for r in repos:
             ltag = r.last_tag
-            if not (PACK/r.dash/"debian").is_dir():
+            if not (PACK / r.dash / "debian").is_dir():
                 continue
-            changes = PACK/f"{r.mdash}_{ltag}-{r.vers.pkg}_{ARCH}.changes"
-            done = PACK/f"{r.mdash}_{ltag}-{r.vers.pkg}_{ARCH}.done"
+            changes = PACK / f"{r.mdash}_{ltag}-{r.vers.pkg}_{ARCH}.changes"
+            done = PACK / f"{r.mdash}_{ltag}-{r.vers.pkg}_{ARCH}.done"
             if done.exists():
                 continue
+            if g_done is not None:
+                gdone = g_done / f"{r.mdash}_{ltag}-{r.vers.pkg}_{ARCH}.done"
+                if gdone.exists():
+                    continue
             try:
                 subprocess.run(["dput", *dput_opts, str(changes)], check=True)
             except subprocess.CalledProcessError:
@@ -1093,7 +1187,7 @@ async def build(no_commit, no_dirty, no_test, no_tag, no_pypi, parts, dput_opts,
             print("Upload errors:", file=sys.stderr)
             print(*err, file=sys.stderr)
             print("Please fix(?) and try again.", file=sys.stderr)
-            return
+            no_commit=True
 
     # Step 8: commit the result
     if run: