|
| 1 | +"""Enhanced dependency system with external library support. |
| 2 | +
|
| 3 | +Supports both internal component dependencies and external library dependencies. |
| 4 | +Automatically checks library versions to detect when blockers are resolved. |
| 5 | +""" |
| 6 | + |
| 7 | +from dataclasses import dataclass, field |
| 8 | +from typing import List, Optional, Dict, Any, Set |
| 9 | +from packaging import version |
| 10 | +import subprocess |
| 11 | +import importlib.metadata |
| 12 | +import logging |
| 13 | + |
| 14 | +logger = logging.getLogger(__name__) |
| 15 | + |
| 16 | + |
| 17 | +@dataclass |
| 18 | +class InternalDependency: |
| 19 | + """Internal component/phase dependency.""" |
| 20 | + phase_id: int |
| 21 | + component: str |
| 22 | + required: bool = True # If False, soft dependency (warn but don't block) |
| 23 | + |
| 24 | + def __str__(self) -> str: |
| 25 | + prefix = "requires" if self.required else "suggests" |
| 26 | + return f"{prefix} Phase {self.phase_id}:{self.component}" |
| 27 | + |
| 28 | + |
| 29 | +@dataclass |
| 30 | +class ExternalDependency: |
| 31 | + """External library dependency.""" |
| 32 | + package: str |
| 33 | + min_version: Optional[str] = None |
| 34 | + max_version: Optional[str] = None |
| 35 | + reason: str = "" |
| 36 | + ticket_url: Optional[str] = None |
| 37 | + |
| 38 | + def __str__(self) -> str: |
| 39 | + ver_str = "" |
| 40 | + if self.min_version: |
| 41 | + ver_str = f">={self.min_version}" |
| 42 | + if self.max_version: |
| 43 | + ver_str += f",<{self.max_version}" if ver_str else f"<{self.max_version}" |
| 44 | + |
| 45 | + pkg_str = f"{self.package}{ver_str}" if ver_str else self.package |
| 46 | + return f"requires {pkg_str}" |
| 47 | + |
| 48 | + def is_satisfied(self) -> bool: |
| 49 | + """Check if this dependency is satisfied. |
| 50 | + |
| 51 | + Returns: |
| 52 | + True if package is installed and meets version requirements |
| 53 | + """ |
| 54 | + try: |
| 55 | + installed_version = importlib.metadata.version(self.package) |
| 56 | + |
| 57 | + if self.min_version: |
| 58 | + if version.parse(installed_version) < version.parse(self.min_version): |
| 59 | + logger.debug(f"{self.package} {installed_version} < required {self.min_version}") |
| 60 | + return False |
| 61 | + |
| 62 | + if self.max_version: |
| 63 | + if version.parse(installed_version) >= version.parse(self.max_version): |
| 64 | + logger.debug(f"{self.package} {installed_version} >= max {self.max_version}") |
| 65 | + return False |
| 66 | + |
| 67 | + logger.debug(f"{self.package} {installed_version} satisfies requirements") |
| 68 | + return True |
| 69 | + |
| 70 | + except importlib.metadata.PackageNotFoundError: |
| 71 | + logger.debug(f"{self.package} not installed") |
| 72 | + return False |
| 73 | + except Exception as e: |
| 74 | + logger.warning(f"Error checking {self.package}: {e}") |
| 75 | + return False |
| 76 | + |
| 77 | + |
| 78 | +@dataclass |
| 79 | +class DependencySpec: |
| 80 | + """Complete dependency specification for a component.""" |
| 81 | + phase_id: int |
| 82 | + component: str |
| 83 | + internal_deps: List[InternalDependency] = field(default_factory=list) |
| 84 | + external_deps: List[ExternalDependency] = field(default_factory=list) |
| 85 | + |
| 86 | + def get_internal_blockers(self, failed_components: Set[str]) -> List[InternalDependency]: |
| 87 | + """Get internal dependencies that are blocking. |
| 88 | + |
| 89 | + Args: |
| 90 | + failed_components: Set of component identifiers that have failed |
| 91 | + Format: "phase_id:component_name" |
| 92 | + |
| 93 | + Returns: |
| 94 | + List of dependencies that are blocking |
| 95 | + """ |
| 96 | + blockers = [] |
| 97 | + for dep in self.internal_deps: |
| 98 | + if not dep.required: |
| 99 | + continue # Soft dependencies don't block |
| 100 | + |
| 101 | + dep_id = f"{dep.phase_id}:{dep.component}" |
| 102 | + if dep_id in failed_components: |
| 103 | + blockers.append(dep) |
| 104 | + |
| 105 | + return blockers |
| 106 | + |
| 107 | + def get_external_blockers(self) -> List[ExternalDependency]: |
| 108 | + """Get external dependencies that are blocking. |
| 109 | + |
| 110 | + Returns: |
| 111 | + List of external dependencies not satisfied |
| 112 | + """ |
| 113 | + return [dep for dep in self.external_deps if not dep.is_satisfied()] |
| 114 | + |
| 115 | + def is_blocked(self, failed_components: Set[str]) -> bool: |
| 116 | + """Check if component is blocked by dependencies. |
| 117 | + |
| 118 | + Args: |
| 119 | + failed_components: Set of failed component identifiers |
| 120 | + |
| 121 | + Returns: |
| 122 | + True if blocked by any dependency |
| 123 | + """ |
| 124 | + return bool(self.get_internal_blockers(failed_components) or |
| 125 | + self.get_external_blockers()) |
| 126 | + |
| 127 | + |
| 128 | +class DependencyManager: |
| 129 | + """Manages all component dependencies.""" |
| 130 | + |
| 131 | + def __init__(self): |
| 132 | + """Initialize dependency manager.""" |
| 133 | + self.specs: Dict[str, DependencySpec] = {} |
| 134 | + self.failed_components: Set[str] = set() |
| 135 | + |
| 136 | + def add_spec(self, spec: DependencySpec): |
| 137 | + """Add a dependency specification. |
| 138 | + |
| 139 | + Args: |
| 140 | + spec: DependencySpec to add |
| 141 | + """ |
| 142 | + key = f"{spec.phase_id}:{spec.component}" |
| 143 | + self.specs[key] = spec |
| 144 | + |
| 145 | + def load_from_config(self, config: Dict[str, Any]): |
| 146 | + """Load dependency specs from .ptsd.yaml config. |
| 147 | + |
| 148 | + Args: |
| 149 | + config: Parsed .ptsd.yaml configuration |
| 150 | + """ |
| 151 | + components = config.get('components', {}) |
| 152 | + |
| 153 | + for comp_name, comp_config in components.items(): |
| 154 | + phase_id = comp_config.get('phase', 1) |
| 155 | + |
| 156 | + spec = DependencySpec(phase_id=phase_id, component=comp_name) |
| 157 | + |
| 158 | + # Load internal dependencies |
| 159 | + internal_deps = comp_config.get('depends_on', []) |
| 160 | + for dep in internal_deps: |
| 161 | + if isinstance(dep, str): |
| 162 | + # Simple format: "component_name" (same phase) |
| 163 | + spec.internal_deps.append( |
| 164 | + InternalDependency(phase_id=phase_id, component=dep) |
| 165 | + ) |
| 166 | + elif isinstance(dep, dict): |
| 167 | + # Detailed format: {phase: 1, component: "name", required: true} |
| 168 | + spec.internal_deps.append( |
| 169 | + InternalDependency( |
| 170 | + phase_id=dep.get('phase', phase_id), |
| 171 | + component=dep['component'], |
| 172 | + required=dep.get('required', True) |
| 173 | + ) |
| 174 | + ) |
| 175 | + |
| 176 | + # Load external dependencies |
| 177 | + external_deps = comp_config.get('external_deps', []) |
| 178 | + for dep in external_deps: |
| 179 | + if isinstance(dep, str): |
| 180 | + # Simple format: "package>=1.0.0" |
| 181 | + spec.external_deps.append(self._parse_external_dep(dep)) |
| 182 | + elif isinstance(dep, dict): |
| 183 | + # Detailed format with reason/ticket |
| 184 | + spec.external_deps.append( |
| 185 | + ExternalDependency( |
| 186 | + package=dep['package'], |
| 187 | + min_version=dep.get('min_version'), |
| 188 | + max_version=dep.get('max_version'), |
| 189 | + reason=dep.get('reason', ''), |
| 190 | + ticket_url=dep.get('ticket_url') |
| 191 | + ) |
| 192 | + ) |
| 193 | + |
| 194 | + if spec.internal_deps or spec.external_deps: |
| 195 | + self.add_spec(spec) |
| 196 | + |
| 197 | + def _parse_external_dep(self, dep_str: str) -> ExternalDependency: |
| 198 | + """Parse external dependency from string like 'package>=1.0.0'.""" |
| 199 | + # Simple parser, can be enhanced |
| 200 | + if '>=' in dep_str: |
| 201 | + package, min_ver = dep_str.split('>=') |
| 202 | + return ExternalDependency(package=package.strip(), min_version=min_ver.strip()) |
| 203 | + elif '>' in dep_str: |
| 204 | + package, min_ver = dep_str.split('>') |
| 205 | + return ExternalDependency(package=package.strip(), min_version=min_ver.strip()) |
| 206 | + elif '<' in dep_str: |
| 207 | + package, max_ver = dep_str.split('<') |
| 208 | + return ExternalDependency(package=package.strip(), max_version=max_ver.strip()) |
| 209 | + else: |
| 210 | + return ExternalDependency(package=dep_str.strip()) |
| 211 | + |
| 212 | + def mark_failed(self, phase_id: int, component: str): |
| 213 | + """Mark a component as failed. |
| 214 | + |
| 215 | + Args: |
| 216 | + phase_id: Phase ID |
| 217 | + component: Component name |
| 218 | + """ |
| 219 | + self.failed_components.add(f"{phase_id}:{component}") |
| 220 | + |
| 221 | + def mark_passed(self, phase_id: int, component: str): |
| 222 | + """Mark a component as passed (clear failed status). |
| 223 | + |
| 224 | + Args: |
| 225 | + phase_id: Phase ID |
| 226 | + component: Component name |
| 227 | + """ |
| 228 | + key = f"{phase_id}:{component}" |
| 229 | + self.failed_components.discard(key) |
| 230 | + |
| 231 | + def is_blocked(self, phase_id: int, component: str) -> bool: |
| 232 | + """Check if component is blocked. |
| 233 | + |
| 234 | + Args: |
| 235 | + phase_id: Phase ID |
| 236 | + component: Component name |
| 237 | + |
| 238 | + Returns: |
| 239 | + True if blocked |
| 240 | + """ |
| 241 | + key = f"{phase_id}:{component}" |
| 242 | + spec = self.specs.get(key) |
| 243 | + |
| 244 | + if not spec: |
| 245 | + return False # No dependencies = not blocked |
| 246 | + |
| 247 | + return spec.is_blocked(self.failed_components) |
| 248 | + |
| 249 | + def get_blocker_summary(self, phase_id: int, component: str) -> Dict[str, Any]: |
| 250 | + """Get summary of what's blocking a component. |
| 251 | + |
| 252 | + Args: |
| 253 | + phase_id: Phase ID |
| 254 | + component: Component name |
| 255 | + |
| 256 | + Returns: |
| 257 | + Dictionary with internal and external blocker details |
| 258 | + """ |
| 259 | + key = f"{phase_id}:{component}" |
| 260 | + spec = self.specs.get(key) |
| 261 | + |
| 262 | + if not spec: |
| 263 | + return {'blocked': False} |
| 264 | + |
| 265 | + internal = spec.get_internal_blockers(self.failed_components) |
| 266 | + external = spec.get_external_blockers() |
| 267 | + |
| 268 | + return { |
| 269 | + 'blocked': bool(internal or external), |
| 270 | + 'internal_blockers': [str(d) for d in internal], |
| 271 | + 'external_blockers': [str(d) for d in external], |
| 272 | + 'can_auto_retest': not external # Can retest if only internal blockers |
| 273 | + } |
0 commit comments