django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/modules/django_client/core/generator/python/templates/main_init.py.jinja

@@ -18,8 +18,8 @@ Usage:
     >>> if api.is_authenticated():
     ...     # ...
     >>>
-    >>> # Get OpenAPI schema
-    >>> schema = api.get_schema()
+    >>> # Get OpenAPI schema path
+    >>> schema_path = api.get_schema_path()
 """
 
 from __future__ import annotations
@@ -30,7 +30,6 @@ from typing import Any
 import httpx
 
 from .client import APIClient
-from .schema import OPENAPI_SCHEMA
 from .logger import LoggerConfig
 from .retry import RetryConfig
 {% for tag in tags %}

django_cfg/modules/django_client/core/generator/typescript/files_generator.py

@@ -196,13 +196,14 @@ class FilesGenerator:
         )
 
     def generate_schema_file(self):
-        """Generate schema.ts with OpenAPI schema as const."""
+        """Generate schema.json with OpenAPI schema."""
+        import json
 
-        template = self.jinja_env.get_template('utils/schema.ts.jinja')
-        content = template.render(schema=self.openapi_schema)
+        # Generate JSON file with proper formatting
+        content = json.dumps(self.openapi_schema, indent=2, ensure_ascii=False)
 
         return GeneratedFile(
-            path="schema.ts",
+            path="schema.json",
             content=content,
-            description="OpenAPI Schema",
+            description="OpenAPI Schema (JSON format)",
         )

django_cfg/modules/django_client/core/generator/typescript/operations_generator.py

@@ -251,13 +251,22 @@ class OperationsGenerator:
         # Handle response
         if operation.is_list_operation and primary_response:
             # Check if response is paginated
-            is_paginated = primary_response.schema_name.startswith('Paginated')
+            is_paginated = primary_response.schema_name and primary_response.schema_name.startswith('Paginated')
+
+            # List of custom list response schemas that return objects with array fields (not DRF pagination)
+            # These return {items: [], total: N} instead of {results: [], count: N, ...}
+            custom_list_schemas = ['ServiceList', 'MethodList', 'TimelineData']
+            is_custom_list = primary_response.schema_name in custom_list_schemas if primary_response.schema_name else False
+
             if is_paginated:
-                # Return full paginated response object
+                # Return full DRF paginated response object {count, results, next, previous, ...}
+                body_lines.append("return response;")
+            elif is_custom_list:
+                # Return full custom list response object {services: [], total_services: N}
                 body_lines.append("return response;")
             else:
-                # Extract results from array response
-                body_lines.append("return (response as any).results || [];")
+                # Fallback: try to extract results field (for unknown list responses)
+                body_lines.append("return (response as any).results || response;")
         elif return_type == "void":
             # No content response (204 No Content or truly void)
             body_lines.append("return;")

django_cfg/modules/django_client/core/generator/typescript/templates/main_index.ts.jinja

@@ -33,7 +33,6 @@
  */
 
 import { APIClient } from "./client";
-import { OPENAPI_SCHEMA } from "./schema";
 import {
   StorageAdapter,
   LocalStorageAdapter,
@@ -82,9 +81,6 @@ export * as Hooks from "./_utils/hooks";
 // Re-export core client
 export { APIClient };
 
-// Re-export OpenAPI schema
-export { OPENAPI_SCHEMA };
-
 // Re-export storage adapters for convenience
 export type { StorageAdapter };
 export { LocalStorageAdapter, CookieStorageAdapter, MemoryStorageAdapter };
@@ -267,11 +263,19 @@ export class API {
   }
 
   /**
-   * Get OpenAPI schema
-   * @returns Complete OpenAPI specification for this API
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
    */
-  getSchema(): any {
-    return OPENAPI_SCHEMA;
+  getSchemaPath(): string {
+    return './schema.json';
   }
 }
 

django_cfg/modules/django_client/core/parser/base.py

@@ -62,8 +62,12 @@ class BaseParser(ABC):
             IRContext with all schemas and operations
 
         Raises:
-            ValueError: If COMPONENT_SPLIT_REQUEST is not detected
+            ValueError: If COMPONENT_SPLIT_REQUEST is not detected or schema name conflicts found
         """
