julee 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

julee/maintenance/release.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Release preparation and tagging script.
+
+Usage:
+    release.py prepare X.Y.Z  # Create release branch and PR
+    release.py tag X.Y.Z      # Tag after PR is merged
+"""
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run(cmd: str, check: bool = True, capture: bool = True) -> subprocess.CompletedProcess:
+    """Run a shell command."""
+    result = subprocess.run(cmd, shell=True, capture_output=capture, text=True)
+    if check and result.returncode != 0:
+        print(f"ERROR: {cmd}", file=sys.stderr)
+        if result.stderr:
+            print(result.stderr, file=sys.stderr)
+        sys.exit(1)
+    return result
+
+
+def get_repo_root() -> Path:
+    """Get the repository root directory."""
+    result = run("git rev-parse --show-toplevel")
+    return Path(result.stdout.strip())
+
+
+def get_package_init(repo_root: Path) -> Path | None:
+    """Find __init__.py with __version__ in src/ directory."""
+    src_dir = repo_root / "src"
+    if not src_dir.exists():
+        return None
+    packages = [p for p in src_dir.iterdir() if p.is_dir() and not p.name.startswith("_")]
+    if len(packages) != 1:
+        # Multiple packages (bounded contexts) - no single __init__.py to update
+        return None
+    init_file = packages[0] / "__init__.py"
+    if init_file.exists() and "__version__" in init_file.read_text():
+        return init_file
+    return None
+
+
+def validate_version(version: str) -> None:
+    """Validate version string format."""
+    if not re.match(r"^\d+\.\d+\.\d+$", version):
+        print(f"ERROR: Invalid version format '{version}'. Expected X.Y.Z", file=sys.stderr)
+        sys.exit(1)
+
+
+def validate_git_state(require_master: bool = True) -> None:
+    """Validate git working tree is clean and on correct branch."""
+    # Check for uncommitted changes
+    result = run("git status --porcelain")
+    if result.stdout.strip():
+        print("ERROR: Working tree has uncommitted changes", file=sys.stderr)
+        sys.exit(1)
+
+    if require_master:
+        # Check we're on master
+        result = run("git branch --show-current")
+        branch = result.stdout.strip()
+        if branch not in ("master", "main"):
+            print(f"ERROR: Must be on master or main branch, currently on '{branch}'", file=sys.stderr)
+            sys.exit(1)
+
+        # Check we're up to date with remote
+        run("git fetch origin")
+        result = run("git rev-list HEAD...origin/master --count 2>/dev/null || git rev-list HEAD...origin/main --count", check=False)
+        if result.stdout.strip() != "0":
+            print("ERROR: Branch is not up to date with remote", file=sys.stderr)
+            sys.exit(1)
+
+
+def update_version_in_file(file_path: Path, version: str, pattern: str, replacement: str) -> None:
+    """Update version string in a file."""
+    content = file_path.read_text()
+    new_content = re.sub(pattern, replacement, content, flags=re.MULTILINE)
+    if content == new_content:
+        print(f"WARNING: No version replacement made in {file_path}", file=sys.stderr)
+    file_path.write_text(new_content)
+
+
+def prepare(version: str) -> None:
+    """Prepare a release: create branch, update versions, push, create PR."""
+    validate_version(version)
+    validate_git_state(require_master=True)
+
+    repo_root = get_repo_root()
+    branch_name = f"release/v{version}"
+
+    # Create release branch
+    print(f"Creating branch {branch_name}...")
+    run(f"git checkout -b {branch_name}")
+
+    # Update pyproject.toml
+    pyproject = repo_root / "pyproject.toml"
+    print(f"Updating {pyproject}...")
+    update_version_in_file(
+        pyproject,
+        version,
+        r'^version\s*=\s*"[^"]*"',
+        f'version = "{version}"',
+    )
+
+    # Update __init__.py if it exists with __version__
+    init_file = get_package_init(repo_root)
+    if init_file:
+        print(f"Updating {init_file}...")
+        update_version_in_file(
+            init_file,
+            version,
+            r'^__version__\s*=\s*"[^"]*"',
+            f'__version__ = "{version}"',
+        )
+
+    # Commit
+    print("Committing version bump...")
+    run(f'git add -A && git commit -m "release: bump version to {version}"')
+
+    # Push
+    print(f"Pushing {branch_name}...")
+    run(f"git push -u origin {branch_name}")
+
+    # Create PR
+    print("Creating pull request...")
+    result = run(
+        f'gh pr create --title "Release v{version}" --body "Bump version to {version}"',
+        check=False,
+    )
+    if result.returncode != 0:
+        print(f"\nTo create PR manually:\n  gh pr create --title 'Release v{version}'")
+
+    print(f"\nRelease branch ready. After PR is merged, run:\n  ./maintenance/release.py tag {version}")
+
+
+def tag(version: str) -> None:
+    """Tag a release after PR is merged."""
+    validate_version(version)
+
+    # Checkout master and pull
+    print("Checking out master...")
+    run("git checkout master || git checkout main")
+    run("git pull")
+
+    validate_git_state(require_master=True)
+
+    tag_name = f"v{version}"
+
+    # Check tag doesn't already exist
+    result = run(f"git tag -l {tag_name}")
+    if result.stdout.strip():
+        print(f"ERROR: Tag {tag_name} already exists", file=sys.stderr)
+        sys.exit(1)
+
+    # Create and push tag
+    print(f"Creating tag {tag_name}...")
+    run(f"git tag {tag_name}")
+    print(f"Pushing tag {tag_name}...")
+    run(f"git push origin {tag_name}")
+
+    print(f"\nRelease {tag_name} tagged and pushed.")
+
+
+def main() -> None:
+    if len(sys.argv) < 3:
+        print(__doc__)
+        sys.exit(1)
+
+    command = sys.argv[1]
+    version = sys.argv[2]
+
+    if command == "prepare":
+        prepare(version)
+    elif command == "tag":
+        tag(version)
+    else:
+        print(f"Unknown command: {command}", file=sys.stderr)
+        print(__doc__)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

julee/repositories/__init__.py

@@ -5,13 +5,16 @@ This package contains concrete implementations of the repository interfaces
 defined in julee.domain.repositories.
 
 Implementation packages:
+
 - memory: In-memory implementations for testing
 - minio: MinIO-based implementations for production
 - temporal: Temporal workflow proxy implementations
 
-Import implementations using their full module paths, e.g.:
+Import implementations using their full module paths, e.g.::
+
     from julee.repositories.memory import MemoryDocumentRepository
     from julee.repositories.minio.document import (
         MinioDocumentRepository,
     )
+
 """

