bakery-ia/shared/clients/__init__.py

# shared/clients/__init__.py
"""
Service Client Factory and Convenient Imports
Provides easy access to all service clients
"""

from .base_service_client import BaseServiceClient, ServiceAuthenticator
from .training_client import TrainingServiceClient
from .sales_client import SalesServiceClient
from .external_client import ExternalServiceClient
from .forecast_client import ForecastServiceClient

# Import config
from shared.config.base import BaseServiceSettings

# Cache clients to avoid recreating them
_client_cache = {}

def get_training_client(config: BaseServiceSettings = None, service_name: str = "unknown") -> TrainingServiceClient:
    """Get or create a training service client"""
    if config is None:
        from app.core.config import settings as config
    
    cache_key = f"training_{service_name}"
    if cache_key not in _client_cache:
        _client_cache[cache_key] = TrainingServiceClient(config, service_name)
    return _client_cache[cache_key]

def get_sales_client(config: BaseServiceSettings = None, service_name: str = "unknown") -> SalesServiceClient:
    """Get or create a sales service client"""
    if config is None:
        from app.core.config import settings as config
    
    cache_key = f"sales_{service_name}"
    if cache_key not in _client_cache:
        _client_cache[cache_key] = SalesServiceClient(config, service_name)
    return _client_cache[cache_key]

def get_external_client(config: BaseServiceSettings = None, service_name: str = "unknown") -> ExternalServiceClient:
    """Get or create an external service client"""
    if config is None:
        from app.core.config import settings as config
    
    cache_key = f"external_{service_name}"
    if cache_key not in _client_cache:
        _client_cache[cache_key] = ExternalServiceClient(config, service_name)
    return _client_cache[cache_key]

def get_forecast_client(config: BaseServiceSettings = None, service_name: str = "unknown") -> ForecastServiceClient:
    """Get or create a forecast service client"""
    if config is None:
        from app.core.config import settings as config
    
    cache_key = f"forecast_{service_name}"
    if cache_key not in _client_cache:
        _client_cache[cache_key] = ForecastServiceClient(config, service_name)
    return _client_cache[cache_key]


class ServiceClients:
    """Convenient wrapper for all service clients"""
    
    def __init__(self, config: BaseServiceSettings = None, service_name: str = "unknown"):
        self.service_name = service_name
        self.config = config or self._get_default_config()
        
        # Initialize clients lazily
        self._training_client = None
        self._sales_client = None
        self._external_client = None
        self._forecast_client = None
    
    def _get_default_config(self):
        """Get default config from app settings"""
        try:
            from app.core.config import settings
            return settings
        except ImportError:
            raise ImportError("Could not import app config. Please provide config explicitly.")
    
    @property
    def training(self) -> TrainingServiceClient:
        """Get training service client"""
        if self._training_client is None:
            self._training_client = get_training_client(self.config, self.service_name)
        return self._training_client
    
    @property
    def sales(self) -> SalesServiceClient:
        """Get sales service client"""
        if self._sales_client is None:
            self._sales_client = get_sales_client(self.config, self.service_name)
        return self._sales_client
    
    @property
    def external(self) -> ExternalServiceClient:
        """Get external service client"""
        if self._external_client is None:
            self._external_client = get_external_client(self.config, self.service_name)
        return self._external_client
    
    @property
    def forecast(self) -> ForecastServiceClient:
        """Get forecast service client"""
        if self._forecast_client is None:
            self._forecast_client = get_forecast_client(self.config, self.service_name)
        return self._forecast_client

# Convenience function to get all clients
def get_service_clients(config: BaseServiceSettings = None, service_name: str = "unknown") -> ServiceClients:
    """Get a wrapper with all service clients"""
    return ServiceClients(config, service_name)

# Export all classes for direct import
__all__ = [
    'BaseServiceClient',
    'ServiceAuthenticator', 
    'TrainingServiceClient',
    'SalesServiceClient',
    'ExternalServiceClient',
    'ForecastServiceClient',
    'ServiceClients',
    'get_training_client',
    'get_sales_client',
    'get_external_client', 
    'get_forecast_client',
    'get_service_clients'
]