wizard-codegen 0.1.5__py3-none-any.whl

core/filter.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import re
+from typing import Any
+from .config import Where, Predicate
+import fnmatch
+
+def _get_opt(item: dict, key: str) -> Any:
+    # expect custom options extracted into item["options"] as dict
+    return (item.get("options") or {}).get(key)
+
+def _match_regex(value: str | None, pattern: str) -> bool:
+    if value is None:
+        return False
+
+    # Treat patterns containing glob chars as glob
+    if any(ch in pattern for ch in ["*", "?", "[", "]"]):
+        return fnmatch.fnmatch(value, pattern)
+
+    return re.search(pattern, value) is not None
+
+def _pred_ok(item: dict, p: Predicate) -> bool:
+    if p.name and not _match_regex(_name_raw(item), p.name):
+        return False
+    if p.package and not _match_regex(item.get("package"), p.package):
+        return False
+    if p.file and not _match_regex(item.get("file"), p.file):
+        return False
+    if p.full_name and not _match_regex(item.get("full_name"), p.full_name):
+        return False
+    if p.option_equals:
+        if _get_opt(item, p.option_equals.key) != p.option_equals.value:
+            return False
+    return True
+
+def where_ok(item: dict, where: Where | None) -> bool:
+    if where is None:
+        return True
+
+    # NOT
+    for p in where.not_:
+        if _pred_ok(item, p):
+            return False
+
+    # ALL (AND)
+    for p in where.all:
+        if not _pred_ok(item, p):
+            return False
+
+    # ANY (OR) - if present, must match at least one
+    if where.any:
+        if not any(_pred_ok(item, p) for p in where.any):
+            return False
+
+    return True
+
+def _name_raw(item: dict) -> str | None:
+    n = item.get("name")
+    if n is None:
+        return None
+    if isinstance(n, str):
+        return n
+    if isinstance(n, dict):
+        return n.get("raw")
+    # dataclass / pydantic / simple object
+    return getattr(n, "raw", str(n))

