wizard-codegen 0.2.0__tar.gz → 0.2.2__tar.gz

wizard_codegen-0.2.0/README.md → wizard_codegen-0.2.2/PKG-INFO

@@ -1,3 +1,18 @@
+Metadata-Version: 2.4
+Name: wizard-codegen
+Version: 0.2.2
+Summary: A powerful, template-driven code generation tool for Protocol Buffers
+Requires-Python: >=3.10
+Requires-Dist: click==8.3.1
+Requires-Dist: jinja2==3.1.6
+Requires-Dist: protobuf==6.33.5
+Requires-Dist: pydantic-core==2.41.5
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: rich==14.3.3
+Requires-Dist: typer==0.21.1
+Description-Content-Type: text/markdown
+
 # 🧙 Wizard Codegen
 
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/ConsultingMD/wizard-codegen/tree/main.svg?style=svg&circle-token=CCIPRJ_6cYihJ2CPYtLrt8VjrCcSV_f02bbbce30f122a85da4e93588e8887e973128fd)](https://dl.circleci.com/status-badge/redirect/gh/ConsultingMD/wizard-codegen/tree/main)
@@ -46,6 +61,8 @@ handlers — this tool has you covered.
 | **Multi-Language Support** | Generate code for TypeScript, Swift, Kotlin, Go, and more                                                                |
 | **Jinja2 Templates**       | Full power of Jinja2 templating with custom filters                                                                      |
 | **Flexible Filtering**     | Target specific messages, enums, or services with `where` clauses                                                        |
+| **Runtime Name Filter**    | Generate only specific items from CLI: `wizard-codegen generate SampleProtoPage`                                         |
+| **Annotation Filtering**   | Filter messages by custom proto annotations/options (e.g., `has_option: "*.page"`)                                         |
 | **Git Proto Sources**      | Fetch proto definitions directly from Git repositories                                                                   |
 | **Multiple Write Modes**   | `overwrite`, `append`, or `write-once` file generation                                                                   |
 | **Custom Hooks**           | Extend with your own Jinja filters and helpers                                                                           |
@@ -53,6 +70,7 @@ handlers — this tool has you covered.
 | **Dry Run Mode**           | Preview changes without writing files                                                                                    |
 | **Verbose Output**         | Debug with detailed proto and context inspection                                                                         |
 | **Nested Type Support**    | Full support for nested messages and enums                                                                               |
+| **Options Extraction**     | Access message, field, and enum options in templates                                                                     |
 
 ---
 
@@ -193,9 +211,18 @@ The CLI is built with [Typer](https://typer.tiangolo.com/) and provides rich, co
 #### `generate` — Generate code from protos
 
 ```bash
-# Basic generation
+# Basic generation (all items)
 wizard-codegen generate
 
+# Generate only specific items by name
+wizard-codegen generate SampleProtoPage
+
+# Generate multiple specific items
+wizard-codegen generate SampleProtoPage UserFormPage
+
+# Use glob patterns to match item names
+wizard-codegen generate "*Page"
+
 # With custom config file
 wizard-codegen --config path/to/codegen.yaml generate
 
@@ -205,10 +232,12 @@ wizard-codegen --dry-run generate
 # Verbose mode (detailed output)
 wizard-codegen --verbose generate
 
-# Combine flags
-wizard-codegen --verbose --dry-run --config custom.yaml generate
+# Combine flags and name filter
+wizard-codegen --verbose --dry-run generate SampleProtoPage
 ```
 
+The optional positional `NAMES` arguments filter which items are generated at runtime. This works alongside any `where` clauses in your config — the config filters are applied first, then the name filter narrows the results further. Glob patterns (`*Page`, `Sample*`) and regex patterns are supported. When no names are provided, all matching items are generated as usual.
+
 #### `list-protos` — List discovered proto files
 
 ```bash
@@ -440,13 +469,14 @@ where:
 
 ##### Predicate Fields
 
-| Field           | Description               | Example                              |
-|-----------------|---------------------------|--------------------------------------|
-| `name`          | Message/enum/service name | `"*Form"`, `"User*"`, `"Order"`      |
-| `package`       | Proto package name        | `"wizard.*"`, `"com.example.*"`      |
-| `file`          | Proto file path           | `"*/shared/*"`, `"user/*.proto"`     |
-| `full_name`     | Fully qualified name      | `".wizard.UserForm"`                 |
-| `option.equals` | Match proto options       | `{ key: "deprecated", value: true }` |
+| Field           | Description                           | Example                                  |
+|-----------------|---------------------------------------|------------------------------------------|
+| `name`          | Message/enum/service name             | `"*Form"`, `"User*"`, `"Order"`          |
+| `package`       | Proto package name                    | `"wizard.*"`, `"com.example.*"`          |
+| `file`          | Proto file path                       | `"*/shared/*"`, `"user/*.proto"`         |
+| `full_name`     | Fully qualified name                  | `".wizard.UserForm"`                     |
+| `option.equals` | Match proto options                   | `{ key: "deprecated", value: true }`     |
+| `has_option`    | Check if option/annotation is present | `"*.page"`, `"annotations.wizard.v1.page"` |
 
 Patterns support:
 
@@ -508,7 +538,10 @@ When a template is rendered, it receives a rich context:
     "messages": [...],
     "enums": [...],
     "services": [...],
-    "options": < FileOptions >,
+    "options": {
+        # Extracted file options (standard and extensions)
+        # e.g., {"java_package": "com.example", "go_package": "example/pb"}
+    },
 }
 ```
 
@@ -529,11 +562,16 @@ When a template is rendered, it receives a rich context:
             "type_name": "",  # For message/enum refs: ".package.Type"
             "json_name": "userName",
             "field": < FieldDescriptor >,
+        "options": {},  # Extracted field options
 },
 ...
 ],
 "nested_messages": [...],
 "nested_enums": [...],
