131 lines
3.6 KiB
Python
131 lines
3.6 KiB
Python
"""
|
|
Configuration Loader
|
|
|
|
Loads and validates framework configuration files.
|
|
"""
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Dict, Any, List, Optional
|
|
from dataclasses import dataclass
|
|
|
|
|
|
@dataclass
|
|
class FrameworkConfig:
|
|
"""Framework metadata"""
|
|
name: str
|
|
slug: str
|
|
version: str
|
|
description: str
|
|
tagline: str
|
|
icon: str
|
|
hub_port: int
|
|
|
|
|
|
@dataclass
|
|
class SystemConfig:
|
|
"""System configuration"""
|
|
key: str
|
|
name: str
|
|
slug: str
|
|
title: str
|
|
tagline: str
|
|
port: int
|
|
icon: str
|
|
|
|
|
|
@dataclass
|
|
class ComponentConfig:
|
|
"""Component configuration"""
|
|
name: str
|
|
title: str
|
|
description: str
|
|
plural: Optional[str] = None
|
|
formula: Optional[str] = None
|
|
|
|
|
|
class ConfigLoader:
|
|
"""Loads and parses framework configuration"""
|
|
|
|
def __init__(self, config_path: Path):
|
|
self.config_path = Path(config_path)
|
|
self.raw_config: Dict[str, Any] = {}
|
|
self.framework: Optional[FrameworkConfig] = None
|
|
self.systems: List[SystemConfig] = []
|
|
self.components: Dict[str, Dict[str, ComponentConfig]] = {}
|
|
|
|
def load(self) -> 'ConfigLoader':
|
|
"""Load configuration from file"""
|
|
with open(self.config_path) as f:
|
|
self.raw_config = json.load(f)
|
|
|
|
self._parse_framework()
|
|
self._parse_systems()
|
|
self._parse_components()
|
|
|
|
return self
|
|
|
|
def _parse_framework(self):
|
|
"""Parse framework metadata"""
|
|
fw = self.raw_config['framework']
|
|
self.framework = FrameworkConfig(**fw)
|
|
|
|
def _parse_systems(self):
|
|
"""Parse system configurations"""
|
|
for sys in self.raw_config['systems']:
|
|
self.systems.append(SystemConfig(**sys))
|
|
|
|
def _parse_components(self):
|
|
"""Parse component configurations"""
|
|
comps = self.raw_config['components']
|
|
|
|
# Shared components
|
|
self.components['shared'] = {}
|
|
for key, value in comps.get('shared', {}).items():
|
|
self.components['shared'][key] = ComponentConfig(**value)
|
|
|
|
# System-specific components
|
|
for system_key in ['data_flow', 'documentation', 'execution']:
|
|
self.components[system_key] = {}
|
|
for comp_key, comp_value in comps.get(system_key, {}).items():
|
|
self.components[system_key][comp_key] = ComponentConfig(**comp_value)
|
|
|
|
def get_system(self, key: str) -> Optional[SystemConfig]:
|
|
"""Get system config by key"""
|
|
for sys in self.systems:
|
|
if sys.key == key:
|
|
return sys
|
|
return None
|
|
|
|
def get_component(self, system_key: str, component_key: str) -> Optional[ComponentConfig]:
|
|
"""Get component config"""
|
|
return self.components.get(system_key, {}).get(component_key)
|
|
|
|
def get_shared_component(self, key: str) -> Optional[ComponentConfig]:
|
|
"""Get shared component config"""
|
|
return self.components.get('shared', {}).get(key)
|
|
|
|
|
|
def load_config(config_path: str | Path) -> ConfigLoader:
|
|
"""Load and validate configuration file"""
|
|
loader = ConfigLoader(config_path)
|
|
return loader.load()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Test with pawprint config
|
|
import sys
|
|
config_path = Path(__file__).parent.parent / "pawprint.config.json"
|
|
|
|
loader = load_config(config_path)
|
|
|
|
print(f"Framework: {loader.framework.name} v{loader.framework.version}")
|
|
print(f"Tagline: {loader.framework.tagline}")
|
|
print(f"\nSystems:")
|
|
for sys in loader.systems:
|
|
print(f" {sys.icon} {sys.title} ({sys.name}) - {sys.tagline}")
|
|
|
|
print(f"\nShared Components:")
|
|
for key, comp in loader.components['shared'].items():
|
|
print(f" {comp.name} - {comp.description}")
|