+        # CRITICAL: Validate schema names BEFORE parsing
+        # This prevents generation from starting with invalid schemas
+        self._validate_schema_names()
+
         # Parse metadata
         openapi_info = self._parse_openapi_info()
         django_metadata = self._parse_django_metadata()
@@ -237,13 +241,134 @@ class BaseParser(ABC):
 
         return False
 
+    # ===== Schema Validation =====
+
+    def _validate_schema_names(self) -> None:
+        """
+        Validate schema names for conflicts BEFORE parsing.
+
+        This method checks for:
+        1. Case-insensitive duplicates (e.g., "User" and "user")
+        2. Exact duplicates (e.g., "GRPCServerInfo" from two different serializers)
+
+        Raises:
+            ValueError: If schema name conflicts are detected (hard exit with traceback)
+
+        Example conflicts:
+            - Case-insensitive: "Profile" and "profile" → filesystem conflict
+            - Exact duplicate: "HealthCheck" from multiple serializers → schema conflict
+        """
+        import traceback
+        import sys
+
+        if not self.spec.components or not self.spec.components.schemas:
+            return  # No schemas to validate
+
+        schema_names = list(self.spec.components.schemas.keys())
+        lowercase_map = {}
+        exact_duplicate_sources = {}
+
+        for name in schema_names:
+            lowercase = name.lower()
+
+            # Check case-insensitive duplicates
+            if lowercase in lowercase_map:
+                existing_name = lowercase_map[lowercase]
+                error_msg = (
+                    f"\n{'=' * 80}\n"
+                    f"❌ SCHEMA NAME CONFLICT DETECTED\n"
+                    f"{'=' * 80}\n\n"
+                    f"Conflict Type: Case-insensitive duplicate\n"
+                    f"Schema Names:\n"
+                    f"  1. '{existing_name}'\n"
+                    f"  2. '{name}'\n\n"
+                    f"Problem:\n"
+                    f"  These names differ only in casing and will cause conflicts on\n"
+                    f"  case-insensitive filesystems (macOS, Windows).\n\n"
+                    f"Solution:\n"
+                    f"  Rename one of the Django serializers to make them distinct.\n"
+                    f"  Example: {name}Serializer → {name}DetailSerializer\n\n"
+                    f"{'=' * 80}\n"
+                )
+
+                # Print full error with traceback
+                print(error_msg, file=sys.stderr)
+                print("\n🔍 Traceback (schema validation):", file=sys.stderr)
+                traceback.print_stack(file=sys.stderr)
+
+                # Hard exit - stop generation immediately
+                raise ValueError(
+                    f"Case-insensitive schema name conflict: '{existing_name}' vs '{name}'. "
+                    f"Cannot generate client with conflicting schema names."
+                )
+
+            lowercase_map[lowercase] = name
+
+            # Track schema sources for exact duplicate detection
+            schema = self.spec.components.schemas.get(name)
+            if schema and not isinstance(schema, ReferenceObject):
+                # Get source information from schema
+                title = getattr(schema, 'title', name)
+                description = getattr(schema, 'description', '')
+
+                # Create signature for duplicate detection
+                if name in exact_duplicate_sources:
+                    # Found exact duplicate!
+                    existing = exact_duplicate_sources[name]
+                    error_msg = (
+                        f"\n{'=' * 80}\n"
+                        f"❌ SCHEMA NAME CONFLICT DETECTED\n"
+                        f"{'=' * 80}\n\n"
+                        f"Conflict Type: Exact duplicate schema name\n"
+                        f"Schema Name: '{name}'\n\n"
+                        f"Sources:\n"
+                        f"  1. {existing['title']}\n"
+                        f"     Description: {existing['description'][:100]}\n"
+                        f"  2. {title}\n"
+                        f"     Description: {description[:100]}\n\n"
+                        f"Problem:\n"
+                        f"  Multiple serializers are generating the same schema name '{name}'.\n"
+                        f"  This causes schema conflicts in the generated API client and\n"
+                        f"  OpenAPI documentation.\n\n"
+                        f"Solution:\n"
+                        f"  Rename one of the serializers to make them unique.\n"
+                        f"  Examples:\n"
+                        f"    - HealthCheckSerializer → GRPCHealthCheckSerializer\n"
+                        f"    - ServerInfoSerializer → GRPCServerStatusSerializer\n\n"
+                        f"{'=' * 80}\n"
+                    )
+
+                    # Print full error with traceback
+                    print(error_msg, file=sys.stderr)
+                    print("\n🔍 Traceback (schema validation):", file=sys.stderr)
+                    traceback.print_stack(file=sys.stderr)
+
+                    # Hard exit - stop generation immediately
+                    raise ValueError(
+                        f"Duplicate schema name detected: '{name}'. "
+                        f"Multiple serializers are generating this schema. "
+                        f"Cannot generate client with conflicting schemas."
+                    )
+
+                # Store for duplicate detection
+                exact_duplicate_sources[name] = {
+                    'title': title,
+                    'description': description,
+                }
+
     # ===== Schema Parsing =====
 
     def _parse_all_schemas(self) -> dict[str, IRSchemaObject]:
