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

julee/domain/use_cases/tests/test_extract_assemble_data.py

@@ -8,35 +8,35 @@ following the Clean Architecture principles.
 
 import io
 import json
-import pytest
-
-from unittest.mock import AsyncMock
 from datetime import datetime, timezone
+from unittest.mock import AsyncMock
+
+import pytest
 
-from julee.domain.use_cases import ExtractAssembleDataUseCase
 from julee.domain.models import (
     Assembly,
+    AssemblySpecification,
+    AssemblySpecificationStatus,
     AssemblyStatus,
+    ContentStream,
     Document,
     DocumentStatus,
-    ContentStream,
-    AssemblySpecification,
-    AssemblySpecificationStatus,
-    KnowledgeServiceQuery,
     KnowledgeServiceConfig,
+    KnowledgeServiceQuery,
 )
 from julee.domain.models.knowledge_service_config import ServiceApi
+from julee.domain.use_cases import ExtractAssembleDataUseCase
 from julee.repositories.memory import (
-    MemoryDocumentRepository,
     MemoryAssemblyRepository,
     MemoryAssemblySpecificationRepository,
+    MemoryDocumentRepository,
     MemoryKnowledgeServiceConfigRepository,
     MemoryKnowledgeServiceQueryRepository,
 )
+from julee.services.knowledge_service import QueryResult
 from julee.services.knowledge_service.memory import (
     MemoryKnowledgeService,
 )
-from julee.services.knowledge_service import QueryResult
 
 
 class TestExtractAssembleDataUseCase:

julee/domain/use_cases/tests/test_initialize_system_data.py

@@ -86,7 +86,7 @@ def fixture_configs() -> list[dict]:
 
     assert fixture_path.exists(), f"Fixture file not found: {fixture_path}"
 
-    with open(fixture_path, "r", encoding="utf-8") as f:
+    with open(fixture_path, encoding="utf-8") as f:
         fixture_data = yaml.safe_load(f)
 
     assert "knowledge_services" in fixture_data
@@ -320,7 +320,7 @@ class TestYamlFixtureIntegration:
         assert fixture_path.exists(), f"Fixture file not found: {fixture_path}"
 
         # Verify file can be parsed
-        with open(fixture_path, "r", encoding="utf-8") as f:
+        with open(fixture_path, encoding="utf-8") as f:
             fixture_data = yaml.safe_load(f)
 
         # Verify structure

julee/domain/use_cases/tests/test_validate_document.py

@@ -7,38 +7,38 @@ following the Clean Architecture principles.
 """
 
 import io
-import pytest
-from unittest.mock import AsyncMock
 from datetime import datetime, timezone
-from pydantic import ValidationError
+from unittest.mock import AsyncMock
 
-from julee.domain.use_cases import ValidateDocumentUseCase
+import pytest
+from pydantic import ValidationError
 
 from julee.domain.models import (
+    ContentStream,
     Document,
     DocumentStatus,
-    ContentStream,
     KnowledgeServiceConfig,
     KnowledgeServiceQuery,
 )
+from julee.domain.models.knowledge_service_config import ServiceApi
 from julee.domain.models.policy import (
-    Policy,
-    PolicyStatus,
     DocumentPolicyValidation,
     DocumentPolicyValidationStatus,
+    Policy,
+    PolicyStatus,
 )
-from julee.domain.models.knowledge_service_config import ServiceApi
+from julee.domain.use_cases import ValidateDocumentUseCase
 from julee.repositories.memory import (
+    MemoryDocumentPolicyValidationRepository,
     MemoryDocumentRepository,
-    MemoryKnowledgeServiceQueryRepository,
     MemoryKnowledgeServiceConfigRepository,
+    MemoryKnowledgeServiceQueryRepository,
     MemoryPolicyRepository,
-    MemoryDocumentPolicyValidationRepository,
 )
+from julee.services.knowledge_service import QueryResult
 from julee.services.knowledge_service.memory import (
     MemoryKnowledgeService,
 )
-from julee.services.knowledge_service import QueryResult
 
 
 class TestValidateDocumentUseCase:

julee/domain/use_cases/validate_document.py

@@ -11,8 +11,8 @@ import hashlib
 import io
 import json
 import logging
+from collections.abc import Callable
 from datetime import datetime
-from typing import Callable, Dict, List, Tuple
 
 import multihash
 
@@ -397,13 +397,13 @@ class ValidateDocumentUseCase:
     @try_use_case_step("all_queries_retrieval")
     async def _retrieve_all_queries(
         self, policy: Policy
-    ) -> Dict[str, KnowledgeServiceQuery]:
+    ) -> dict[str, KnowledgeServiceQuery]:
         """Retrieve all knowledge service queries needed for validation and
         transformation."""
         all_queries = {}
 
         # Get validation queries
-        for query_id, required_score in policy.validation_scores:
+        for query_id, _required_score in policy.validation_scores:
             query = await self.knowledge_service_query_repo.get(query_id)
             if not query:
                 raise ValueError(f"Validation query not found: {query_id}")
@@ -423,8 +423,8 @@ class ValidateDocumentUseCase:
     async def _register_document_with_services(
         self,
         document: Document,
-        queries: Dict[str, KnowledgeServiceQuery],
-    ) -> Dict[str, str]:
+        queries: dict[str, KnowledgeServiceQuery],
+    ) -> dict[str, str]:
         """
         Register the document with all knowledge services needed for
         validation.
@@ -464,9 +464,9 @@ class ValidateDocumentUseCase:
         self,
         document: Document,
         policy: Policy,
-        document_registrations: Dict[str, str],
-        queries: Dict[str, KnowledgeServiceQuery],
-    ) -> List[Tuple[str, int]]:
+        document_registrations: dict[str, str],
+        queries: dict[str, KnowledgeServiceQuery],
+    ) -> list[tuple[str, int]]:
         """
         Execute all validation queries and return the actual scores achieved.
 
@@ -528,7 +528,7 @@ class ValidateDocumentUseCase:
 
         return validation_scores
 
-    def _extract_score_from_result(self, result_data: Dict) -> int:
+    def _extract_score_from_result(self, result_data: dict) -> int:
         """
         Extract a numeric score from the knowledge service query result.
 
@@ -551,8 +551,8 @@ class ValidateDocumentUseCase:
 
     def _determine_validation_result(
         self,
-        actual_scores: List[Tuple[str, int]],
-        required_scores: List[Tuple[str, int]],
+        actual_scores: list[tuple[str, int]],
+        required_scores: list[tuple[str, int]],
     ) -> bool:
         """
         Determine if validation passed based on actual vs required scores.
@@ -591,8 +591,8 @@ class ValidateDocumentUseCase:
         self,
         document: Document,
         policy: Policy,
-        all_queries: Dict[str, KnowledgeServiceQuery],
-        document_registrations: Dict[str, str],
+        all_queries: dict[str, KnowledgeServiceQuery],
+        document_registrations: dict[str, str],
     ) -> Document:
         """
         Apply transformation queries to a document and return the
@@ -714,7 +714,7 @@ class ValidateDocumentUseCase:
 
         return transformed_document
 
-    def _extract_transformed_content(self, result_data: Dict) -> str:
+    def _extract_transformed_content(self, result_data: dict) -> str:
         """
         Extract transformed document content from knowledge service result.
 

julee/maintenance/__init__.py

@@ -0,0 +1 @@
+"""Maintenance utilities for julee and julee-based solutions."""

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/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__)
@@ -48,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:
@@ -82,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:
@@ -96,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:
@@ -118,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)