+"options": {
+    # Extracted message options (standard and extensions)
+    # Example: {"annotations.wizard.v1.page": True}
+},
 }
 ```
 
@@ -550,6 +588,7 @@ When a template is rendered, it receives a rich context:
         {"name": "STATUS_ACTIVE", "number": 1},
         ...
     ],
+    "options": {},  # Extracted enum options
 }
 ```
 
@@ -558,6 +597,7 @@ When a template is rendered, it receives a rich context:
 ```python
 {
     "name": Name("UserService"),
+    "full_name": ".wizard.UserService",
     "file": "user/user_service.proto",
     "package": "wizard",
     "methods": [
@@ -567,10 +607,11 @@ When a template is rendered, it receives a rich context:
             "output_type": ".wizard.User",
             "client_streaming": False,
             "server_streaming": False,
-            "options": < MethodOptions >,
-},
-...
-],
+            "options": {},  # Extracted method options
+        },
+        ...
+    ],
+    "options": {},  # Extracted service options
 }
 ```
 

wizard_codegen-0.2.0/PKG-INFO → wizard_codegen-0.2.2/README.md

@@ -1,18 +1,3 @@
-Metadata-Version: 2.4
-Name: wizard-codegen
-Version: 0.2.0
-Summary: A powerful, template-driven code generation tool for Protocol Buffers
-Requires-Python: >=3.10
-Requires-Dist: click==8.3.1
-Requires-Dist: jinja2==3.1.6
-Requires-Dist: protobuf==6.33.4
-Requires-Dist: pydantic-core==2.41.5
-Requires-Dist: pydantic==2.12.5
-Requires-Dist: pyyaml==6.0.3
-Requires-Dist: rich==14.3.1
-Requires-Dist: typer==0.21.1
-Description-Content-Type: text/markdown
-
 # 🧙 Wizard Codegen
 
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/ConsultingMD/wizard-codegen/tree/main.svg?style=svg&circle-token=CCIPRJ_6cYihJ2CPYtLrt8VjrCcSV_f02bbbce30f122a85da4e93588e8887e973128fd)](https://dl.circleci.com/status-badge/redirect/gh/ConsultingMD/wizard-codegen/tree/main)
@@ -61,6 +46,8 @@ handlers — this tool has you covered.
 | **Multi-Language Support** | Generate code for TypeScript, Swift, Kotlin, Go, and more                                                                |
 | **Jinja2 Templates**       | Full power of Jinja2 templating with custom filters                                                                      |
 | **Flexible Filtering**     | Target specific messages, enums, or services with `where` clauses                                                        |
+| **Runtime Name Filter**    | Generate only specific items from CLI: `wizard-codegen generate SampleProtoPage`                                         |
+| **Annotation Filtering**   | Filter messages by custom proto annotations/options (e.g., `has_option: "*.page"`)                                         |
 | **Git Proto Sources**      | Fetch proto definitions directly from Git repositories                                                                   |
 | **Multiple Write Modes**   | `overwrite`, `append`, or `write-once` file generation                                                                   |
 | **Custom Hooks**           | Extend with your own Jinja filters and helpers                                                                           |
@@ -68,6 +55,7 @@ handlers — this tool has you covered.
 | **Dry Run Mode**           | Preview changes without writing files                                                                                    |
 | **Verbose Output**         | Debug with detailed proto and context inspection                                                                         |
 | **Nested Type Support**    | Full support for nested messages and enums                                                                               |
+| **Options Extraction**     | Access message, field, and enum options in templates                                                                     |
 
 ---
 
@@ -208,9 +196,18 @@ The CLI is built with [Typer](https://typer.tiangolo.com/) and provides rich, co
 #### `generate` — Generate code from protos
 
 ```bash
-# Basic generation
+# Basic generation (all items)
 wizard-codegen generate
 
+# Generate only specific items by name
+wizard-codegen generate SampleProtoPage
+
+# Generate multiple specific items
+wizard-codegen generate SampleProtoPage UserFormPage
+
+# Use glob patterns to match item names
+wizard-codegen generate "*Page"
+
 # With custom config file
 wizard-codegen --config path/to/codegen.yaml generate
 
@@ -220,10 +217,12 @@ wizard-codegen --dry-run generate
 # Verbose mode (detailed output)
 wizard-codegen --verbose generate
 
-# Combine flags
-wizard-codegen --verbose --dry-run --config custom.yaml generate
+# Combine flags and name filter
+wizard-codegen --verbose --dry-run generate SampleProtoPage
 ```
 
+The optional positional `NAMES` arguments filter which items are generated at runtime. This works alongside any `where` clauses in your config — the config filters are applied first, then the name filter narrows the results further. Glob patterns (`*Page`, `Sample*`) and regex patterns are supported. When no names are provided, all matching items are generated as usual.
+
 #### `list-protos` — List discovered proto files
 
 ```bash
@@ -455,13 +454,14 @@ where:
 
 ##### Predicate Fields
 
-| Field           | Description               | Example                              |
-|-----------------|---------------------------|--------------------------------------|
-| `name`          | Message/enum/service name | `"*Form"`, `"User*"`, `"Order"`      |
-| `package`       | Proto package name        | `"wizard.*"`, `"com.example.*"`      |
-| `file`          | Proto file path           | `"*/shared/*"`, `"user/*.proto"`     |
-| `full_name`     | Fully qualified name      | `".wizard.UserForm"`                 |
-| `option.equals` | Match proto options       | `{ key: "deprecated", value: true }` |
+| Field           | Description                           | Example                                  |
+|-----------------|---------------------------------------|------------------------------------------|
+| `name`          | Message/enum/service name             | `"*Form"`, `"User*"`, `"Order"`          |
+| `package`       | Proto package name                    | `"wizard.*"`, `"com.example.*"`          |
+| `file`          | Proto file path                       | `"*/shared/*"`, `"user/*.proto"`         |
+| `full_name`     | Fully qualified name                  | `".wizard.UserForm"`                     |
+| `option.equals` | Match proto options                   | `{ key: "deprecated", value: true }`     |
+| `has_option`    | Check if option/annotation is present | `"*.page"`, `"annotations.wizard.v1.page"` |
 
 Patterns support:
 
@@ -523,7 +523,10 @@ When a template is rendered, it receives a rich context:
     "messages": [...],
     "enums": [...],
     "services": [...],
-    "options": < FileOptions >,
+    "options": {
+        # Extracted file options (standard and extensions)
+        # e.g., {"java_package": "com.example", "go_package": "example/pb"}
+    },
 }
 ```
 
@@ -544,11 +547,16 @@ When a template is rendered, it receives a rich context:
             "type_name": "",  # For message/enum refs: ".package.Type"
             "json_name": "userName",
             "field": < FieldDescriptor >,
+        "options": {},  # Extracted field options
 },
 ...
 ],
 "nested_messages": [...],
 "nested_enums": [...],
