Skip to content

Commit f5390fb

Browse files
author
Catalin Sopirla
committed
feat: Enhanced dependency system with external library support
Major enhancements: - InternalDependency: phase+component targeting (fixes duplicate names) - ExternalDependency: library version tracking with auto-checking - DependencySpec: combines internal + external deps per component - DependencyManager: unified dependency resolution Features: - Targeted deps: Phase 1:acl → Phase 2:oauth - External deps: pytest>=7.0.0, waiting for release - Auto version check via importlib.metadata - Soft dependencies (warn but don't block) Config format (.ptsd.yaml): components: acl: phase: 2 depends_on: - {phase: 1, component: 'architecture', required: true} external_deps: - package: 'pytest' min_version: '7.0.0' reason: 'Waiting for bugfix' ticket_url: 'pytest-dev/pytest#123' Phase 4: Advanced dependencies complete
1 parent ca7d3e1 commit f5390fb

1 file changed

Lines changed: 273 additions & 0 deletions

File tree

Lines changed: 273 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,273 @@
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

Comments
 (0)