odoo-dev 1.3.0__tar.gz → 1.4.0__tar.gz

odoo_dev-1.4.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.4.0"
+}

{odoo_dev-1.3.0 → odoo_dev-1.4.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.4.0](https://github.com/bemade/odoo-dev/compare/v1.3.0...v1.4.0) (2026-09-04)
+
+
+### Features
+
+* **git:** add `sweep` — classify remote branches, pick, delete ([86fc297](https://github.com/bemade/odoo-dev/commit/86fc29774916f35b6c7470daf9188e2c4bf78907))
+* **git:** add `sweep` — classify remote branches, pick, delete ([69fb870](https://github.com/bemade/odoo-dev/commit/69fb8708c940aa1534e1c342ee138966df584e0f))
+
 ## [1.3.0](https://github.com/bemade/odoo-dev/compare/v1.2.3...v1.3.0) (2026-09-02)
 
 

{odoo_dev-1.3.0 → odoo_dev-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: odoo-dev
-Version: 1.3.0
+Version: 1.4.0
 Summary: Odoo Development Environment Helper
 Project-URL: Homepage, https://github.com/bemade/odoo-dev
 Project-URL: Repository, https://github.com/bemade/odoo-dev
@@ -8,6 +8,7 @@ Project-URL: Issues, https://github.com/bemade/odoo-dev/issues
 License-Expression: LGPL-3.0
 Requires-Python: >=3.12
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: questionary>=2.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.9.0
 Description-Content-Type: text/markdown

{odoo_dev-1.3.0 → odoo_dev-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "odoo-dev"
-version = "1.3.0"
+version = "1.4.0"
 description = "Odoo Development Environment Helper"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -8,6 +8,7 @@ dependencies = [
     "typer>=0.9.0",
     "rich>=13.0.0",
     "pyyaml>=6.0",
+    "questionary>=2.0",
 ]
 license = "LGPL-3.0"
 

odoo_dev-1.4.0/src/odoo_dev/__init__.py

@@ -0,0 +1,3 @@
+"""Odoo Development Environment Helper."""
+
+__version__ = "1.4.0"  # x-release-please-version

{odoo_dev-1.3.0 → odoo_dev-1.4.0}/src/odoo_dev/commands/git.py

@@ -19,7 +19,14 @@ is no configured remote left to prune against -- they simply persist, and show
 up in every ref listing as branches that do not exist.
 """
 
+import json
+import os
+import re
+import shutil
 import subprocess
+import sys
+import time
+from datetime import datetime, timezone
 from typing import Annotated, Optional
 
 import typer
@@ -343,3 +350,347 @@ def shipped(
             info(f"  git diff {ref} {target} -- {p}")
     else:
         success("\nEvery path matches -- this work is present in the target.")
+
+
+# --- sweep -------------------------------------------------------------------
+#
+# The classification ladder below is the one that survived a real cleanup of two
+# long-lived client repos (89 and 41 branches). Its shape is dictated by what
+# each test can actually prove:
+#
+#   KEEP          long-lived lines. Never a candidate, whatever their age.
+#   IN-FLIGHT     an open MR/PR names it as source. Deleting one of these closes
+#                 the request out from under its author.
+#   CONTAINED     `merge-base --is-ancestor` says every commit is reachable from
+#                 a branch we keep. This is the ONLY class that proves deletion
+#                 loses nothing, and so the only one pre-checked.
+#   STALE-BY-BASE not contained, and its diff against the target mass-deletes
+#                 paths the target owns -- the fingerprint of a branch cut before
+#                 a structural change (e.g. submodules -> vendored files). These
+#                 look mergeable and are not: an MR would propose deleting the
+#                 target's tree. Never auto-select.
+#   UNKNOWN       everything else. Genuinely needs a human.
+#
+# Deliberately absent: proving supersession by content across a base gap. The
+# obvious implementation -- diff the paths the old branch touched against its
+# replacement -- reads as "identical" for branches whose fork point predates a
+# tree reorganisation, because the derived path set is dominated by the
+# reorganisation rather than the branch's own work. `odoo-dev git shipped`
+# answers that question properly, per branch, with markers. A branch superseded
+# by an open MR becomes CONTAINED for free once that MR merges, so the honest
+# move is to wait rather than guess.
+
+_KEEP_RE = re.compile(r"^(\d+\.\d+(-(prod|staging))?|main|master)$")
+
+
+def _default_targets(remote: str) -> list[str]:
+    """Long-lived lines, by name. Version branches plus main/master."""
+    out = []
+    for line in _git(
+        "for-each-ref", "--format=%(refname:short)", f"refs/remotes/{remote}"
+    ).splitlines():
+        short = line[len(remote) + 1 :]
+        if short and short != "HEAD" and _KEEP_RE.match(short):
+            out.append(short)
+    return sorted(out)
+
+
+def _open_request_sources(remote: str) -> tuple[set[str], Optional[str]]:
+    """Source branches of open MRs/PRs. Returns (branches, warning_or_None).
+
+    JSON endpoints only. Scraping the human-readable `glab mr list` table looks
+    easier and is a trap: its header line ("... (Page 1)") satisfies a naive
+    "text in parentheses" match and yields a phantom branch named `Page 1`.
+    """
+    url = _git("remote", "get-url", remote, check=False)
+    if not url:
+        return set(), f"no URL for remote {remote!r} -- skipping request lookup"
+
+    if "github" in url:
+        tool, args = "gh", [
+            "pr",
+            "list",
+            "--state",
+            "open",
+            "--limit",
+            "200",
+            "--json",
+            "headRefName",
+        ]
+    else:
+        tool, args = "glab", [
+            "api",
+            "projects/:id/merge_requests?state=opened&per_page=100",
+        ]
+
+    if not shutil.which(tool):
+        return set(), (
+            f"{tool} not installed -- cannot see open requests. Branches with an "
+            f"open MR/PR will appear as UNKNOWN, not as safe to delete."
+        )
+
+    r = subprocess.run([tool, *args], capture_output=True, text=True)
+    if r.returncode != 0:
+        return set(), (
+            f"{tool} failed ({(r.stderr or r.stdout).strip().splitlines()[:1]}) -- "
+            f"treating all branches as having no open request."
+        )
+    try:
+        payload = json.loads(r.stdout or "[]")
+    except json.JSONDecodeError:
+        return set(), f"could not parse {tool} output as JSON"
+
+    key = "headRefName" if tool == "gh" else "source_branch"
+    return {item[key] for item in payload if item.get(key)}, None
+
+
+def _missing_share(target: str, ref: str) -> tuple[int, float]:
+    """(count, share) of TARGET's paths that REF does not have.
+
+    The SHARE is what distinguishes the two cases, and using the raw count
+    instead is a false-positive generator:
+
+      * a branch merely BEHIND a fast-moving target legitimately lacks whatever
+        was added since -- dozens of files, but a tiny fraction of the tree;
+      * a branch cut before a structural change (submodules -> vendored files,
+        a big reorganisation) lacks most of the tree.
+
+    Only the second is dangerous to merge, and only a ratio separates them.
+    """
+    out = _git("diff", "--name-status", target, ref, check=False)
+    missing = sum(1 for ln in out.splitlines() if ln.startswith("D\t"))
+    total = len(_git("ls-tree", "-r", "--name-only", target, check=False).splitlines())
+    return missing, (missing / total if total else 0.0)
+
+
+@app.command()
+def sweep(
+    targets: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--target",
+            "-t",
+            help="Branch that counts as 'kept'. Repeatable. "
+            "Default: version branches (19.0, 19.0-prod, 19.0-staging...) plus main/master.",
+        ),
+    ] = None,
+    remote: Annotated[str, typer.Option("--remote", help="Remote name")] = "origin",
+    apply: Annotated[
+        bool, typer.Option("--apply", help="Actually delete. Default is a dry run.")
+    ] = False,
+    no_fetch: Annotated[
+        bool, typer.Option("--no-fetch", help="Skip the fetch --prune first")
+    ] = False,
+    check_requests: Annotated[
+        bool,
+        typer.Option(
+            "--check-requests/--no-check-requests",
+            help="Ask glab/gh which branches have an open MR/PR.",
+        ),
+    ] = True,
+    stale_ratio: Annotated[
+        float,
+        typer.Option(
+            "--stale-ratio",
+            help="Share of the target's tree a branch must be missing to count "
+            "as STALE-BY-BASE. A branch that is merely behind lacks a few "
+            "files; one cut before a tree change lacks most of them.",
+        ),
+    ] = 0.25,
+    non_interactive: Annotated[
+        bool,
+        typer.Option(
+            "--non-interactive",
+            help="Skip the picker and take exactly the CONTAINED set.",
+        ),
+    ] = False,
+) -> None:
+    """Classify remote branches and delete the ones you select. DRY RUN unless --apply.
+
+    Writes a manifest of every branch with its SHA *before* deleting anything,
+    so a branch removed here is restorable with::
+
+        git push <remote> <sha>:refs/heads/<branch>
+
+    That matters for anything outside CONTAINED: once such a branch is gone its
+    commits are unreachable, and the SHA in the manifest is the only way back.
+    """
+    if not no_fetch:
+        info(f"fetching {remote} --prune ...")
+        _git("fetch", "--prune", "--quiet", remote)
+
+    keep = list(targets) if targets else _default_targets(remote)
+    if not keep:
+        error(
+            "no target branches found -- pass --target explicitly. Refusing to "
+            "classify anything as deletable with nothing to measure against."
+        )
+        raise typer.Exit(2)
+    info(f"targets: {', '.join(keep)}")
+
+    for t in keep:
+        if not _ok("rev-parse", "--verify", f"{remote}/{t}"):
+            error(f"{remote}/{t} does not exist")
+            raise typer.Exit(2)
+
+    in_flight: set[str] = set()
+    if check_requests:
+        in_flight, warn = _open_request_sources(remote)
+        if warn:
+            warning(f"  {warn}")
+        else:
+            info(f"  {len(in_flight)} branch(es) have an open MR/PR")
+
+    rows: list[dict] = []
+    for line in _git(
+        "for-each-ref",
+        "--format=%(refname:short)%09%(objectname)%09%(committerdate:short)",
+        f"refs/remotes/{remote}",
+    ).splitlines():
+        ref, sha, date = (line.split("\t") + ["", ""])[:3]
+        short = ref[len(remote) + 1 :]
+        if not short or short == "HEAD":
+            continue
+        if short in keep:
+            cls, why = "KEEP", "long-lived line"
+        elif short in in_flight:
+            cls, why = "IN-FLIGHT", "open MR/PR names it as source"
+        else:
+            holder = next(
+                (
+                    t
+                    for t in keep
+                    if _ok("merge-base", "--is-ancestor", ref, f"{remote}/{t}")
+                ),
+                None,
+            )
+            if holder:
+                cls, why = "CONTAINED", f"contained in {remote}/{holder}"
+            else:
+                worst_n, worst_share, worst_t = 0, 0.0, ""
+                for t in keep:
+                    n, share = _missing_share(f"{remote}/{t}", ref)
+                    if share > worst_share:
+                        worst_n, worst_share, worst_t = n, share, t
+                if worst_share >= stale_ratio:
+                    cls = "STALE-BY-BASE"
+                    why = (
+                        f"lacks {worst_n} paths ({worst_share:.0%}) of {worst_t} "
+                        f"-- cut before a tree change"
+                    )
+                else:
+                    cls, why = "UNKNOWN", "not contained; needs a human"
+        rows.append({"branch": short, "sha": sha, "date": date, "cls": cls, "why": why})
+
+    counts: dict[str, int] = {}
+    for r in rows:
+        counts[r["cls"]] = counts.get(r["cls"], 0) + 1
+    info("")
+    for cls in ("KEEP", "IN-FLIGHT", "CONTAINED", "STALE-BY-BASE", "UNKNOWN"):
+        if counts.get(cls):
+            info(f"  {cls:<14} {counts[cls]}")
+
+    candidates = [r for r in rows if r["cls"] not in ("KEEP", "IN-FLIGHT")]
+    if not candidates:
+        success("\nnothing to sweep -- every branch is a keeper or in flight")
+        return
+
+    man = _write_manifest(rows, remote)
+    success(f"\nmanifest: {man}")
+
+    contained = [r for r in candidates if r["cls"] == "CONTAINED"]
+    if non_interactive or not sys.stdin.isatty():
+        chosen = [r["branch"] for r in contained]
+        info(f"non-interactive: taking the {len(chosen)} CONTAINED branch(es) only")
+    else:
+        chosen = _pick(candidates, apply=apply)
+
+    if not chosen:
+        info("nothing selected -- done")
+        return
+
+    warning(f"\n{len(chosen)} branch(es) selected:")
+    for b in chosen:
+        r = next(x for x in rows if x["branch"] == b)
+        info(f"  {r['cls']:<14} {b}")
+
+    if not apply:
+        info("\nDRY RUN -- nothing deleted. Re-run with --apply.")
+        return
+
+    # Re-verify containment immediately before deleting: the survey and the
+    # delete are separated by however long the picker was open, and another
+    # session pushing in that window is not hypothetical.
+    for b in chosen:
+        r = next(x for x in rows if x["branch"] == b)
+        if r["cls"] == "CONTAINED":
+            holder = r["why"].rsplit("/", 1)[-1]
+            if not _ok(
+                "merge-base", "--is-ancestor", f"{remote}/{b}", f"{remote}/{holder}"
+            ):
+                error(
+                    f"{b} is no longer contained in {holder} -- aborting, nothing deleted"
+                )
+                raise typer.Exit(1)
+
+    failed = []
+    for b in chosen:
+        for attempt in (1, 2, 3):
+            r = subprocess.run(
+                ["git", "push", remote, "--delete", b], capture_output=True, text=True
+            )
+            if r.returncode == 0:
+                success(f"  deleted {b}")
+                break
+            if attempt < 3:
+                time.sleep(attempt)
+        else:
+            error(f"  FAILED {b}: {(r.stderr or r.stdout).strip().splitlines()[-1:]}")
+            failed.append(b)
+
+    if failed:
+        error(f"\n{len(failed)} deletion(s) failed -- rerun to retry them")
+        raise typer.Exit(1)
+    success(f"\n{len(chosen)} branch(es) deleted. Restore any of them with:")
+    info(f"  git push {remote} <sha>:refs/heads/<branch>   # SHAs in {man}")
+
+
+def _write_manifest(rows: list[dict], remote: str) -> str:
+    """Record every branch and SHA under .git/ before anything is deleted."""
+    d = os.path.join(_git("rev-parse", "--git-dir"), "odoo-dev")
+    os.makedirs(d, exist_ok=True)
+    path = os.path.join(d, f"sweep-{datetime.now(timezone.utc):%Y%m%dT%H%M%SZ}.tsv")
+    with open(path, "w") as fh:
+        fh.write(
+            f"# odoo-dev git sweep -- {datetime.now(timezone.utc):%Y-%m-%d %H:%M:%SZ}\n"
+        )
+        fh.write(f"# restore with: git push {remote} <sha>:refs/heads/<branch>\n")
+        fh.write("branch\tsha\tlast_commit\tclass\tevidence\n")
+        for r in rows:
+            fh.write(
+                f"{r['branch']}\t{r['sha']}\t{r['date']}\t{r['cls']}\t{r['why']}\n"
+            )
+    return path
+
+
+def _pick(candidates: list[dict], apply: bool = False) -> list[str]:
+    """Checkbox picker. CONTAINED pre-checked; nothing else is."""
+    import questionary
+
+    order = {"CONTAINED": 0, "STALE-BY-BASE": 1, "UNKNOWN": 2}
+    ordered = sorted(candidates, key=lambda r: (order.get(r["cls"], 9), r["date"]))
+    choices = [
+        questionary.Choice(
+            title=f"{r['cls']:<14} {r['date']}  {r['branch']:<48} {r['why']}",
+            value=r["branch"],
+            checked=r["cls"] == "CONTAINED",
+        )
+        for r in ordered
+    ]
+    prompt = (
+        "Select branches to DELETE (space toggles, enter confirms):"
+        if apply
+        else "Select branches (DRY RUN -- the selection is only reported):"
+    )
+    picked = questionary.checkbox(prompt, choices=choices).ask()
+    return picked or []

{odoo_dev-1.3.0 → odoo_dev-1.4.0}/tests/test_git_hygiene.py

@@ -277,3 +277,143 @@ def test_unmerged_reads_remote_refs_not_stale_local_ones(repo):
     res = runner.invoke(app, ["git", "unmerged", "main", "--no-fetch"])
     assert res.exit_code == 0
     assert "wip" in res.stdout
+
+
+# --- sweep -------------------------------------------------------------------
+
+
+def _sweep_repo(repo):
+    """Add branches covering each class sweep must distinguish."""
+    # contained: merged into main
+    _run("checkout", "-q", "-b", "done", cwd=repo)
+    (repo / "done.py").write_text("x = 1\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "feat: done", cwd=repo)
+    _run("checkout", "-q", "main", cwd=repo)
+    _run("merge", "--no-ff", "-m", "merge done", "done", cwd=repo)
+    # unknown: real unmerged work, same era as main
+    _run("checkout", "-q", "-b", "live", cwd=repo)
+    (repo / "live.py").write_text("y = 2\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "feat: live", cwd=repo)
+    _run("checkout", "-q", "main", cwd=repo)
+    _run("push", "-q", "origin", "main", "done", "live", cwd=repo)
+    _run("fetch", "-q", "--prune", "origin", cwd=repo)
+
+
+def test_sweep_classifies_contained_and_unknown(repo):
+    _sweep_repo(repo)
+    res = runner.invoke(app, ["git", "sweep", "--no-check-requests", "--no-fetch"])
+    assert res.exit_code == 0, res.stdout
+    assert "CONTAINED" in res.stdout
+    assert "UNKNOWN" in res.stdout
+    assert "DRY RUN" in res.stdout
+
+
+def test_sweep_is_dry_by_default(repo):
+    """Nothing is deleted without --apply, even the provably safe class."""
+    _sweep_repo(repo)
+    res = runner.invoke(
+        app, ["git", "sweep", "--no-check-requests", "--no-fetch", "--non-interactive"]
+    )
+    assert res.exit_code == 0
+    out = subprocess.run(
+        ["git", "ls-remote", "--heads", "origin"],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    ).stdout
+    assert "refs/heads/done" in out
+
+
+def test_sweep_apply_deletes_only_contained(repo):
+    """--non-interactive takes exactly CONTAINED; unmerged work survives."""
+    _sweep_repo(repo)
+    res = runner.invoke(
+        app,
+        [
+            "git",
+            "sweep",
+            "--no-check-requests",
+            "--no-fetch",
+            "--non-interactive",
+            "--apply",
+        ],
+    )
+    assert res.exit_code == 0, res.stdout
+    out = subprocess.run(
+        ["git", "ls-remote", "--heads", "origin"],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    ).stdout
+    assert "refs/heads/done" not in out
+    assert "refs/heads/live" in out
+    assert "refs/heads/main" in out
+
+
+def test_sweep_writes_manifest_with_shas(repo):
+    """The manifest exists before deletion and carries a restorable SHA."""
+    _sweep_repo(repo)
+    sha = subprocess.run(
+        ["git", "rev-parse", "origin/done"],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    runner.invoke(
+        app,
+        [
+            "git",
+            "sweep",
+            "--no-check-requests",
+            "--no-fetch",
+            "--non-interactive",
+            "--apply",
+        ],
+    )
+    manifests = list((repo / ".git" / "odoo-dev").glob("sweep-*.tsv"))
+    assert len(manifests) == 1
+    body = manifests[0].read_text()
+    assert sha in body
+    assert "done\t" in body
+    # and that SHA really does bring it back
+    _run("push", "origin", f"{sha}:refs/heads/done", cwd=repo)
+    out = subprocess.run(
+        ["git", "ls-remote", "--heads", "origin"],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    ).stdout
+    assert "refs/heads/done" in out
+
+
+def test_sweep_flags_stale_by_base(repo):
+    """A branch cut before a mass tree change is STALE-BY-BASE, not UNKNOWN.
+
+    This is the class that age cannot detect: the branch below is the newest in
+    the repo and still must never be merged, because it predates files main
+    owns.
+    """
+    for i in range(60):
+        (repo / f"vendored_{i}.py").write_text(f"V = {i}\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "chore: vendor the tree", cwd=repo)
+    _run("push", "-q", "origin", "main", cwd=repo)
+    # branch from BEFORE that commit, then add something new to it
+    _run("checkout", "-q", "-b", "oldbase", "HEAD~1", cwd=repo)
+    (repo / "late.py").write_text("late = True\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "feat: late work on an old base", cwd=repo)
+    _run("push", "-q", "origin", "oldbase", cwd=repo)
+    _run("checkout", "-q", "main", cwd=repo)
+    _run("fetch", "-q", "--prune", "origin", cwd=repo)
+
+    res = runner.invoke(app, ["git", "sweep", "--no-check-requests", "--no-fetch"])
+    assert res.exit_code == 0, res.stdout
+    assert "STALE-BY-BASE" in res.stdout
+    # and it is never auto-selected
+    res2 = runner.invoke(
+        app, ["git", "sweep", "--no-check-requests", "--no-fetch", "--non-interactive"]
+    )
+    assert "oldbase" not in res2.stdout.split("selected:")[-1]

{odoo_dev-1.3.0 → odoo_dev-1.4.0}/uv.lock

@@ -96,10 +96,11 @@ wheels = [
 
 [[package]]
 name = "odoo-dev"
-version = "1.2.2"
+version = "1.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },
+    { name = "questionary" },
     { name = "rich" },
     { name = "typer" },
 ]
@@ -113,6 +114,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "pyyaml", specifier = ">=6.0" },
+    { name = "questionary", specifier = ">=2.0" },
     { name = "rich", specifier = ">=13.0.0" },
     { name = "typer", specifier = ">=0.9.0" },
 ]
@@ -159,6 +161,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.53"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ea/39b988c938f75cb75d7045b5c69f8bfed47ee2152c8837fb403de29d6fb8/prompt_toolkit-3.0.53.tar.gz", hash = "sha256:9ec8a0ad96d5c56148b3f914aa79c1564c3fde5d2e6b876e7bc327e353cf8fa6", size = 435492, upload-time = "2026-07-26T20:56:14.758Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/6f/84908cad2d6aa5144abcf7b42709fe4fdb459bc640ec7ac5786e7693dabc/prompt_toolkit-3.0.53-py3-none-any.whl", hash = "sha256:01c0891d7f9237d5e339f7d3e42cdae80b7534abb1c7c0e3352efba6231492f2", size = 392288, upload-time = "2026-07-26T20:56:12.512Z" },
+]
+
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -259,6 +273,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
+[[package]]
+name = "questionary"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "prompt-toolkit" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f6/45/eafb0bba0f9988f6a2520f9ca2df2c82ddfa8d67c95d6625452e97b204a5/questionary-2.1.1.tar.gz", hash = "sha256:3d7e980292bb0107abaa79c68dd3eee3c561b83a0f89ae482860b181c8bd412d", size = 25845, upload-time = "2025-08-28T19:00:20.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/26/1062c7ec1b053db9e499b4d2d5bc231743201b74051c973dadeac80a8f43/questionary-2.1.1-py3-none-any.whl", hash = "sha256:a51af13f345f1cdea62347589fbb6df3b290306ab8930713bfae4d475a7d4a59", size = 36753, upload-time = "2025-08-28T19:00:19.56Z" },
+]
+
 [[package]]
 name = "rich"
 version = "14.3.2"
@@ -304,3 +330,12 @@ sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac8
 wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
+
+[[package]]
+name = "wcwidth"
+version = "0.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/36/57/ed58088fafdf4c55a0ad6bde846502567645424d7ebf325230b9237f4085/wcwidth-0.8.3.tar.gz", hash = "sha256:d128512515fbf4612e0ff21fd6380399210318b7b54a9af59dff8454cf9730eb", size = 1458450, upload-time = "2026-08-28T18:10:06.875Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/0e/57f6bb3024a597b2e8ec4aee710ffe62ddc95af2e2bb1ee7a7abdc22c68c/wcwidth-0.8.3-py3-none-any.whl", hash = "sha256:d5b73dba6158a595ec9370350e7f2637bcac8d6c5e4fde34f30fcffb6103a5e4", size = 331669, upload-time = "2026-08-28T18:10:04.909Z" },
+]

odoo_dev-1.3.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.3.0"
-}

odoo_dev-1.3.0/src/odoo_dev/__init__.py

@@ -1,3 +0,0 @@
-"""Odoo Development Environment Helper."""
-
-__version__ = "1.3.0"  # x-release-please-version