-        """Parse all schemas from components."""
+        """
+        Parse all schemas from components.
+
+        Note: Schema name validation is done in _validate_schema_names()
+        which is called BEFORE this method in parse().
+        """
         if not self.spec.components or not self.spec.components.schemas:
             return {}
 
+        # Parse schemas (validation already done in _validate_schema_names)
         schemas = {}
         for name, schema_or_ref in self.spec.components.schemas.items():
             # Skip references for now
@@ -468,6 +593,14 @@ class BaseParser(ABC):
         if schema.base_type:
             return schema.base_type
 
+        # Check anyOf: [{"type": "X"}, {"type": "null"}] pattern (Pydantic style)
+        # Extract the actual type from anyOf if it's a simple nullable pattern
+        if schema.anyOf and len(schema.anyOf) == 2:
+            for item in schema.anyOf:
+                if isinstance(item, SchemaObject) and item.base_type and item.base_type != 'null':
+                    # Found the actual type (not null)
+                    return item.base_type
+
         # Fallback: infer from other properties
         if schema.properties is not None:
             return "object"

django_cfg/modules/django_client/management/commands/generate_client.py

@@ -8,12 +8,15 @@ Usage:
 """
 
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 
+from django_cfg.management.utils import AdminCommand
 
-class Command(BaseCommand):
+
+class Command(AdminCommand):
     """Generate OpenAPI clients for configured application groups."""
 
+    command_name = 'generate_client'
     help = "Generate Python, TypeScript, and Go API clients from OpenAPI schemas"
 
     def add_arguments(self, parser):

django_cfg/modules/django_client/management/commands/validate_openapi.py

@@ -12,12 +12,15 @@ Usage:
 from pathlib import Path
 from typing import List
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 
+from django_cfg.management.utils import AdminCommand
 
-class Command(BaseCommand):
+
+class Command(AdminCommand):
     """Validate and fix OpenAPI schema quality issues in DRF serializers."""
 
+    command_name = 'validate_openapi'
     help = "Validate and auto-fix OpenAPI schema quality issues"
 
     def add_arguments(self, parser):

django_cfg/modules/django_currency/examples/example_database_usage.py

@@ -63,7 +63,7 @@ def example_django_integration():
     print("""
     # In your Django management command or view:
     from django_cfg.modules.django_currency.database_loader import load_currencies_to_database_format
