common.py

"""
Core infrastructure module providing enhanced resource management and error handling.

This module integrates and coordinates the core components required for video processing
while avoiding circular dependencies through proper type management.
"""

import logging
#import os
#from pathlib import Path
#import signal
#import threading
#from contextlib import contextmanager
from typing import Optional #Dict, Optional, Set, TypeVar

# Import core types
from core.types import (
    Frame, RGBFrame, GrayFrame,
    FrameMetadata, VideoMetadata,
    FrameProcessor, FrameAnalyzer, FrameFilter,
    VideoReader, AnalysisResult, ProcessingState,
    ProcessingResults
)

# Import error types
from core.errors import (
    VideoError,
    CodecError,
    ResourceError,
    TimeoutError,
    FrameError
)

# Import configuration
from config import OutputFormat, VideoConfig

# Import core functionality
from retry import RetryManager
from resource import VideoResource, timeout

__all__ = [
    # Core types
    'Frame', 'RGBFrame', 'GrayFrame',
    'FrameMetadata', 'VideoMetadata',
    'FrameProcessor', 'FrameAnalyzer', 'FrameFilter',
    'VideoReader', 'AnalysisResult', 'ProcessingState',
    'ProcessingResults',

    # Errors
    'VideoError', 'CodecError', 'ResourceError',
    'TimeoutError', 'FrameError',

    # Configuration
    'OutputFormat', 'VideoConfig',

    # Core classes
    'RetryManager', 'VideoResource',

    # Utilities
    'timeout',

    # Module functions
    'setup_logging', 'initialize'
]

# Module constants
DEFAULT_LOGGING_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
DEFAULT_LOG_LEVEL = logging.INFO

# Global state
_initialized = False
_log_configured = False

def setup_logging(
    level: int = DEFAULT_LOG_LEVEL,
    format_string: str = DEFAULT_LOGGING_FORMAT,
    log_file: Optional[str] = None
) -> None:
    """
    Configure logging for the video processing system.

    Args:
        level: Logging level (default: INFO)
        format_string: Log format string
        log_file: Optional log file path

    This function is idempotent and can be called multiple times.
    """
    global _log_configured

    if _log_configured:
        logger.debug("Logging already configured")
        return

    # Configure basic logging
    logging.basicConfig(
        level=level,
        format=format_string,
        filename=log_file
    )

    # Add console handler if logging to file
    if log_file:
        console_handler = logging.StreamHandler()
        console_handler.setFormatter(logging.Formatter(format_string))
        logging.getLogger().addHandler(console_handler)

    logger.info("Logging configured at level %s", level)
    _log_configured = True

def initialize(
    log_level: int = DEFAULT_LOG_LEVEL,
    log_format: str = DEFAULT_LOGGING_FORMAT,
    log_file: Optional[str] = None
) -> None:
    """
    Initialize the video processing system.

    Args:
        log_level: Logging level to use
        log_format: Logging format string
        log_file: Optional log file path

    This function is idempotent and can be called multiple times.
    """
    global _initialized

    if _initialized:
        logger.debug("System already initialized")
        return

    # Configure logging first
    setup_logging(log_level, log_format, log_file)

    # Additional initialization can be added here
    # For example:
    # - Check system capabilities
    # - Initialize global resources
    # - Set up signal handlers

    logger.info("Video processing system initialized")
    _initialized = True

def cleanup() -> None:
    """
    Cleanup system resources.

    This function should be called before system shutdown.
    """
    global _initialized, _log_configured

    # Add cleanup logic here
    # For example:
    # - Release global resources
    # - Close log handlers
    # - Reset state

    _initialized = False
    _log_configured = False
    logger.info("System cleanup completed")

logger = logging.getLogger(__name__)

# Initialize system on module import
initialize()

# Register cleanup on interpreter shutdown
import atexit
atexit.register(cleanup)