+"options": {
+    # Extracted message options (standard and extensions)
+    # Example: {"annotations.wizard.v1.page": True}
+},
 }
 ```
 
@@ -565,6 +573,7 @@ When a template is rendered, it receives a rich context:
         {"name": "STATUS_ACTIVE", "number": 1},
         ...
     ],
+    "options": {},  # Extracted enum options
 }
 ```
 
@@ -573,6 +582,7 @@ When a template is rendered, it receives a rich context:
 ```python
 {
     "name": Name("UserService"),
+    "full_name": ".wizard.UserService",
     "file": "user/user_service.proto",
     "package": "wizard",
     "methods": [
@@ -582,10 +592,11 @@ When a template is rendered, it receives a rich context:
             "output_type": ".wizard.User",
             "client_streaming": False,
             "server_streaming": False,
-            "options": < MethodOptions >,
-},
-...
-],
+            "options": {},  # Extracted method options
+        },
+        ...
+    ],
+    "options": {},  # Extracted service options
 }
 ```
 

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/cli/main.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import typer
 from pathlib import Path
+from contextlib import contextmanager
 from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
@@ -18,6 +19,17 @@ app = typer.Typer(no_args_is_help=True, rich_markup_mode="rich")
 console = Console()
 
 
+@contextmanager
+def _step(label: str, verbose: bool = False):
+    """Show a Rich spinner while a pipeline step runs. In verbose mode, print the label instead."""
+    if verbose:
+        console.print(f"[dim]→ {label}[/]")
+        yield
+    else:
+        with console.status(f"[bold]{label}[/]", spinner="dots"):
+            yield
+
+
 def version_callback(value: bool):
     if value:
         ver = get_version("wizard-codegen")
