wry 0.5.1.dev5__tar.gz → 0.5.2__tar.gz

{wry-0.5.1.dev5 → wry-0.5.2}/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.2] - 2025-10-14
+
+### Fixed
+
+- **Optional list fields with comma-separated parsing** 🐛
+  **THE BIG ONE:** Fixed critical bug where `list[str] | None` and `Optional[list[str]]` fields didn't work with comma-separated parsing
+  - **Root cause**: Nested `Annotated` types created by `AutoWryModel` (e.g., `Annotated[Optional[Annotated[list[str], CommaSeparated]], AutoOption]`) weren't being properly unwrapped
+  - **Fix 1**: Extract metadata from inner `Annotated` types within `Optional`/`Union` wrappers
+  - **Fix 2**: Unwrap `Annotated` types after unwrapping `Optional` to get to the base list type
+  - Works with both model-wide `comma_separated_lists` ClassVar and per-field `CommaSeparated` annotation
+  - Works with `list[str] | None`, `Optional[list[T]]`, and all numeric types (int, float)
+
+### Added
+
+- **Comprehensive tests for optional comma-separated lists** ✅
+  Added 13 test cases covering all use cases and edge cases:
+  - MVP bug: `list[str] | None` with model-wide `comma_separated_lists`
+  - Per-field `Annotated[list[T], CommaSeparated] | None`
+  - Old-style `Optional[list[T]]` syntax
+  - Multiple types: str, int, float
+  - Required vs optional lists
+  - Source tracking verification
+  - Default values: `None`, `[]`, `default_factory`
+  - Space handling in comma-separated input
+  - Double-nested `Annotated` types (the actual bug pattern)
+  - **Total test count: 507 tests (all passing)** ✨
+
+## [0.5.1] - 2025-10-14
+
+### Fixed
+
+- **Comma-separated lists with `default_factory`** 🐛
+  - Fixed bug where fields with `default_factory=list` would receive `None` instead of empty list when not provided
+  - Added proper handling in `click_integration.py` to call `default_factory()` for default values
+  - All comma-separated list tests now pass without validation errors
+
 ### Added
 
 - **Development guidelines** 📚
@@ -17,6 +53,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **Test quality improvements** ✨
+  - Fixed Pydantic shadow warnings by renaming `source` field to `source_path`/`source_file` in test cases
+  - Added `@pytest.mark.filterwarnings` to suppress intentional warnings in tests
+  - Tests that validate warning behavior no longer pollute test output
+  - All 494 tests pass cleanly with zero warnings
+
+- **Test quality improvements** ✨
+  - Fixed Pydantic shadow warnings by renaming `source` field to `source_path`/`source_file` in test cases
+  - Added `@pytest.mark.filterwarnings` to suppress intentional warnings in tests
+  - Tests that validate warning behavior no longer pollute test output
+  - All 494 tests pass cleanly with zero warnings
+
 - **Documentation cross-references** 🔗
   - README.md: Added Contributing section with links to CONTRIBUTING.md, .cursorrules, AI_KNOWLEDGE_BASE.md
   - AI_KNOWLEDGE_BASE.md: Updated header with related documentation links

