pyopenapi-gen 0.8.6__tar.gz → 0.9.0__tar.gz

{pyopenapi_gen-0.8.6 → pyopenapi_gen-0.9.0}/PKG-INFO

@@ -1,19 +1,14 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: pyopenapi-gen
-Version: 0.8.6
+Version: 0.9.0
 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
-Project-URL: Repository, https://github.com/your-org/pyopenapi-gen
-Project-URL: Issues, https://github.com/your-org/pyopenapi-gen/issues
-Project-URL: Changelog, https://github.com/your-org/pyopenapi-gen/blob/main/CHANGELOG.md
-Project-URL: Bug Reports, https://github.com/your-org/pyopenapi-gen/issues
-Project-URL: Source Code, https://github.com/your-org/pyopenapi-gen
-Author-email: Mindhive Oy <contact@mindhive.fi>
-Maintainer-email: Ville Venäläinen | Mindhive Oy <ville@mindhive.fi>
 License: MIT
-License-File: LICENSE
-Keywords: api,async,client,code-generation,enterprise,generator,http,openapi,python,rest,swagger,type-safe
+Keywords: openapi,swagger,client,generator,async,python,api,http,rest,type-safe,code-generation,enterprise
+Author: Mindhive Oy
+Author-email: contact@mindhive.fi
+Maintainer: Ville Venäläinen | Mindhive Oy
+Maintainer-email: ville@mindhive.fi
+Requires-Python: >=3.12,<4.0.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Framework :: AsyncIO
@@ -21,39 +16,45 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: MacOS
-Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Networking
 Classifier: Typing :: Typed
-Requires-Python: <4.0.0,>=3.12
-Requires-Dist: click>=8.0.0
-Requires-Dist: dataclass-wizard>=0.22.0
-Requires-Dist: httpx>=0.24.0
-Requires-Dist: openapi-core>=0.19
-Requires-Dist: openapi-spec-validator>=0.7
-Requires-Dist: pyyaml>=6.0
-Requires-Dist: typer>=0.12.0
 Provides-Extra: dev
-Requires-Dist: bandit[toml]>=1.7.0; extra == 'dev'
-Requires-Dist: black>=23.0; extra == 'dev'
-Requires-Dist: dataclass-wizard>=0.22.0; extra == 'dev'
-Requires-Dist: httpx>=0.24.0; extra == 'dev'
-Requires-Dist: mypy>=1.7; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.20.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0; extra == 'dev'
-Requires-Dist: pytest-timeout>=2.1.0; extra == 'dev'
-Requires-Dist: pytest-xdist>=3.0.0; extra == 'dev'
-Requires-Dist: pytest>=7.0; extra == 'dev'
-Requires-Dist: ruff>=0.4; extra == 'dev'
-Requires-Dist: safety>=2.0.0; extra == 'dev'
-Requires-Dist: types-pyyaml>=6.0.12; extra == 'dev'
-Requires-Dist: types-toml>=0.10.8; extra == 'dev'
+Requires-Dist: PyYAML (>=6.0)
+Requires-Dist: bandit[toml] (>=1.7.0) ; extra == "dev"
+Requires-Dist: black (>=23.0) ; extra == "dev"
+Requires-Dist: click (>=8.0.0,<9.0.0)
+Requires-Dist: dataclass-wizard (>=0.22.0)
+Requires-Dist: dataclass-wizard (>=0.22.0) ; extra == "dev"
+Requires-Dist: httpx (>=0.24.0)
+Requires-Dist: httpx (>=0.24.0) ; extra == "dev"
+Requires-Dist: mypy (>=1.7) ; extra == "dev"
+Requires-Dist: openapi-core (>=0.19)
+Requires-Dist: openapi-spec-validator (>=0.7)
+Requires-Dist: pytest (>=7.0) ; extra == "dev"
+Requires-Dist: pytest-asyncio (>=0.20.0) ; extra == "dev"
+Requires-Dist: pytest-cov (>=4.0) ; extra == "dev"
+Requires-Dist: pytest-timeout (>=2.1.0) ; extra == "dev"
+Requires-Dist: pytest-xdist (>=3.0.0) ; extra == "dev"
+Requires-Dist: ruff (>=0.4) ; extra == "dev"
+Requires-Dist: safety (>=2.0.0) ; extra == "dev"
+Requires-Dist: typer (>=0.12.0,<0.14.0)
+Requires-Dist: types-pyyaml (>=6.0.12) ; extra == "dev"
+Requires-Dist: types-toml (>=0.10.8) ; extra == "dev"
+Project-URL: Bug Reports, https://github.com/your-org/pyopenapi-gen/issues
+Project-URL: Changelog, https://github.com/your-org/pyopenapi-gen/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/your-org/pyopenapi-gen/blob/main/README.md
+Project-URL: Homepage, https://github.com/your-org/pyopenapi-gen
+Project-URL: Issues, https://github.com/your-org/pyopenapi-gen/issues
+Project-URL: Repository, https://github.com/your-org/pyopenapi-gen
+Project-URL: Source Code, https://github.com/your-org/pyopenapi-gen
 Description-Content-Type: text/markdown
 
 # PyOpenAPI Generator
