django-cfg 1.4.61__py3-none-any.whl → 1.4.63__py3-none-any.whl

django_cfg/apps/centrifugo/codegen/generators/python_thin/generator.py

@@ -0,0 +1,241 @@
+"""
+Python thin wrapper client generator.
+
+Generates Pydantic models + thin wrapper over CentrifugoRPCClient.
+"""
+
+import logging
+from pathlib import Path
+from typing import List, Type
+from pydantic import BaseModel
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from ...discovery import RPCMethodInfo
+from ...utils import to_python_method_name
+
+logger = logging.getLogger(__name__)
+
+
+class PythonThinGenerator:
+    """
+    Generator for Python thin wrapper clients.
+
+    Creates:
+    - models.py: Pydantic models
+    - client.py: Thin wrapper class over RPC client
+    - rpc_client.py: Base CentrifugoRPCClient
+    - __init__.py: Exports
+    """
+
+    def __init__(
+        self,
+        methods: List[RPCMethodInfo],
+        models: List[Type[BaseModel]],
+        output_dir: Path,
+    ):
+        """
+        Initialize generator.
+
+        Args:
+            methods: List of discovered RPC methods
+            models: List of Pydantic models
+            output_dir: Output directory for generated files
+        """
+        self.methods = methods
+        self.models = models
+        self.output_dir = Path(output_dir)
+
+        # Setup Jinja2 environment
+        templates_dir = Path(__file__).parent / "templates"
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            autoescape=select_autoescape(),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def generate(self):
+        """Generate all Python files."""
+        # Create output directory
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Generate models
+        self._generate_models()
+
+        # Generate RPC client base
+        self._generate_rpc_client()
+
+        # Generate thin wrapper
+        self._generate_client()
+
+        # Generate __init__
+        self._generate_init()
+
+        # Generate config files
+        self._generate_requirements()
+        self._generate_readme()
+
+        logger.info(f"✅ Generated Python client in {self.output_dir}")
+
+    def _generate_models(self):
+        """Generate models.py file with Pydantic models."""
+        template = self.jinja_env.get_template("models.py.j2")
+
+        # Prepare models data
+        models_data = []
+        for model in self.models:
+            model_code = self._generate_model_code(model)
+            models_data.append({
+                'name': model.__name__,
+                'code': model_code,
+            })
+
+        content = template.render(models=models_data)
+
+        output_file = self.output_dir / "models.py"
+        output_file.write_text(content)
+        logger.debug(f"Generated {output_file}")
+
+    def _generate_model_code(self, model: Type[BaseModel]) -> str:
+        """Generate code for a single Pydantic model."""
+        schema = model.model_json_schema()
+        properties = schema.get('properties', {})
+        required = schema.get('required', [])
+
+        fields = []
+        for field_name, field_info in properties.items():
+            py_type = self._json_type_to_python(field_info)
+            description = field_info.get('description', '')
+
+            if field_name in required:
+                if description:
+                    fields.append(f"    {field_name}: {py_type} = Field(..., description='{description}')")
+                else:
+                    fields.append(f"    {field_name}: {py_type}")
+            else:
+                if description:
+                    fields.append(f"    {field_name}: Optional[{py_type}] = Field(None, description='{description}')")
+                else:
+                    fields.append(f"    {field_name}: Optional[{py_type}] = None")
+
+        doc = model.__doc__ or f"{model.__name__} model."
+
+        code = f'class {model.__name__}(BaseModel):\n'
+        code += f'    """{doc}"""\n'
+        if fields:
+            code += '\n'.join(fields)
+        else:
+            code += '    pass'
+
+        return code
+
+    def _json_type_to_python(self, field_info: dict) -> str:
+        """Convert JSON schema type to Python type."""
+        if "anyOf" in field_info:
+            types = [self._json_type_to_python(t) for t in field_info["anyOf"]]
+            return f"Union[{', '.join(types)}]"
+
+        field_type = field_info.get("type", "Any")
+
+        if field_type == "string":
+            return "str"
+        elif field_type == "integer":
+            return "int"
+        elif field_type == "number":
+            return "float"
+        elif field_type == "boolean":
+            return "bool"
+        elif field_type == "array":
+            items = field_info.get("items", {})
+            item_type = self._json_type_to_python(items)
+            return f"List[{item_type}]"
+        elif field_type == "object":
+            return "Dict[str, Any]"
+        elif field_type == "null":
+            return "None"
+        else:
+            return "Any"
+
+    def _generate_rpc_client(self):
+        """Generate rpc_client.py base class."""
+        template = self.jinja_env.get_template("rpc_client.py.j2")
+        content = template.render()
+
+        output_file = self.output_dir / "rpc_client.py"
+        output_file.write_text(content)
+        logger.debug(f"Generated {output_file}")
+
+    def _generate_client(self):
+        """Generate client.py thin wrapper."""
+        template = self.jinja_env.get_template("client.py.j2")
+
+        # Prepare methods for template
+        methods_data = []
+        for method in self.methods:
+            param_type = method.param_type.__name__ if method.param_type else "dict"
+            return_type = method.return_type.__name__ if method.return_type else "dict"
+
+            # Convert method name to valid Python identifier
+            method_name_python = to_python_method_name(method.name)
+
+            methods_data.append({
+                'name': method.name,  # Original name for RPC call
+                'name_python': method_name_python,  # Python-safe name
+                'param_type': param_type,
+                'return_type': return_type,
+                'docstring': method.docstring or f"Call {method.name} RPC method",
+            })
+
+        # Prepare model names for imports
+        model_names = [m.__name__ for m in self.models]
+
+        content = template.render(
+            methods=methods_data,
+            models=model_names,
+        )
+
+        output_file = self.output_dir / "client.py"
+        output_file.write_text(content)
+        logger.debug(f"Generated {output_file}")
+
+    def _generate_init(self):
+        """Generate __init__.py file."""
+        template = self.jinja_env.get_template("__init__.py.j2")
+
+        model_names = [m.__name__ for m in self.models]
+
+        content = template.render(models=model_names)
+
+        output_file = self.output_dir / "__init__.py"
+        output_file.write_text(content)
+        logger.debug(f"Generated {output_file}")
+
+    def _generate_requirements(self):
+        """Generate requirements.txt file."""
+        template = self.jinja_env.get_template("requirements.txt.j2")
+        content = template.render()
+        output_file = self.output_dir / "requirements.txt"
+        output_file.write_text(content)
+        logger.debug(f"Generated {output_file}")
+
+    def _generate_readme(self):
+        """Generate README.md file."""
+        template = self.jinja_env.get_template("README.md.j2")
+
+        # Prepare methods for examples
+        methods_data = []
+        for method in self.methods[:3]:  # First 3 methods for examples
+            methods_data.append({
+                'name': method.name,
+                'name_python': to_python_method_name(method.name),
+            })
+
+        model_names = [m.__name__ for m in self.models]
+
+        content = template.render(methods=methods_data, models=model_names)
+        output_file = self.output_dir / "README.md"
+        output_file.write_text(content)
+        logger.debug(f"Generated {output_file}")
+
+
+__all__ = ['PythonThinGenerator']

