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

django_cfg/apps/tasks/services/client/client.py

@@ -1,234 +0,0 @@
-"""
-ReArq client wrapper for Django-CFG.
-
-Provides singleton access to ReArq with django-cfg configuration.
-"""
-from typing import TYPE_CHECKING, Optional
-
-from django_cfg.modules.django_logging import get_logger
-
-if TYPE_CHECKING:
-    from rearq import ReArq
-
-logger = get_logger("tasks.client")
-
-
-class ReArqClient:
-    """
-    Django wrapper for ReArq client.
-
-    Provides singleton access to ReArq with django-cfg configuration.
-
-    Features:
-    - Async task queue with Redis backend
-    - Job persistence with Tortoise ORM
-    - Built-in retry logic
-    - Cron task support
-    - Job result tracking
-
-    Example:
-        >>> from django_cfg.apps.tasks import get_rearq_client
-        >>>
-        >>> client = get_rearq_client()
-        >>>
-        >>> # Define task
-        >>> @client.task(queue="default")
-        >>> async def process_data(data_id: str):
-        ...     # Process data
-        ...     return {"status": "done"}
-        >>>
-        >>> # Execute task
-        >>> job = await process_data.delay(data_id="123")
-        >>> result = await job.result(timeout=30)
-    """
-
-    def __init__(
-        self,
-        redis_url: str,
-        db_url: str,
-        max_jobs: int = 10,
-        job_timeout: int = 300,
-        job_retry: int = 3,
-        job_retry_after: int = 60,
-        keep_job_days: int | None = 7,
-    ):
-        """
-        Initialize ReArq client.
-
-        Args:
-            redis_url: Redis connection URL for task queue
-            db_url: Database URL for job persistence (Tortoise ORM)
-            max_jobs: Maximum concurrent jobs per worker
-            job_timeout: Default job timeout in seconds
-            job_retry: Default number of retries for failed jobs
-            job_retry_after: Delay in seconds before retrying failed job
-            keep_job_days: Days to keep job history (None = forever)
-        """
-        self.redis_url = redis_url
-        self.db_url = db_url
-        self.max_jobs = max_jobs
-        self.job_timeout = job_timeout
-        self.job_retry = job_retry
-        self.job_retry_after = job_retry_after
-        self.keep_job_days = keep_job_days
-
-        # Lazy import ReArq to avoid distutils issues at startup
-        from rearq import ReArq
-
-        # Create ReArq instance
-        self.rearq = ReArq(
-            redis_url=redis_url,
-            job_retry=job_retry,
-            job_retry_after=job_retry_after,
-            max_jobs=max_jobs,
-            job_timeout=job_timeout,
-            keep_job_days=keep_job_days,
-        )
-
-        logger.info(f"ReArq client initialized: {redis_url}")
-
-    def task(self, queue: str = "default", **kwargs):
-        """
-        Task decorator for defining async tasks.
-
-        Args:
-            queue: Queue name for the task
-            **kwargs: Additional task options
-
-        Returns:
-            Task decorator
-
-        Example:
-            >>> @client.task(queue="default")
-            >>> async def my_task(arg1: str):
-            ...     return f"Processed {arg1}"
-        """
-        return self.rearq.task(queue=queue, **kwargs)
-
-    def cron_task(self, cron: str, **kwargs):
-        """
-        Cron task decorator for scheduled tasks.
-
-        Args:
-            cron: Cron expression (e.g., "0 * * * *" for hourly)
-            **kwargs: Additional task options
-
-        Returns:
-            Task decorator
-
-        Example:
-            >>> @client.cron_task(cron="0 0 * * *")  # Daily at midnight
-            >>> async def daily_cleanup():
-            ...     return "Cleanup complete"
-        """
-        return self.rearq.task(cron=cron, **kwargs)
-
-    async def close(self):
-        """
-        Close client connections.
-
-        Call this when shutting down application to clean up resources.
-
-        Example:
-            >>> await client.close()
-        """
-        await self.rearq.close()
-        logger.info("ReArq client closed")
-
-    def get_connection_info(self) -> dict:
-        """
-        Get connection information.
-
-        Returns:
-            Dictionary with connection details
-
-        Example:
-            >>> info = client.get_connection_info()
-            >>> print(info["redis_url"])
-        """
-        return {
-            "redis_url": self.redis_url,
-            "db_url": self.db_url,
-            "max_jobs": self.max_jobs,
-            "job_timeout": self.job_timeout,
-            "job_retry": self.job_retry,
-            "job_retry_after": self.job_retry_after,
-            "keep_job_days": self.keep_job_days,
-        }
-
-
-# ==================== Singleton Pattern ====================
-
-_rearq_client: Optional[ReArqClient] = None
-_rearq_client_lock = None
-
-
-def get_rearq_client(force_new: bool = False) -> ReArqClient:
-    """
-    Get global ReArq client instance (singleton).
-
-    Creates client from Django settings on first call.
-    Subsequent calls return the same instance (thread-safe).
-
-    Args:
-        force_new: Force create new instance (for testing)
-
-    Returns:
-        ReArqClient instance
-
-    Example:
-        >>> from django_cfg.apps.tasks import get_rearq_client
-        >>> client = get_rearq_client()
-        >>> @client.task(queue="default")
-        >>> async def my_task():
-        ...     pass
-    """
-    global _rearq_client, _rearq_client_lock
-
-    if force_new:
-        return _create_client_from_settings()
-
-    if _rearq_client is None:
-        # Thread-safe singleton creation
-        import threading
-
-        if _rearq_client_lock is None:
-            _rearq_client_lock = threading.Lock()
-
-        with _rearq_client_lock:
-            if _rearq_client is None:
-                _rearq_client = _create_client_from_settings()
-
-    return _rearq_client
-
-
-def _create_client_from_settings() -> ReArqClient:
-    """
-    Create ReArq client from django-cfg config.
-
-    Returns:
-        ReArqClient instance
-
-    Raises:
-        ConfigurationError: If settings not configured
-    """
-    from ..config_helper import get_tasks_config_or_default
-
-    cfg = get_tasks_config_or_default()
-    logger.debug(f"Creating ReArq client from config: {cfg.rearq.redis_url}")
-
-    return ReArqClient(
-        redis_url=cfg.rearq.redis_url,
-        db_url=cfg.rearq.db_url,
-        max_jobs=cfg.rearq.max_jobs,
-        job_timeout=cfg.rearq.job_timeout,
-        job_retry=cfg.rearq.job_retry,
-        job_retry_after=cfg.rearq.job_retry_after,
-        keep_job_days=cfg.rearq.keep_job_days,
-    )
-
-
-__all__ = [
-    "ReArqClient",
-    "get_rearq_client",
-]