@@ -99,7 +100,7 @@ poetry add pyopenapi-gen
 
 ### 1. Generate Your First Client
 ```bash
-pyopenapi-gen gen openapi.yaml \
+pyopenapi-gen openapi.yaml \
   --project-root . \
   --output-package my_api_client
 ```
@@ -127,7 +128,7 @@ asyncio.run(main())
 
 ### Standalone Client (Default)
 ```bash
-pyopenapi-gen gen openapi.yaml \
+pyopenapi-gen openapi.yaml \
   --project-root . \
   --output-package my_api_client
 ```
@@ -135,7 +136,7 @@ Creates self-contained client with embedded core dependencies.
 
 ### Shared Core (Multiple Clients)
 ```bash
-pyopenapi-gen gen openapi.yaml \
+pyopenapi-gen openapi.yaml \
   --project-root . \
   --output-package clients.api_client \
   --core-package clients.core
@@ -358,6 +359,20 @@ make typecheck     # Type checking with mypy
 make security      # Security scanning with Bandit
 ```
 
+### Release Process
+The project uses **automated semantic versioning** with conventional commits:
+
+```bash
+# Conventional commit format triggers automatic releases
+git commit -m "feat(auth): add OAuth2 support"    # → Minor version bump
+git commit -m "fix(parser): resolve memory leak"  # → Patch version bump
+
+# Push to main triggers automatic PyPI release
+git push origin main
+```
+
+All releases are automatically published to PyPI with generated changelogs. See [Release Management](CLAUDE.md#release-management--semantic-versioning) for complete details.
+
 See our [Contributing Guide](CONTRIBUTING.md) for detailed information on:
 - 📋 Development setup and workflow
 - 🧪 Testing guidelines and standards
@@ -381,3 +396,4 @@ Generated clients are self-contained and can be distributed under any license co
 ---
 
 **Made with ❤️ for the Python community**
+

{pyopenapi_gen-0.8.6 → pyopenapi_gen-0.9.0}/README.md

@@ -41,7 +41,7 @@ poetry add pyopenapi-gen
 
 ### 1. Generate Your First Client
 ```bash
-pyopenapi-gen gen openapi.yaml \
+pyopenapi-gen openapi.yaml \
   --project-root . \
   --output-package my_api_client
 ```
@@ -69,7 +69,7 @@ asyncio.run(main())
 
 ### Standalone Client (Default)
 ```bash
-pyopenapi-gen gen openapi.yaml \
+pyopenapi-gen openapi.yaml \
   --project-root . \
   --output-package my_api_client
 ```
@@ -77,7 +77,7 @@ Creates self-contained client with embedded core dependencies.
 
 ### Shared Core (Multiple Clients)
 ```bash
-pyopenapi-gen gen openapi.yaml \
+pyopenapi-gen openapi.yaml \
   --project-root . \
   --output-package clients.api_client \
   --core-package clients.core
@@ -300,6 +300,20 @@ make typecheck     # Type checking with mypy
 make security      # Security scanning with Bandit
 ```
 
+### Release Process
+The project uses **automated semantic versioning** with conventional commits:
+
+```bash
+# Conventional commit format triggers automatic releases
+git commit -m "feat(auth): add OAuth2 support"    # → Minor version bump
+git commit -m "fix(parser): resolve memory leak"  # → Patch version bump
+
+# Push to main triggers automatic PyPI release
+git push origin main
+```
+
+All releases are automatically published to PyPI with generated changelogs. See [Release Management](CLAUDE.md#release-management--semantic-versioning) for complete details.
+
 See our [Contributing Guide](CONTRIBUTING.md) for detailed information on:
 - 📋 Development setup and workflow
 - 🧪 Testing guidelines and standards

{pyopenapi_gen-0.8.6 → pyopenapi_gen-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyopenapi-gen"
-version = "0.8.6"
+version = "0.9.0"
 description = "Modern, async-first Python client generator for OpenAPI specifications with advanced cycle detection and unified type resolution"
 authors = [{ name = "Mindhive Oy", email = "contact@mindhive.fi" }]
 maintainers = [{ name = "Ville Venäläinen | Mindhive Oy", email = "ville@mindhive.fi" }]
@@ -14,8 +14,8 @@ dependencies = [
   "openapi-spec-validator>=0.7",
   "openapi-core>=0.19",
   "PyYAML>=6.0",
-  "typer>=0.12.0",
-  "click>=8.0.0",
+  "typer>=0.12.0,<0.14.0",
+  "click>=8.0.0,<9.0.0",
   "httpx>=0.24.0",
   "dataclass-wizard>=0.22.0",
 ]
@@ -111,6 +111,7 @@ python_files = ["test_*.py"]
 python_functions = ["test_"]
 log_cli = false
 log_cli_level = "WARNING"
+asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 # For details on registering custom marks, see:
 # https://docs.pytest.org/en/stable/how-to/mark.html
@@ -121,8 +122,47 @@ markers = [
 
 [tool.poetry.group.dev.dependencies]
 types-pyyaml = "^6.0.12.20250516"
-bandit = {extras = ["toml"], version = "^1.8.3"}
+bandit = {extras = ["toml"], version = "^1.8.6"}
 pytest-timeout = "^2.4.0"
+pytest-asyncio = "^1.1.0"
+black = "^25.1.0"
+ruff = "^0.12.3"
+mypy = "^1.17.0"
+commitizen = "^3.29.0"
+python-semantic-release = "^9.12.0"
+pytest-xdist = "^3.8.0"
+pytest-cov = "^6.2.1"
+build = "^1.2.0"
 
 [project.scripts]
 pyopenapi-gen = "pyopenapi_gen.cli:app"
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "0.9.0"
+version_files = [
+    "pyproject.toml:version",
+    "src/pyopenapi_gen/__init__.py:__version__"
+]
+tag_format = "v$version"
+major_version_zero = false
+changelog_file = "CHANGELOG.md"
+changelog_format = "## [$version] - $date\\n\\n$changes"
+commit_parser = "^(?P<change_type>feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(?:\\((?P<scope>[^)]+)\\))?!?:\\s(?P<message>.+)$"
+bump_message = "bump: version $current_version → $new_version"
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version", "pyproject.toml:tool.commitizen.version"]
+version_pattern = [
+    "src/pyopenapi_gen/__init__.py:__version__: str = \"{version}\""
+]
+branch = "main"
+upload_to_pypi = true
+upload_to_repository = true
+commit_message = "chore(release): {version}"
+tag_commit = true
+changelog_file = "CHANGELOG.md"
+changelog_format = "# Changelog\\n\\n{changelog}"
+hvcs = "github"
+commit_parser = "conventional"
+major_on_zero = false

{pyopenapi_gen-0.8.6 → pyopenapi_gen-0.9.0}/src/pyopenapi_gen/__init__.py

@@ -42,8 +42,8 @@ __all__ = [
     "WarningCollector",
 ]
 
-# Semantic version of the generator core – bumped manually for now.
-__version__: str = "0.6.0"
+# Semantic version of the generator core – automatically managed by semantic-release.
+__version__: str = "0.9.0"
 
 
 # ---------------------------------------------------------------------------

pyopenapi_gen-0.9.0/src/pyopenapi_gen/context/CLAUDE.md

@@ -0,0 +1,284 @@
+# context/ - Rendering Context Management
+
+## Why This Folder?
+Manage stateful information during code generation: imports, templates, file paths, and rendering state. Provides clean interface between visitors and emitters.
+
+## Key Dependencies
+- **Input**: Path configuration, package names, template data
+- **Output**: Import statements, resolved file paths, template rendering
+- **Used by**: All visitors and emitters for consistent code generation
+
+## Essential Architecture
+
+### 1. Context Lifecycle
+```python
+# 1. Create context for generation session
+context = RenderContext(project_root="/path/to/project", output_package="my_client")
+
+# 2. Visitors use context for type resolution and imports
+visitor.visit_schema(schema, context)  # Registers imports
+
+# 3. Emitters use context for file organization
+emitter.emit_models(schemas, context)  # Consumes imports
+```
+
+### 2. State Management
+```python
+# render_context.py
+class RenderContext:
+    def __init__(self, project_root: Path, output_package: str):
+        self.import_collector = ImportCollector()
+        self.file_manager = FileManager(project_root)
+        self.template_vars = {}
+        self.output_package = output_package
+        self.forward_refs = set()
+```
+
+## Critical Components
+
+### render_context.py
+**Purpose**: Main context object passed through generation pipeline
+```python
+class RenderContext:
+    def add_import(self, import_statement: str) -> None:
+        """Register import for current file being generated"""
+        self.import_collector.add_import(import_statement)
+    
+    def get_imports(self) -> List[str]:
+        """Get sorted, deduplicated imports for current file"""
+        return self.import_collector.get_sorted_imports()
+    
+    def clear_imports(self) -> None:
+        """Clear imports for next file generation"""
+        self.import_collector.clear()
+    
+    def resolve_relative_import(self, from_package: str, to_package: str) -> str:
+        """Convert absolute import to relative import"""
+        return self.import_collector.make_relative_import(from_package, to_package)
+```
+
+### import_collector.py
+**Purpose**: Collect and manage import statements during code generation
+```python
+class ImportCollector:
+    def __init__(self):
+        self.imports: Set[str] = set()
+        self.from_imports: Dict[str, Set[str]] = defaultdict(set)
+    
+    def add_import(self, import_statement: str) -> None:
+        """Add import statement, handling both 'import' and 'from' forms"""
+        if import_statement.startswith("from "):
+            self.parse_from_import(import_statement)
+        else:
+            self.imports.add(import_statement)
+    
+    def get_sorted_imports(self) -> List[str]:
+        """Return sorted imports: stdlib, third-party, local"""
+        return self.sort_imports_by_category()
+```
+
+### file_manager.py
+**Purpose**: Handle file operations and path resolution
+```python
+class FileManager:
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+    
+    def write_file(self, file_path: Path, content: str) -> None:
+        """Write file with proper directory creation"""
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(content)
+    
+    def resolve_package_path(self, package_name: str) -> Path:
+        """Convert package.name to file system path"""
+        parts = package_name.split(".")
+        return self.project_root / Path(*parts)
+```
+
+## Import Management Patterns
+
+### 1. Import Categories
+```python
+# import_collector.py
+def categorize_import(self, import_statement: str) -> ImportCategory:
+    """Categorize imports for proper sorting"""
+    if self.is_stdlib_import(import_statement):
+        return ImportCategory.STDLIB
+    elif self.is_third_party_import(import_statement):
+        return ImportCategory.THIRD_PARTY
+    else:
+        return ImportCategory.LOCAL
+```
+
+### 2. From Import Consolidation
+```python
+# Convert multiple from imports to single statement
+# "from typing import List"
+# "from typing import Dict"
+# →
+# "from typing import Dict, List"
+
+def consolidate_from_imports(self) -> List[str]:
+    consolidated = []
+    for module, imports in self.from_imports.items():
+        sorted_imports = sorted(imports)
+        consolidated.append(f"from {module} import {', '.join(sorted_imports)}")
+    return consolidated
+```
+
+### 3. Relative Import Conversion
+```python
+def make_relative_import(self, from_package: str, to_package: str) -> str:
+    """Convert absolute import to relative import"""
+    # from my_client.models.user import User
+    # →
+    # from ..models.user import User (when called from my_client.endpoints)
+    
+    from_parts = from_package.split(".")
+    to_parts = to_package.split(".")
+    
+    # Find common prefix
+    common_len = self.find_common_prefix_length(from_parts, to_parts)
+    
+    # Calculate relative depth
+    relative_depth = len(from_parts) - common_len
+    prefix = "." * relative_depth
+    
+    # Build relative import
+    remaining_path = ".".join(to_parts[common_len:])
+    return f"from {prefix}{remaining_path} import"
+```
+
+## Template Management
+
+### 1. Template Variables
+```python
+# Store template variables for consistent rendering
+context.template_vars.update({
+    "client_name": "MyAPIClient",
+    "base_url": "https://api.example.com",
+    "version": "1.0.0",
+    "auth_type": "bearer"
+})
+```
+
+### 2. Template Rendering
+```python
+def render_template(self, template: str, **kwargs) -> str:
+    """Render template with context variables"""
+    all_vars = {**self.template_vars, **kwargs}
+    return template.format(**all_vars)
+```
+
+## Dependencies on Other Systems
+
+### From types/
+- Implements `TypeContext` protocol for type resolution
+- Provides import registration for complex types
+
+### From visit/
+- Receives import registration during code generation
+- Provides path resolution for relative imports
+
+### From emitters/
+- Provides file writing capabilities
+- Supplies consolidated imports for file headers
+
+## Testing Requirements
+
+### Import Management Tests
+```python
+def test_import_collector__multiple_from_imports__consolidates_correctly():
+    # Arrange
+    collector = ImportCollector()
+    collector.add_import("from typing import List")
+    collector.add_import("from typing import Dict")
+    
+    # Act
+    imports = collector.get_sorted_imports()
+    
+    # Assert
+    assert "from typing import Dict, List" in imports
+```
+
+### Path Resolution Tests
+```python
+def test_file_manager__package_path__resolves_correctly():
+    # Test package name to file path conversion
+    manager = FileManager(Path("/project"))
+    path = manager.resolve_package_path("my_client.models")
+    
+    assert path == Path("/project/my_client/models")
+```
+
+## Extension Points
+
+### Custom Import Sorting
+```python
+class CustomImportCollector(ImportCollector):
+    def sort_imports_by_category(self) -> List[str]:
+        # Custom import sorting logic
+        # Example: Group all async imports together
+        pass
+```
+
+### Template System Integration
+```python
+def add_template_engine(self, engine: TemplateEngine) -> None:
+    """Add custom template engine (Jinja2, etc.)"""
+    self.template_engine = engine
+    
+def render_template(self, template_name: str, **kwargs) -> str:
+    """Render template using custom engine"""
+    return self.template_engine.render(template_name, **kwargs)
+```
+
+## Critical Implementation Details
+
+### Thread Safety
+```python
+# Context is NOT thread-safe by design
+# Each generation session gets its own context instance
+def create_context() -> RenderContext:
+    return RenderContext(project_root, output_package)
+```
+
+### Memory Management
+```python
+# Clear context between files to prevent memory leaks
+def emit_file(self, file_path: Path, generator_func: Callable) -> None:
+    self.context.clear_imports()
+    
+    # Generate code
+    code = generator_func(self.context)
+    
+    # Write file with imports
+    imports = self.context.get_imports()
+    final_code = self.combine_imports_and_code(imports, code)
+    
+    self.file_manager.write_file(file_path, final_code)
+```
+
+### Error Context
+```python
+# Always provide context in error messages
+def add_import_with_context(self, import_statement: str, file_context: str) -> None:
+    try:
+        self.import_collector.add_import(import_statement)
+    except Exception as e:
+        raise ImportError(f"Failed to add import '{import_statement}' in {file_context}: {e}")
+```
+
+## Common Pitfalls
+
+1. **Import Leakage**: Not clearing imports between files
+2. **Path Confusion**: Using absolute paths instead of relative
+3. **State Mutation**: Modifying context from multiple threads
+4. **Memory Leaks**: Not cleaning up context after generation
+
+## Best Practices
+
+1. **One Context Per Session**: Create new context for each generation
+2. **Clear Between Files**: Always clear imports between file generations
+3. **Use Relative Imports**: Convert absolute imports to relative
+4. **Error Context**: Include file/operation context in errors

{pyopenapi_gen-0.8.6 → pyopenapi_gen-0.9.0}/src/pyopenapi_gen/context/import_collector.py

@@ -274,10 +274,10 @@ class ImportCollector:
                 is_core_module_to_be_absolute = True
 
             if is_core_module_to_be_absolute:
-                import_statement = f"from {module_name} import {", ".join(names)}"
+                import_statement = f"from {module_name} import {', '.join(names)}"
                 standard_import_lines.append(import_statement)
             elif is_stdlib_module:
-                import_statement = f"from {module_name} import {", ".join(names)}"
+                import_statement = f"from {module_name} import {', '.join(names)}"
                 standard_import_lines.append(import_statement)
             elif (
                 current_module_dot_path_to_use
@@ -286,13 +286,13 @@ class ImportCollector:
             ):
                 try:
                     relative_module = make_relative_import(current_module_dot_path_to_use, module_name)
-                    import_statement = f"from {relative_module} import {", ".join(names)}"
+                    import_statement = f"from {relative_module} import {', '.join(names)}"
                     standard_import_lines.append(import_statement)
                 except ValueError as e:
-                    import_statement = f"from {module_name} import {", ".join(names)}"
+                    import_statement = f"from {module_name} import {', '.join(names)}"
                     standard_import_lines.append(import_statement)
             else:
-                import_statement = f"from {module_name} import {", ".join(names)}"
+                import_statement = f"from {module_name} import {', '.join(names)}"
                 standard_import_lines.append(import_statement)
 
         plain_import_lines: List[str] = []
@@ -331,7 +331,7 @@ class ImportCollector:
 
         for module in stdlib_modules:
             names = sorted(self.imports[module])
-            statements.append(f"from {module} import {", ".join(names)}")
+            statements.append(f"from {module} import {', '.join(names)}")
 
         # Then third-party and app imports
         other_modules = sorted([m for m in self.imports.keys() if not _is_stdlib(m)])
@@ -341,7 +341,7 @@ class ImportCollector:
 
         for module in other_modules:
             names = sorted(self.imports[module])
-            statements.append(f"from {module} import {", ".join(names)}")
+            statements.append(f"from {module} import {', '.join(names)}")
 
         # Then plain imports
         if self.plain_imports:
@@ -357,7 +357,7 @@ class ImportCollector:
 
         for module in sorted(self.relative_imports.keys()):
             names = sorted(self.relative_imports[module])
-            statements.append(f"from {module} import {", ".join(names)}")
+            statements.append(f"from {module} import {', '.join(names)}")
 
         return "\n".join(statements)