-    from django_cfg.apps.payments.models import Currency
+    from django_cfg.apps.business.payments.models import Currency
     
     # Load currency data
     currency_data = load_currencies_to_database_format()

django_cfg/modules/django_email/management/commands/test_email.py

@@ -5,22 +5,16 @@ Tests email sending functionality using django_cfg configuration.
 """
 
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
 User = get_user_model()
-logger = get_logger('test_email')
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to test email functionality."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'test_email'
     help = "Test email sending functionality"
 
     def add_arguments(self, parser):
@@ -48,7 +42,7 @@ class Command(BaseCommand):
         subject = options["subject"]
         message = options["message"]
 
-        logger.info(f"Starting email test for {email}")
+        self.logger.info(f"Starting email test for {email}")
         self.stdout.write(f"🚀 Testing email service for {email}")
 
         # Create test user if not exists

django_cfg/modules/django_logging/__init__.py

@@ -7,6 +7,7 @@ Auto-configuring logging utilities.
 from .django_logger import (
     RESERVED_LOG_ATTRS,
     DjangoLogger,
+    clean_old_logs,
     get_logger,
     sanitize_extra,
 )
@@ -17,5 +18,6 @@ __all__ = [
     "DjangoLogger",
     "get_logger",
     "sanitize_extra",
+    "clean_old_logs",
     "RESERVED_LOG_ATTRS",
 ]

django_cfg/modules/django_logging/django_logger.py

@@ -2,9 +2,16 @@
 Simple auto-configuring Django Logger for django_cfg.
 
 KISS principle: simple, unified logging configuration.
+
+Features:
+- Modular logging with separate files per module
+- Automatic log rotation (daily, keeps 30 days)
+- INFO+ to files, WARNING+ to console
+- Auto-cleanup of old logs
 """
 
 import logging
+from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -95,12 +102,18 @@ class DjangoLogger(BaseCfgModule):
 
         # Create handlers
         try:
-            # Handler for general Django logs
+            # Handler for general Django logs with rotation
             django_log_path = logs_dir / 'django.log'
-            django_handler = logging.FileHandler(django_log_path, encoding='utf-8')
-            django_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
+            django_handler = TimedRotatingFileHandler(
+                django_log_path,
+                when='midnight',  # Rotate at midnight
+                interval=1,  # Every 1 day
+                backupCount=30,  # Keep 30 days of logs
+                encoding='utf-8',
+            )
+            django_handler.setLevel(logging.DEBUG if debug else logging.INFO)  # INFO+ in production, DEBUG in dev
 
-            # Console handler
+            # Console handler - WARNING+ always (less noise)
             console_handler = logging.StreamHandler()
             console_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
 
@@ -111,7 +124,7 @@ class DjangoLogger(BaseCfgModule):
 
             # Configure root logger
             root_logger = logging.getLogger()
-            root_logger.setLevel(logging.DEBUG if debug else logging.WARNING)
+            root_logger.setLevel(logging.DEBUG if debug else logging.INFO)  # INFO+ in production, DEBUG in dev
 
             # Clear existing handlers
             root_logger.handlers.clear()
@@ -159,8 +172,14 @@ class DjangoLogger(BaseCfgModule):
 
                 log_file_path = djangocfg_logs_dir / f'{module_name}.log'
 
-                # Create file handler for this specific module
-                file_handler = logging.FileHandler(log_file_path, encoding='utf-8')
+                # Create rotating file handler for this specific module
+                file_handler = TimedRotatingFileHandler(
+                    log_file_path,
+                    when='midnight',  # Rotate at midnight
+                    interval=1,  # Every 1 day
+                    backupCount=30,  # Keep 30 days of logs
+                    encoding='utf-8',
+                )
 
                 # Get debug mode
                 try:
@@ -170,7 +189,7 @@ class DjangoLogger(BaseCfgModule):
                 except Exception:
                     debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
 
-                file_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
+                file_handler.setLevel(logging.DEBUG if debug else logging.INFO)  # INFO+ in production, DEBUG in dev
 
                 # Set format
                 formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s')