django_cfg/apps/centrifugo/codegen/generators/python_thin/templates/README.md.j2

@@ -0,0 +1,128 @@
+# Generated Python Client
+
+Auto-generated type-safe Python client for Centrifugo WebSocket RPC.
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+import asyncio
+from client import CentrifugoRPCClient, APIClient
+{% if models %}from models import {{ models[0] if models else 'YourModel' }}
+{% endif %}
+
+async def main():
+    # Create RPC client
+    rpc = CentrifugoRPCClient(
+        url='ws://localhost:8000/connection/websocket',
+        token='your-jwt-token',
+        user_id='user-123'
+    )
+
+    # Connect
+    await rpc.connect()
+
+    # Create API client
+    api = APIClient(rpc)
+
+    try:
+        # Call RPC methods
+{% if methods %}
+{% for method in methods %}
+        result = await api.{{ method.name_python }}(params)
+        print(result)
+{% endfor %}
+{% else %}
+        # result = await api.some_method(params)
+{% endif %}
+
+    finally:
+        # Disconnect
+        await rpc.disconnect()
+
+# Run
+asyncio.run(main())
+```
+
+### With Context Manager
+
+```python
+async def main():
+    async with CentrifugoRPCClient(
+        url='ws://localhost:8000/connection/websocket',
+        token='your-jwt-token',
+        user_id='user-123'
+    ) as rpc:
+        api = APIClient(rpc)
+        result = await api.some_method(params)
+        print(result)
+
+asyncio.run(main())
+```
+
+## Generated Models
+
+{% if models %}
+Available Pydantic models:
+{% for model_name in models %}
+- `{{ model_name }}`
+{% endfor %}
+{% else %}
+No models generated.
+{% endif %}
+
+## Generated Methods
+
+{% if methods %}
+Available RPC methods:
+{% for method in methods %}
+- `{{ method.name_python }}()` - {{ method.docstring.split('\n')[0] if method.docstring else 'No description' }}
+{% endfor %}
+{% else %}
+No methods generated.
+{% endif %}
+
+## Type Safety
+
+All methods are fully type-safe:
+- Parameters validated with Pydantic
+- Return types checked at runtime
+- IDE autocomplete support
+- mypy compatible
+
+## Error Handling
+
+```python
+from asyncio import TimeoutError
+
+try:
+    result = await api.some_method(params)
+except TimeoutError:
+    print("RPC call timed out")
+except Exception as e:
+    print(f"RPC error: {e}")
+```
+
+## Configuration
+
+### Custom Timeout
+
+```python
+rpc = CentrifugoRPCClient(
+    url='ws://localhost:8000/connection/websocket',
+    token='your-jwt-token',
+    user_id='user-123',
+    timeout=60.0  # 60 seconds
+)
+```
+
+---
+
+**Generated by django_cfg.apps.centrifugo.codegen**

django_cfg/apps/centrifugo/codegen/generators/python_thin/templates/__init__.py.j2

@@ -0,0 +1,22 @@
+"""
+Generated Python Client Package.
+
+Auto-generated - DO NOT EDIT
+"""
+
+from .rpc_client import CentrifugoRPCClient
+from .client import APIClient
+{% if models %}
+from .models import (
+{% for model_name in models | unique | sort %}    {{ model_name }},
+{% endfor %})
+{% endif %}
+
+__all__ = [
+    "CentrifugoRPCClient",
+    "APIClient",
+{% if models %}
+{% for model_name in models | unique | sort %}    "{{ model_name }}",
+{% endfor %}
+{% endif %}
+]

django_cfg/apps/centrifugo/codegen/generators/python_thin/templates/client.py.j2

@@ -0,0 +1,73 @@
+"""
+Generated API Client.
+
+Auto-generated thin wrapper over CentrifugoRPCClient - DO NOT EDIT
+"""
+
+from typing import Optional
+{% if models %}
+from .models import (
+{% for model_name in models | unique | sort %}    {{ model_name }},
+{% endfor %})
+{% endif %}
+from .rpc_client import CentrifugoRPCClient
+
+
+class APIClient:
+    """
+    Generated API client.
+
+    Thin wrapper over CentrifugoRPCClient providing type-safe RPC methods.
+    """
+
+    def __init__(self, rpc_client: CentrifugoRPCClient):
+        """
+        Initialize API client.
+
+        Args:
+            rpc_client: Connected CentrifugoRPCClient instance
+
+        Example:
+            >>> rpc = CentrifugoRPCClient(
+            ...     url='ws://localhost:8000/connection/websocket',
+            ...     token='jwt-token',
+            ...     user_id='user-123'
+            ... )
+            >>> await rpc.connect()
+            >>>
+            >>> api = APIClient(rpc)
+            >>> result = await api.some_method(params)
+        """
+        self._rpc = rpc_client
+
+    # ========== Generated RPC Methods ==========
+
+{% for method in methods %}
+    async def {{ method.name_python }}(self, params: {{ method.param_type }}) -> {{ method.return_type }}:
+        """
+        {{ method.docstring | replace('\n', '\n        ') }}
+
+        Args:
+            params: {{ method.param_type }} parameters
+
+        Returns:
+            {{ method.return_type }}
+
+        Raises:
+            asyncio.TimeoutError: If RPC call times out
+            Exception: If RPC call fails
+        """
+{% if method.param_type == 'dict' %}
+        result = await self._rpc.call('{{ method.name }}', params)
+{% else %}
+        result = await self._rpc.call('{{ method.name }}', params.model_dump())
+{% endif %}
+{% if method.return_type == 'dict' %}
+        return result
+{% else %}
+        return {{ method.return_type }}(**result)
+{% endif %}
+
+{% endfor %}
+
+__all__ = ["APIClient"]

django_cfg/apps/centrifugo/codegen/generators/python_thin/templates/models.py.j2

@@ -0,0 +1,19 @@
+"""
+Generated Pydantic Models.
+
+Auto-generated from RPC handler type hints - DO NOT EDIT
+"""
+
+from typing import Optional, List, Dict, Any, Union
+from pydantic import BaseModel, Field
+
+
+{% for model in models %}
+{{ model.code }}
+
+
+{% endfor %}
+
+__all__ = [
+{% for model in models %}    "{{ model.name }}",
+{% endfor %}]

django_cfg/apps/centrifugo/codegen/generators/python_thin/templates/requirements.txt.j2

@@ -0,0 +1,8 @@
+# Generated Python Client Dependencies
+
+# Core dependencies
+pydantic>=2.0.0
+centrifuge-python>=0.4.0
+
+# Optional: for sync wrapper (if needed)
+asyncio-compat>=0.0.1

django_cfg/apps/centrifugo/codegen/generators/python_thin/templates/rpc_client.py.j2

@@ -0,0 +1,193 @@
+"""
+Base Centrifugo RPC Client.
+
+Handles WebSocket connection and RPC call correlation.
+"""
+
+import asyncio
+import json
+import logging
+import uuid
+from typing import Any, Dict, Optional
+from centrifuge import Client, ClientEventContext, ConnectedContext, DisconnectedContext
+
+logger = logging.getLogger(__name__)
+
+
+class CentrifugoRPCClient:
+    """
+    Base RPC client for Centrifugo WebSocket communication.
+
+    Implements request-response pattern over Centrifugo pub/sub using correlation IDs.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        token: str,
+        user_id: str,
+        timeout: float = 30.0,
+    ):
+        """
+        Initialize RPC client.
+
+        Args:
+            url: Centrifugo WebSocket URL (e.g., "ws://localhost:8000/connection/websocket")
+            token: JWT token for authentication
+            user_id: User ID for reply channel
+            timeout: RPC call timeout in seconds
+        """
+        self.url = url
+        self.token = token
+        self.user_id = user_id
+        self.timeout = timeout
+
+        self.client: Optional[Client] = None
+        self._pending_requests: Dict[str, asyncio.Future] = {}
+        self._reply_channel = f"user#{user_id}"
+
+    async def connect(self) -> None:
+        """Connect to Centrifugo WebSocket."""
+        self.client = Client(
+            self.url,
+            token=self.token,
+            events={
+                "connected": self._on_connected,
+                "disconnected": self._on_disconnected,
+            }
+        )
+
+        await self.client.connect()
+
+        # Subscribe to reply channel for RPC responses
+        subscription = self.client.new_subscription(
+            self._reply_channel,
+            events={
+                "publication": self._on_response,
+            }
+        )
+        await subscription.subscribe()
+
+        logger.info(f"✅ Connected to Centrifugo at {self.url}")
+
+    async def disconnect(self) -> None:
+        """Disconnect from Centrifugo WebSocket."""
+        if self.client:
+            await self.client.disconnect()
+            self.client = None
+            logger.info("Disconnected from Centrifugo")
+
+    async def call(self, method: str, params: Any) -> Any:
+        """
+        Call RPC method and wait for response.
+
+        Args:
+            method: RPC method name (e.g., "tasks.get_stats")
+            params: Method parameters (dict or Pydantic model)
+
+        Returns:
+            Method result
+
+        Raises:
+            asyncio.TimeoutError: If RPC call times out
+            Exception: If RPC call fails
+        """
+        if not self.client:
+            raise Exception("Not connected to Centrifugo")
+
+        # Generate correlation ID
+        correlation_id = str(uuid.uuid4())
+
+        # Prepare params
+        params_dict = params if isinstance(params, dict) else params
+
+        # Create request message
+        message = {
+            "method": method,
+            "params": params_dict,
+            "correlation_id": correlation_id,
+            "reply_to": self._reply_channel,
+        }
+
+        # Create future for response
+        future = asyncio.Future()
+        self._pending_requests[correlation_id] = future
+
+        try:
+            # Publish request to RPC channel
+            await self.client.publish(
+                channel="rpc.requests",
+                data=message
+            )
+
+            logger.debug(f"📤 RPC call: {method} (correlation_id: {correlation_id})")
+
+            # Wait for response with timeout
+            result = await asyncio.wait_for(future, timeout=self.timeout)
+            logger.debug(f"📥 RPC response: {method} (correlation_id: {correlation_id})")
+
+            return result
+
+        except asyncio.TimeoutError:
+            self._pending_requests.pop(correlation_id, None)
+            logger.error(f"❌ RPC timeout: {method} (correlation_id: {correlation_id})")
+            raise
+        except Exception as e:
+            self._pending_requests.pop(correlation_id, None)
+            logger.error(f"❌ RPC error: {method} - {e}")
+            raise
+
+    async def _on_connected(self, ctx: ConnectedContext):
+        """Handle connection event."""
+        logger.info(f"Connected: client_id={ctx.client}")
+
+    async def _on_disconnected(self, ctx: DisconnectedContext):
+        """Handle disconnection event."""
+        logger.warning(f"Disconnected: code={ctx.code}, reason={ctx.reason}")
+
+        # Reject all pending requests
+        for correlation_id, future in list(self._pending_requests.items()):
+            if not future.done():
+                future.set_exception(Exception("Disconnected from Centrifugo"))
+        self._pending_requests.clear()
+
+    async def _on_response(self, ctx: ClientEventContext):
+        """Handle RPC response publication."""
+        try:
+            data = ctx.data
+
+            # Extract correlation ID
+            correlation_id = data.get("correlation_id")
+            if not correlation_id:
+                logger.warning("Received response without correlation_id")
+                return
+
+            # Find pending request
+            future = self._pending_requests.pop(correlation_id, None)
+            if not future:
+                logger.warning(f"Received response for unknown correlation_id: {correlation_id}")
+                return
+
+            # Check for error
+            if "error" in data:
+                error_msg = data["error"].get("message", "RPC error")
+                future.set_exception(Exception(error_msg))
+            else:
+                # Resolve with result
+                result = data.get("result")
+                future.set_result(result)
+
+        except Exception as e:
+            logger.error(f"Error handling response: {e}")
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.disconnect()
+
+
+__all__ = ["CentrifugoRPCClient"]

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/__init__.py

@@ -0,0 +1,5 @@
+"""TypeScript thin wrapper generator."""
+
+from .generator import TypeScriptThinGenerator
+
+__all__ = ["TypeScriptThinGenerator"]