django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/apps/integrations/centrifugo/codegen/utils/type_converter.py

@@ -0,0 +1,349 @@
+"""
+Type conversion utilities for code generation.
+
+Converts Pydantic models to TypeScript interfaces and Python type hints.
+Adapted from unrealon-openapi/generators/common/utils.py
+"""
+
+import logging
+from typing import Any, Dict, Type, List, get_args, get_origin
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+def convert_json_schema_to_typescript(field_info: Dict[str, Any]) -> str:
+    """
+    Convert JSON schema field to TypeScript type.
+
+    Args:
+        field_info: JSON schema field information
+
+    Returns:
+        str: TypeScript type string
+    """
+    # Handle anyOf (union types)
+    if "anyOf" in field_info:
+        types = [convert_json_schema_to_typescript(t) for t in field_info["anyOf"]]
+        return " | ".join(types)
+
+    field_type = field_info.get("type", "any")
+
+    if field_type == "string":
+        return "string"
+    elif field_type == "integer":
+        return "number"
+    elif field_type == "number":
+        return "number"
+    elif field_type == "boolean":
+        return "boolean"
+    elif field_type == "array":
+        items = field_info.get("items", {})
+        item_type = convert_json_schema_to_typescript(items)
+        return f"{item_type}[]"
+    elif field_type == "object":
+        return "Record<string, any>"
+    elif field_type == "null":
+        return "null"
+    else:
+        return "any"
+
+
+def convert_json_schema_to_python(field_info: Dict[str, Any]) -> str:
+    """
+    Convert JSON schema field to Python type.
+
+    Args:
+        field_info: JSON schema field information
+
+    Returns:
+        str: Python type string
+    """
+    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 = convert_json_schema_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 pydantic_to_typescript(model: Type[BaseModel]) -> str:
+    """
+    Convert Pydantic model to TypeScript interface.
+
+    Args:
+        model: Pydantic model class
+
+    Returns:
+        str: TypeScript interface definition
+    """
+    if not issubclass(model, BaseModel):
+        return "any"
+
+    try:
+        schema = model.model_json_schema()
+        properties = schema.get('properties', {})
+        required = schema.get('required', [])
+
+        ts_fields = []
+        for field_name, field_info in properties.items():
+            ts_type = convert_json_schema_to_typescript(field_info)
+            optional = '?' if field_name not in required else ''
+
+            # Add description as comment if available
+            description = field_info.get('description')
+            if description:
+                ts_fields.append(f"  /** {description} */")
+
+            ts_fields.append(f"  {field_name}{optional}: {ts_type};")
+
+        interface_code = f"export interface {model.__name__} {{\n"
+        interface_code += "\n".join(ts_fields)
+        interface_code += "\n}"
+
+        return interface_code
+
+    except Exception as e:
+        logger.error(f"Failed to convert {model.__name__} to TypeScript: {e}")
+        return f"export interface {model.__name__} {{ [key: string]: any; }}"
+
+
+def pydantic_to_python(model: Type[BaseModel]) -> str:
+    """
+    Convert Pydantic model to Python class definition.
+
+    Args:
+        model: Pydantic model class
+
+    Returns:
+        str: Python class definition
+    """
+    if not issubclass(model, BaseModel):
+        return "Any"
+
+    try:
+        schema = model.model_json_schema()
+        properties = schema.get('properties', {})
+        required = schema.get('required', [])
+
+        py_fields = []
+        for field_name, field_info in properties.items():
+            py_type = convert_json_schema_to_python(field_info)
+
+            # Add description as docstring comment
+            description = field_info.get('description')
+            if description:
+                py_fields.append(f'    """{description}"""')
+
+            if field_name in required:
+                py_fields.append(f"    {field_name}: {py_type}")
+            else:
+                py_fields.append(f"    {field_name}: Optional[{py_type}] = None")
+
+        doc = model.__doc__ or f"{model.__name__} model"
+
+        class_code = f"class {model.__name__}(BaseModel):\n"
+        class_code += f'    """{doc}"""\n\n'
+        class_code += "\n".join(py_fields) if py_fields else "    pass"
+
+        return class_code
+
+    except Exception as e:
+        logger.error(f"Failed to convert {model.__name__} to Python: {e}")
+        return f"class {model.__name__}(BaseModel):\n    pass"
+
+
+def generate_typescript_types(models: List[Type[BaseModel]]) -> str:
+    """
+    Generate TypeScript type definitions for multiple Pydantic models.
+
+    Args:
+        models: List of Pydantic model classes
+
+    Returns:
+        str: Complete TypeScript type definitions
+    """
+    lines = []
+    lines.append("// Generated TypeScript Types")
+    lines.append("// Auto-generated from Pydantic models - DO NOT EDIT")
+    lines.append("")
+
+    for model in models:
+        interface = pydantic_to_typescript(model)
+        lines.append(interface)
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_python_types(models: List[Type[BaseModel]]) -> str:
+    """
+    Generate Python type definitions for multiple Pydantic models.
+
+    Args:
+        models: List of Pydantic model classes
+
+    Returns:
+        str: Complete Python type definitions
+    """
+    lines = []
+    lines.append('"""Generated Python Types"""')
+    lines.append('"""Auto-generated from Pydantic models - DO NOT EDIT"""')
+    lines.append("")
+    lines.append("from typing import Optional, List, Dict, Any")
+    lines.append("from pydantic import BaseModel")
+    lines.append("")
+
+    for model in models:
+        class_def = pydantic_to_python(model)
+        lines.append(class_def)
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def convert_json_schema_to_go(field_info: Dict[str, Any]) -> str:
+    """
+    Convert JSON schema field to Go type.
+
+    Args:
+        field_info: JSON schema field information
+
+    Returns:
+        str: Go type string
+    """
+    # Handle anyOf (union types) - Go doesn't have union types, use interface{}
+    if "anyOf" in field_info:
+        return "interface{}"
+
+    field_type = field_info.get("type", "any")
+
+    if field_type == "string":
+        return "string"
+    elif field_type == "integer":
+        return "int64"
+    elif field_type == "number":
+        return "float64"
+    elif field_type == "boolean":
+        return "bool"
+    elif field_type == "array":
+        items = field_info.get("items", {})
+        item_type = convert_json_schema_to_go(items)
+        return f"[]{item_type}"
+    elif field_type == "object":
+        return "map[string]interface{}"
+    elif field_type == "null":
+        return "interface{}"
+    else:
+        return "interface{}"
+
+
+def pydantic_to_go(model: Type[BaseModel]) -> Dict[str, Any]:
+    """
+    Convert Pydantic model to Go struct definition.
+
+    Args:
+        model: Pydantic model class
+
+    Returns:
+        dict: Go struct information with name, fields, and doc
+    """
+    if not issubclass(model, BaseModel):
+        return {
+            "name": "UnknownStruct",
+            "fields": [],
+            "doc": "",
+        }
+
+    try:
+        schema = model.model_json_schema()
+        properties = schema.get('properties', {})
+        required = schema.get('required', [])
+
+        fields = []
+        for field_name, field_info in properties.items():
+            go_type = convert_json_schema_to_go(field_info)
+
+            # Convert snake_case to PascalCase for Go field names
+            go_field_name = ''.join(word.capitalize() for word in field_name.split('_'))
+
+            # Pointer types for optional fields
+            is_optional = field_name not in required
+            if is_optional and go_type not in ["interface{}", "map[string]interface{}"]:
+                go_type = f"*{go_type}"
+
+            # JSON tag
+            json_tag = f'`json:"{field_name}"`'
+
+            # Description
+            description = field_info.get('description', '')
+
+            fields.append({
+                "name": go_field_name,
+                "type": go_type,
+                "json_tag": json_tag,
+                "description": description,
+            })
+
+        doc = model.__doc__ or f"{model.__name__} struct"
+
+        return {
+            "name": model.__name__,
+            "fields": fields,
+            "doc": doc,
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to convert {model.__name__} to Go: {e}")
+        return {
+            "name": model.__name__,
+            "fields": [],
+            "doc": f"{model.__name__} struct",
+        }
+
+
+def generate_go_types(models: List[Type[BaseModel]]) -> str:
+    """
+    Generate Go type definitions for multiple Pydantic models.
+
+    Args:
+        models: List of Pydantic model classes
+
+    Returns:
+        str: Complete Go type definitions
+    """
+    lines = []
+    lines.append("// Generated Go Types")
+    lines.append("// Auto-generated from Pydantic models - DO NOT EDIT")
+    lines.append("")
+
+    for model in models:
+        struct_info = pydantic_to_go(model)
+
+        # Add doc comment
+        lines.append(f"// {struct_info['doc']}")
+        lines.append(f"type {struct_info['name']} struct {{")
+
+        for field in struct_info['fields']:
+            if field['description']:
+                lines.append(f"\t// {field['description']}")
+            lines.append(f"\t{field['name']} {field['type']} {field['json_tag']}")
+
+        lines.append("}")
+        lines.append("")
+
+    return "\n".join(lines)

django_cfg/apps/integrations/centrifugo/decorators.py

@@ -0,0 +1,137 @@
+"""
+Decorators for Centrifugo RPC handlers.
+"""
+
+import logging
+import inspect
+from typing import Callable, Optional, Type, get_type_hints
+from pydantic import BaseModel
+
+from .router import get_global_router
+from .registry import get_global_registry
+
+logger = logging.getLogger(__name__)
+
+
+def websocket_rpc(method_name: str):
+    """
+    Decorator to register WebSocket RPC handler.
+
+    Registers handler with both MessageRouter (for runtime)
+    and RPCRegistry (for code generation).
+
+    Args:
+        method_name: RPC method name (e.g., "tasks.get_stats")
+
+    Returns:
+        Decorator function
+
+    Example:
+        >>> from pydantic import BaseModel
+        >>>
+        >>> class TaskStatsParams(BaseModel):
+        ...     date_from: str
+        ...     date_to: str
+        >>>
+        >>> class TaskStatsResult(BaseModel):
+        ...     total: int
+        ...     completed: int
+        >>>
+        >>> @websocket_rpc("tasks.get_stats")
+        >>> async def get_stats(conn, params: TaskStatsParams) -> TaskStatsResult:
+        ...     # Business logic here
+        ...     return TaskStatsResult(total=100, completed=50)
+
+    Notes:
+        - Handler must be async function
+        - Handler signature: async def handler(conn, params: ParamsModel) -> ResultModel
+        - ParamsModel and ResultModel must be Pydantic BaseModel subclasses
+        - Type hints are required for code generation
+    """
+    def decorator(handler_func: Callable) -> Callable:
+        # Validate handler is async
+        if not inspect.iscoroutinefunction(handler_func):
+            raise TypeError(f"Handler '{method_name}' must be async function")
+
+        # Extract type hints
+        try:
+            hints = get_type_hints(handler_func)
+        except Exception as e:
+            logger.warning(f"Could not extract type hints for '{method_name}': {e}")
+            hints = {}
+
+        # Extract parameter type (second parameter after conn)
+        param_type: Optional[Type[BaseModel]] = None
+        signature = inspect.signature(handler_func)
+        params_list = list(signature.parameters.values())
+
+        if len(params_list) >= 2:
+            params_param = params_list[1]
+            param_type_hint = hints.get(params_param.name)
+
+            if param_type_hint and _is_pydantic_model(param_type_hint):
+                param_type = param_type_hint
+            elif param_type_hint:
+                logger.warning(
+                    f"⚠️  Handler '{method_name}' uses '{param_type_hint}' for params. "
+                    f"Pydantic models recommended for type-safe client generation."
+                )
+
+        # Extract return type
+        return_type: Optional[Type[BaseModel]] = None
+        return_type_hint = hints.get("return")
+
+        if return_type_hint and _is_pydantic_model(return_type_hint):
+            return_type = return_type_hint
+        elif return_type_hint:
+            logger.warning(
+                f"⚠️  Handler '{method_name}' returns '{return_type_hint}'. "
+                f"Pydantic models recommended for type-safe client generation."
+            )
+
+        # Get docstring
+        docstring = inspect.getdoc(handler_func)
+
+        # Register with MessageRouter (for runtime)
+        router = get_global_router()
+        router.register(method_name)(handler_func)
+
+        # Register with RPCRegistry (for codegen)
+        registry = get_global_registry()
+        registry.register(
+            name=method_name,
+            handler=handler_func,
+            param_type=param_type,
+            return_type=return_type,
+            docstring=docstring,
+        )
+
+        logger.info(f"✅ Registered WebSocket RPC: {method_name}")
+
+        return handler_func
+
+    return decorator
+
+
+def _is_pydantic_model(type_hint) -> bool:
+    """
+    Check if type hint is a Pydantic model.
+
+    Args:
+        type_hint: Type hint to check
+
+    Returns:
+        True if it's a Pydantic BaseModel subclass
+    """
+    try:
+        return (
+            inspect.isclass(type_hint)
+            and issubclass(type_hint, BaseModel)
+        )
+    except (TypeError, AttributeError):
+        return False
+
+
+__all__ = [
+    "websocket_rpc",
+]

django_cfg/apps/integrations/centrifugo/management/__init__.py

@@ -0,0 +1 @@
+"""Django management commands for Centrifugo."""

django_cfg/apps/integrations/centrifugo/management/commands/__init__.py

@@ -0,0 +1 @@
+"""Centrifugo management commands."""