django_cfg/apps/tasks/services/config_helper.py

@@ -1,63 +0,0 @@
-"""
-Task configuration helper.
-
-Provides access to task configuration from global state.
-"""
-from typing import Optional
-
-from django_cfg.modules.django_logging import get_logger
-
-logger = get_logger("tasks.config")
-
-
-def get_tasks_config():
-    """
-    Get tasks configuration from global state.
-
-    Returns:
-        TaskConfig instance if found, None otherwise
-
-    Example:
-        >>> from django_cfg.apps.tasks.services import get_tasks_config
-        >>> config = get_tasks_config()
-        >>> if config:
-        ...     print(config.rearq.redis_url)
-    """
-    from django_cfg.core import get_current_config
-
-    config = get_current_config()
-
-    if config and hasattr(config, "tasks") and config.tasks:
-        return config.tasks
-
-    return None
-
-
-def get_tasks_config_or_default():
-    """
-    Get tasks configuration or return default.
-
-    Returns:
-        TaskConfig instance (from global state or default)
-
-    Example:
-        >>> from django_cfg.apps.tasks.services import get_tasks_config_or_default
-        >>> config = get_tasks_config_or_default()
-        >>> print(config.rearq.redis_url)
-    """
-    config = get_tasks_config()
-
-    if config:
-        return config
-
-    # Fallback to default
-    from django_cfg.models.tasks import TaskConfig
-
-    logger.warning("Tasks config not found in global state, using default")
-    return TaskConfig()
-
-
-__all__ = [
-    "get_tasks_config",
-    "get_tasks_config_or_default",
-]

django_cfg/apps/tasks/services/sync.py

