API Gateway Proxy for Vision Models

class VisionGateway:
    """Unified gateway for vision model APIs"""
    
    def __init__(self, config):
        self.providers = {
            'openai': OpenAIVisionProvider(),
            'google': GoogleVisionProvider(),
            'azure': AzureVisionProvider(),
            'aws': RekognitionProvider()
        }
        self.cache = RedisCache()
        self.router = VisionRouter(config)
        
    async def analyze_image(
        self,
        image: bytes,
        task: str,
        options: dict = None
    ) -> VisionResponse:
        """Analyze image with optimal provider"""
        
        # Check cache first
        cache_key = self.generate_cache_key(image, task)
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        
        # Route to best provider for task
        provider_name = await self.router.select(
            task, options
        )
        provider = self.providers[provider_name]
        
        # Execute with fallback
        try:
            result = await provider.analyze(
                image, task, options
            )
            await self.cache.set(cache_key, result)
            return result
        except Exception as e:
            # Fallback to next best provider
            fallback = await self.router.get_fallback(
                provider_name
            )
            return await self.providers[fallback].analyze(
                image, task, options
            )
    
    async def batch_analyze(
        self,
        images: List[bytes],
        task: str
    ) -> List[VisionResponse]:
        """Batch process multiple images"""
        
        # Group by cache status
        cached_results = {}
        uncached_images = []
        
        for idx, image in enumerate(images):
            cache_key = self.generate_cache_key(image, task)
            cached = await self.cache.get(cache_key)
            if cached:
                cached_results[idx] = cached
            else:
                uncached_images.append((idx, image))
        
        # Batch process uncached images
        if uncached_images:
            provider = await self.router.select_batch(task)
            batch_results = await provider.batch_analyze(
                [img for _, img in uncached_images],
                task
            )
            
            for (idx, _), result in zip(uncached_images, batch_results):
                cached_results[idx] = result
        
        # Return in original order
        return [cached_results[i] for i in range(len(images))]