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

julee/maintenance/release.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+Release preparation and tagging script.
+
+Usage:
+    release.py prepare X.Y.Z [--message-file FILE]  # Create release branch and PR
+    release.py tag X.Y.Z                            # Tag after PR is merged
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+import tempfile
+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, message_file: Path | None = None) -> None:
+    """Prepare a release: create branch, update versions, push, create PR."""
+    validate_version(version)
+    validate_git_state(require_master=True)
+
+    # Read release notes if provided
+    release_notes = None
+    if message_file:
+        if not message_file.exists():
+            print(f"ERROR: Message file not found: {message_file}", file=sys.stderr)
+            sys.exit(1)
+        release_notes = message_file.read_text().strip()
+
+    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 with release notes or default message
+    print("Committing version bump...")
+    if release_notes:
+        commit_msg = f"release: v{version}\n\n{release_notes}"
+    else:
+        commit_msg = f"release: bump version to {version}"
+
+    # Use a temp file for the commit message to handle multiline properly
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write(commit_msg)
+        commit_msg_file = f.name
+    try:
+        run(f'git add -A && git commit -F "{commit_msg_file}"')
+    finally:
+        Path(commit_msg_file).unlink()
+
+    # Push
+    print(f"Pushing {branch_name}...")
+    run(f"git push -u origin {branch_name}")
+
+    # Create PR with release notes as body
+    print("Creating pull request...")
+    pr_body = release_notes if release_notes else f"Bump version to {version}"
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write(pr_body)
+        pr_body_file = f.name
+    try:
+        result = run(
+            f'gh pr create --title "Release v{version}" --body-file "{pr_body_file}"',
+            check=False,
+        )
+    finally:
+        Path(pr_body_file).unlink()
+
+    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:
+    parser = argparse.ArgumentParser(description="Release preparation and tagging script")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # prepare subcommand
+    prepare_parser = subparsers.add_parser("prepare", help="Create release branch and PR")
+    prepare_parser.add_argument("version", help="Version number (X.Y.Z)")
+    prepare_parser.add_argument(
+        "--message-file", "-m",
+        type=Path,
+        help="File containing release notes for commit message and PR body",
+    )
+
+    # tag subcommand
+    tag_parser = subparsers.add_parser("tag", help="Tag after PR is merged")
+    tag_parser.add_argument("version", help="Version number (X.Y.Z)")
+
+    args = parser.parse_args()
+
+    if args.command == "prepare":
+        prepare(args.version, args.message_file)
+    elif args.command == "tag":
+        tag(args.version)
+
+
+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:
@@ -59,46 +60,52 @@ class MemoryDocumentRepository(DocumentRepository, MemoryRepositoryMixin[Documen
     async def save(self, document: Document) -> None:
         """Save a document with its content and metadata.
 
-        If the document has content_string, it will be converted to a
-        ContentStream and the content hash will be calculated automatically.
+        If the document has content_bytes, it will be normalized to bytes
+        (encoding str as UTF-8), converted to a ContentStream and the
+        content hash will be calculated automatically.
 
         Args:
             document: Document object to save
 
         Raises:
-            ValueError: If document has no content or content_string
+            ValueError: If document has no content or content_bytes
+            TypeError: If content_bytes is not bytes or str
         """
         # Handle content_string conversion (only if no content provided)
-        if document.content_string is not None:
-            # Convert content_string to ContentStream
-            assert document.content_string is not None  # For MyPy
-            content_bytes = document.content_string.encode("utf-8")
-            content_stream = ContentStream(io.BytesIO(content_bytes))
+        if document.content_bytes is not None:
+            if isinstance(document.content_bytes, str):
+                raw_bytes = document.content_bytes.encode("utf-8")
+            elif isinstance(document.content_bytes, bytes):
+                raw_bytes = document.content_bytes
+            else:
+                raise TypeError("content_bytes must be of type 'bytes' or 'str'.")
+
+            content_stream = ContentStream(io.BytesIO(raw_bytes))
 
             # Calculate content hash
-            content_hash = hashlib.sha256(content_bytes).hexdigest()
+            content_hash = hashlib.sha256(raw_bytes).hexdigest()
 
             # Create new document with ContentStream and calculated hash
             document = document.model_copy(
                 update={
                     "content": content_stream,
                     "content_multihash": content_hash,
-                    "size_bytes": len(content_bytes),
+                    "size_bytes": len(raw_bytes),
                 }
             )
 
             self.logger.debug(
-                "Converted content_string to ContentStream for document save",
+                "Converted content_bytes to ContentStream for document save",
                 extra={
                     "document_id": document.document_id,
                     "content_hash": content_hash,
-                    "content_length": len(content_bytes),
+                    "content_length": len(raw_bytes),
                 },
             )
 
         # Create a copy without content_string (content saved
         # in separate content-addressable storage)
-        document_for_storage = document.model_copy(update={"content_string": None})
+        document_for_storage = document.model_copy(update={"content_bytes": None})
         self.save_entity(document_for_storage, "document_id")
 
     async def generate_id(self) -> str:
@@ -109,7 +116,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 +127,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 +149,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__)
@@ -48,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:
@@ -80,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:
@@ -94,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:
@@ -116,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)