@@ -1,204 +0,0 @@
-"""
-ReArq to TaskLog sync utilities.
-
-Helpers for syncing data from ReArq (Tortoise ORM) to TaskLog (Django ORM).
-"""
-from typing import Optional
-from django.utils import timezone
-from ..models import TaskLog
-
-
-def create_task_log_from_job(
-    job_id: str,
-    task_name: str,
-    queue_name: str = "default",
-    args: list = None,
-    kwargs: dict = None,
-    job_retry: int = 0,
-    job_retry_after: int = 60,
-    enqueue_time = None,
-    expire_time = None,
-    status: str = "queued",
-    user=None,
-) -> TaskLog:
-    """
-    Create TaskLog entry from ReArq Job data.
-
-    Args:
-        job_id: Unique job identifier from ReArq
-        task_name: Name of the task function
-        queue_name: Queue name (default: "default")
-        args: Positional arguments
-        kwargs: Keyword arguments
-        job_retry: Max retry count from task definition
-        job_retry_after: Seconds to wait before retry
-        enqueue_time: When job was enqueued (Job.enqueue_time)
-        expire_time: When job will expire (Job.expire_time)
-        status: Job status (default: "queued")
-        user: Django User who triggered the task
-
-    Returns:
-        Created TaskLog instance
-    """
-    return TaskLog.objects.create(
-        job_id=job_id,
-        task_name=task_name,
-        queue_name=queue_name,
-        args=args or [],
-        kwargs=kwargs or {},
-        job_retry=job_retry,
-        job_retry_after=job_retry_after,
-        enqueue_time=enqueue_time or timezone.now(),
-        expire_time=expire_time,
-        status=status,
-        user=user,
-    )
-
-
-def update_task_log_from_result(
-    job_id: str,
-    worker: str,
-    success: bool,
-    result: str = None,
-    start_time = None,
-    finish_time = None,
-) -> Optional[TaskLog]:
-    """
-    Update TaskLog with JobResult data.
-
-    Args:
-        job_id: Job identifier
-        worker: Worker that processed the task
-        success: Whether task succeeded
-        result: Task result (JSON string)
-        start_time: When execution started (JobResult.start_time)
-        finish_time: When execution finished (JobResult.finish_time)
-
-    Returns:
-        Updated TaskLog instance or None if not found
-    """
-    try:
-        task_log = TaskLog.objects.get(job_id=job_id)
-    except TaskLog.DoesNotExist:
-        return None
-
-    # Update fields from JobResult
-    task_log.worker_id = worker
-    task_log.success = success
-    task_log.start_time = start_time
-    task_log.finish_time = finish_time
-
-    if result is not None:
-        task_log.result = result
-
-    # Calculate duration
-    if start_time and finish_time:
-        delta = finish_time - start_time
-        task_log.duration_ms = int(delta.total_seconds() * 1000)
-
-    # Update status based on success
-    if success:
-        task_log.status = TaskLog.StatusChoices.SUCCESS
-    else:
-        task_log.status = TaskLog.StatusChoices.FAILED
-
-    task_log.save()
-    return task_log
-
-
-def sync_job_status(job_id: str, status: str, job_retries: int = None) -> Optional[TaskLog]:
-    """
-    Sync Job status to TaskLog.
-
-    Args:
-        job_id: Job identifier
-        status: ReArq JobStatus value
-        job_retries: Current retry count
-
-    Returns:
-        Updated TaskLog instance or None if not found
-    """
-    try:
-        task_log = TaskLog.objects.get(job_id=job_id)
-    except TaskLog.DoesNotExist:
-        return None
-
-    task_log.status = status
-    if job_retries is not None:
-        task_log.job_retries = job_retries
-
-    task_log.save(update_fields=["status", "job_retries", "updated_at"])
-    return task_log
-
-
-async def sync_from_rearq_job(rearq_job):
-    """
-    Sync TaskLog from ReArq Job instance (Tortoise model).
-
-    Usage:
-        from rearq.server.models import Job
-        job = await Job.get(job_id="...")
-        await sync_from_rearq_job(job)
-
-    Args:
-        rearq_job: ReArq Job instance (Tortoise ORM)
-
-    Returns:
-        TaskLog instance
-    """
-    from asgiref.sync import sync_to_async
-
-    # Extract queue name from full queue path
-    queue_name = rearq_job.task.split(':')[-1] if ':' in rearq_job.task else "default"
-
-    # Check if TaskLog exists
-    task_log = await sync_to_async(TaskLog.objects.filter(job_id=rearq_job.job_id).first)()
-
-    if task_log:
-        # Update existing
-        task_log.status = rearq_job.status
-        task_log.job_retries = rearq_job.job_retries
-        await sync_to_async(task_log.save)(update_fields=["status", "job_retries", "updated_at"])
-    else:
-        # Create new
-        task_log = await sync_to_async(create_task_log_from_job)(
-            job_id=rearq_job.job_id,
-            task_name=rearq_job.task,
-            queue_name=queue_name,
-            args=rearq_job.args or [],
-            kwargs=rearq_job.kwargs or {},
-            job_retry=rearq_job.job_retry,
-            job_retry_after=rearq_job.job_retry_after,
-            enqueue_time=rearq_job.enqueue_time,
-            expire_time=rearq_job.expire_time,
-            status=rearq_job.status,
-        )
-
-    return task_log
-
-
-async def sync_from_rearq_result(rearq_result):
-    """
-    Sync TaskLog from ReArq JobResult instance (Tortoise model).
-
-    Usage:
-        from rearq.server.models import JobResult
-        result = await JobResult.get(job_id="...").prefetch_related("job")
-        await sync_from_rearq_result(result)
-
-    Args:
-        rearq_result: ReArq JobResult instance (Tortoise ORM)
-
-    Returns:
-        TaskLog instance or None
-    """
-    from asgiref.sync import sync_to_async
-
-    return await sync_to_async(update_task_log_from_result)(
-        job_id=rearq_result.job_id,
-        worker=rearq_result.worker,
-        success=rearq_result.success,
-        result=rearq_result.result,
-        start_time=rearq_result.start_time,
-        finish_time=rearq_result.finish_time,
-    )

