Source code for vcon.extensions.registry

"""
Extension registry for managing vCon extensions.

This module provides a centralized registry for managing vCon extensions,
including registration, validation, and processing capabilities.
"""

from typing import Dict, List, Optional, Any
import logging
from .base import ExtensionInfo, ExtensionType, ValidationResult, ProcessingResult

logger = logging.getLogger(__name__)


[docs]class ExtensionRegistry: """Central registry for managing vCon extensions.""" def __init__(self): self._extensions: Dict[str, ExtensionInfo] = {} self._initialized = False
[docs] def register_extension(self, extension_info: ExtensionInfo) -> None: """Register a new extension.""" if extension_info.name in self._extensions: logger.warning(f"Extension {extension_info.name} is already registered, overwriting") self._extensions[extension_info.name] = extension_info logger.info(f"Registered extension: {extension_info.name} v{extension_info.version}")
[docs] def get_extension(self, name: str) -> Optional[ExtensionInfo]: """Get extension information by name.""" return self._extensions.get(name)
[docs] def list_extensions(self) -> List[str]: """List all registered extension names.""" return list(self._extensions.keys())
def initialize_default_extensions(self) -> None: """Initialize default extensions.""" try: from .lawful_basis import LawfulBasisExtension from .wtf import WTFExtension # Register lawful basis extension lawful_basis_ext = LawfulBasisExtension() self.register_extension(lawful_basis_ext.get_extension_info()) # Register WTF extension wtf_ext = WTFExtension() self.register_extension(wtf_ext.get_extension_info()) logger.info("Default extensions initialized") except ImportError as e: logger.warning(f"Could not initialize default extensions: {str(e)}")
[docs] def is_extension_registered(self, name: str) -> bool: """Check if an extension is registered.""" return name in self._extensions
[docs] def validate_extension(self, name: str, vcon_dict: Dict[str, Any]) -> ValidationResult: """Validate an extension in a vCon.""" extension = self.get_extension(name) if not extension: return ValidationResult(False, [f"Extension {name} is not registered"]) if not extension.validator: return ValidationResult(True, warnings=[f"No validator for extension {name}"]) try: return extension.validator.validate_extension_usage(vcon_dict) except Exception as e: logger.error(f"Error validating extension {name}: {str(e)}") return ValidationResult(False, [f"Validation error for {name}: {str(e)}"])
[docs] def validate_attachment(self, attachment: Dict[str, Any]) -> ValidationResult: """Validate an extension attachment.""" attachment_purpose = attachment.get("purpose") if not attachment_purpose: return ValidationResult(False, ["Attachment missing purpose field"]) # Find extension that handles this attachment type for extension in self._extensions.values(): if attachment_purpose in extension.attachment_types: if extension.validator: try: return extension.validator.validate_attachment(attachment) except Exception as e: logger.error(f"Error validating attachment {attachment_purpose}: {str(e)}") return ValidationResult(False, [f"Validation error for {attachment_purpose}: {str(e)}"]) else: return ValidationResult(True, warnings=[f"No validator for attachment type {attachment_purpose}"]) # If no extension handles this attachment type, it's not an extension attachment return ValidationResult(True)
[docs] def process_extensions(self, vcon_dict: Dict[str, Any]) -> Dict[str, ProcessingResult]: """Process all extensions in a vCon.""" results = {} extensions = vcon_dict.get("extensions", []) for extension_name in extensions: extension = self.get_extension(extension_name) if not extension: results[extension_name] = ProcessingResult( False, errors=[f"Extension {extension_name} is not registered"] ) continue if not extension.processor: results[extension_name] = ProcessingResult( True, data={"message": f"No processor for extension {extension_name}"} ) continue try: result = extension.processor.process(vcon_dict) results[extension_name] = result except Exception as e: logger.error(f"Error processing extension {extension_name}: {str(e)}") results[extension_name] = ProcessingResult( False, errors=[f"Processing error for {extension_name}: {str(e)}"] ) return results
[docs] def get_required_extensions(self, vcon_dict: Dict[str, Any]) -> List[str]: """Get list of extensions that must be supported.""" critical = vcon_dict.get("critical", []) required = [] for extension_name in critical: extension = self.get_extension(extension_name) if extension and extension.type == ExtensionType.INCOMPATIBLE: required.append(extension_name) return required
[docs] def check_compatibility(self, vcon_dict: Dict[str, Any]) -> ValidationResult: """Check if all required extensions are supported.""" required = self.get_required_extensions(vcon_dict) missing = [] for extension_name in required: if not self.is_extension_registered(extension_name): missing.append(extension_name) if missing: return ValidationResult( False, [f"Missing required extensions: {', '.join(missing)}"] ) return ValidationResult(True)
[docs] def initialize_default_extensions(self): """Initialize default extensions.""" if self._initialized: return # Import and register default extensions try: from .lawful_basis import LawfulBasisExtension from .wtf import WTFExtension # Register lawful basis extension lawful_basis = LawfulBasisExtension() self.register_extension(lawful_basis.get_extension_info()) # Register WTF extension wtf = WTFExtension() self.register_extension(wtf.get_extension_info()) self._initialized = True logger.info("Default extensions initialized") except ImportError as e: logger.warning(f"Could not import default extensions: {str(e)}")
# Global registry instance _global_registry = ExtensionRegistry()
[docs]def get_extension_registry() -> ExtensionRegistry: """Get the global extension registry.""" if not _global_registry._initialized: _global_registry.initialize_default_extensions() return _global_registry
[docs]def register_extension(extension_info: ExtensionInfo) -> None: """Register an extension with the global registry.""" _global_registry.register_extension(extension_info)
[docs]def validate_extension(name: str, vcon_dict: Dict[str, Any]) -> ValidationResult: """Validate an extension using the global registry.""" return _global_registry.validate_extension(name, vcon_dict)
[docs]def validate_attachment(attachment: Dict[str, Any]) -> ValidationResult: """Validate an attachment using the global registry.""" return _global_registry.validate_attachment(attachment)