{wry-0.5.1.dev5/wry.egg-info → wry-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wry
-Version: 0.5.1.dev5
+Version: 0.5.2
 Summary: Why Repeat Yourself? - Define your CLI once with Pydantic models
 Author-email: Tyler House <26489166+tahouse@users.noreply.github.com>
 License: MIT
@@ -1071,6 +1071,7 @@ mypy wry
 wry has comprehensive documentation for different audiences:
 
 ### For Users
+
 - 📘 **`README.md`** (this file) - Getting started, features, usage examples
 - 📁 **`examples/`** - Working code examples
   - `examples/autowrymodel_comprehensive.py` - Complete AutoWryModel features
@@ -1078,12 +1079,14 @@ wry has comprehensive documentation for different audiences:
   - `examples/multimodel_comprehensive.py` - Multi-model usage
 
 ### For Contributors
+
 - 📖 **`CONTRIBUTING.md`** - Complete contributor guide with code patterns and checklists
 - 🤖 **`.cursorrules`** - AI assistant quick reference (references CONTRIBUTING.md)
 - 🚀 **`RELEASE_PROCESS.md`** - How to create releases and manage versions
 - 📋 **`TODO.md`** - Current tasks, planned features, and work in progress
 
 ### Technical Reference
+
 - 📚 **`AI_KNOWLEDGE_BASE.md`** - Complete technical reference for AI/LLMs (also useful for humans)
 - 📝 **`CHANGELOG.md`** - Version history and all changes
 - 🧪 **`tests/README.md`** - Test organization and structure
@@ -1092,12 +1095,14 @@ wry has comprehensive documentation for different audiences:
 ### Quick Start Navigation
 
 **I'm a user, I want to...**
+
 - Get started → README.md "Quick Start" section
 - See examples → `examples/` directory
 - Understand features → README.md "Features" section
 - Track config sources → README.md "Value Source Tracking" section
 
 **I'm a contributor, I want to...**
+
 - Set up development → CONTRIBUTING.md "Development Setup" section
 - Add a feature → CONTRIBUTING.md "Adding New Features" section
 - Run tests → CONTRIBUTING.md "Testing" section
@@ -1105,6 +1110,7 @@ wry has comprehensive documentation for different audiences:
 - Check current tasks → TODO.md
 
 **I'm an AI assistant, I want to...**
+
 - Quick reference → `.cursorrules`
 - Technical details → `AI_KNOWLEDGE_BASE.md`
 - Code patterns → `CONTRIBUTING.md`

{wry-0.5.1.dev5 → wry-0.5.2}/README.md

@@ -1027,6 +1027,7 @@ mypy wry
 wry has comprehensive documentation for different audiences:
 
 ### For Users
+
 - 📘 **`README.md`** (this file) - Getting started, features, usage examples
 - 📁 **`examples/`** - Working code examples
   - `examples/autowrymodel_comprehensive.py` - Complete AutoWryModel features
@@ -1034,12 +1035,14 @@ wry has comprehensive documentation for different audiences:
   - `examples/multimodel_comprehensive.py` - Multi-model usage
 
 ### For Contributors
+
 - 📖 **`CONTRIBUTING.md`** - Complete contributor guide with code patterns and checklists
 - 🤖 **`.cursorrules`** - AI assistant quick reference (references CONTRIBUTING.md)
 - 🚀 **`RELEASE_PROCESS.md`** - How to create releases and manage versions
 - 📋 **`TODO.md`** - Current tasks, planned features, and work in progress
 
 ### Technical Reference
+
 - 📚 **`AI_KNOWLEDGE_BASE.md`** - Complete technical reference for AI/LLMs (also useful for humans)
 - 📝 **`CHANGELOG.md`** - Version history and all changes
 - 🧪 **`tests/README.md`** - Test organization and structure
@@ -1048,12 +1051,14 @@ wry has comprehensive documentation for different audiences:
 ### Quick Start Navigation
 
 **I'm a user, I want to...**
+
 - Get started → README.md "Quick Start" section
 - See examples → `examples/` directory
 - Understand features → README.md "Features" section
 - Track config sources → README.md "Value Source Tracking" section
 
 **I'm a contributor, I want to...**
+
 - Set up development → CONTRIBUTING.md "Development Setup" section
 - Add a feature → CONTRIBUTING.md "Adding New Features" section
 - Run tests → CONTRIBUTING.md "Testing" section
@@ -1061,6 +1066,7 @@ wry has comprehensive documentation for different audiences:
 - Check current tasks → TODO.md
 
 **I'm an AI assistant, I want to...**
+
 - Quick reference → `.cursorrules`
 - Technical details → `AI_KNOWLEDGE_BASE.md`
 - Code patterns → `CONTRIBUTING.md`

{wry-0.5.1.dev5 → wry-0.5.2}/tests/features/test_inheritance.py

@@ -483,6 +483,8 @@ class TestInheritanceEdgeCases:
         assert len(ChildConfig.model_fields) == 2
 
 
+@pytest.mark.filterwarnings("ignore:Function.*already decorated:UserWarning")
+@pytest.mark.filterwarnings("ignore:The parameter.*is used more than once:UserWarning")
 class TestMultiModelInheritance:
     """Test inheritance scenarios with multi-model commands."""
 

{wry-0.5.1.dev5 → wry-0.5.2}/tests/features/test_multi_model.py

@@ -44,6 +44,7 @@ class CacheArgs(WryModel):
 class TestSplitKwargs:
     """Test the split_kwargs_by_model function."""
 
+    @pytest.mark.filterwarnings("ignore:Unused kwargs:UserWarning")
     def test_split_kwargs_basic(self):
         """Test basic kwarg splitting between models."""
         kwargs = {"host": "example.com", "port": 3306, "debug": True, "workers": 8, "unknown": "ignored"}
@@ -133,6 +134,8 @@ class TestCreateModels:
             create_models(ctx, kwargs, DatabaseArgs)
 
 
+@pytest.mark.filterwarnings("ignore:Function.*already decorated:UserWarning")
+@pytest.mark.filterwarnings("ignore:The parameter.*is used more than once:UserWarning")
 class TestMultiModelDecorator:
     """Test the multi_model decorator."""
 
@@ -279,6 +282,8 @@ class TestSingletonOption:
         # They should be different objects
         assert option1 is not option2
 
+    @pytest.mark.filterwarnings("ignore:Function.*already decorated:UserWarning")
+    @pytest.mark.filterwarnings("ignore:The parameter.*is used more than once:UserWarning")
     def test_singleton_option_in_model(self):
         """Test using singleton option in a model."""
         from wry.multi_model import _SINGLETON_OPTIONS

{wry-0.5.1.dev5 → wry-0.5.2}/tests/integration/test_click_integration_extended.py

@@ -457,6 +457,7 @@ class TestAddConfigOption:
 class TestExplicitClickDecorators:
     """Test handling of explicit Click decorators in annotations."""
 
+    @pytest.mark.filterwarnings("ignore:The parameter.*is used more than once:UserWarning")
     def test_explicit_option_decorator(self):
         """Test field with explicit click.option in annotation."""
 

{wry-0.5.1.dev5 → wry-0.5.2}/tests/integration/test_context_handling.py

@@ -3,6 +3,7 @@
 from typing import Annotated, Any
 
 import click
+import pytest
 from click.testing import CliRunner
 from pydantic import Field
 
@@ -78,6 +79,8 @@ class TestContextHandling:
         assert result.exit_code == 0
         assert "Name: direct" in result.output
 
+    @pytest.mark.filterwarnings("ignore:Function.*already decorated:UserWarning")
+    @pytest.mark.filterwarnings("ignore:The parameter.*is used more than once:UserWarning")
     def test_multiple_decorators_requires_care(self):
         """Test that multiple decorators need explicit pass_context control."""
 

wry-0.5.2/tests/unit/auto_model/test_optional_list_comma_separated.py

@@ -0,0 +1,388 @@
+"""Tests for comma-separated lists with Optional/Union types."""
+
+from typing import Annotated, Any, ClassVar
+
+import click
+from click.testing import CliRunner
+from pydantic import Field
+
+from wry import AutoWryModel, CommaSeparated
+
+
+class TestOptionalListCommaSeparated:
+    """Test comma-separated parsing with Optional list types."""
+
+    def test_mvp_bug_optional_list_model_wide_comma_separated(self):
+        """Test the exact MVP bug: list[str] | None with model-wide comma_separated_lists.
+
+        This was the original bug report where Optional list fields with comma_separated_lists
+        enabled at the model level would fail with validation errors.
+        """
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            items: list[str] | None = Field(default=None, description="List of items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Raw kwargs: {kwargs}")
+            click.echo(f"Parsed config: {config.items}")
+
+        runner = CliRunner()
+
+        # This was the failing case - passing comma-separated values
+        result = runner.invoke(cmd, ["--items", "x,y,z"])
+        assert result.exit_code == 0, f"Failed: {result.output}"
+        assert "Parsed config: ['x', 'y', 'z']" in result.output
+
+        # Also test with no value
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Parsed config: None" in result.output
+
+    def test_optional_list_with_comma_separated_model_wide(self):
+        """Test that Optional[list[T]] works with model-wide comma_separated_lists."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            items: list[str] | None = Field(default=None, description="List of items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+
+        runner = CliRunner()
+
+        # Test with comma-separated values
+        result = runner.invoke(cmd, ["--items", "a,b,c"])
+        assert result.exit_code == 0, f"Failed: {result.output}"
+        assert "Items: ['a', 'b', 'c']" in result.output
+
+        # Test with single value
+        result = runner.invoke(cmd, ["--items", "single"])
+        assert result.exit_code == 0
+        assert "Items: ['single']" in result.output
+
+        # Test with no value (should be None)
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Items: None" in result.output
+
+    def test_optional_list_with_per_field_comma_separated(self):
+        """Test that Optional[list[T]] works with per-field CommaSeparated annotation."""
+
+        class Config(AutoWryModel):
+            items: Annotated[list[str], CommaSeparated] | None = Field(default=None, description="List of items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+
+        runner = CliRunner()
+
+        # Test with comma-separated values
+        result = runner.invoke(cmd, ["--items", "x,y,z"])
+        assert result.exit_code == 0
+        assert "Items: ['x', 'y', 'z']" in result.output
+
+        # Test with no value (should be None)
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Items: None" in result.output
+
+    def test_optional_list_int_with_comma_separated(self):
+        """Test that Optional[list[int]] works with comma-separated parsing."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            ports: list[int] | None = Field(default=None, description="Port numbers")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Ports: {config.ports}")
+            if config.ports:
+                click.echo(f"Types: {[type(p).__name__ for p in config.ports]}")
+
+        runner = CliRunner()
+
+        # Test with comma-separated integers
+        result = runner.invoke(cmd, ["--ports", "80,443,8080"])
+        assert result.exit_code == 0
+        assert "Ports: [80, 443, 8080]" in result.output
+        assert "Types: ['int', 'int', 'int']" in result.output
+
+        # Test with no value (should be None)
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Ports: None" in result.output
+
+    def test_optional_list_with_default_empty_list(self):
+        """Test Optional list with default=[] instead of default=None."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            tags: list[str] | None = Field(default=[], description="Tags")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Tags: {config.tags}")
+
+        runner = CliRunner()
+
+        # Test with values
+        result = runner.invoke(cmd, ["--tags", "a,b"])
+        assert result.exit_code == 0
+        assert "Tags: ['a', 'b']" in result.output
+
+        # Test with no value (should be empty list)
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Tags: []" in result.output
+
+    def test_optional_list_with_default_factory(self):
+        """Test Optional list with default_factory."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            items: list[str] = Field(default_factory=list, description="Items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+
+        runner = CliRunner()
+
+        # Test with values
+        result = runner.invoke(cmd, ["--items", "a,b,c"])
+        assert result.exit_code == 0
+        assert "Items: ['a', 'b', 'c']" in result.output
+
+        # Test with no value (should be empty list from factory)
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Items: []" in result.output
+
+    def test_optional_list_old_syntax(self):
+        """Test Optional[list[T]] using old Optional[] syntax instead of | None."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            items: list[str] | None = Field(default=None, description="Items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+
+        runner = CliRunner()
+
+        # Test with values
+        result = runner.invoke(cmd, ["--items", "x,y"])
+        assert result.exit_code == 0
+        assert "Items: ['x', 'y']" in result.output
+
+        # Test with no value
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Items: None" in result.output
+
+    def test_optional_list_float(self):
+        """Test Optional[list[float]] with comma-separated parsing."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            values: list[float] | None = Field(default=None, description="Float values")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Values: {config.values}")
+            if config.values:
+                click.echo(f"Types: {[type(v).__name__ for v in config.values]}")
+
+        runner = CliRunner()
+
+        # Test with comma-separated floats
+        result = runner.invoke(cmd, ["--values", "1.5,2.7,3.14"])
+        assert result.exit_code == 0
+        assert "Values: [1.5, 2.7, 3.14]" in result.output
+        assert "Types: ['float', 'float', 'float']" in result.output
+
+        # Test with no value
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Values: None" in result.output
+
+    def test_mixed_optional_and_required_lists(self):
+        """Test model with both optional and required list fields."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            required_items: list[str] = Field(description="Required items")
+            optional_items: list[str] | None = Field(default=None, description="Optional items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Required: {config.required_items}")
+            click.echo(f"Optional: {config.optional_items}")
+
+        runner = CliRunner()
+
+        # Test with both fields
+        result = runner.invoke(cmd, ["--required-items", "a,b", "--optional-items", "x,y"])
+        assert result.exit_code == 0
+        assert "Required: ['a', 'b']" in result.output
+        assert "Optional: ['x', 'y']" in result.output
+
+        # Test with only required field
+        result = runner.invoke(cmd, ["--required-items", "a"])
+        assert result.exit_code == 0
+        assert "Required: ['a']" in result.output
+        assert "Optional: None" in result.output
+
+        # Test missing required field should fail
+        result = runner.invoke(cmd, [])
+        assert result.exit_code != 0
+
+    def test_optional_list_source_tracking(self):
+        """Test that source tracking works correctly with optional comma-separated lists."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            items: list[str] | None = Field(default=None, description="Items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+            click.echo(f"Source: {config.get_value_source('items').value}")
+
+        runner = CliRunner()
+
+        # Test CLI source
+        result = runner.invoke(cmd, ["--items", "a,b,c"])
+        assert result.exit_code == 0
+        assert "Items: ['a', 'b', 'c']" in result.output
+        assert "Source: cli" in result.output
+
+        # Test DEFAULT source when not provided
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Items: None" in result.output
+        assert "Source: default" in result.output
+
+    def test_optional_annotated_list_non_optional(self):
+        """Test non-optional Annotated list with CommaSeparated (for contrast)."""
+
+        class Config(AutoWryModel):
+            items: Annotated[list[str], CommaSeparated] = Field(description="Required items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+
+        runner = CliRunner()
+
+        # Test with values
+        result = runner.invoke(cmd, ["--items", "a,b,c"])
+        assert result.exit_code == 0
+        assert "Items: ['a', 'b', 'c']" in result.output
+
+        # Test without values should fail (required)
+        result = runner.invoke(cmd, [])
+        assert result.exit_code != 0
+
+    def test_optional_list_with_spaces(self):
+        """Test comma-separated parsing handles spaces correctly."""
+
+        class Config(AutoWryModel):
+            comma_separated_lists: ClassVar[bool] = True
+            items: list[str] | None = Field(default=None, description="Items")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+
+        runner = CliRunner()
+
+        # Test with spaces after commas (should be stripped)
+        result = runner.invoke(cmd, ["--items", "a, b, c"])
+        assert result.exit_code == 0
+        assert "Items: ['a', 'b', 'c']" in result.output
+
+        # Test single item with spaces
+        result = runner.invoke(cmd, ["--items", "  item  "])
+        assert result.exit_code == 0
+        assert "Items: ['item']" in result.output
+
+    def test_double_nested_optional_annotated(self):
+        """Test the specific pattern that was buggy.
+
+        Tests: Annotated[Optional[Annotated[list, CommaSeparated]], AutoOption]
+        """
+
+        class Config(AutoWryModel):
+            # This creates: Annotated[Optional[Annotated[list[str], CommaSeparated]], AutoOption]
+            items: Annotated[list[str], CommaSeparated] | None = Field(default=None, description="Items")
+            ports: Annotated[list[int], CommaSeparated] | None = Field(default=None, description="Ports")
+
+        @click.command()
+        @Config.generate_click_parameters()
+        @click.pass_context
+        def cmd(ctx: click.Context, **kwargs: Any):
+            config = Config.from_click_context(ctx, **kwargs)
+            click.echo(f"Items: {config.items}")
+            click.echo(f"Ports: {config.ports}")
+
+        runner = CliRunner()
+
+        # Test both fields
+        result = runner.invoke(cmd, ["--items", "a,b,c", "--ports", "80,443"])
+        assert result.exit_code == 0
+        assert "Items: ['a', 'b', 'c']" in result.output
+        assert "Ports: [80, 443]" in result.output
+
+        # Test neither field
+        result = runner.invoke(cmd, [])
+        assert result.exit_code == 0
+        assert "Items: None" in result.output
+        assert "Ports: None" in result.output
+
+        # Test only one field
+        result = runner.invoke(cmd, ["--items", "x"])
+        assert result.exit_code == 0
+        assert "Items: ['x']" in result.output
+        assert "Ports: None" in result.output

{wry-0.5.1.dev5 → wry-0.5.2}/tests/unit/click/test_explicit_argument_help_injection.py

@@ -57,7 +57,7 @@ class TestExplicitArgumentHelpInjection:
 
         class Config(WryModel):
             # Auto-generated argument with Field description
-            source: Annotated[str, AutoArgument] = Field(description="Source file")
+            source_file: Annotated[str, AutoArgument] = Field(description="Source file")
             # Explicit click.argument with help
             dest: Annotated[str, click.argument("destination", help="Destination file")] = Field()
 
@@ -70,7 +70,7 @@ class TestExplicitArgumentHelpInjection:
         # Both should be in the docstring
         assert cmd.__doc__ is not None
         assert "Arguments:" in cmd.__doc__
-        assert "SOURCE" in cmd.__doc__
+        assert "SOURCE_FILE" in cmd.__doc__
         assert "Source file" in cmd.__doc__
         assert "DESTINATION" in cmd.__doc__
         assert "Destination file" in cmd.__doc__

{wry-0.5.1.dev5 → wry-0.5.2}/tests/unit/test_argument_help_injection.py

@@ -16,7 +16,7 @@ class TestArgumentHelpInjection:
         """Test that AutoWryModel injects argument help into docstring."""
 
         class Config(AutoWryModel):
-            source: Annotated[str, AutoClickParameter.ARGUMENT] = Field(description="Source file path")
+            source_path: Annotated[str, AutoClickParameter.ARGUMENT] = Field(description="Source file path")
             dest: Annotated[str, AutoClickParameter.ARGUMENT] = Field(description="Destination file path")
             verbose: bool = False
 
@@ -25,14 +25,14 @@ class TestArgumentHelpInjection:
         def copy(**kwargs: Any):
             """Copy files from source to destination."""
             config = Config(**kwargs)
-            click.echo(f"{config.source} -> {config.dest}")
+            click.echo(f"{config.source_path} -> {config.dest}")
 
         runner = CliRunner()
         result = runner.invoke(copy, ["--help"])
 
         assert result.exit_code == 0
         assert "Arguments:" in result.output
-        assert "SOURCE" in result.output
+        assert "SOURCE_PATH" in result.output
         assert "Source file path" in result.output
         assert "DEST" in result.output
         assert "Destination file path" in result.output
@@ -116,7 +116,7 @@ class TestArgumentHelpInjection:
 
         class Config(AutoWryModel):
             # Argument with description
-            source: Annotated[str, AutoClickParameter.ARGUMENT] = Field(description="Source path")
+            source_path: Annotated[str, AutoClickParameter.ARGUMENT] = Field(description="Source path")
             # Argument without description - should not appear in docstring
             dest: Annotated[str, AutoClickParameter.ARGUMENT] = Field(default="out.txt")
 
@@ -125,14 +125,14 @@ class TestArgumentHelpInjection:
         def copy(**kwargs: Any):
             """Copy file."""
             config = Config(**kwargs)
-            click.echo(f"{config.source} -> {config.dest}")
+            click.echo(f"{config.source_path} -> {config.dest}")
 
         runner = CliRunner()
         result = runner.invoke(copy, ["--help"])
 
         assert result.exit_code == 0
         assert "Arguments:" in result.output
-        assert "SOURCE" in result.output
+        assert "SOURCE_PATH" in result.output
         assert "Source path" in result.output
         # DEST should not appear in Arguments section since it has no description
         # (it will appear in usage line though)