django_cfg/apps/tasks/urls.py

@@ -1,16 +0,0 @@
-"""
-ReArq Tasks API URLs.
-
-REST API endpoints for task monitoring and management.
-"""
-from django.urls import path
-from rest_framework.routers import DefaultRouter
-
-from .views import TaskLogViewSet
-
-app_name = 'django_cfg_tasks'
-
-router = DefaultRouter()
-router.register(r'logs', TaskLogViewSet, basename='tasklog')
-
-urlpatterns = router.urls

django_cfg/apps/tasks/views/__init__.py

@@ -1,10 +0,0 @@
-"""
-ReArq Tasks API Views.
-
-ViewSets for task monitoring and management.
-"""
-from .task_log import TaskLogViewSet
-
-__all__ = [
-    "TaskLogViewSet",
-]

django_cfg/apps/tasks/views/task_log.py

@@ -1,41 +0,0 @@
-"""
-TaskLog ViewSet - Main Entry Point.
-
-Combines all task log functionality through mixins.
-"""
-from .task_log_base import TaskLogBaseViewSet
-from .task_log_stats import TaskLogStatsMixin
-from .task_log_timeline import TaskLogTimelineMixin
-from .task_log_overview import TaskLogOverviewMixin
-from .task_log_related import TaskLogRelatedMixin
-
-
-class TaskLogViewSet(
-    TaskLogStatsMixin,
-    TaskLogTimelineMixin,
-    TaskLogOverviewMixin,
-    TaskLogRelatedMixin,
-    TaskLogBaseViewSet,
-):
-    """
-    Complete ViewSet for TaskLog monitoring.
-
-    Provides read-only access to task execution logs with filtering,
-    searching, and statistics.
-
-    Endpoints:
-        GET /api/tasks/logs/ - List all task logs
-        GET /api/tasks/logs/{id}/ - Get task log details
-        GET /api/tasks/logs/{id}/related/ - Get related task logs
-        GET /api/tasks/logs/stats/ - Get aggregated statistics
-        GET /api/tasks/logs/timeline/ - Get task execution timeline
-        GET /api/tasks/logs/overview/ - Get summary overview
-
-    Mixins:
-        - TaskLogStatsMixin: Aggregated statistics
-        - TaskLogTimelineMixin: Time-series data
-        - TaskLogOverviewMixin: High-level summary
-        - TaskLogRelatedMixin: Related task lookup
-        - TaskLogBaseViewSet: Base CRUD operations
-    """
-    pass

django_cfg/apps/tasks/views/task_log_base.py

@@ -1,41 +0,0 @@
-"""
-TaskLog Base ViewSet.
-
-Base viewset with common configuration for task log endpoints.
-"""
-from rest_framework import viewsets
-from rest_framework.filters import SearchFilter, OrderingFilter
-from django_filters.rest_framework import DjangoFilterBackend
-
-from django_cfg.mixins import AdminAPIMixin
-from ..models import TaskLog
-from ..serializers import (
-    TaskLogSerializer,
-    TaskLogListSerializer,
-    TaskLogDetailSerializer,
-)
-from ..filters import TaskLogFilter
-
-
-class TaskLogBaseViewSet(AdminAPIMixin, viewsets.ReadOnlyModelViewSet):
-    """
-    Base ViewSet for TaskLog monitoring.
-
-    Provides read-only access to task execution logs with filtering and searching.
-    Extended by mixins for additional functionality (stats, timeline, overview).
-    Requires admin authentication (JWT, Session, or Basic Auth).
-    """
-
-    queryset = TaskLog.objects.all().order_by('-enqueue_time')
-    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
-    filterset_class = TaskLogFilter
-    search_fields = ['task_name', 'job_id', 'queue_name', 'error_message', 'worker_id']
-    ordering_fields = ['enqueue_time', 'start_time', 'finish_time', 'duration_ms', 'job_retries', 'created_at']
-
-    def get_serializer_class(self):
-        """Return appropriate serializer based on action."""
-        if self.action == 'list':
-            return TaskLogListSerializer
-        elif self.action == 'retrieve':
-            return TaskLogDetailSerializer
-        return TaskLogSerializer