@@ -59,25 +71,44 @@ def common(
 
 
 @app.command(help="Generate code from protos")
-def generate(ctx: typer.Context):
+def generate(
+    ctx: typer.Context,
+    names: Optional[list[str]] = typer.Argument(
+        default=None,
+        help="Only generate for items matching these names (supports glob patterns)",
+    ),
+):
+    verbose = ctx.obj.verbose
     _print_verbose_enabled(ctx)
     config = _load_config(ctx.obj.config_path, ctx)
-    proto_root = resolve_proto_root(config, use_local=ctx.obj.local)
-    files = discover_proto_files(proto_root, config)
+
+    with _step("Resolving proto source", verbose):
+        proto_root = resolve_proto_root(config, use_local=ctx.obj.local)
+
+    with _step("Discovering proto files", verbose):
+        files = discover_proto_files(proto_root, config)
     _validate_proto_files(files, config, proto_root)
-    if ctx.obj.verbose:
+    if verbose:
         _print_files_table(files, proto_root)
 
-    fds_path, tmp_dir = build_descriptor_set(config, proto_root, files, ctx.obj.verbose)
+    with _step("Running protoc", verbose):
+        fds_path, tmp_dir = build_descriptor_set(config, proto_root, files, verbose)
     print_fds_content(fds_path, ctx, console)
-    fds = load_fds(fds_path)
-    jinja_ctx = build_context(config, fds)
+
+    with _step("Building context", verbose):
+        fds = load_fds(fds_path)
+        jinja_ctx = build_context(config, fds)
     print_build_context(jinja_ctx, ctx, console)
-    plan = render_all(config, jinja_ctx)
 
-    apply_plan(plan, ctx.obj.dry_run, ctx.obj.verbose)
+    with _step("Rendering templates", verbose):
+        plan = render_all(config, jinja_ctx, name_filter=names)
+
+    if names and not plan:
+        console.print(f"[bold yellow]Warning:[/] No items matched: {', '.join(names)}")
+
+    with _step("Writing files", verbose):
+        apply_plan(plan, ctx.obj.dry_run, verbose)
 
-    # Cleanup Tmp Dir
     if tmp_dir:
         shutil.rmtree(tmp_dir)
 
@@ -89,32 +120,45 @@ def generate(ctx: typer.Context):
 
 @app.command("list-protos", help="List available protos")
 def list_protos(ctx: typer.Context):
+    verbose = ctx.obj.verbose
     _print_verbose_enabled(ctx)
     config = _load_config(ctx.obj.config_path, ctx)
-    proto_root = resolve_proto_root(config, use_local=ctx.obj.local)
-    files = discover_proto_files(proto_root, config)
+
+    with _step("Resolving proto source", verbose):
+        proto_root = resolve_proto_root(config, use_local=ctx.obj.local)
+
+    with _step("Discovering proto files", verbose):
+        files = discover_proto_files(proto_root, config)
     _print_files_table(files, proto_root)
 
 
 @app.command(help="Validate the jinja2 templates, resolves proto root (git checkout), runs protoc descriptor build if needed, prints missing filters/variables")
 def validate(ctx: typer.Context):
+    verbose = ctx.obj.verbose
     _print_verbose_enabled(ctx)
     config = _load_config(ctx.obj.config_path, ctx)
-    proto_root = resolve_proto_root(config, use_local=ctx.obj.local)
-    files = discover_proto_files(proto_root, config)
-    _validate_proto_files(files, config, proto_root)
 
-    if ctx.obj.verbose:
+    with _step("Resolving proto source", verbose):
+        proto_root = resolve_proto_root(config, use_local=ctx.obj.local)
+
+    with _step("Discovering proto files", verbose):
+        files = discover_proto_files(proto_root, config)
+    _validate_proto_files(files, config, proto_root)
+    if verbose:
         _print_files_table(files, proto_root)
 
-    fds_path, tmp_dir = build_descriptor_set(config, proto_root, files, ctx.obj.verbose)
+    with _step("Running protoc", verbose):
+        fds_path, tmp_dir = build_descriptor_set(config, proto_root, files, verbose)
     print_fds_content(fds_path, ctx, console)
-    fds = load_fds(fds_path)
-    jinja_ctx = build_context(config, fds)
+
+    with _step("Building context", verbose):
+        fds = load_fds(fds_path)
+        jinja_ctx = build_context(config, fds)
     print_build_context(jinja_ctx, ctx, console)
-    render_all(config, jinja_ctx)
 
-    # Cleanup Tmp Dir
+    with _step("Rendering templates", verbose):
+        render_all(config, jinja_ctx)
+
     if tmp_dir:
         shutil.rmtree(tmp_dir)
 

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/core/config.py

@@ -33,6 +33,7 @@ class Predicate(BaseModel):
     file: str | None = None
     full_name: str | None = None
     option_equals: EqualsKV | None = Field(default=None, alias="option.equals")
+    has_option: str | None = Field(default=None, alias="has_option")
 
     model_config = {"populate_by_name": True}
 

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/core/context_builder.py

@@ -11,6 +11,7 @@ from rich.pretty import Pretty
 
 from .config import CodegenConfig
 from utils import Name
+from utils.options import extract_options, build_extension_registry
 
 
 def topo_order(files_by_name: dict[str, descriptor_pb2.FileDescriptorProto]) -> list[str]:
@@ -55,7 +56,11 @@ def _build_field_data(field: Any) -> Dict[str, Any]:
         "type": int(field.type),
         "type_name": field.type_name,
         "json_name": field.json_name,
-        "field": field
+        "field": field,
+        "options": extract_options(
+            getattr(field, 'options', None),
+            extendee_type=".google.protobuf.FieldOptions"
+        ),
     }
 
 
@@ -67,13 +72,23 @@ def _build_method_data(method: Any) -> Dict[str, Any]:
         "output_type": method.output_type,
         "client_streaming": bool(method.client_streaming),
         "server_streaming": bool(method.server_streaming),
-        "options": method.options,
+        "options": extract_options(
+            getattr(method, 'options', None),
+            extendee_type=".google.protobuf.MethodOptions"
+        ),
     }
 
 
 def _build_enum_value_data(value: Any) -> Dict[str, Any]:
     """Build enum value data dictionary from protobuf enum value descriptor."""
-    return {"name": value.name, "number": value.number}
+    return {
+        "name": value.name,
+        "number": value.number,
+        "options": extract_options(
+            getattr(value, 'options', None),
+            extendee_type=".google.protobuf.EnumValueOptions"
+        ),
+    }
 
 
 def _update_type_index(type_index: Dict[str, Any], full_name: str, kind: str, file_name: str, package: str) -> None:
@@ -99,6 +114,10 @@ def _process_nested_enum(
         "file": file_name,
         "package": package,
         "enum_values": enum_values,  # Use enum_values to avoid conflict with dict.values()
+        "options": extract_options(
+            getattr(enum, 'options', None),
+            extendee_type=".google.protobuf.EnumOptions"
+        ),
     }
 
     _update_type_index(type_index, full_name, "enum", file_name, package)
@@ -160,6 +179,10 @@ def _process_message_recursive(
         "package": package,
         "nested_messages": nested_messages,
         "nested_enums": nested_enums,
+        "options": extract_options(
+            getattr(message, 'options', None),
+            extendee_type=".google.protobuf.MessageOptions"
+        ),
     }
 
     _update_type_index(type_index, full_name, "message", file_name, package)
@@ -214,6 +237,10 @@ def _process_enums(
             "file": file_name,
             "package": package,
             "enum_values": enum_values,  # Use enum_values to avoid conflict with dict.values()
+            "options": extract_options(
+                getattr(enum, 'options', None),
+                extendee_type=".google.protobuf.EnumOptions"
+            ),
         }
 
         enums.append(enum_data)
