pactown 0.1.4__py3-none-any.whl → 0.1.47__py3-none-any.whl

pactown/registry/models.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
+import json
 from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Optional, Any
+from datetime import datetime, timezone
 from pathlib import Path
-import json
+from typing import Any, Optional
 
 
 @dataclass
@@ -15,9 +15,9 @@ class ArtifactVersion:
     version: str
     readme_content: str
     checksum: str
-    published_at: datetime = field(default_factory=datetime.utcnow)
+    published_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     metadata: dict[str, Any] = field(default_factory=dict)
-    
+
     def to_dict(self) -> dict:
         return {
             "version": self.version,
@@ -26,7 +26,7 @@ class ArtifactVersion:
             "published_at": self.published_at.isoformat(),
             "metadata": self.metadata,
         }
-    
+
     @classmethod
     def from_dict(cls, data: dict) -> "ArtifactVersion":
         return cls(
@@ -46,24 +46,24 @@ class Artifact:
     description: str = ""
     versions: dict[str, ArtifactVersion] = field(default_factory=dict)
     latest_version: Optional[str] = None
-    created_at: datetime = field(default_factory=datetime.utcnow)
-    updated_at: datetime = field(default_factory=datetime.utcnow)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     tags: list[str] = field(default_factory=list)
-    
+
     @property
     def full_name(self) -> str:
         return f"{self.namespace}/{self.name}"
-    
+
     def add_version(self, version: ArtifactVersion) -> None:
         self.versions[version.version] = version
         self.latest_version = version.version
-        self.updated_at = datetime.utcnow()
-    
+        self.updated_at = datetime.now(timezone.utc)
+
     def get_version(self, version: str = "latest") -> Optional[ArtifactVersion]:
         if version == "latest" or version == "*":
             version = self.latest_version
         return self.versions.get(version)
-    
+
     def to_dict(self) -> dict:
         return {
             "name": self.name,
@@ -75,11 +75,11 @@ class Artifact:
             "updated_at": self.updated_at.isoformat(),
             "tags": self.tags,
         }
-    
+
     @classmethod
     def from_dict(cls, data: dict) -> "Artifact":
         versions = {
-            k: ArtifactVersion.from_dict(v) 
+            k: ArtifactVersion.from_dict(v)
             for k, v in data.get("versions", {}).items()
         }
         return cls(
@@ -96,41 +96,41 @@ class Artifact:
 
 class RegistryStorage:
     """File-based storage for registry artifacts."""
-    
+
     def __init__(self, storage_path: Path):
         self.storage_path = Path(storage_path)
         self.storage_path.mkdir(parents=True, exist_ok=True)
         self._index_path = self.storage_path / "index.json"
         self._artifacts: dict[str, Artifact] = {}
         self._load()
-    
+
     def _load(self) -> None:
         if self._index_path.exists():
             with open(self._index_path) as f:
                 data = json.load(f)
                 for full_name, artifact_data in data.get("artifacts", {}).items():
                     self._artifacts[full_name] = Artifact.from_dict(artifact_data)
-    
+
     def _save(self) -> None:
         data = {
             "artifacts": {k: v.to_dict() for k, v in self._artifacts.items()},
-            "updated_at": datetime.utcnow().isoformat(),
+            "updated_at": datetime.now(timezone.utc).isoformat(),
         }
         with open(self._index_path, "w") as f:
             json.dump(data, f, indent=2)
-    
+
     def get(self, namespace: str, name: str) -> Optional[Artifact]:
         return self._artifacts.get(f"{namespace}/{name}")
-    
+
     def list(self, namespace: Optional[str] = None) -> list[Artifact]:
         if namespace:
             return [a for a in self._artifacts.values() if a.namespace == namespace]
         return list(self._artifacts.values())
-    
+
     def save_artifact(self, artifact: Artifact) -> None:
         self._artifacts[artifact.full_name] = artifact
         self._save()
-    
+
     def delete(self, namespace: str, name: str) -> bool:
         key = f"{namespace}/{name}"
         if key in self._artifacts:
@@ -138,12 +138,12 @@ class RegistryStorage:
             self._save()
             return True
         return False
-    
+
     def search(self, query: str) -> list[Artifact]:
         query = query.lower()
         results = []
         for artifact in self._artifacts.values():
-            if (query in artifact.name.lower() or 
+            if (query in artifact.name.lower() or
                 query in artifact.description.lower() or
                 any(query in tag.lower() for tag in artifact.tags)):
                 results.append(artifact)

pactown/registry/server.py

@@ -49,13 +49,13 @@ class VersionInfo(BaseModel):
 
 def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
     """Create the registry FastAPI application."""
-    
+
     app = FastAPI(
         title="Pactown Registry",
         description="Local artifact registry for markpact modules",
         version="0.1.0",
     )
-    
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"],
@@ -63,13 +63,13 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
         allow_methods=["*"],
         allow_headers=["*"],
     )
-    
+
     storage = RegistryStorage(Path(storage_path))
-    
+
     @app.get("/health")
     def health():
         return {"status": "ok", "service": "pactown-registry"}
-    
+
     @app.get("/v1/artifacts", response_model=list[ArtifactInfo])
     def list_artifacts(
         namespace: Optional[str] = Query(None, description="Filter by namespace"),
@@ -79,7 +79,7 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
             artifacts = storage.search(search)
         else:
             artifacts = storage.list(namespace)
-        
+
         return [
             ArtifactInfo(
                 name=a.name,
@@ -91,13 +91,13 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
             )
             for a in artifacts
         ]
-    
+
     @app.get("/v1/artifacts/{namespace}/{name}", response_model=ArtifactInfo)
     def get_artifact(namespace: str, name: str):
         artifact = storage.get(namespace, name)
         if not artifact:
             raise HTTPException(status_code=404, detail="Artifact not found")
-        
+
         return ArtifactInfo(
             name=artifact.name,
             namespace=artifact.namespace,
@@ -106,17 +106,17 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
             versions=list(artifact.versions.keys()),
             tags=artifact.tags,
         )
-    
+
     @app.get("/v1/artifacts/{namespace}/{name}/{version}", response_model=VersionInfo)
     def get_version(namespace: str, name: str, version: str):
         artifact = storage.get(namespace, name)
         if not artifact:
             raise HTTPException(status_code=404, detail="Artifact not found")
-        
+
         ver = artifact.get_version(version)
         if not ver:
             raise HTTPException(status_code=404, detail="Version not found")
-        
+
         return VersionInfo(
             version=ver.version,
             readme_content=ver.readme_content,
@@ -124,23 +124,23 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
             published_at=ver.published_at.isoformat(),
             metadata=ver.metadata,
         )
-    
+
     @app.get("/v1/artifacts/{namespace}/{name}/{version}/readme")
     def get_readme(namespace: str, name: str, version: str):
         artifact = storage.get(namespace, name)
         if not artifact:
             raise HTTPException(status_code=404, detail="Artifact not found")
-        
+
         ver = artifact.get_version(version)
         if not ver:
             raise HTTPException(status_code=404, detail="Version not found")
-        
+
         return {"content": ver.readme_content}
-    
+
     @app.post("/v1/publish", response_model=PublishResponse)
     def publish(req: PublishRequest):
         checksum = hashlib.sha256(req.readme_content.encode()).hexdigest()
-        
+
         artifact = storage.get(req.namespace, req.name)
         if not artifact:
             artifact = Artifact(
@@ -149,40 +149,40 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
                 description=req.description,
                 tags=req.tags,
             )
-        
+
         version = ArtifactVersion(
             version=req.version,
             readme_content=req.readme_content,
             checksum=checksum,
             metadata=req.metadata,
         )
-        
+
         artifact.add_version(version)
         if req.description:
             artifact.description = req.description
         if req.tags:
             artifact.tags = list(set(artifact.tags + req.tags))
-        
+
         storage.save_artifact(artifact)
-        
+
         return PublishResponse(
             success=True,
             artifact=artifact.full_name,
             version=req.version,
             checksum=checksum,
         )
-    
+
     @app.delete("/v1/artifacts/{namespace}/{name}")
     def delete_artifact(namespace: str, name: str):
         if storage.delete(namespace, name):
             return {"success": True, "message": f"Deleted {namespace}/{name}"}
         raise HTTPException(status_code=404, detail="Artifact not found")
-    
+
     @app.get("/v1/namespaces")
     def list_namespaces():
         namespaces = set(a.namespace for a in storage.list())
         return {"namespaces": sorted(namespaces)}
-    
+
     return app
 
 
@@ -193,7 +193,7 @@ def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
 @click.option("--reload", is_flag=True, help="Enable auto-reload")
 def main(host: str, port: int, storage: str, reload: bool):
     """Start the pactown registry server."""
-    app = create_app(storage)
+    create_app(storage)
     uvicorn.run(
         "pactown.registry.server:create_app",
         host=host,

pactown/resolver.py

@@ -1,8 +1,8 @@
 """Dependency resolver for pactown ecosystems."""
 
+from collections import deque
 from dataclasses import dataclass
 from typing import Optional
-from collections import deque
 
 from .config import EcosystemConfig, ServiceConfig
 
@@ -19,12 +19,12 @@ class ResolvedDependency:
 
 class DependencyResolver:
     """Resolves dependencies between services in an ecosystem."""
-    
+
     def __init__(self, config: EcosystemConfig):
         self.config = config
         self._graph: dict[str, list[str]] = {}
         self._build_graph()
-    
+
     def _build_graph(self) -> None:
         """Build dependency graph from configuration."""
         for name, service in self.config.services.items():
@@ -32,7 +32,7 @@ class DependencyResolver:
             for dep in service.depends_on:
                 if dep.name in self.config.services:
                     self._graph[name].append(dep.name)
-    
+
     def get_startup_order(self) -> list[str]:
         """
         Get services in topological order for startup.
@@ -40,46 +40,46 @@ class DependencyResolver:
         """
         # in_degree[X] = number of dependencies X has
         in_degree = {name: len(deps) for name, deps in self._graph.items()}
-        
+
         # Start with services that have no dependencies
         queue = deque([name for name, degree in in_degree.items() if degree == 0])
         order = []
-        
+
         while queue:
             current = queue.popleft()
             order.append(current)
-            
+
             # For each service that depends on current, decrease its in_degree
             for name, deps in self._graph.items():
                 if current in deps:
                     in_degree[name] -= 1
                     if in_degree[name] == 0:
                         queue.append(name)
-        
+
         if len(order) != len(self._graph):
             missing = set(self._graph.keys()) - set(order)
             raise ValueError(f"Circular dependency detected involving: {missing}")
-        
+
         return order
-    
+
     def get_shutdown_order(self) -> list[str]:
         """Get services in reverse order for shutdown."""
         return list(reversed(self.get_startup_order()))
-    
+
     def resolve_service_deps(self, service_name: str) -> list[ResolvedDependency]:
         """Resolve all dependencies for a service."""
         if service_name not in self.config.services:
             raise ValueError(f"Unknown service: {service_name}")
-        
+
         service = self.config.services[service_name]
         resolved = []
-        
+
         for dep in service.depends_on:
             if dep.name in self.config.services:
                 dep_service = self.config.services[dep.name]
                 endpoint = dep.endpoint or f"http://localhost:{dep_service.port}"
                 env_var = dep.env_var or f"{dep.name.upper().replace('-', '_')}_URL"
-                
+
                 resolved.append(ResolvedDependency(
                     name=dep.name,
                     version=dep.version,
@@ -90,43 +90,43 @@ class DependencyResolver:
             else:
                 endpoint = dep.endpoint or f"http://localhost:8800/v1/{dep.name}"
                 env_var = dep.env_var or f"{dep.name.upper().replace('-', '_')}_URL"
-                
+
                 resolved.append(ResolvedDependency(
                     name=dep.name,
                     version=dep.version,
                     endpoint=endpoint,
                     env_var=env_var,
                 ))
-        
+
         return resolved
-    
+
     def get_environment(self, service_name: str) -> dict[str, str]:
         """Get environment variables for a service including dependency endpoints."""
         if service_name not in self.config.services:
             raise ValueError(f"Unknown service: {service_name}")
-        
+
         service = self.config.services[service_name]
         env = dict(service.env)
-        
+
         for dep in self.resolve_service_deps(service_name):
             env[dep.env_var] = dep.endpoint
-        
+
         env["PACTOWN_SERVICE_NAME"] = service_name
         env["PACTOWN_ECOSYSTEM"] = self.config.name
         if service.port:
             env["MARKPACT_PORT"] = str(service.port)
-        
+
         return env
-    
+
     def validate(self) -> list[str]:
         """Validate the dependency graph and return any issues."""
         issues = []
-        
+
         try:
             self.get_startup_order()
         except ValueError as e:
             issues.append(str(e))
-        
+
         for name, service in self.config.services.items():
             for dep in service.depends_on:
                 if dep.name not in self.config.services:
@@ -135,26 +135,26 @@ class DependencyResolver:
                             f"Service '{name}' depends on '{dep.name}' which is not "
                             f"defined locally and no registry is configured"
                         )
-        
+
         return issues
-    
+
     def print_graph(self) -> str:
         """Return ASCII representation of dependency graph."""
         lines = [f"Ecosystem: {self.config.name}", ""]
-        
+
         try:
             order = self.get_startup_order()
         except ValueError:
             order = list(self._graph.keys())
-        
+
         for name in order:
             service = self.config.services[name]
             deps = [d.name for d in service.depends_on]
             port = f":{service.port}" if service.port else ""
-            
+
             if deps:
                 lines.append(f"  [{name}{port}] → {', '.join(deps)}")
             else:
                 lines.append(f"  [{name}{port}] (no deps)")
-        
+
         return "\n".join(lines)