contextweave 0.3.1__tar.gz → 2.7.0__tar.gz

{contextweave-0.3.1 → contextweave-2.7.0}/.github/workflows/release.yml

@@ -373,8 +373,69 @@ jobs:
           if-no-files-found: error
           retention-days: 5
 
+  build-python-package:
+    name: Build Python package
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set package version from tag
+        shell: bash
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          uv version "$VERSION" --frozen
+          echo "Building contextweave $(uv version --short)"
+
+      - name: Build package distributions
+        run: uv build --clear
+
+      - name: Validate package distributions
+        run: uvx --from twine twine check dist/*
+
+      - name: Upload Python package distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/*
+          if-no-files-found: error
+          retention-days: 5
+
+  publish-pypi:
+    name: Publish Python package to PyPI
+    needs: [build, build-python-package]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/contextweave
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download Python package distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
   release:
-    needs: build
+    needs: [build, build-python-package]
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/v')
 

{contextweave-0.3.1 → contextweave-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextweave
-Version: 0.3.1
+Version: 2.7.0
 Summary: ContextWeave: context-aware document translation with glossary management
 Project-URL: Homepage, https://github.com/bot-32142/ContextWeave
 Project-URL: Documentation, https://bot-32142.github.io/ContextWeave/

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/__init__.py

@@ -9,6 +9,8 @@ import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from context_aware_translation.stdio import configure_standard_streams
+
 if TYPE_CHECKING:
     from context_aware_translation.config import Config
 
@@ -53,6 +55,8 @@ def configure_logging(config: "Config") -> None:
     """
     global _logging_configured
 
+    configure_standard_streams()
+
     # Skip configuration if we're in a test environment (pytest will handle it)
     is_test_env = (
         "pytest" in sys.modules

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/adapters/qt/workers/translate_and_export_task_worker.py

@@ -191,7 +191,9 @@ class TranslateAndExportTaskWorker(BaseWorker):
                     progress_callback=self._on_progress,
                 )
 
-        preserve_structure = bool(self._options.get("preserve_structure", False))
+        export_documents = bootstrap_ops.load_documents(workflow, [self._document_id])
+        requires_preserve_structure = any(document.document_type == "galgame" for document in export_documents)
+        preserve_structure = requires_preserve_structure or bool(self._options.get("preserve_structure", False))
         if preserve_structure:
             await export_ops.export_preserve_structure(
                 workflow,

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/contracts/document.py

@@ -132,6 +132,17 @@ class SaveTranslationRequest(ContractModel):
     translated_text: str
 
 
+class TranslationUnitUpdate(ContractModel):
+    unit_id: str
+    translated_text: str
+
+
+class SaveTranslationsRequest(ContractModel):
+    project_id: str
+    document_id: int
+    updates: list[TranslationUnitUpdate] = Field(default_factory=list)
+
+
 class RetranslateRequest(ContractModel):
     project_id: str
     document_id: int
@@ -192,6 +203,7 @@ class DocumentExportState(ContractModel):
     default_output_path: str | None = None
     blocker: BlockerInfo | None = None
     supports_preserve_structure: bool = False
+    requires_preserve_structure: bool = False
     supports_original_image_export: bool = False
     supports_epub_layout_conversion: bool = False
     incomplete_translation_message: str | None = None
@@ -216,6 +228,7 @@ class TranslateAndExportState(ContractModel):
     default_output_path: str | None = None
     blocker: BlockerInfo | None = None
     supports_preserve_structure: bool = False
+    requires_preserve_structure: bool = False
     supports_original_image_export: bool = False
     supports_epub_layout_conversion: bool = False
     batch_available: bool = False

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/contracts/work.py

@@ -94,6 +94,7 @@ class ExportDialogState(ContractModel):
     default_output_path: str | None = None
     blocker: BlockerInfo | None = None
     supports_preserve_structure: bool = False
+    requires_preserve_structure: bool = False
     supports_original_image_export: bool = False
     supports_epub_layout_conversion: bool = False
     incomplete_translation_message: str | None = None

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/runtime.py

@@ -53,6 +53,10 @@ from context_aware_translation.application.events import (
     WorkboardInvalidatedEvent,
 )
 from context_aware_translation.config import Config, infer_async_batch_provider
+from context_aware_translation.languages import (
+    display_target_language_name,
+    require_storage_target_language_name,
+)
 from context_aware_translation.storage.library.book_manager import BookManager
 from context_aware_translation.storage.models.book import Book
 from context_aware_translation.storage.models.config_profile import ConfigProfile
@@ -61,10 +65,6 @@ from context_aware_translation.storage.repositories.document_repository import D
 from context_aware_translation.storage.repositories.task_store import TaskRecord, TaskStore
 from context_aware_translation.storage.repositories.term_repository import TermRepository
 from context_aware_translation.storage.schema.book_db import SQLiteBookDB
-from context_aware_translation.ui.constants import (
-    display_target_language_name,
-    storage_target_language_name,
-)
 from context_aware_translation.workflow.tasks.models import TaskAction
 
 if TYPE_CHECKING:
@@ -900,9 +900,7 @@ def build_workflow_profile_payload(
     source_profile_id: str | None = None,
 ) -> dict[str, Any]:
     payload = dict(base_config or {})
-    payload["translation_target_language"] = (
-        storage_target_language_name(profile.target_language) or profile.target_language
-    )
+    payload["translation_target_language"] = require_storage_target_language_name(profile.target_language)
     if source_profile_id:
         payload[_UI_SOURCE_PROFILE_ID_KEY] = source_profile_id
     else:

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/services/_export_support.py

@@ -20,6 +20,7 @@ from context_aware_translation.workflow.ops import export_ops
 from context_aware_translation.workflow.session import WorkflowSession
 
 _INTERNAL_DOCUMENT_LABEL_PATHS = frozenset({"__epub_metadata__.json", "__epub_original__.epub"})
+_NATIVE_FORMAT_ID = "native"
 
 
 @dataclass(frozen=True)
@@ -31,6 +32,7 @@ class PreparedExport:
     available_formats: list[ExportOption]
     default_output_path: str
     supports_preserve_structure: bool = False
+    requires_preserve_structure: bool = False
     supports_original_image_export: bool = False
     supports_epub_layout_conversion: bool = False
     incomplete_translation_message: str | None = None
@@ -89,15 +91,20 @@ def prepare_export(
     document_labels = [
         _document_label(int(doc["document_id"]), sources_by_doc.get(int(doc["document_id"]), [])) for doc in docs
     ]
-    format_ids = list(get_supported_formats_for_type(document_type))
+    format_ids = _format_ids_for_export(
+        document_type=document_type,
+        document_ids=document_ids,
+        sources_by_doc=sources_by_doc,
+    )
     if not format_ids:
         raise_application_error(
             ApplicationErrorCode.UNSUPPORTED,
             f"No export formats are available for document type '{document_type}'.",
         )
+    requires_preserve_structure = _requires_preserve_structure(document_type)
     default_format = _preferred_default_format(document_type, format_ids, document_labels)
     available_formats = [
-        ExportOption(format_id=fmt, label=fmt.upper(), is_default=(fmt == default_format)) for fmt in format_ids
+        ExportOption(format_id=fmt, label=_format_label(fmt), is_default=(fmt == default_format)) for fmt in format_ids
     ]
 
     incomplete = False
@@ -120,6 +127,7 @@ def prepare_export(
         project_id=project_id,
         document_labels=document_labels,
         default_format=default_format,
+        requires_preserve_structure=requires_preserve_structure,
     )
 
     return PreparedExport(
@@ -130,6 +138,7 @@ def prepare_export(
         available_formats=available_formats,
         default_output_path=default_output_path,
         supports_preserve_structure=supports_preserve_structure_for_type(document_type),
+        requires_preserve_structure=requires_preserve_structure,
         supports_original_image_export=supports_original_image_export_for_type(document_type),
         supports_epub_layout_conversion=document_type == "epub",
         incomplete_translation_message=(
@@ -148,6 +157,7 @@ def to_export_dialog_state(prepared: PreparedExport) -> ExportDialogState:
         available_formats=prepared.available_formats,
         default_output_path=prepared.default_output_path,
         supports_preserve_structure=prepared.supports_preserve_structure,
+        requires_preserve_structure=prepared.requires_preserve_structure,
         supports_original_image_export=prepared.supports_original_image_export,
         supports_epub_layout_conversion=prepared.supports_epub_layout_conversion,
         incomplete_translation_message=prepared.incomplete_translation_message,
@@ -165,7 +175,7 @@ def run_export(
 ) -> DocumentExportResult:
     prepared = prepare_export(runtime, project_id=project_id, document_ids=document_ids)
 
-    preserve_structure = bool(options.get("preserve_structure", False))
+    preserve_structure = prepared.requires_preserve_structure or bool(options.get("preserve_structure", False))
     allow_original_fallback = bool(options.get("allow_original_fallback", False))
     use_original_images = bool(options.get("use_original_images", False))
     epub_force_horizontal_ltr = bool(options.get("epub_force_horizontal_ltr", False))
@@ -195,7 +205,7 @@ def run_export(
         )
     if not output_path.strip():
         raise_application_error(ApplicationErrorCode.VALIDATION, "Output path is required.", project_id=project_id)
-    if not preserve_structure and format_id not in {option.format_id for option in prepared.available_formats}:
+    if format_id not in {option.format_id for option in prepared.available_formats}:
         raise_application_error(
             ApplicationErrorCode.VALIDATION,
             f"Unsupported export format: {format_id}.",
@@ -253,6 +263,29 @@ def _document_label(document_id: int, sources: list[dict]) -> str:
     return f"Document {document_id}"
 
 
+def _format_ids_for_export(
+    *,
+    document_type: str,
+    document_ids: list[int],
+    sources_by_doc: dict[int, list[dict]],
+) -> list[str]:
+    format_ids = list(get_supported_formats_for_type(document_type))
+    _ = (document_ids, sources_by_doc)
+    if document_type == "galgame":
+        return [_NATIVE_FORMAT_ID] if _NATIVE_FORMAT_ID in format_ids else []
+    return format_ids
+
+
+def _requires_preserve_structure(document_type: str) -> bool:
+    return document_type == "galgame"
+
+
+def _format_label(format_id: str) -> str:
+    if format_id == _NATIVE_FORMAT_ID:
+        return "Native"
+    return format_id.upper()
+
+
 def _preferred_default_format(document_type: str, format_ids: list[str], document_labels: list[str]) -> str:
     if document_type == "subtitle" and len(document_labels) == 1:
         source_extension = Path(document_labels[0]).suffix.lower().lstrip(".")
@@ -267,11 +300,14 @@ def _default_output_path(
     project_id: str,
     document_labels: list[str],
     default_format: str,
+    requires_preserve_structure: bool,
 ) -> str:
     export_root = runtime.book_manager.get_book_path(project_id) / "export"
     base_name = "export"
     if len(document_labels) == 1:
         base_name = _slugify(Path(document_labels[0]).stem or document_labels[0]) or "export"
+    if requires_preserve_structure:
+        return str(export_root / base_name)
     return str(export_root / f"{base_name}.{default_format}")
 
 

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/services/app_setup.py

@@ -38,6 +38,7 @@ from context_aware_translation.application.runtime import (
     recommended_workflow_profile_from_drafts,
     wizard_connection_key_for_draft,
 )
+from context_aware_translation.languages import display_target_language_name
 from context_aware_translation.storage.models.config_profile import ConfigProfile
 from context_aware_translation.storage.models.endpoint_profile import EndpointProfile
 
@@ -133,7 +134,12 @@ class DefaultAppSetupService:
             target_language = current_detail.target_language
         requested_target_language = (request.target_language or "").strip()
         if requested_target_language:
-            target_language = requested_target_language
+            target_language = display_target_language_name(requested_target_language) or ""
+            if not target_language:
+                raise_application_error(
+                    ApplicationErrorCode.VALIDATION,
+                    "Target language must be one of the supported language presets.",
+                )
         profile_name = (request.profile_name or "").strip() or None
         recommendation = recommended_workflow_profile_from_drafts(
             request.connections,

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/services/document.py

@@ -40,10 +40,12 @@ from context_aware_translation.application.contracts.document import (
     RunTranslateAndExportRequest,
     SaveOCRPageRequest,
     SaveTranslationRequest,
+    SaveTranslationsRequest,
     TranslateAndExportState,
     TranslationUnitActionState,
     TranslationUnitKind,
     TranslationUnitState,
+    TranslationUnitUpdate,
 )
 from context_aware_translation.application.contracts.terms import TermsTableState
 from context_aware_translation.application.errors import (
@@ -133,6 +135,8 @@ class DocumentService(Protocol):
 
     def save_translation(self, request: SaveTranslationRequest) -> DocumentTranslationState: ...
 
+    def save_translations(self, request: SaveTranslationsRequest) -> DocumentTranslationState: ...
+
     def retranslate(self, request: RetranslateRequest) -> AcceptedCommand: ...
 
     def run_translation(self, request: RunDocumentTranslationRequest) -> AcceptedCommand: ...
@@ -412,57 +416,76 @@ class DefaultDocumentService:
         )
 
     def save_translation(self, request: SaveTranslationRequest) -> DocumentTranslationState:
+        return self.save_translations(
+            SaveTranslationsRequest(
+                project_id=request.project_id,
+                document_id=request.document_id,
+                updates=[
+                    TranslationUnitUpdate(
+                        unit_id=request.unit_id,
+                        translated_text=request.translated_text,
+                    )
+                ],
+            )
+        )
+
+    def save_translations(self, request: SaveTranslationsRequest) -> DocumentTranslationState:
         with self._runtime.open_book_db(request.project_id) as dbx:
             doc = dbx.document_repo.get_document_by_id(request.document_id)
             if doc is None:
                 raise_application_error(ApplicationErrorCode.NOT_FOUND, f"Document not found: {request.document_id}")
             blocker = self._translation_save_blocker(request.project_id, request.document_id)
             if blocker is not None:
-                self._raise_blocked_blocker(blocker, document_id=request.document_id, unit_id=request.unit_id)
+                if len(request.updates) == 1:
+                    self._raise_blocked_blocker(
+                        blocker,
+                        document_id=request.document_id,
+                        unit_id=request.updates[0].unit_id,
+                    )
+                self._raise_blocked_blocker(blocker, document_id=request.document_id)
 
             document_type = str(doc.get("document_type") or "")
-            if document_type == "manga":
-                chunk = self._resolve_manga_chunk_for_source(
-                    dbx=dbx,
-                    document_id=request.document_id,
-                    source_id=int(request.unit_id),
-                )
-                if chunk is None:
-                    raise_blocked_or_not_found_for_manga_unit(
-                        project_id=request.project_id,
+            updated_chunks: list[Any] = []
+            for update in request.updates:
+                if document_type == "manga":
+                    chunk = self._resolve_manga_chunk_for_source(
+                        dbx=dbx,
                         document_id=request.document_id,
-                        source_id=int(request.unit_id),
+                        source_id=int(update.unit_id),
                     )
-                updated_chunk = replace(
-                    chunk,
-                    is_translated=bool(request.translated_text.strip()),
-                    translation=request.translated_text if request.translated_text.strip() else None,
-                )
-            else:
-                chunk = dbx.db.get_chunk_by_id(int(request.unit_id))
-                if chunk is None or chunk.document_id is None or chunk.document_id != request.document_id:
-                    raise_application_error(
-                        ApplicationErrorCode.NOT_FOUND,
-                        f"Translation unit not found: {request.unit_id}",
-                    )
-                source_line_count = self._line_count(chunk.text)
-                translated_line_count = self._line_count(request.translated_text)
-                if source_line_count > 0 and translated_line_count != source_line_count:
-                    raise_application_error(
-                        ApplicationErrorCode.VALIDATION,
-                        (
-                            f"Cannot save translation with {translated_line_count} lines; "
-                            f"expected {source_line_count} lines."
-                        ),
-                        document_id=request.document_id,
-                        unit_id=request.unit_id,
+                    if chunk is None:
+                        raise_blocked_or_not_found_for_manga_unit(
+                            project_id=request.project_id,
+                            document_id=request.document_id,
+                            source_id=int(update.unit_id),
+                        )
+                else:
+                    chunk = dbx.db.get_chunk_by_id(int(update.unit_id))
+                    if chunk is None or chunk.document_id is None or chunk.document_id != request.document_id:
+                        raise_application_error(
+                            ApplicationErrorCode.NOT_FOUND,
+                            f"Translation unit not found: {update.unit_id}",
+                        )
+                    source_line_count = self._line_count(chunk.text)
+                    translated_line_count = self._line_count(update.translated_text)
+                    if source_line_count > 0 and translated_line_count != source_line_count:
+                        raise_application_error(
+                            ApplicationErrorCode.VALIDATION,
+                            (
+                                f"Cannot save translation with {translated_line_count} lines; "
+                                f"expected {source_line_count} lines."
+                            ),
+                            document_id=request.document_id,
+                            unit_id=update.unit_id,
+                        )
+                updated_chunks.append(
+                    replace(
+                        chunk,
+                        is_translated=bool(update.translated_text.strip()),
+                        translation=update.translated_text if update.translated_text.strip() else None,
                     )
-                updated_chunk = replace(
-                    chunk,
-                    is_translated=bool(request.translated_text.strip()),
-                    translation=request.translated_text if request.translated_text.strip() else None,
                 )
-            dbx.db.upsert_chunks([updated_chunk])
+            dbx.db.upsert_chunks(updated_chunks)
         self._runtime.invalidate_document(
             request.project_id,
             request.document_id,
@@ -662,6 +685,7 @@ class DefaultDocumentService:
             available_formats=prepared.available_formats,
             default_output_path=prepared.default_output_path,
             supports_preserve_structure=prepared.supports_preserve_structure,
+            requires_preserve_structure=prepared.requires_preserve_structure,
             supports_original_image_export=prepared.supports_original_image_export,
             supports_epub_layout_conversion=prepared.supports_epub_layout_conversion,
             incomplete_translation_message=prepared.incomplete_translation_message,
@@ -726,6 +750,7 @@ class DefaultDocumentService:
             default_output_path=prepared.default_output_path,
             blocker=start_blocker,
             supports_preserve_structure=prepared.supports_preserve_structure,
+            requires_preserve_structure=prepared.requires_preserve_structure,
             supports_original_image_export=prepared.supports_original_image_export,
             supports_epub_layout_conversion=prepared.supports_epub_layout_conversion,
             batch_available=batch_blocker is None,

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/services/projects.py

@@ -16,11 +16,11 @@ from context_aware_translation.application.runtime import (
     build_project_summary,
     raise_application_error,
 )
-from context_aware_translation.storage.models.book import BookStatus
-from context_aware_translation.ui.constants import (
+from context_aware_translation.languages import (
     display_target_language_name,
     storage_target_language_name,
 )
+from context_aware_translation.storage.models.book import BookStatus
 
 
 class ProjectsService(Protocol):
@@ -75,6 +75,11 @@ class DefaultProjectsService:
                 )
 
         requested_target_language = storage_target_language_name(request.target_language)
+        if request.target_language is not None and requested_target_language is None:
+            raise_application_error(
+                ApplicationErrorCode.VALIDATION,
+                "Target language must be one of the supported language presets.",
+            )
         profile_for_defaults = requested_profile or self._runtime.get_default_profile()
         default_target_language = None
         if profile_for_defaults is not None:
@@ -127,11 +132,15 @@ class DefaultProjectsService:
             if updated is None:
                 raise_application_error(ApplicationErrorCode.NOT_FOUND, f"Project not found: {request.project_id}")
         if request.target_language is not None:
+            target_language = storage_target_language_name(request.target_language)
+            if target_language is None:
+                raise_application_error(
+                    ApplicationErrorCode.VALIDATION,
+                    "Target language must be one of the supported language presets.",
+                )
             book = self._runtime.get_book(request.project_id)
             config = self._runtime.get_effective_config_payload(request.project_id)
-            config["translation_target_language"] = (
-                storage_target_language_name(request.target_language) or request.target_language
-            )
+            config["translation_target_language"] = target_language
             if book.profile_id is not None:
                 config["_ui_source_profile_id"] = book.profile_id
             self._runtime.book_manager.set_book_custom_config(request.project_id, config)

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/application/services/work.py

@@ -208,7 +208,15 @@ class DefaultWorkService:
             elif total_chunks > 0 and translated_chunks == total_chunks:
                 status = SurfaceStatus.DONE
                 summary = "Ready to export"
-                action = DocumentRowAction(kind=DocumentRowActionKind.EXPORT, label="Export")
+                action = DocumentRowAction(
+                    kind=DocumentRowActionKind.EXPORT,
+                    label="Export",
+                    target=NavigationTarget(
+                        kind=NavigationTargetKind.DOCUMENT_EXPORT,
+                        project_id=project_id,
+                        document_id=document_id,
+                    ),
+                )
                 frontier_last_ready = ref
             else:
                 status = SurfaceStatus.READY

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/cli/config_file.py

@@ -12,6 +12,7 @@ from context_aware_translation.app_identity import default_user_config_dir
 from context_aware_translation.application.contracts.app_setup import ConnectionDraft, WorkflowProfileDetail
 from context_aware_translation.application.runtime import build_workflow_profile_payload
 from context_aware_translation.config import EndpointProfile, ensure_valid_persisted_config_payload
+from context_aware_translation.languages import storage_target_language_name
 
 from .output import EXIT_USAGE, CliError
 
@@ -218,6 +219,13 @@ def load_cli_config(path: Path) -> ResolvedCliConfig:
         )
 
     profile = WorkflowProfileDetail.model_validate(profile_payload)
+    if storage_target_language_name(profile.target_language) is None:
+        raise CliError(
+            "invalid_config",
+            "target_language must be one of the supported language presets.",
+            exit_code=EXIT_USAGE,
+            details={"target_language": profile.target_language},
+        )
     _validate_route_connections(profile, endpoint_profiles)
     custom_config = build_workflow_profile_payload(base_config=None, profile=profile)
     custom_config["endpoint_profiles"] = {

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/cli/main.py

@@ -4,6 +4,7 @@ import argparse
 from pathlib import Path
 from typing import Any, cast
 
+from context_aware_translation import configure_standard_streams
 from context_aware_translation.application.contracts.common import ContractModel
 from context_aware_translation.application.contracts.document import RunTranslateAndExportRequest
 from context_aware_translation.application.contracts.work import ImportDocumentsRequest, InspectImportPathsRequest
@@ -36,6 +37,7 @@ def main() -> None:
 
 
 def run(argv: list[str] | None = None) -> int:
+    configure_standard_streams()
     parser = build_parser()
     args = parser.parse_args(argv)
     command = command_name(args)

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/config.py

@@ -10,6 +10,10 @@ from typing import TYPE_CHECKING, Any, Protocol, TypeVar
 import yaml
 
 from context_aware_translation import configure_logging
+from context_aware_translation.languages import (
+    require_storage_target_language_name,
+    storage_target_language_name,
+)
 from context_aware_translation.llm.image_generator import ImageBackend
 
 if TYPE_CHECKING:
@@ -980,6 +984,7 @@ class Config:
         )
 
     def __post_init__(self) -> None:
+        self.translation_target_language = require_storage_target_language_name(self.translation_target_language)
         self.output_dir = Path(self.output_dir)
         if self.working_dir is None:
             self.working_dir = self.output_dir / DEFAULT_WORKING_SUBDIR
@@ -1148,6 +1153,8 @@ def validate_persisted_config_payload(
     target_language = config.get("translation_target_language")
     if not isinstance(target_language, str) or target_language.strip() == "":
         errors.append("translation_target_language is required")
+    elif storage_target_language_name(target_language) is None:
+        errors.append("translation_target_language must be one of the supported language presets")
 
     endpoint_profiles = config.get("endpoint_profiles", {})
     if endpoint_profiles is None:

{contextweave-0.3.1 → contextweave-2.7.0}/context_aware_translation/core/context_manager.py

@@ -321,6 +321,19 @@ class ContextManager:
 
         return " ".join(value for index, (_key, value) in enumerate(entries) if index in selected_indexes).strip()
 
+    def _latest_raw_description(self, descriptions: dict[str, str], *, query_index: int) -> str:
+        """Return one causal description for a lightweight translation prompt."""
+        entries = self._ordered_description_entries(descriptions, query_index=query_index)
+        numeric_values = [value for key, value in entries if (idx := description_index(key)) is not None and idx >= 0]
+        if numeric_values:
+            description = numeric_values[-1]
+        else:
+            description = next(
+                (value for key, value in entries if description_index(key) == -1),
+                "",
+            )
+        return self._truncate_description(description, self.max_term_description_length)
+
     @staticmethod
     def _term_requires_term_memory(term: Term) -> bool:
         return term.term_type in {"character", "organization"}
@@ -572,7 +585,7 @@ class ContextManager:
     def get_term_description_for_query(self, term: Term, query_index: int) -> str:
         """Return the term description text used for chunk translation prompts."""
         if not self._term_requires_term_memory(term):
-            return self._compact_raw_description(term.descriptions, query_index=query_index)
+            return self._latest_raw_description(term.descriptions, query_index=query_index)
         description = self._best_available_summary(
             term,
             query_index,