@@ -238,9 +265,14 @@ def _process_services(
 
         service_data = {
             "name": Name(service.name),
+            "full_name": full_name,
             "methods": methods,
             "file": file_name,
-            "package": package
+            "package": package,
+            "options": extract_options(
+                getattr(service, 'options', None),
+                extendee_type=".google.protobuf.ServiceOptions"
+            ),
         }
 
         services.append(service_data)
@@ -274,12 +306,18 @@ def _process_proto_file(
         "messages": messages,
         "enums": enums,
         "services": services,
-        "options": proto_file.options,
+        "options": extract_options(
+            getattr(proto_file, 'options', None),
+            extendee_type=".google.protobuf.FileOptions"
+        ),
     }
 
 
 def build_context(cfg: CodegenConfig, fds: descriptor_pb2.FileDescriptorSet) -> Dict[str, Any]:
     """Build the complete context for code generation from proto file descriptors."""
+    # Build extension registry for extracting custom options
+    build_extension_registry(fds)
+
     files_by_name = {f.name: f for f in fds.file}
     ordered_files = topo_order(files_by_name)
 

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/core/filter.py

@@ -2,12 +2,18 @@ from __future__ import annotations
 import re
 from typing import Any
 from .config import Where, Predicate
+from utils import has_option as _has_option_util
 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 _has_opt(item: dict, option_name: str) -> bool:
+    """Check if an item has a specific option (supports suffix matching)."""
+    options = item.get("options") or {}
+    return _has_option_util(options, option_name)
+
 def _match_regex(value: str | None, pattern: str) -> bool:
     if value is None:
         return False
@@ -30,6 +36,9 @@ def _pred_ok(item: dict, p: Predicate) -> bool:
     if p.option_equals:
         if _get_opt(item, p.option_equals.key) != p.option_equals.value:
             return False
+    if p.has_option:
+        if not _has_opt(item, p.has_option):
+            return False
     return True
 
 def where_ok(item: dict, where: Where | None) -> bool:
@@ -53,6 +62,11 @@ def where_ok(item: dict, where: Where | None) -> bool:
 
     return True
 
+def matches_name_filter(item: dict, names: list[str]) -> bool:
+    """Return True if item's name matches any of the given name patterns."""
+    raw = _name_raw(item)
+    return any(_match_regex(raw, n) for n in names)
+
 def _name_raw(item: dict) -> str | None:
     n = item.get("name")
     if n is None:
@@ -62,4 +76,4 @@ def _name_raw(item: dict) -> str | None:
     if isinstance(n, dict):
         return n.get("raw")
     # dataclass / pydantic / simple object
-    return getattr(n, "raw", str(n))
+    return getattr(n, "raw", str(n))

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/core/renderer.py

@@ -5,7 +5,7 @@ from jinja2 import Environment, FileSystemLoader, StrictUndefined
 
 from .config import CodegenConfig
 from hooks import load_hooks
-from .filter import where_ok
+from .filter import where_ok, matches_name_filter
 from utils import expand_path
 
 @dataclass
@@ -46,7 +46,12 @@ def _render_item(item, context: dict, tpl, out_tpl, out_root: Path, mode: str) -
     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]:
+def render_all(
+    cfg: CodegenConfig,
+    context: dict,
+    out_override: Path | None = None,
+    name_filter: list[str] | None = None,
+) -> list[PlanItem]:
     plan: list[PlanItem] = []
 
     for target, tcfg in cfg.targets.items():