julee/repositories/memory/assembly.py

@@ -12,10 +12,11 @@ All operations are still async to maintain interface compatibility.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Any
 
 from julee.domain.models.assembly import Assembly
 from julee.domain.repositories.assembly import AssemblyRepository
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -34,11 +35,11 @@ class MemoryAssemblyRepository(AssemblyRepository, MemoryRepositoryMixin[Assembl
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "Assembly"
-        self.storage_dict: Dict[str, Assembly] = {}
+        self.storage_dict: dict[str, Assembly] = {}
 
         logger.debug("Initializing MemoryAssemblyRepository")
 
-    async def get(self, assembly_id: str) -> Optional[Assembly]:
+    async def get(self, assembly_id: str) -> Assembly | None:
         """Retrieve an assembly by ID.
 
         Args:
@@ -65,7 +66,7 @@ class MemoryAssemblyRepository(AssemblyRepository, MemoryRepositoryMixin[Assembl
         """
         return self.generate_entity_id("assembly")
 
-    async def get_many(self, assembly_ids: List[str]) -> Dict[str, Optional[Assembly]]:
+    async def get_many(self, assembly_ids: list[str]) -> dict[str, Assembly | None]:
         """Retrieve multiple assemblies by ID.
 
         Args:
@@ -77,7 +78,7 @@ class MemoryAssemblyRepository(AssemblyRepository, MemoryRepositoryMixin[Assembl
         return self.get_many_entities(assembly_ids)
 
     def _add_entity_specific_log_data(
-        self, entity: Assembly, log_data: Dict[str, Any]
+        self, entity: Assembly, log_data: dict[str, Any]
     ) -> None:
         """Add assembly-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

julee/repositories/memory/assembly_specification.py

@@ -14,7 +14,7 @@ avoided. All operations are still async to maintain interface compatibility.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Any
 
 from julee.domain.models.assembly_specification import (
     AssemblySpecification,
@@ -22,6 +22,7 @@ from julee.domain.models.assembly_specification import (
 from julee.domain.repositories.assembly_specification import (
     AssemblySpecificationRepository,
 )
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -36,6 +37,7 @@ class MemoryAssemblySpecificationRepository(
     dictionaries.
 
     This implementation stores assembly specifications in memory:
+
     - Specifications: Dictionary keyed by assembly_specification_id containing
       AssemblySpecification objects
 
@@ -47,13 +49,11 @@ class MemoryAssemblySpecificationRepository(
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "AssemblySpecification"
-        self.storage_dict: Dict[str, AssemblySpecification] = {}
+        self.storage_dict: dict[str, AssemblySpecification] = {}
 
         logger.debug("Initializing MemoryAssemblySpecificationRepository")
 
-    async def get(
-        self, assembly_specification_id: str
-    ) -> Optional[AssemblySpecification]:
+    async def get(self, assembly_specification_id: str) -> AssemblySpecification | None:
         """Retrieve an assembly specification by ID.
 
         Args:
@@ -81,8 +81,8 @@ class MemoryAssemblySpecificationRepository(
         return self.generate_entity_id("spec")
 
     async def get_many(
-        self, assembly_specification_ids: List[str]
-    ) -> Dict[str, Optional[AssemblySpecification]]:
+        self, assembly_specification_ids: list[str]
+    ) -> dict[str, AssemblySpecification | None]:
         """Retrieve multiple assembly specifications by ID.
 
         Args:
@@ -95,7 +95,7 @@ class MemoryAssemblySpecificationRepository(
         """
         return self.get_many_entities(assembly_specification_ids)
 
-    async def list_all(self) -> List[AssemblySpecification]:
+    async def list_all(self) -> list[AssemblySpecification]:
         """List all assembly specifications.
 
         Returns:
@@ -117,7 +117,7 @@ class MemoryAssemblySpecificationRepository(
         return specifications
 
     def _add_entity_specific_log_data(
-        self, entity: AssemblySpecification, log_data: Dict[str, Any]
+        self, entity: AssemblySpecification, log_data: dict[str, Any]
     ) -> None:
         """Add assembly specification-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

julee/repositories/memory/base.py

@@ -20,7 +20,8 @@ Classes using this mixin must provide:
 
 import uuid
 from datetime import datetime, timezone
-from typing import Optional, Dict, Any, TypeVar, Generic, List
+from typing import Any, Generic, TypeVar
+
 from pydantic import BaseModel
 
 T = TypeVar("T", bound=BaseModel)
@@ -45,11 +46,11 @@ class MemoryRepositoryMixin(Generic[T]):
     """
 
     # Type annotations for attributes that implementing classes must provide
-    storage_dict: Dict[str, T]
+    storage_dict: dict[str, T]
     entity_name: str
     logger: Any  # logging.Logger, but avoiding import
 
-    def get_entity(self, entity_id: str) -> Optional[T]:
+    def get_entity(self, entity_id: str) -> T | None:
         """Get an entity from memory storage with standardized logging.
 
         Args:
@@ -84,7 +85,7 @@ class MemoryRepositoryMixin(Generic[T]):
 
         return entity
 
-    def get_many_entities(self, entity_ids: List[str]) -> Dict[str, Optional[T]]:
+    def get_many_entities(self, entity_ids: list[str]) -> dict[str, T | None]:
         """Get multiple entities from memory storage with standardized
         logging.
 
@@ -103,7 +104,7 @@ class MemoryRepositoryMixin(Generic[T]):
             },
         )
 
-        result: Dict[str, Optional[T]] = {}
+        result: dict[str, T | None] = {}
         found_count = 0
 
         for entity_id in entity_ids:
@@ -160,7 +161,7 @@ class MemoryRepositoryMixin(Generic[T]):
             extra=success_extra,
         )
 
-    def generate_entity_id(self, prefix: Optional[str] = None) -> str:
+    def generate_entity_id(self, prefix: str | None = None) -> str:
         """Generate a unique entity ID with consistent format.
 
         Args:
@@ -196,14 +197,14 @@ class MemoryRepositoryMixin(Generic[T]):
             hasattr(entity, "created_at")
             and getattr(entity, "created_at", None) is None
         ):
-            setattr(entity, "created_at", now)
+            entity.created_at = now
 
         # Always update updated_at
         if hasattr(entity, "updated_at"):
-            setattr(entity, "updated_at", now)
+            entity.updated_at = now
 
     def _add_entity_specific_log_data(
-        self, entity: T, log_data: Dict[str, Any]
+        self, entity: T, log_data: dict[str, Any]
     ) -> None:
         """Add entity-specific data to log entries for richer logging.
 
@@ -216,12 +217,12 @@ class MemoryRepositoryMixin(Generic[T]):
         """
         # Default implementation adds basic model info
         if hasattr(entity, "status"):
-            status = getattr(entity, "status")
+            status = entity.status
             log_data["status"] = (
                 status.value if hasattr(status, "value") else str(status)
             )
 
         if hasattr(entity, "updated_at"):
-            updated_at = getattr(entity, "updated_at")
+            updated_at = entity.updated_at
             if updated_at:
                 log_data["updated_at"] = updated_at.isoformat()

julee/repositories/memory/document.py

@@ -14,13 +14,14 @@ All operations are still async to maintain interface compatibility.
 import hashlib
 import io
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Any
 
-from julee.domain.models.document import Document
 from julee.domain.models.custom_fields.content_stream import (
     ContentStream,
 )
+from julee.domain.models.document import Document
 from julee.domain.repositories.document import DocumentRepository
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -41,11 +42,11 @@ class MemoryDocumentRepository(DocumentRepository, MemoryRepositoryMixin[Documen
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "Document"
-        self.storage_dict: Dict[str, Document] = {}
+        self.storage_dict: dict[str, Document] = {}
 
         logger.debug("Initializing MemoryDocumentRepository")
 
-    async def get(self, document_id: str) -> Optional[Document]:
+    async def get(self, document_id: str) -> Document | None:
         """Retrieve a document with metadata and content.
 
         Args:
@@ -109,7 +110,7 @@ class MemoryDocumentRepository(DocumentRepository, MemoryRepositoryMixin[Documen
         """
         return self.generate_entity_id("doc")
 
-    async def get_many(self, document_ids: List[str]) -> Dict[str, Optional[Document]]:
+    async def get_many(self, document_ids: list[str]) -> dict[str, Document | None]:
         """Retrieve multiple documents by ID.
 
         Args:
@@ -120,7 +121,7 @@ class MemoryDocumentRepository(DocumentRepository, MemoryRepositoryMixin[Documen
         """
         return self.get_many_entities(document_ids)
 
-    async def list_all(self) -> List[Document]:
+    async def list_all(self) -> list[Document]:
         """List all documents.
 
         Returns:
@@ -142,7 +143,7 @@ class MemoryDocumentRepository(DocumentRepository, MemoryRepositoryMixin[Documen
         return documents
 
     def _add_entity_specific_log_data(
-        self, entity: Document, log_data: Dict[str, Any]
+        self, entity: Document, log_data: dict[str, Any]
     ) -> None:
         """Add document-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

julee/repositories/memory/document_policy_validation.py

@@ -13,12 +13,13 @@ All operations are still async to maintain interface compatibility.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Any
 
 from julee.domain.models.policy import DocumentPolicyValidation
 from julee.domain.repositories.document_policy_validation import (
     DocumentPolicyValidationRepository,
 )
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -41,11 +42,11 @@ class MemoryDocumentPolicyValidationRepository(
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "DocumentPolicyValidation"
-        self.storage_dict: Dict[str, DocumentPolicyValidation] = {}
+        self.storage_dict: dict[str, DocumentPolicyValidation] = {}
 
         logger.debug("Initializing MemoryDocumentPolicyValidationRepository")
 
-    async def get(self, validation_id: str) -> Optional[DocumentPolicyValidation]:
+    async def get(self, validation_id: str) -> DocumentPolicyValidation | None:
         """Retrieve a document policy validation by ID.
 
         Args:
@@ -73,8 +74,8 @@ class MemoryDocumentPolicyValidationRepository(
         return self.generate_entity_id("validation")
 
     async def get_many(
-        self, validation_ids: List[str]
-    ) -> Dict[str, Optional[DocumentPolicyValidation]]:
+        self, validation_ids: list[str]
+    ) -> dict[str, DocumentPolicyValidation | None]:
         """Retrieve multiple document policy validations by ID.
 
         Args:
@@ -87,7 +88,7 @@ class MemoryDocumentPolicyValidationRepository(
         return self.get_many_entities(validation_ids)
 
     def _add_entity_specific_log_data(
-        self, entity: DocumentPolicyValidation, log_data: Dict[str, Any]
+        self, entity: DocumentPolicyValidation, log_data: dict[str, Any]
     ) -> None:
         """Add validation-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

julee/repositories/memory/knowledge_service_config.py

@@ -14,7 +14,7 @@ interface compatibility.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Any
 
 from julee.domain.models.knowledge_service_config import (
     KnowledgeServiceConfig,
@@ -22,6 +22,7 @@ from julee.domain.models.knowledge_service_config import (
 from julee.domain.repositories.knowledge_service_config import (
     KnowledgeServiceConfigRepository,
 )
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -36,6 +37,7 @@ class MemoryKnowledgeServiceConfigRepository(
     dictionaries.
 
     This implementation stores knowledge service configurations in memory:
+
     - Knowledge Services: Dictionary keyed by knowledge_service_id containing
       KnowledgeServiceConfig objects
 
@@ -47,11 +49,11 @@ class MemoryKnowledgeServiceConfigRepository(
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "KnowledgeServiceConfig"
-        self.storage_dict: Dict[str, KnowledgeServiceConfig] = {}
+        self.storage_dict: dict[str, KnowledgeServiceConfig] = {}
 
         logger.debug("Initializing MemoryKnowledgeServiceConfigRepository")
 
-    async def get(self, knowledge_service_id: str) -> Optional[KnowledgeServiceConfig]:
+    async def get(self, knowledge_service_id: str) -> KnowledgeServiceConfig | None:
         """Retrieve a knowledge service configuration by ID.
 
         Args:
@@ -79,8 +81,8 @@ class MemoryKnowledgeServiceConfigRepository(
         return self.generate_entity_id("ks")
 
     async def get_many(
-        self, knowledge_service_ids: List[str]
-    ) -> Dict[str, Optional[KnowledgeServiceConfig]]:
+        self, knowledge_service_ids: list[str]
+    ) -> dict[str, KnowledgeServiceConfig | None]:
         """Retrieve multiple knowledge service configs by ID.
 
         Args:
@@ -93,7 +95,7 @@ class MemoryKnowledgeServiceConfigRepository(
         """
         return self.get_many_entities(knowledge_service_ids)
 
-    async def list_all(self) -> List[KnowledgeServiceConfig]:
+    async def list_all(self) -> list[KnowledgeServiceConfig]:
         """List all knowledge service configurations.
 
         Returns:
@@ -115,7 +117,7 @@ class MemoryKnowledgeServiceConfigRepository(
         return configs
 
     def _add_entity_specific_log_data(
-        self, entity: KnowledgeServiceConfig, log_data: Dict[str, Any]
+        self, entity: KnowledgeServiceConfig, log_data: dict[str, Any]
     ) -> None:
         """Add knowledge service config-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

julee/repositories/memory/knowledge_service_query.py

@@ -13,7 +13,7 @@ should be avoided.
 """
 
 import logging
-from typing import Dict, Optional, Any, List
+from typing import Any
 
 from julee.domain.models.assembly_specification import (
     KnowledgeServiceQuery,
@@ -21,6 +21,7 @@ from julee.domain.models.assembly_specification import (
 from julee.domain.repositories.knowledge_service_query import (
     KnowledgeServiceQueryRepository,
 )
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -35,6 +36,7 @@ class MemoryKnowledgeServiceQueryRepository(
     dictionaries.
 
     This implementation stores knowledge service queries in memory:
+
     - Queries: Dictionary keyed by query_id containing KnowledgeServiceQuery
       objects
 
@@ -46,11 +48,11 @@ class MemoryKnowledgeServiceQueryRepository(
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "KnowledgeServiceQuery"
-        self.storage_dict: Dict[str, KnowledgeServiceQuery] = {}
+        self.storage_dict: dict[str, KnowledgeServiceQuery] = {}
 
         logger.debug("Initializing MemoryKnowledgeServiceQueryRepository")
 
-    async def get(self, query_id: str) -> Optional[KnowledgeServiceQuery]:
+    async def get(self, query_id: str) -> KnowledgeServiceQuery | None:
         """Retrieve a knowledge service query by ID.
 
         Args:
@@ -70,8 +72,8 @@ class MemoryKnowledgeServiceQueryRepository(
         self.save_entity(query, "query_id")
 
     async def get_many(
-        self, query_ids: List[str]
-    ) -> Dict[str, Optional[KnowledgeServiceQuery]]:
+        self, query_ids: list[str]
+    ) -> dict[str, KnowledgeServiceQuery | None]:
         """Retrieve multiple knowledge service queries by ID.
 
         Args:
@@ -91,7 +93,7 @@ class MemoryKnowledgeServiceQueryRepository(
         """
         return self.generate_entity_id("query")
 
-    async def list_all(self) -> List[KnowledgeServiceQuery]:
+    async def list_all(self) -> list[KnowledgeServiceQuery]:
         """List all knowledge service queries.
 
         Returns:
@@ -112,7 +114,7 @@ class MemoryKnowledgeServiceQueryRepository(
         return entities
 
     def _add_entity_specific_log_data(
-        self, entity: KnowledgeServiceQuery, log_data: Dict[str, Any]
+        self, entity: KnowledgeServiceQuery, log_data: dict[str, Any]
     ) -> None:
         """Add knowledge service query-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)