@@ -188,6 +207,57 @@ class DjangoLogger(BaseCfgModule):
         return logger
 
 
+def clean_old_logs(days: int = 30, logs_dir: Optional[Path] = None) -> Dict[str, int]:
+    """
+    Clean up log files older than specified days.
+
+    Args:
+        days: Number of days to keep (default: 30)
+        logs_dir: Optional custom logs directory (default: ./logs)
+
+    Returns:
+        Dictionary with cleanup statistics
+
+    Example:
+        >>> from django_cfg.modules.django_logging import clean_old_logs
+        >>> stats = clean_old_logs(days=7)  # Keep only last 7 days
+        >>> print(f"Deleted {stats['deleted']} files, freed {stats['bytes']} bytes")
+    """
+    import os
+    from datetime import datetime, timedelta
+
+    if logs_dir is None:
+        current_dir = Path(os.getcwd())
+        logs_dir = current_dir / 'logs'
+
+    if not logs_dir.exists():
+        return {'deleted': 0, 'bytes': 0, 'error': 'Logs directory not found'}
+
+    cutoff_date = datetime.now() - timedelta(days=days)
+    deleted_count = 0
+    deleted_bytes = 0
+
+    # Recursively find all .log files (including rotated ones like .log.2024-11-01)
+    for log_file in logs_dir.rglob('*.log*'):
+        if log_file.is_file():
+            try:
+                # Check file modification time
+                mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+                if mtime < cutoff_date:
+                    file_size = log_file.stat().st_size
+                    log_file.unlink()
+                    deleted_count += 1
+                    deleted_bytes += file_size
+            except Exception as e:
+                print(f"[django-cfg] Error deleting {log_file}: {e}")
+
+    return {
+        'deleted': deleted_count,
+        'bytes': deleted_bytes,
+        'human_readable': f"{deleted_bytes / 1024 / 1024:.2f} MB" if deleted_bytes > 0 else "0 MB",
+    }
+
+
 # Convenience function for quick access
 def get_logger(name: str = "django_cfg") -> logging.Logger:
     """

django_cfg/modules/django_ngrok/management/commands/runserver_ngrok.py

@@ -12,8 +12,6 @@ from django.core.management.commands.runserver import Command as RunServerComman
 from django_cfg.modules.django_logging import get_logger
 from django_cfg.modules.django_ngrok import get_ngrok_service
 
-logger = get_logger('runserver_ngrok')
-
 
 class Command(RunServerCommand):
     """Enhanced runserver command with ngrok tunnel support."""
@@ -25,6 +23,11 @@ class Command(RunServerCommand):
 
     help = f'{RunServerCommand.help.rstrip(".")} with ngrok tunnel.'
 
+    def __init__(self, *args, **kwargs):
+        """Initialize with logger."""
+        super().__init__(*args, **kwargs)
+        self.logger = get_logger('runserver_ngrok')
+
     def add_arguments(self, parser):
         super().add_arguments(parser)
         parser.add_argument(
@@ -76,14 +79,14 @@ class Command(RunServerCommand):
         ngrok_service = get_ngrok_service()
 
         self.stdout.write("🚇 Starting ngrok tunnel...")
-        logger.info(f"Starting ngrok tunnel for port {server_port}")
+        self.logger.info(f"Starting ngrok tunnel for port {server_port}")
 
         tunnel_url = ngrok_service.start_tunnel(server_port)
 
         if tunnel_url:
             # Wait for tunnel to be fully established
             self.stdout.write("⏳ Waiting for tunnel to be established...")
-            logger.info("Waiting for ngrok tunnel to be fully established")
+            self.logger.info("Waiting for ngrok tunnel to be fully established")
 
             max_retries = 10
             retry_count = 0
@@ -98,10 +101,10 @@ class Command(RunServerCommand):
                     current_url = ngrok_service.get_tunnel_url()
                     if current_url and current_url == tunnel_url:
                         tunnel_ready = True
-                        logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
+                        self.logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
                         break
                 except Exception as e:
-                    logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
+                    self.logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
 
                 self.stdout.write(f"⏳ Tunnel check {retry_count}/{max_retries}...")
 
@@ -116,16 +119,16 @@ class Command(RunServerCommand):
                 self.stdout.write(
                     self.style.SUCCESS(f"✅ Ngrok tunnel ready: {tunnel_url}")
                 )
-                logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
+                self.logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
             else:
                 self.stdout.write(
                     self.style.WARNING("⚠️ Ngrok tunnel started but may not be fully ready")
                 )
-                logger.warning("Ngrok tunnel started but readiness check failed")
+                self.logger.warning("Ngrok tunnel started but readiness check failed")
         else:
             error_msg = "Failed to start ngrok tunnel"
             self.stdout.write(self.style.ERROR(f"❌ {error_msg}"))
-            logger.error(error_msg)
+            self.logger.error(error_msg)
 
     def _set_ngrok_env_vars(self, tunnel_url: str):
         """Set environment variables with ngrok URL for easy access."""
@@ -145,10 +148,10 @@ class Command(RunServerCommand):
             os.environ['NGROK_API_URL'] = tunnel_url
 
             # Environment variables set - no need for verbose output
-            logger.info(f"Set ngrok environment variables: {tunnel_url}")
+            self.logger.info(f"Set ngrok environment variables: {tunnel_url}")
 
         except Exception as e:
-            logger.warning(f"Could not set ngrok environment variables: {e}")
+            self.logger.warning(f"Could not set ngrok environment variables: {e}")
 
     def _update_allowed_hosts(self, tunnel_url: str):
         """Update ALLOWED_HOSTS with ngrok domain."""
@@ -164,7 +167,7 @@ class Command(RunServerCommand):
             if hasattr(settings, 'ALLOWED_HOSTS'):
                 if ngrok_host not in settings.ALLOWED_HOSTS:
                     settings.ALLOWED_HOSTS.append(ngrok_host)
-                    logger.info(f"Added {ngrok_host} to ALLOWED_HOSTS")
+                    self.logger.info(f"Added {ngrok_host} to ALLOWED_HOSTS")
 
         except Exception as e:
-            logger.warning(f"Could not update ALLOWED_HOSTS: {e}")
+            self.logger.warning(f"Could not update ALLOWED_HOSTS: {e}")

django_cfg/modules/django_telegram/management/commands/test_telegram.py

@@ -4,20 +4,13 @@ Test Telegram Command
 Tests Telegram notification functionality using django_cfg configuration.
 """
 
-from django.core.management.base import BaseCommand
+from django_cfg.management.utils import SafeCommand
 
-from django_cfg.modules.django_logging import get_logger
 
-logger = get_logger('test_telegram')
-
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to test Telegram functionality."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'test_telegram'
     help = "Test Telegram notification functionality"
 
     def add_arguments(self, parser):
@@ -29,7 +22,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting test_telegram command")
+        self.logger.info("Starting test_telegram command")
         message = options["message"]
 
         self.stdout.write("🚀 Testing Telegram notification service")

django_cfg/modules/django_twilio/management/commands/test_twilio.py

@@ -4,20 +4,13 @@ Test Twilio Command
 Tests Twilio messaging functionality using django_cfg configuration.
 """
 
-from django.core.management.base import BaseCommand
+from django_cfg.management.utils import SafeCommand
 
-from django_cfg.modules.django_logging import get_logger
 
-logger = get_logger('test_twilio')
-
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to test Twilio functionality."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'test_twilio'
     help = "Test Twilio messaging functionality"
 
     def add_arguments(self, parser):
@@ -45,7 +38,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting test_twilio command")
+        self.logger.info("Starting test_twilio command")
         to_number = options["to"]
         message = options["message"]
         is_whatsapp = options["whatsapp"]