core/renderer.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from .config import CodegenConfig
+from hooks import load_hooks
+from .filter import where_ok
+
+@dataclass
+class PlanItem:
+    output_path: Path
+    content: str
+    mode: str = "overwrite"
+
+def _make_env(template_dir: Path) -> Environment:
+    env = Environment(
+        loader=FileSystemLoader(str(template_dir)),
+        undefined=StrictUndefined,
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+    # add a couple generic filters
+    env.filters["replace"] = lambda s, a, b: str(s).replace(a, b)
+    return env
+
+def _get_items_for_each_type(context: dict, for_each_type: str):
+    """Get the appropriate items to iterate over based on for_each type."""
+    if for_each_type == "file":
+        return context["files"]
+    elif for_each_type == "message":
+        return context["message"].values()
+    elif for_each_type == "enum":
+        return context["enum"].values()
+    elif for_each_type == "service":
+        return context["service"].values()
+    else:
+        raise ValueError(f"Unknown for_each type: {for_each_type}")
+
+def _render_item(item, context: dict, tpl, out_tpl, out_root: Path, mode: str) -> PlanItem:
+    """Render a single item and return a PlanItem."""
+    ctx = dict(context)
+    ctx["item"] = item
+    rel_out = Path(out_tpl.render(**ctx))
+    content = tpl.render(**ctx)
+    return PlanItem(output_path=out_root / rel_out, content=content, mode=mode)
+
+def render_all(cfg: CodegenConfig, context: dict, out_override: Path | None = None) -> list[PlanItem]:
+    plan: list[PlanItem] = []
+
+    for target, tcfg in cfg.targets.items():
+        template_dir = (Path(tcfg.templates)).resolve()
+        out_root = (out_override or Path(tcfg.out)).resolve()
+
+        env = _make_env(template_dir)
+
+        hooks = load_hooks(cfg, Path(cfg.hooks.root))
+        if hooks:
+            hooks.register(env, target=target, config=cfg)
+
+        for ep in tcfg.render:
+            tpl = env.get_template(ep.template)
+            out_tpl = env.from_string(ep.output)
+
+            if ep.for_each:
+                items = _get_items_for_each_type(context, ep.for_each)
+                for item in items:
+                    if not where_ok(item, ep.where):
+                        continue
+                    plan_item = _render_item(item, context, tpl, out_tpl, out_root, ep.mode)
+                    plan.append(plan_item)
+            else:
+                rel_out = Path(out_tpl.render(**context))
+                content = tpl.render(**context)
+                plan.append(PlanItem(output_path=out_root / rel_out, content=content, mode=ep.mode))
+
+    return plan

core/writer.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import hashlib
+from typing import Literal
+
+from .renderer import PlanItem
+
+
+def _sha256(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8")).hexdigest()
+
+
+def apply_plan(plan: list[PlanItem], dry_run: bool, verbose: bool):
+    for item in plan:
+        mode: Literal["overwrite", "append", "write-once"] = getattr(item, "mode", "overwrite")
+
+        # write-once: if the file exists, never touch it
+        if mode == "write-once" and item.output_path.exists():
+            if verbose:
+                print(f"skip (write-once exists): {item.output_path}")
+            continue
+
+        if not dry_run:
+            item.output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        new_hash = _sha256(item.content)
+
+        old_text = ""
+        if item.output_path.exists():
+            old_text = item.output_path.read_text(encoding="utf-8")
+
+            if mode == "overwrite":
+                old_hash = _sha256(old_text)
+                if old_hash == new_hash:
+                    if verbose:
+                        print(f"skip (unchanged): {item.output_path}")
+                    continue
+
+            elif mode == "append":
+                # guard against duplicating the same block
+                if old_text.endswith(item.content):
+                    if verbose:
+                        print(f"skip (already appended): {item.output_path}")
+                    continue
+
+            elif mode == "write-once":
+                # handled earlier, but keep it explicit
+                if verbose:
+                    print(f"skip (write-once exists): {item.output_path}")
+                continue
+
+            else:
+                raise ValueError(f"Unknown mode {mode!r} for {item.output_path}")
+
+        action = "append" if mode == "append" and item.output_path.exists() else "write"
+
+        if dry_run:
+            print(f"would {action}: {item.output_path}")
+            continue
+
+        if mode == "append" and item.output_path.exists():
+            # ensure we start on a new line
+            prefix = "" if old_text.endswith("\n") or item.content.startswith("\n") else "\n"
+            item.output_path.write_text(old_text + prefix + item.content, encoding="utf-8")
+        else:
+            # overwrite + write_once (new file) both come here
+            item.output_path.write_text(item.content, encoding="utf-8")
+
+        if verbose:
+            print(f"{action}d: {item.output_path}")

hooks/__init__.py

@@ -0,0 +1,6 @@
+from .hooks import load_hooks, HooksModule
+
+__all__ = [
+    "load_hooks",
+    "HooksModule"
+]

hooks/hooks.py

@@ -0,0 +1,28 @@
+import importlib
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from jinja2 import Environment
+from core import CodegenConfig
+
+
+@runtime_checkable
+class HooksModule(Protocol):
+    def register(self, env: Environment, *, target: str, config: CodegenConfig) -> None: ...
+
+
+def load_hooks(cfg: CodegenConfig, repo_root: Path) -> HooksModule | None:
+    if not cfg.hooks.module:
+        return None
+
+    import sys
+    if str(repo_root) not in sys.path:
+        sys.path.insert(0, str(repo_root))
+
+    try:
+        module = importlib.import_module(cfg.hooks.module)
+        if not isinstance(module, HooksModule):
+            raise ValueError(f"Hooks module {cfg.hooks.module} doesn't implement required interface")
+        return module
+    except ImportError as e:
+        raise RuntimeError(f"Failed to import hooks module {cfg.hooks.module}: {e}") from e

proto/__init__.py

@@ -0,0 +1,19 @@
+"""
+Protobuf handling functionality.
+
+Handles proto file discovery, descriptor set building, and proto source resolution.
+"""
+
+from .discover import discover_proto_files
+from .fds_loader import load_fds, print_fds_content
+from .proto_source import resolve_proto_root, ensure_git_checkout, LATEST_TAG
+from .protoc_runner import build_descriptor_set
+
+__all__ = [
+    "discover_proto_files",
+    "load_fds",
+    "print_fds_content",
+    "resolve_proto_root",
+    "ensure_git_checkout",
+    "build_descriptor_set",
+]

proto/discover.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from pathlib import Path
+import re
+
+from core import CodegenConfig
+
+
+_PROTO_ROOT_TOKEN = re.compile(r"\{\s*proto_root\s*\}")
+
+def _resolve_include(proto_root: Path, inc: str) -> list[Path]:
+    """
+    inc can be:
+      - relative folder: "google" or "foo/bar"
+      - templated: "{proto_root}/google" or "{ proto_root }/google"
+      - globby: "google/**" or "{proto_root}/**/v1"
+    Returns 1..N base paths (if glob expands).
+    """
+    proto_root = proto_root.resolve()
+
+    # Replace mustache-ish token if present
+    if _PROTO_ROOT_TOKEN.search(inc):
+        expanded = _PROTO_ROOT_TOKEN.sub(str(proto_root), inc)
+        base = Path(expanded)
+    else:
+        base = proto_root / inc
+
+    # If include contains glob chars, expand it
+    s = str(base)
+    if any(ch in s for ch in ["*", "?", "["]):
+        # glob needs a directory base; easiest is to glob from filesystem root if absolute
+        if base.is_absolute():
+            # Use Path("/") as root for absolute globs
+            matches = [p.resolve() for p in Path("/").glob(s.lstrip("/"))]
+        else:
+            matches = [p.resolve() for p in proto_root.glob(str(base.relative_to(proto_root)))]
+        return [p for p in matches if p.exists()]
+    else:
+        return [base.resolve()]
+
+
+def discover_proto_files(proto_root: Path, config: CodegenConfig) -> list[Path]:
+    proto_root = proto_root.resolve()
+
+    roots: list[Path] = []
+    if config.proto.includes:
+        for inc in config.proto.includes:
+            for r in _resolve_include(proto_root, inc):
+                # keep only dirs that are inside proto_root (avoid escaping)
+                if r == proto_root or proto_root in r.parents:
+                    roots.append(r)
+    else:
+        roots = [proto_root]
+
+    out: list[Path] = []
+    for base in roots:
+        if not base.exists():
+            continue
+        for pat in config.proto.files:
+            out.extend(base.glob(pat))  # supports **/*.proto, etc.
+
+    # unique + stable
+    uniq: list[Path] = []
+    seen: set[Path] = set()
+    for p in sorted(out):
+        rp = p.resolve()
+        if rp.is_file() and rp.suffix == ".proto" and rp not in seen:
+            uniq.append(rp)
+            seen.add(rp)
+    return uniq

proto/fds_loader.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.tree import Tree
+from rich.panel import Panel
+
+from google.protobuf import descriptor_pb2
+
+def load_fds(path: Path) -> descriptor_pb2.FileDescriptorSet:
+    fds = descriptor_pb2.FileDescriptorSet()
+    fds.ParseFromString(path.read_bytes())
+    return fds
+
+def print_fds_content(fds_path: Path, ctx: typer.Context, console: Console) -> None:
+    if not ctx.obj.verbose:
+        return
+
+    fds = descriptor_pb2.FileDescriptorSet()
+    fds.ParseFromString(fds_path.read_bytes())
+
+    tree = Tree(f"[bold]Descriptor Set[/] [dim]{fds_path}[/]")
+
+    files_node = tree.add(f"[cyan]Files[/] ({len(fds.file)})")
+    for fd in sorted(fds.file, key=lambda x: x.name):
+        file_node = files_node.add(f"[bold]{fd.name}[/] [dim]package={fd.package or '-'}[/]")
+
+        if fd.dependency:
+            deps = file_node.add(f"[dim]deps[/] ({len(fd.dependency)})")
+            for d in fd.dependency:
+                deps.add(d)
+
+        if fd.message_type:
+            msgs = file_node.add(f"[green]messages[/] ({len(fd.message_type)})")
+            for m in fd.message_type:
+                msgs.add(m.name)
+
+        if fd.enum_type:
+            enums = file_node.add(f"[magenta]enums[/] ({len(fd.enum_type)})")
+            for e in fd.enum_type:
+                enums.add(e.name)
+
+        if fd.service:
+            svcs = file_node.add(f"[yellow]services[/] ({len(fd.service)})")
+            for s in fd.service:
+                svc = svcs.add(s.name)
+                for meth in s.method:
+                    svc.add(f"{meth.name}  [dim]{meth.input_type} -> {meth.output_type}[/]")
+
+    console.print(Panel(tree, title="[bold]Descriptor contents[/]", border_style="blue"))

proto/proto_source.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+from pathlib import Path
+import subprocess
+import re
+
+from core.config import CodegenConfig, ProtoSource
+
+LATEST_TAG = "latest-tag"
+
+
+def _run(cmd: list[str], cwd: Path | None = None) -> str:
+    result = subprocess.run(cmd, cwd=str(cwd) if cwd else None, check=True, capture_output=True, text=True)
+    return result.stdout
+
+
+def _parse_semver(tag: str) -> tuple[int, int, int, str] | None:
+    """
+    Parse a semver-like tag into a comparable tuple.
+    Supports formats: v1.2.3, 1.2.3, v1.2.3-beta, etc.
+    Returns (major, minor, patch, suffix) or None if not a valid semver.
+    """
+    # Remove leading 'v' if present
+    version = tag.lstrip('v')
+
+    # Match semver pattern: major.minor.patch with optional suffix
+    match = re.match(r'^(\d+)\.(\d+)\.(\d+)(.*)$', version)
+    if not match:
+        return None
+
+    major, minor, patch, suffix = match.groups()
+    return (int(major), int(minor), int(patch), suffix)
+
+
+def _get_latest_semver_tag(dst: Path) -> str:
+    """
+    Get all tags from the repo and return the latest one by semver.
+    Raises RuntimeError if no valid semver tags are found.
+    """
+    output = _run(["git", "tag", "--list"], cwd=dst)
+    tags = [t.strip() for t in output.strip().split('\n') if t.strip()]
+
+    if not tags:
+        raise RuntimeError("No tags found in repository")
+
+    # Parse and filter valid semver tags
+    semver_tags = []
+    for tag in tags:
+        parsed = _parse_semver(tag)
+        if parsed:
+            # Sort by (major, minor, patch), prefer no suffix over suffix
+            # Empty suffix sorts after non-empty (we want stable releases first)
+            sort_key = (parsed[0], parsed[1], parsed[2], parsed[3] == '', parsed[3])
+            semver_tags.append((sort_key, tag))
+
+    if not semver_tags:
+        raise RuntimeError(f"No valid semver tags found. Available tags: {', '.join(tags)}")
+
+    # Sort by semver and get the latest
+    semver_tags.sort(reverse=True)
+    latest_tag = semver_tags[0][1]
+
+    return latest_tag
+
+
+def ensure_git_checkout(repo_url: str, ref: str, dst: Path) -> str:
+    """
+    Ensure git repo is cloned and checked out to the specified ref.
+    If ref is "latest-tag", resolves to the latest semver tag.
+    Returns the actual ref that was checked out.
+    """
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if not dst.exists():
+        _run(["git", "clone", repo_url, str(dst)])
+    _run(["git", "fetch", "--all", "--tags"], cwd=dst)
+
+    actual_ref = ref
+    if ref == LATEST_TAG:
+        actual_ref = _get_latest_semver_tag(dst)
+
+    _run(["git", "checkout", "--force", actual_ref], cwd=dst)
+    return actual_ref
+
+def resolve_proto_root(cfg: CodegenConfig, *, use_local: bool = False) -> Path:
+    """
+    Resolve the proto root directory.
+
+    When use_local=True (--local flag):
+        Uses proto.root from config (local filesystem path)
+
+    When use_local=False (default):
+        Uses proto.source.git to clone/fetch from git repository
+        Falls back to proto.root if no git source is configured
+    """
+    if use_local:
+        # --local flag: use local proto.root
+        if cfg.proto.root and cfg.proto.root != "":
+            p = Path(cfg.proto.root).resolve()
+            if p.exists():
+                return p
+            raise RuntimeError(f"proto.root path does not exist: {cfg.proto.root}")
+        raise RuntimeError("--local flag requires proto.root to be configured")
+
+    # Default: use git source
+    if cfg.proto.source:
+        src = cfg.proto.source
+        git_url = src.git
+        ref = src.ref or LATEST_TAG  # Default to latest-tag if not specified
+        if git_url:
+            cache_dir = Path(cfg.proto.cache_dir).resolve()
+            ensure_git_checkout(git_url, ref, cache_dir)
+            return cache_dir
+
+    # Fallback to local root if no git source configured
+    if cfg.proto.root and cfg.proto.root != "":
+        p = Path(cfg.proto.root).resolve()
+        if p.exists():
+            return p
+
+    raise RuntimeError("No proto.source.git configured and proto.root not found")

proto/protoc_runner.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+from pathlib import Path
+import subprocess
+import tempfile
+
+from core import CodegenConfig
+
+def build_descriptor_set(
+    config: CodegenConfig,
+    proto_root: Path,
+    proto_files: list[Path],
+    verbose: bool,
+) -> tuple[Path, Path | None]:
+    proto_root = proto_root.resolve()
+
+    if config.proto.source and config.proto.source.fds:
+        return Path(config.proto.source.fds), None
+
+    cache_dir = Path(config.proto.cache_dir).resolve() if config.proto.cache_dir else (Path.cwd() / ".cache")
+    out_dir = Path(tempfile.mkdtemp(prefix="wizard_protoc_codegen_", dir=cache_dir))
+    fds_path = out_dir / "descriptor.pb"
+
+    cmd: list[str] = ["protoc"]
+
+    # Include roots: proto_root + each configured include dir (resolve relative to proto_root)
+    include_dirs: list[Path] = [proto_root]
+    for inc in (config.proto.includes or []):
+        # if you support {proto_root} templating, apply it here the same way you do in discovery
+        p = (proto_root / inc).resolve() if "{proto_root}" not in inc else Path(inc.replace("{proto_root}", str(proto_root))).resolve()
+        if p.exists():
+            include_dirs.append(p)
+
+    # de-dupe include dirs
+    seen = set()
+    for d in include_dirs:
+        ds = str(d)
+        if ds not in seen:
+            cmd += ["-I", ds]
+            seen.add(ds)
+
+    cmd += ["--include_imports"]
+    if config.proto.source and getattr(config.proto.source, "include_info", False):
+        cmd += ["--include_source_info"]
+
+    cmd += [f"--descriptor_set_out={fds_path}"]
+
+    # pass proto file paths relative to proto_root
+    rels = [str(p.resolve().relative_to(proto_root)) for p in proto_files]
+    cmd += rels
+
+    if verbose:
+        print(" ".join(cmd))
+
+    subprocess.run(cmd, cwd=str(proto_root), check=True)
+    return fds_path, out_dir

utils/__init__.py

@@ -0,0 +1,17 @@
+"""
+Utility functions and classes.
+
+Contains helper functions for name transformations and other utilities.
+"""
+
+from .name import Name, to_snake, to_kebab, to_pascal, to_camel, to_macro_snake, to_macro
+
+__all__ = [
+    "Name",
+    "to_snake",
+    "to_kebab",
+    "to_pascal",
+    "to_camel",
+    "to_macro",
+    "to_macro_snake"
+]

utils/name.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+
+_WORD_RE = re.compile(r"[A-Z]+(?=[A-Z][a-z]|[0-9]|$)|[A-Z]?[a-z]+|[0-9]+")
+
+def _words(s: str) -> list[str]:
+    # Handles "MyMessage", "my_message", "my-message", "my message", "HTTPServer2"
+    s = s.replace("_", " ").replace("-", " ").strip()
+    parts: list[str] = []
+    for token in s.split():
+        parts.extend(_WORD_RE.findall(token))
+    return [p for p in parts if p]
+
+def to_snake(s: str) -> str:
+    w = _words(s)
+    return "_".join(p.lower() for p in w)
+
+def to_kebab(s: str) -> str:
+    w = _words(s)
+    return "-".join(p.lower() for p in w)
+
+def to_pascal(s: str) -> str:
+    w = _words(s)
+    return "".join(p[:1].upper() + p[1:].lower() for p in w)
+
+def to_camel(s: str) -> str:
+    w = _words(s)
+    if not w:
+        return ""
+    first = w[0].lower()
+    rest = "".join(p[:1].upper() + p[1:].lower() for p in w[1:])
+    return first + rest
+
+def to_macro(s: str) -> str:
+    w = _words(s)
+    return "".join(p.upper() for p in w)
+
+def to_macro_snake(s: str) -> str:
+    w = _words(s)
+    return "_".join(p.upper() for p in w)
+
+@dataclass(frozen=True)
+class Name:
+    raw: str
+
+    @property
+    def snake_case(self) -> str:
+        return to_snake(self.raw)
+
+    @property
+    def kebab_case(self) -> str:
+        return to_kebab(self.raw)
+
+    @property
+    def pascal_case(self) -> str:
+        return to_pascal(self.raw)
+
+    @property
+    def camel_case(self) -> str:
+        return to_camel(self.raw)
+
+    @property
+    def macro_case(self) -> str:
+        return to_macro(self.raw)
+
+    @property
+    def macro_snake_case(self) -> str:
+        return to_macro_snake(self.raw)