matrice-inference 0.1.0__py3-none-manylinux_2_17_x86_64.whl

matrice_inference/deploy/server/stream/kafka_producer_worker.pyi

@@ -0,0 +1,50 @@
+"""Auto-generated stub for module: kafka_producer_worker."""
+from typing import Any, Dict, List, Optional
+
+from datetime import datetime, timezone
+from matrice_inference.deploy.stream.kafka_stream import MatriceKafkaDeployment
+import asyncio
+import logging
+
+# Classes
+class KafkaProducerWorker:
+    """
+    Kafka producer worker that consumes from output queue and produces to topics.
+    """
+
+    def __init__(self: Any, worker_id: str, session: Any, deployment_id: str, deployment_instance_id: str, output_queue: Any, app_name: str = '', app_version: str = '', produce_timeout: float = 10.0, inference_pipeline_id: str = '') -> None: ...
+        """
+        Initialize Kafka producer worker.
+        
+                Args:
+                    worker_id: Unique identifier for this worker
+                    session: Session object for authentication and RPC
+                    deployment_id: ID of the deployment
+                    deployment_instance_id: ID of the deployment instance
+                    output_queue: Queue to get result messages from
+                    app_name: Application name for result formatting
+                    app_version: Application version for result formatting
+                    produce_timeout: Timeout for producing to Kafka
+                    inference_pipeline_id: ID of the inference pipeline
+        """
+
+    def get_metrics(self: Any) -> Dict[str, Any]: ...
+        """
+        Get worker metrics.
+        """
+
+    def reset_metrics(self: Any) -> None: ...
+        """
+        Reset worker metrics.
+        """
+
+    async def start(self: Any) -> None: ...
+        """
+        Start the producer worker.
+        """
+
+    async def stop(self: Any) -> None: ...
+        """
+        Stop the producer worker.
+        """
+

matrice_inference/deploy/server/stream/stream_debug_logger.pyi

@@ -0,0 +1,47 @@
+"""Auto-generated stub for module: stream_debug_logger."""
+from typing import Any, Dict, List
+
+from datetime import datetime, timezone
+import logging
+import time
+
+# Classes
+class StreamDebugLogger:
+    """
+    Debug logging component for stream processing pipeline.
+    """
+
+    def __init__(self: Any, enabled: bool = False, log_interval: float = 30.0) -> None: ...
+        """
+        Initialize debug logger.
+        
+                Args:
+                    enabled: Whether debug logging is enabled
+                    log_interval: Interval between debug log messages in seconds
+        """
+
+    def disable(self: Any) -> Any: ...
+        """
+        Disable debug logging.
+        """
+
+    def enable(self: Any) -> Any: ...
+        """
+        Enable debug logging.
+        """
+
+    def get_debug_summary(self: Any) -> Dict[str, Any]: ...
+        """
+        Get debug logging summary.
+        """
+
+    def log_pipeline_status(self: Any, stream_manager: Any) -> Any: ...
+        """
+        Log pipeline status if enabled and interval passed.
+        """
+
+    def should_log(self: Any) -> bool: ...
+        """
+        Check if we should log based on interval.
+        """
+

matrice_inference/deploy/server/stream/stream_manager.pyi

@@ -0,0 +1,69 @@
+"""Auto-generated stub for module: stream_manager."""
+from typing import Any, Dict, Optional
+
+from matrice_inference.deploy.server.inference.inference_interface import InferenceInterface
+from matrice_inference.deploy.server.stream.inference_worker import InferenceWorker
+from matrice_inference.deploy.server.stream.kafka_consumer_worker import KafkaConsumerWorker
+from matrice_inference.deploy.server.stream.kafka_producer_worker import KafkaProducerWorker
+from matrice_inference.deploy.server.stream.stream_debug_logger import StreamDebugLogger
+import asyncio
+import logging
+import uuid
+
+# Classes
+class StreamManager:
+    """
+    Stream manager with asyncio queues and integrated debug logging.
+    """
+
+    def __init__(self: Any, session: Any, deployment_id: str, deployment_instance_id: str, inference_interface: Any, num_consumers: int = 1, num_inference_workers: int = 1, num_producers: int = 1, app_name: str = '', app_version: str = '', inference_pipeline_id: str = '', debug_logging_enabled: bool = False, debug_log_interval: float = 30.0, input_queue_maxsize: int = 0, output_queue_maxsize: int = 0) -> None: ...
+        """
+        Initialize stream manager.
+        
+                Args:
+                    session: Session object for authentication and RPC
+                    deployment_id: ID of the deployment
+                    deployment_instance_id: ID of the deployment instance
+                    inference_interface: Inference interface to use for inference
+                    num_consumers: Number of consumer workers
+                    num_inference_workers: Number of inference workers
+                    num_producers: Number of producer workers
+                    app_name: Application name for result formatting
+                    app_version: Application version for result formatting
+                    inference_pipeline_id: ID of the inference pipeline
+                    debug_logging_enabled: Whether to enable debug logging
+                    debug_log_interval: Interval for debug logging in seconds
+                    input_queue_maxsize: Maximum size for input queue (0 = unlimited)
+                    output_queue_maxsize: Maximum size for output queue (0 = unlimited)
+        """
+
+    def disable_debug_logging(self: Any) -> Any: ...
+        """
+        Disable debug logging.
+        """
+
+    def enable_debug_logging(self: Any, log_interval: Optional[float] = None) -> Any: ...
+        """
+        Enable debug logging.
+        """
+
+    def get_debug_summary(self: Any) -> Dict[str, Any]: ...
+        """
+        Get debug logging summary.
+        """
+
+    def get_metrics(self: Any) -> Dict[str, Any]: ...
+        """
+        Get comprehensive metrics.
+        """
+
+    async def start(self: Any) -> None: ...
+        """
+        Start the stream manager and all workers.
+        """
+
+    async def stop(self: Any) -> None: ...
+        """
+        Stop the stream manager and all workers.
+        """
+

