pyopenapi-gen 0.13.0__tar.gz → 0.14.1__tar.gz

{pyopenapi_gen-0.13.0 → pyopenapi_gen-0.14.1}/CHANGELOG.md

@@ -1,6 +1,296 @@
 # CHANGELOG
 
 
+## v0.14.1 (2025-10-10)
+
+### Bug Fixes
+
+- **exceptions**: Sort alias names before generating __all__ list
+  ([`3a623ec`](https://github.com/mindhiveoy/pyopenapi_gen/commit/3a623ecde7457410ab3c0ed2a62adfdb378d3f6a))
+
+- **helpers**: Modernize TypeCleaner for Python 3.9+ type syntax and union preservation
+  ([`856fc33`](https://github.com/mindhiveoy/pyopenapi_gen/commit/856fc330752fa1046aac0fb028376329569d8b99))
+
+Extended TypeCleaner to handle modern Python type syntax patterns:
+
+1. Dict/dict case sensitivity (Lines 69, 261-296): - Added "or container == 'dict'" to container
+  type detection - Updated _clean_dict_type() to handle both Dict[] and dict[] - Always outputs
+  lowercase dict[] per Python 3.9+ conventions - Preserves backward compatibility during transition
+  period
+
+2. Modern union syntax preservation (Lines 45-51): - Added early handling for " | " to prevent type
+  truncation - Detects top-level unions before container parsing - Splits by pipe, cleans parts
+  independently, rejoins with union operator - Prevents "List[X] | None" being treated as malformed
+  List type
+
+3. Optional to modern union conversion: - Updated special cases to convert Optional[X] to X | None
+  format - Removed Optional from imports (no longer needed) - Modernizes type annotations throughout
+  cleaned output
+
+Bug fixes resolved: - 36 syntax errors from union truncation: "List[X] | None" → "List[X] | Non]" -
+  Case sensitivity failures after Ruff auto-formatting Dict → dict - Inconsistent type syntax in
+  generated code
+
+Impact: Fixes business_swagger.json client generation errors
+
+Quality gates: All 1278 tests passing, zero regressions
+
+- **parsing**: Add type annotation for additionalProperties field to resolve mypy error
+  ([`6d4244a`](https://github.com/mindhiveoy/pyopenapi_gen/commit/6d4244a00a35d375c666510ec61754c1d36774e8))
+
+Define explicit type for additional_properties_value parameter in _parse_schema(): - Type
+  annotation: bool | IRSchema | None - Resolves mypy strict mode error on line 566 - Supports three
+  OpenAPI additionalProperties patterns: * bool: true/false for allowing/disallowing additional
+  properties * IRSchema: schema object defining additional property validation * None:
+  additionalProperties not specified in OpenAPI spec
+
+Technical context: - mypy --strict requires explicit types for union type assignments - Field can
+  receive different types based on OpenAPI specification structure - Conditional assignment at line
+  573 assigns bool, dict-parsed IRSchema, or None - No functional changes, only type safety
+  improvement for static analysis
+
+Resolves: mypy error "Incompatible types in assignment (expression has type...)"
+
+### Code Style
+
+- **format**: Apply Black formatting to modernised type syntax changes
+  ([`3fb6baa`](https://github.com/mindhiveoy/pyopenapi_gen/commit/3fb6baaf6d1e2c1918cd0d64935f7d5a390daadc))
+
+- **format**: Apply Ruff auto-formatting to entire codebase
+  ([`3b0ab6b`](https://github.com/mindhiveoy/pyopenapi_gen/commit/3b0ab6bcabe4caeee33a0e09f83bf28f58bfde76))
+
+Applied Ruff formatting to 116 files for code style consistency: - Executed: make quality-fix (Ruff
+  format + lint --fix) - Changes: Import sorting, line breaks, whitespace normalization - No
+  functional changes, only formatting adjustments
+
+Files affected: - src/pyopenapi_gen/: 72 files (core, helpers, types, visit, emitters) - tests/: 44
+  files (all test modules) - input/business_swagger.json: Reformatted JSON structure
+
+Formatting changes: - Import statement ordering per PEP 8 - Line length normalization (120 char
+  limit) - Trailing whitespace removal - Consistent indentation and spacing
+
+Quality gates: ✅ make format-check: PASSED ✅ make lint: PASSED ✅ make typecheck: PASSED ✅ make test:
+  1278 passed, 88.48% coverage
+
+No functional changes, zero test regressions
+
+- **lint**: Remove unused TypeFinalizer import from alias_generator
+  ([`7b27e7c`](https://github.com/mindhiveoy/pyopenapi_gen/commit/7b27e7c5306c252bd816661e6815395ec431f2ce))
+
+### Refactoring
+
+- **types**: Enforce modern Python 3.10+ type syntax across unified type system
+  ([`f642a67`](https://github.com/mindhiveoy/pyopenapi_gen/commit/f642a679760d84aa7f3c3fdbefd856056b8a02bd))
+
+Eliminate legacy Optional[X] syntax in favour of modern X | None throughout the unified type
+  resolution pipeline, establishing architectural guarantees with three-layer protection against
+  Optional[X] leaks.
+
+Technical changes:
+
+1. UnifiedTypeService (_format_resolved_type): - Added SANITY CHECK raising ValueError for
+  Optional[X] production - Reordered formatting: quote forward refs BEFORE adding | None - Modern
+  syntax: "DataSource" | None (not "DataSource | None") - Architecture guarantee: ONLY X | None
+  syntax, NEVER Optional[X]
+
+2. TypeFinalizer (_wrap_with_optional_if_needed): - Added SANITY CHECK with error logging for
+  Optional[X] reception - Removed all Optional import statements (not needed in Python 3.10+) -
+  Fixed operation order: clean BEFORE wrapping prevents TypeCleaner breaking patterns - Defensive
+  conversion with warning for architectural violations
+
+3. ResponseHandlerGenerator (_get_base_schema_deserialization_code): - Added SANITY CHECK for
+  Optional[X] in response deserialization - New code path for modern X | None syntax handling -
+  Removed Optional from type checking and model detection - Maintains backward compatibility with
+  defensive conversion
+
+4. SchemaResolver: - Fixed null schema handling to respect required parameter - Changed
+  _resolve_any() to accept required parameter for correct optionality - Updated all Any fallbacks to
+  respect required throughout resolver chain
+
+5. ResponseResolver: - Modernised AsyncIterator[Dict[str, Any]] to AsyncIterator[dict[str, Any]] -
+  Removed unnecessary Dict import (uses lowercase dict)
+
+6. AliasGenerator & DataclassGenerator: - Removed duplicate TypeCleaner calls (already handled by
+  TypeFinalizer) - TypeFinalizer now performs cleaning in correct order - Added type hints to
+  dict-like methods (keys, values, items)
+
+Three-layer protection against Optional[X]: - Layer 1: UnifiedTypeService raises exception if
+  Optional[X] produced - Layer 2: TypeFinalizer logs error if Optional[X] received - Layer 3:
+  ResponseHandlerGenerator logs error if Optional[X] in deserialization
+
+Breaking changes: None (defensive conversions maintain compatibility)
+
+All tests passing: 1298 tests, zero regressions
+
+### Testing
+
+- Update test assertions for modern Python 3.10+ type syntax
+  ([`9644bf7`](https://github.com/mindhiveoy/pyopenapi_gen/commit/9644bf72d41769510b3d9a6774521ee5fd75b6c9))
+
+Update test expectations to align with unified type system's modern X | None syntax, removing
+  assertions for Optional import presence and modernising type checking patterns.
+
+Test changes:
+
+1. test_type_helper.py: - Removed 8 assertions checking for Optional import (not needed in Python
+  3.10+) - Updated finalize() expectations to use X | None syntax - Fixed Union type expectations:
+  Union[int, float] | None (not Optional[Union[...]])
+
+2. test_loader.py: - Updated regex to match modern dict[str, Any] (not Dict[str, Any]) - Updated
+  both params and query_params patterns
+
+3. test_endpoints_emitter.py: - Accept both Dict and dict in type checking - Removed strict Optional
+  import requirement
+
+4. test_models_emitter.py: - Updated datetime test: Python 3.10+ doesn't need Optional import -
+  Updated optional list factory test: only List import needed - Updated union anyof test: accepts
+  modern syntax
+
+5. test_type_cleaner.py: - Fixed test to use public API instead of private _clean_simple_patterns -
+  Tests now verify clean_type_parameters() public interface
+
+6. test_agent_include_parameter_typing.py: - Added circular reference placeholder detection - Test
+  now handles unified cycle detection properly
+
+7. test_response_resolver.py, test_schema_resolver.py, test_business_swagger_message_type.py: -
+  Updated type expectations for modern syntax - Removed Optional-specific assertions
+
+All test updates are assertion-only (no logic changes) Test results: 1298 tests passing, 2 warnings
+  (expected from edge case tests)
+
+- **regression**: Add comprehensive coverage for three critical bug classes
+  ([`0b5a7ba`](https://github.com/mindhiveoy/pyopenapi_gen/commit/0b5a7ba44d7b58007ef5ed0d446547ec34f8199f))
+
+Added 8 regression tests protecting against recently discovered bugs:
+
+1. JsonValue wrapper class generation (1 test) File: tests/visit/model/test_json_value_wrapper.py
+  Scenario: Schema with additionalProperties: {nullable: true} Bug: Generated empty class instead of
+  dict-like wrapper with __getitem__ Protection: Validates wrapper class structure and dict-like
+  interface
+
+2. Null schema resolution (4 tests) File: tests/types/test_schema_resolver.py Bug: Schemas with
+  type=None resolved to None instead of Any Impact: Type name collisions across unrelated fields in
+  generated code Tests cover: - test_resolve_schema__null_type_schema__returns_any -
+  test_resolve_schema__null_type_schema_optional__returns_any_with_optional_flag -
+  test_resolve_schema__schema_no_type_no_generation_name__returns_any -
+  test_resolve_schema__schema_no_type_but_has_generation_name__resolves_as_named
+
+3. Modern union syntax preservation (2 tests) File: tests/helpers/test_type_cleaner.py Bug:
+  Top-level unions "List[X] | None" truncated to "List[X] | Non]" Impact: 36 syntax errors in
+  business_swagger.json client Tests cover: -
+  test_clean_type_parameters__modern_union_syntax_with_list__preserves_full_type -
+  test_clean_type_parameters__modern_union_syntax_nested__handles_correctly
+
+4. Integration test (1 test) File: tests/visit/model/test_json_value_integration.py End-to-end
+  validation of wrapper generation pipeline
+
+Test execution results: - New tests: 8/8 PASSING - Total suite: 1278 passed - Coverage: 88.48%
+  (above 85% requirement) - Zero regressions introduced
+
+Protects against: business_swagger.json generation failures discovered in production
+
+
+## v0.14.0 (2025-10-06)
+
+### Documentation
+
+- Remove legacy commands from development guide
+  ([`396680e`](https://github.com/mindhiveoy/pyopenapi_gen/commit/396680e93f15cabc638af0a1170853cfa3d6e5de))
+
+Removed outdated "Legacy Commands" section from CLAUDE.md development guide as modern commands are
+  already documented in "Essential Commands" section.
+
+Technical Details: - Removed 5 lines of legacy command documentation - Deleted commands that are
+  superseded by Makefile targets: * pytest --cov=src --cov-report=html (use: make test-cov) * ruff
+  check --fix src/ (use: make lint-fix) * mypy src/ --strict (use: make typecheck) - Modern
+  equivalents already documented with better descriptions - Simplified development workflow
+  documentation
+
+Impact: - No functional changes - Documentation now clearer with single source of truth for commands
+  - Developers directed to use consistent Makefile targets
+
+### Features
+
+- **exceptions**: Implement human-readable exception names and shared core registry
+  ([`6983037`](https://github.com/mindhiveoy/pyopenapi_gen/commit/69830375a5a8e93b14c6cf2cf7b289093b57a346))
+
+Replaces generic numeric exception names with semantic, human-readable names and adds registry
+  system for multi-client shared core scenarios.
+
+Technical Details: - Created http_status_codes.py with comprehensive HTTP status code mapping (400 →
+  BadRequestError, 404 → NotFoundError, 500 → InternalServerError) - Exception classes now include
+  human-readable status names in docstrings - Filters out 2xx success codes from exception
+  generation (no error classes for successful responses using is_error_code() helper) - Implements
+  .exception_registry.json to track exceptions needed by each client in shared core scenarios -
+  Registry prevents last client from overwriting exceptions needed by earlier clients when multiple
+  clients share a core package - Generated exception_aliases.py is Ruff-compliant from generation
+  (proper import ordering with third-party before local, correct spacing)
+
+Breaking Changes: - Generated exception class names changed from Error{code} to semantic names
+  (Error404 → NotFoundError, Error401 → UnauthorisedError, etc.) - Affects generated client code but
+  not runtime behavior - ExceptionsEmitter.emit() now accepts optional client_package_name parameter
+  - ExceptionVisitor.visit() returns tuple of (code, names, status_codes) instead of (code, names)
+
+Migration Notes: - Regenerate all clients to get new human-readable exception names - No code
+  changes required for clients using exception handling - Registry file (.exception_registry.json)
+  automatically managed - Clients continue to catch exceptions the same way, just with better names
+
+Implementation: - HTTP_EXCEPTION_NAMES maps status codes to semantic class names -
+  get_exception_class_name() provides consistent name resolution - get_status_name() provides
+  human-readable descriptions - is_error_code() filters to only 4xx/5xx codes - Registry system uses
+  JSON to track multi-client exception requirements
+
+### Performance Improvements
+
+- **postprocess**: Optimize Ruff execution with bulk operations (25x faster)
+  ([`eed3c34`](https://github.com/mindhiveoy/pyopenapi_gen/commit/eed3c346da9ddbb9daa1d745e8bc8f8f46c6e9b6))
+
+Changed from per-file Ruff subprocess calls to bulk operations on all files, reducing generation
+  time from 120+ seconds to 5.4 seconds for large specs.
+
+Technical Details: - Added remove_unused_imports_bulk(), sort_imports_bulk(), format_code_bulk()
+  methods that process all files in a single subprocess call - Changed from 2,331 individual
+  subprocess calls to 3 bulk calls for 777 files - Performance improvement: 120+ seconds → 5.4
+  seconds (25x speedup) - Temporarily disabled mypy type checking for faster iteration
+  (configurable, can be re-enabled when full validation needed) - Fixed docstring empty line
+  handling in PythonConstructRenderer to avoid trailing whitespace (Ruff W293 compliance)
+
+Implementation Approach: - Subprocess.run() executes ruff with list of all file paths as arguments
+  instead of individual calls per file - Maintained existing error handling and output filtering
+  logic - Preserved per-file methods for backward compatibility - Empty lines in class body_lines
+  now use writer.newline() instead of write_line("") to prevent indentation on blank lines
+
+Performance Impact: - Large spec generation (777 files): 120s → 5.4s - No change to generated code
+  quality or Ruff compliance - All formatting, linting, and import organization still applied - Mypy
+  still available but disabled by default for speed
+
+Non-breaking Change: - Generated code quality unchanged - All existing functionality preserved -
+  Mypy can be re-enabled by uncommenting lines 63-68 in postprocess_manager.py
+
+### Testing
+
+- Update exception tests for human-readable names
+  ([`26e2aef`](https://github.com/mindhiveoy/pyopenapi_gen/commit/26e2aef9df2e713a1d4098608f7c191bcd5992ab))
+
+Updated all exception-related tests to expect new human-readable exception names instead of generic
+  numeric names (NotFoundError vs Error404).
+
+Technical Details: - Updated test_exceptions_emitter.py assertions: * Now expects NotFoundError
+  instead of Error404 * Now expects InternalServerError instead of Error500 * Added validation for
+  human-readable status descriptions in docstrings * Removed HTTPError import assertion (no longer
+  used in exception_aliases.py) - Updated test_response_handler_generator.py: * Changed Error404
+  assertions to NotFoundError * Updated test docstrings to reflect human-readable names - Updated
+  test_match_case_response.py: * Changed Error400/401/404/500 to BadRequestError/UnauthorisedError/
+  NotFoundError/InternalServerError - Updated test_response_handler_generator_strategy.py: * Changed
+  Error404/500 assertions to NotFoundError/InternalServerError
+
+Test Results: - All 1,280 tests passing (100% success rate) - Coverage maintained at 85%+ - All
+  exception-related assertions updated and verified - No test failures or regressions
+
+Changes Tested: - Exception class name generation - Exception docstring content - Import statements
+  in generated code - Response handler error raising - Match-case statement error handling
+
+
 ## v0.13.0 (2025-09-08)
 
 ### Bug Fixes

{pyopenapi_gen-0.13.0 → pyopenapi_gen-0.14.1}/CLAUDE.md

@@ -94,11 +94,6 @@ make test-fast            # Run tests, stop on first failure
 make test-cov             # Run tests in parallel with coverage report (85% required)
 pytest -n auto            # Run tests in parallel (faster, use with --timeout=300 if needed)
 
-# Legacy Commands (still work)
-pytest --cov=src --cov-report=html  # Generate coverage report
-ruff check --fix src/     # Auto-fix linting issues
-mypy src/ --strict        # Strict type checking
-
 # Development
 make build                # Build package
 make clean                # Clean build artifacts

{pyopenapi_gen-0.13.0 → pyopenapi_gen-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenapi-gen
-Version: 0.13.0
+Version: 0.14.1
 Summary: Modern, async-first Python client generator for OpenAPI specifications with advanced cycle detection and unified type resolution
 Project-URL: Homepage, https://github.com/your-org/pyopenapi-gen
 Project-URL: Documentation, https://github.com/your-org/pyopenapi-gen/blob/main/README.md