@@ -68,6 +73,8 @@ def render_all(cfg: CodegenConfig, context: dict, out_override: Path | None = No
                 for item in items:
                     if not where_ok(item, ep.where):
                         continue
+                    if name_filter and not matches_name_filter(item, name_filter):
+                        continue
                     plan_item = _render_item(item, context, tpl, out_tpl, out_root, ep.mode)
                     plan.append(plan_item)
             else:

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wizard-codegen"
-version = "0.2.0"
+version = "0.2.2"
 description = "A powerful, template-driven code generation tool for Protocol Buffers"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -9,9 +9,9 @@ dependencies = [
     "pydantic==2.12.5",
     "pydantic_core==2.41.5",
     "jinja2==3.1.6",
-    "rich==14.3.1",
+    "rich==14.3.3",
     "click==8.3.1",
-    "protobuf==6.33.4",
+    "protobuf==6.33.5",
     "pyyaml==6.0.3",
 ]
 

{wizard_codegen-0.2.0 → wizard_codegen-0.2.2}/utils/__init__.py

@@ -6,6 +6,7 @@ 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, to_micro
 from .path import expand_path
+from .options import extract_options, has_option, get_option, build_extension_registry
 
 __all__ = [
     "Name",
@@ -17,4 +18,8 @@ __all__ = [
     "to_micro",
     "to_macro_snake",
     "expand_path",
+    "extract_options",
+    "has_option",
+    "get_option",
+    "build_extension_registry",
 ]

wizard_codegen-0.2.2/utils/options.py

@@ -0,0 +1,511 @@
+"""Utility functions for extracting protobuf options and annotations."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Tuple
+import logging
+import struct
+
+# Global extension registry: maps (extendee_type, field_number) -> (full_name, type_name, field_type)
+# field_type is the protobuf type enum (TYPE_BOOL, TYPE_INT32, etc.) for decoding primitives.
+# This is populated by build_extension_registry() when loading the FDS
+_extension_registry: Dict[tuple, Tuple[str, str, int]] = {}
+
+# Global message registry: maps full_name -> list of (field_number, field_name, field_type)
+_message_registry: Dict[str, List[Tuple[int, str, int]]] = {}
+
+# Proto wire types
+WIRETYPE_VARINT = 0
+WIRETYPE_FIXED64 = 1
+WIRETYPE_LENGTH_DELIMITED = 2
+WIRETYPE_FIXED32 = 5
+
+# Proto field types
+TYPE_DOUBLE = 1
+TYPE_FLOAT = 2
+TYPE_INT64 = 3
+TYPE_UINT64 = 4
+TYPE_INT32 = 5
+TYPE_FIXED64 = 6
+TYPE_FIXED32 = 7
+TYPE_BOOL = 8
+TYPE_STRING = 9
+TYPE_MESSAGE = 11
+TYPE_BYTES = 12
+TYPE_UINT32 = 13
+TYPE_ENUM = 14
+TYPE_SFIXED32 = 15
+TYPE_SFIXED64 = 16
+TYPE_SINT32 = 17
+TYPE_SINT64 = 18
+
+
+def build_extension_registry(fds: Any) -> Dict[tuple, Tuple[str, str, int]]:
+    """
+    Build a registry of extensions from a FileDescriptorSet.
+
+    This extracts all extension definitions and creates a mapping from
+    (extendee, field_number) to (extension_full_name, extension_type_name, field_type).
+
+    Also builds a message registry for parsing extension message values.
+
+    Args:
+        fds: A FileDescriptorSet protobuf message
+
+    Returns:
+        A dictionary mapping (extendee_type, field_number) to (full_name, type_name, field_type).
+    """
+    global _extension_registry, _message_registry
+    registry: Dict[tuple, Tuple[str, str, int]] = {}
+    msg_registry: Dict[str, List[Tuple[int, str, int]]] = {}
+
+    try:
+        for file_desc in fds.file:
+            # Get package prefix for building full names
+            package = file_desc.package
+
+            # Build message registry for all messages
+            def register_message(msg, parent_name: str):
+                msg_full_name = f"{parent_name}.{msg.name}" if parent_name else f".{msg.name}"
+                if package and not parent_name:
+                    msg_full_name = f".{package}.{msg.name}"
+
+                fields = []
+                for field in msg.field:
+                    fields.append((field.number, field.name, field.type))
+                msg_registry[msg_full_name] = fields
+
+                for nested in msg.nested_type:
+                    register_message(nested, msg_full_name)
+
+            for msg in file_desc.message_type:
+                register_message(msg, "")
+
+            # Process file-level extensions
+            for ext in file_desc.extension:
+                extendee = ext.extendee  # e.g., ".google.protobuf.MessageOptions"
+                field_number = ext.number
+                type_name = ext.type_name  # e.g., ".annotations.wizard.v1.WizardPageOptions"
+                raw_type = getattr(ext, "type", 0)
+                field_type = int(raw_type) if isinstance(raw_type, int) else 0  # TYPE_* enum for decoding primitives
+                # Build full name: package.name
+                full_name = f"{package}.{ext.name}" if package else ext.name
+                registry[(extendee, field_number)] = (full_name, type_name, field_type)
+
+            # Process extensions nested in messages
+            def process_nested_extensions(msg, parent_name: str):
+                for ext in msg.extension:
+                    extendee = ext.extendee
+                    field_number = ext.number
+                    type_name = ext.type_name
+                    raw_type = getattr(ext, "type", 0)
+                    field_type = int(raw_type) if isinstance(raw_type, int) else 0
+                    full_name = f"{parent_name}.{ext.name}"
+                    registry[(extendee, field_number)] = (full_name, type_name, field_type)
+
+                for nested in msg.nested_type:
+                    nested_name = f"{parent_name}.{nested.name}"
+                    process_nested_extensions(nested, nested_name)
+
+            for msg in file_desc.message_type:
+                msg_name = f"{package}.{msg.name}" if package else msg.name
+                process_nested_extensions(msg, msg_name)
+    except (AttributeError, TypeError) as e:
+        # Intentionally ignore descriptor shape/type issues and fall back to empty registries.
+        # This allows callers to treat "unparseable" FileDescriptorSet objects as having no extensions.
+        _ = e
+
+    _extension_registry = registry
+    _message_registry = msg_registry
+    return registry
+
+
+def _parse_varint(data: bytes, pos: int) -> tuple:
+    """Parse a varint from bytes at the given position."""
+    result = 0
+    shift = 0
+    while pos < len(data):
+        byte = data[pos]
+        result |= (byte & 0x7f) << shift
+        pos += 1
+        if not (byte & 0x80):
+            break
+        shift += 7
+    return result, pos
+
+
+def _decode_zigzag(n: int) -> int:
+    """Decode a ZigZag-encoded signed integer."""
+    return (n >> 1) ^ -(n & 1)
+
+
+def _decode_varint_value(raw: int, field_type: int) -> Any:
+    """Decode a varint value according to protobuf field type (TYPE_*)."""
+    if field_type == TYPE_BOOL:
+        return bool(raw)
+    if field_type in (TYPE_SINT32, TYPE_SINT64):
+        return _decode_zigzag(raw)
+    return raw
+
+
+def _decode_fixed64_value(data: bytes, pos: int, field_type: int) -> Tuple[Any, int]:
+    """Decode 8 bytes at pos as FIXED64; return (value, new_pos)."""
+    if field_type == TYPE_DOUBLE:
+        return struct.unpack("<d", data[pos : pos + 8])[0], pos + 8
+    return int.from_bytes(data[pos : pos + 8], "little"), pos + 8
+
+
+def _decode_fixed32_value(data: bytes, pos: int, field_type: int) -> Tuple[Any, int]:
+    """Decode 4 bytes at pos as FIXED32; return (value, new_pos)."""
+    if field_type == TYPE_FLOAT:
+        return struct.unpack("<f", data[pos : pos + 4])[0], pos + 4
+    return int.from_bytes(data[pos : pos + 4], "little"), pos + 4
+
+
+def _parse_message_bytes(data: bytes, type_name: str) -> Dict[str, Any]:
+    """
+    Parse a serialized protobuf message into a dictionary.
+
+    Uses the message registry to map field numbers to names.
+
+    Args:
+        data: Serialized protobuf message bytes
+        type_name: Full name of the message type (e.g., ".annotations.wizard.v1.WizardPageOptions")
+
+    Returns:
+        A dictionary of field names to values.
+    """
+    result: Dict[str, Any] = {}
+
+    # Get field definitions for this message type
+    fields = _message_registry.get(type_name, [])
+    if not fields:
+        return result
+
+    # Build field lookup: number -> (name, type)
+    field_lookup: Dict[int, Tuple[str, int]] = {
+        f[0]: (f[1], f[2]) for f in fields
+    }
+
+    pos = 0
+    while pos < len(data):
+        try:
+            # Parse tag
+            tag, pos = _parse_varint(data, pos)
+            field_number = tag >> 3
+            wire_type = tag & 0x7
+
+            value: Any = None
+
+            if wire_type == WIRETYPE_VARINT:
+                value, pos = _parse_varint(data, pos)
+                # Check if it's a bool
+                if field_number in field_lookup:
+                    _, field_type = field_lookup[field_number]
+                    if field_type == TYPE_BOOL:
+                        value = bool(value)
+                    elif field_type in (TYPE_SINT32, TYPE_SINT64):
+                        value = _decode_zigzag(value)
+
+            elif wire_type == WIRETYPE_FIXED64:
+                value = int.from_bytes(data[pos:pos+8], 'little')
+                pos += 8
+
+            elif wire_type == WIRETYPE_LENGTH_DELIMITED:
+                length, pos = _parse_varint(data, pos)
+                raw_bytes = data[pos:pos+length]
+                pos += length
+
+                # Determine if it's a string or bytes based on field type
+                if field_number in field_lookup:
+                    _, field_type = field_lookup[field_number]
+                    if field_type == TYPE_STRING:
+                        value = raw_bytes.decode('utf-8')
+                    elif field_type == TYPE_BYTES:
+                        value = raw_bytes
+                    elif field_type == TYPE_MESSAGE:
+                        # Recursively parse nested message
+                        # We'd need to look up the nested type - for now just mark as present
+                        value = True
+                    else:
+                        value = raw_bytes
+                else:
+                    # Try to decode as string, fall back to bytes
+                    try:
+                        value = raw_bytes.decode('utf-8')
+                    except UnicodeDecodeError:
+                        value = raw_bytes
+
+            elif wire_type == WIRETYPE_FIXED32:
+                value = int.from_bytes(data[pos:pos+4], 'little')
+                pos += 4
+            else:
+                # Unknown wire type, skip
+                break
+
+            # Map field number to name
+            if field_number in field_lookup:
+                field_name, _ = field_lookup[field_number]
+                result[field_name] = value
+
+        except (IndexError, UnicodeDecodeError):
+            break
+
+    return result
+
+
+def _extract_unknown_extensions(options: Any, extendee_type: str) -> Dict[str, Any]:
+    """
+    Extract extension options from serialized unknown fields.
+
+    Custom extensions that aren't registered with Python protobuf are stored
+    as serialized bytes. This function parses those bytes to extract
+    extension field numbers and matches them against our registry.
+
+    Args:
+        options: A protobuf options message
+        extendee_type: The full name of the options type (e.g., ".google.protobuf.MessageOptions")
+
+    Returns:
+        A dictionary of extension names to values.
+    """
+    result: Dict[str, Any] = {}
+
+    try:
+        # Serialize the options to get all data including unknown fields
+        serialized = options.SerializeToString()
+        if not serialized:
+            return result
+
+        # Parse the wire format to find field numbers
+        pos = 0
+        while pos < len(serialized):
+            # Parse the tag (field number + wire type)
+            tag, pos = _parse_varint(serialized, pos)
+            field_number = tag >> 3
+            wire_type = tag & 0x7
+
+            value_bytes: bytes = b""
+            scalar_value: Any = None  # For VARINT/FIXED32/FIXED64
+
+            # Extract the value based on wire type
+            if wire_type == WIRETYPE_VARINT:
+                raw_varint, pos = _parse_varint(serialized, pos)
+                scalar_value = raw_varint
+            elif wire_type == WIRETYPE_FIXED64:
+                if (extendee_type, field_number) in _extension_registry:
+                    _, __, field_type = _extension_registry[(extendee_type, field_number)]
+                    scalar_value, pos = _decode_fixed64_value(serialized, pos, field_type)
+                else:
+                    pos += 8
+            elif wire_type == WIRETYPE_LENGTH_DELIMITED:
+                length, pos = _parse_varint(serialized, pos)
+                value_bytes = serialized[pos : pos + length]
+                pos += length
+            elif wire_type == WIRETYPE_FIXED32:
+                if (extendee_type, field_number) in _extension_registry:
+                    _, __, field_type = _extension_registry[(extendee_type, field_number)]
+                    scalar_value, pos = _decode_fixed32_value(serialized, pos, field_type)
+                else:
+                    pos += 4
+            else:
+                # Unknown wire type, can't continue
+                break
+
+            # Check if this field number is a known extension
+            key = (extendee_type, field_number)
+            if key in _extension_registry:
+                ext_name, ext_type_name, field_type = _extension_registry[key]
+
+                # If it's a message type (length-delimited), try to parse the value
+                if wire_type == WIRETYPE_LENGTH_DELIMITED and ext_type_name:
+                    parsed_value = _parse_message_bytes(value_bytes, ext_type_name)
+                    # If no fields were set, return True to indicate presence
+                    result[ext_name] = parsed_value if parsed_value else True
+                elif scalar_value is not None:
+                    # VARINT, FIXED32, or FIXED64: use actual decoded value
+                    if wire_type == WIRETYPE_VARINT:
+                        result[ext_name] = _decode_varint_value(scalar_value, field_type)
+                    else:
+                        result[ext_name] = scalar_value
+                else:
+                    result[ext_name] = True
+
+    except (AttributeError, TypeError, IndexError) as e:
+        # Intentionally ignore malformed / unexpected option data and fall back to an empty result.
+        # Log at debug level to aid troubleshooting without breaking callers.
+        logging.debug("Failed to extract unknown extensions from options %r: %s", options, e)
+
+    return result
+
+
+def extract_options(options: Any, extendee_type: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Extract options from a protobuf options message into a dictionary.
+
+    This function handles both standard protobuf options (like 'deprecated')
+    and custom extension options (like 'annotations.wizard.v1.page').
+
+    Args:
+        options: A protobuf options message (MessageOptions, FieldOptions, etc.)
+                 or None
+        extendee_type: Optional. The full name of the options message type
+                       (e.g., ".google.protobuf.MessageOptions"). Required for
+                       extracting custom extensions.
+
+    Returns:
+        A dictionary mapping option names to their values.
+        Standard options use short names (e.g., 'deprecated').
+        Extension options use their full qualified name
+        (e.g., 'annotations.wizard.v1.page').
+
+    Example:
+        For a message with option (annotations.wizard.v1.page) = {};
+        Returns: {'annotations.wizard.v1.page': True}
+
+        For a message with option deprecated = true;
+        Returns: {'deprecated': True}
+    """
+    if options is None:
+        return {}
+
+    result: Dict[str, Any] = {}
+
+    # First, extract known fields via ListFields()
+    try:
+        for field_desc, value in options.ListFields():
+            # Check if this is an extension field
+            if field_desc.is_extension:
+                # Use the full name for extension options
+                # e.g., "annotations.wizard.v1.page"
+                key = field_desc.full_name
+            else:
+                # Use the simple name for standard options
+                # e.g., "deprecated", "java_package"
+                key = field_desc.name
+
+            # Convert the value to a Python-friendly format
+            result[key] = _convert_value(value)
+    except (AttributeError, TypeError):
+        # If options doesn't support ListFields (e.g., Mock object without setup)
+        pass
+
+    # Then, extract unknown extensions from serialized data.
+    # Only add entries for keys not already in result, so we never overwrite
+    # extensions that were properly extracted via ListFields() with lower-fidelity
+    # wire-parsed values (e.g., nested messages would become True).
+    if extendee_type and _extension_registry:
+        unknown_extensions = _extract_unknown_extensions(options, extendee_type)
+        for k, v in unknown_extensions.items():
+            if k not in result:
+                result[k] = v
+
+    return result
+
+
+def _convert_value(value: Any) -> Any:
+    """
+    Convert a protobuf value to a Python-friendly format.
+
+    Args:
+        value: A protobuf value (could be a message, repeated field, etc.)
+
+    Returns:
+        A Python-native representation of the value.
+    """
+    # Check if it's a repeated field (list-like)
+    if hasattr(value, '__iter__') and not isinstance(value, (str, bytes)):
+        try:
+            # Try to convert as a list
+            return [_convert_value(v) for v in value]
+        except TypeError:
+            pass
+
+    # Check if it's a message type with fields
+    if hasattr(value, 'ListFields'):
+        # It's a nested message, convert it to a dict
+        nested = {}
+        try:
+            for field_desc, field_value in value.ListFields():
+                nested[field_desc.name] = _convert_value(field_value)
+        except (AttributeError, TypeError) as exc:
+            # Intentionally ignore descriptor/type issues when inspecting nested messages.
+            # This keeps option extraction robust for mock or non-standard message-like objects.
+            logging.debug("Failed to ListFields() on nested value %r: %s", value, exc)
+        # If the message is empty (no fields set), return True to indicate presence
+        return nested if nested else True
+
+    # Check if it's an enum value
+    if hasattr(value, 'number') and hasattr(value, 'name'):
+        return value.name
+
+    # Return primitive values as-is
+    return value
+
+
+def has_option(options: Dict[str, Any], option_name: str) -> bool:
+    """
+    Check if an option is present in the extracted options dictionary.
+
+    Matching modes:
+    - Exact match: `"annotations.wizard.v1.page"` matches only that exact key
+    - Glob pattern (with `*`): `"*.page"` matches any option ending with `.page`
+    - Glob pattern: `"annotations.*"` matches any option starting with `annotations.`
+
+    Args:
+        options: The extracted options dictionary
+        option_name: The option name or glob pattern to check for
+
+    Returns:
+        True if the option is present, False otherwise.
+
+    Examples:
+        has_option({"annotations.wizard.v1.page": True}, "annotations.wizard.v1.page")  # True
+        has_option({"annotations.wizard.v1.page": True}, "*.page")  # True
+        has_option({"annotations.wizard.v1.page": True}, "page")  # False (no wildcard)
+    """
+    import fnmatch
+
+    if not options:
+        return False
+
+    # Check if it's a glob pattern (contains *)
+    if "*" in option_name:
+        for key in options:
+            if fnmatch.fnmatch(key, option_name):
+                return True
+        return False
+
+    # Exact match only
+    return option_name in options
+
+
+def get_option(options: Dict[str, Any], option_name: str) -> Any:
+    """
+    Get an option value from the extracted options dictionary.
+
+    Supports the same matching as has_option:
+    - Exact match: `"annotations.wizard.v1.page"` matches only that exact key
+    - Glob pattern (with `*`): `"*.page"` matches any option ending with `.page`
+
+    Args:
+        options: The extracted options dictionary
+        option_name: The option name or glob pattern to get
+
+    Returns:
+        The option value if found, None otherwise.
+    """
+    import fnmatch
+
+    if not options:
+        return None
+
+    # Check if it's a glob pattern (contains *)
+    if "*" in option_name:
+        for key, value in options.items():
+            if fnmatch.fnmatch(key, option_name):
+                return value
+        return None
+
+    # Exact match only
+    return options.get(option_name)