matrice_inference/deploy/server/stream/video_buffer.pyi

@@ -0,0 +1,120 @@
+"""Auto-generated stub for module: video_buffer."""
+from typing import Any, Dict, List, Optional
+
+from collections import defaultdict, deque
+from datetime import datetime, timezone
+import asyncio
+import base64
+import cv2
+import logging
+import numpy as np
+import os
+import tempfile
+
+# Functions
+def base64_frames_to_video_bytes_cv2(base64_frames: Any, fps: Any = 10, output_format: Any = 'mp4') -> Any: ...
+    """
+    Convert base64-encoded JPEG frames to a video using OpenCV,
+    and return the video bytes by writing to a temp file.
+    """
+
+# Classes
+class FrameBuffer:
+    """
+    Buffer for collecting frames into video chunks.
+    """
+
+    def __init__(self: Any, stream_key: str, buffer_config: Dict[str, Any]) -> None: ...
+        """
+        Initialize frame buffer for a specific stream.
+        
+                Args:
+                    stream_key: Unique identifier for the stream
+                    buffer_config: Configuration for buffering (fps, duration, etc.)
+        """
+
+    def add_frame(self: Any, base64_frame: str, metadata: Dict[str, Any]) -> bool: ...
+        """
+        Add a frame to the buffer.
+        
+                Args:
+                    base64_frame: Base64 encoded frame data
+                    metadata: Frame metadata
+        
+                Returns:
+                    True if buffer is ready for processing, False otherwise
+        """
+
+    def clear(self: Any) -> Any: ...
+        """
+        Clear the buffer.
+        """
+
+    def create_video_chunk(self: Any) -> Optional[Dict[str, Any]]: ...
+        """
+        Create a video chunk from buffered frames.
+        
+                Returns:
+                    Dictionary containing video data and metadata, or None if failed
+        """
+
+    def is_expired(self: Any, max_idle_time: float = 30.0) -> bool: ...
+        """
+        Check if buffer has been idle too long.
+        """
+
+    def is_ready(self: Any) -> bool: ...
+        """
+        Check if buffer is ready for processing.
+        """
+
+class VideoBufferManager:
+    """
+    Manages multiple frame buffers for different streams.
+    """
+
+    def __init__(self: Any, default_fps: int = 10, default_chunk_duration: float = 5.0, default_timeout: float = 10.0, max_idle_time: float = 30.0, cleanup_interval: float = 60.0) -> None: ...
+        """
+        Initialize video buffer manager.
+        
+                Args:
+                    default_fps: Default FPS for video chunks
+                    default_chunk_duration: Default chunk duration in seconds
+                    default_timeout: Default timeout for buffering in seconds
+                    max_idle_time: Maximum idle time before buffer cleanup
+                    cleanup_interval: Interval for cleanup tasks
+        """
+
+    async def add_frame(self: Any, stream_key: str, base64_frame: str, metadata: Dict[str, Any]) -> Optional[Dict[str, Any]]: ...
+        """
+        Add a frame to the appropriate buffer.
+        
+                Args:
+                    stream_key: Stream identifier
+                    base64_frame: Base64 encoded frame data
+                    metadata: Frame metadata
+        
+                Returns:
+                    Video chunk data if buffer is ready, None otherwise
+        """
+
+    def get_metrics(self: Any) -> Dict[str, Any]: ...
+        """
+        Get buffer manager metrics.
+        """
+
+    def reset_metrics(self: Any) -> Any: ...
+        """
+        Reset metrics.
+        """
+
+    async def start(self: Any) -> Any: ...
+        """
+        Start the buffer manager.
+        """
+
+    async def stop(self: Any) -> Any: ...
+        """
+        Stop the buffer manager.
+        """
+