lokit-python 0.1.0__cp312-cp312-win32.whl

lokit/data/structure.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Optional
+
+from lokit.data.tag_types import TieData
+
+
+class TranslationStatus(StrEnum):
+    NEW = "new"
+    DRAFT = "draft"
+    TRANSLATED = "translated"
+    REVIEWED = "reviewed"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+    UNKNOWN = "unknown"
+
+
+class PluralCategory(StrEnum):
+    GENERIC = "generic"
+    ZERO = "zero"
+    ONE = "one"
+    TWO = "two"
+    FEW = "few"
+    MANY = "many"
+    OTHER = "other"
+
+
+@dataclass(slots=True)
+class Plural:
+    variant: str
+    count: Optional[int] = None
+    category: Optional[PluralCategory] = None
+    extensions: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class Meta:
+    usage_count: Optional[int] = None
+    last_used: Optional[str] = None
+    first_used: Optional[str] = None
+    created: Optional[str] = None
+    updated: Optional[str] = None
+    max_length: Optional[int] = None
+    min_length: Optional[int] = None
+    extensions: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class Origin:
+    system: Optional[str] = None
+    project: Optional[str] = None
+    creator_id: Optional[str] = None
+    extensions: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class Comment:
+    context: str
+    timestamp: Optional[str] = None
+    origin: Optional[Origin] = None
+    context_key: Optional[str] = None
+    extensions: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class TextPart:
+    value: str
+
+
+@dataclass(slots=True)
+class CodePart:
+    ref: str
+
+
+SegmentPart = TextPart | CodePart
+
+
+@dataclass(slots=True)
+class Tags:
+    source_tag_map: dict[str, TieData] = field(default_factory=dict)
+    target_tag_map: dict[str, TieData] = field(default_factory=dict)
+    source_parts: list[SegmentPart] = field(default_factory=list)
+    target_parts: list[SegmentPart] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class AdjacentContext:
+    unit_id: Optional[str] = None
+    source: Optional[str] = None
+    target: Optional[str] = None
+    extensions: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class Data:
+    source: str
+    target: Optional[str] = None
+    plural: Optional[Plural] = None
+    tags: Optional[Tags] = None
+    meta: Meta = field(default_factory=Meta)
+    status: TranslationStatus = TranslationStatus.UNKNOWN
+    comments: list[Comment] = field(default_factory=list)
+    previous_context: Optional[AdjacentContext] = None
+    next_context: Optional[AdjacentContext] = None
+    extensions: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class BaseStructure:
+    source_locale: str
+    target_locale: Optional[str]
+    data: dict[str, Data]
+    format_version: str = "0.1"
+    export_origin: str = ""
+    export_timestamp: str = ""
+    source_language: Optional[str] = None
+    target_language: Optional[str] = None
+    extensions: dict[str, str] = field(default_factory=dict)

lokit/data/tag_types.py

@@ -0,0 +1,78 @@
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Optional
+
+
+class TieType(StrEnum):
+    A_OPEN = "a.open"
+    A_CLOSE = "a.close"
+    ABBR_OPEN = "abbr.open"
+    ABBR_CLOSE = "abbr.close"
+    B_OPEN = "b.open"
+    B_CLOSE = "b.close"
+    BDI_OPEN = "bdi.open"
+    BDI_CLOSE = "bdi.close"
+    BDO_OPEN = "bdo.open"
+    BDO_CLOSE = "bdo.close"
+    BR = "br.standalone"
+    CITE_OPEN = "cite.open"
+    CITE_CLOSE = "cite.close"
+    CODE_OPEN = "code.open"
+    CODE_CLOSE = "code.close"
+    DATA_OPEN = "data.open"
+    DATA_CLOSE = "data.close"
+    DFN_OPEN = "dfn.open"
+    DFN_CLOSE = "dfn.close"
+    EM_OPEN = "em.open"
+    EM_CLOSE = "em.close"
+    I_OPEN = "i.open"
+    I_CLOSE = "i.close"
+    IMG = "img.standalone"
+    KBD_OPEN = "kbd.open"
+    KBD_CLOSE = "kbd.close"
+    MARK_OPEN = "mark.open"
+    MARK_CLOSE = "mark.close"
+    Q_OPEN = "q.open"
+    Q_CLOSE = "q.close"
+    RP_OPEN = "rp.open"
+    RP_CLOSE = "rp.close"
+    RT_OPEN = "rt.open"
+    RT_CLOSE = "rt.close"
+    RUBY_OPEN = "ruby.open"
+    RUBY_CLOSE = "ruby.close"
+    S_OPEN = "s.open"
+    S_CLOSE = "s.close"
+    SAMP_OPEN = "samp.open"
+    SAMP_CLOSE = "samp.close"
+    SMALL_OPEN = "small.open"
+    SMALL_CLOSE = "small.close"
+    SPAN_OPEN = "span.open"
+    SPAN_CLOSE = "span.close"
+    STRONG_OPEN = "strong.open"
+    STRONG_CLOSE = "strong.close"
+    SUB_OPEN = "sub.open"
+    SUB_CLOSE = "sub.close"
+    SUP_OPEN = "sup.open"
+    SUP_CLOSE = "sup.close"
+    TIME_OPEN = "time.open"
+    TIME_CLOSE = "time.close"
+    U_OPEN = "u.open"
+    U_CLOSE = "u.close"
+    VAR_OPEN = "var.open"
+    VAR_CLOSE = "var.close"
+    WBR = "wbr.standalone"
+    CUSTOM_OPEN = "custom.open"
+    CUSTOM_CLOSE = "custom.close"
+    CUSTOM_STANDALONE = "custom.standalone"
+
+
+@dataclass(slots=True)
+class TieData:
+    id: str
+    type: TieType
+    attributes: dict[str, str] = field(default_factory=dict)
+    attribute_data: str = ""
+    position: int = 0
+    order: int = 0
+    pair_id: Optional[str] = None
+    original_name: Optional[str] = None

lokit/exporters/__init__.py

@@ -0,0 +1,34 @@
+from lokit.exporters.csv import export_csv, export_csv_async
+from lokit.exporters.html import export_html, export_html_async
+from lokit.exporters.idml import export_idml, export_idml_async
+from lokit.exporters.json_i18n import export_json_i18n, export_json_i18n_async
+from lokit.exporters.po import export_po, export_po_async
+from lokit.exporters.tmx import export_tmx, export_tmx_from_json
+from lokit.exporters.xliff import (
+    export_xliff,
+    export_xliff_async,
+    export_xliff_from_json,
+    export_xliff_from_json_async,
+)
+from lokit.exporters.xlsx import export_xlsx, export_xlsx_async
+
+__all__ = [
+    "export_csv",
+    "export_csv_async",
+    "export_html",
+    "export_html_async",
+    "export_idml",
+    "export_idml_async",
+    "export_json_i18n",
+    "export_json_i18n_async",
+    "export_po",
+    "export_po_async",
+    "export_tmx",
+    "export_tmx_from_json",
+    "export_xliff",
+    "export_xliff_async",
+    "export_xliff_from_json",
+    "export_xliff_from_json_async",
+    "export_xlsx",
+    "export_xlsx_async",
+]

lokit/exporters/csv.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import asyncio
+import csv
+from pathlib import Path
+
+from lokit.data.structure import BaseStructure, TranslationStatus
+
+
+def export_csv(document: BaseStructure, filepath: str | Path) -> None:
+    path = Path(filepath)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    with path.open("w", newline="", encoding="utf-8") as fh:
+        writer = csv.DictWriter(fh, fieldnames=["id", "source", "target", "status", "comment"])
+        writer.writeheader()
+
+        for unit_id, unit in document.data.items():
+            comment = "; ".join(c.context for c in unit.comments if c.context)
+            status = unit.status.value if unit.status != TranslationStatus.UNKNOWN else ""
+
+            writer.writerow({
+                "id": unit_id,
+                "source": unit.source,
+                "target": unit.target or "",
+                "status": status,
+                "comment": comment,
+            })
+
+
+async def export_csv_async(document: BaseStructure, filepath: str | Path) -> None:
+    await asyncio.to_thread(export_csv, document, filepath)

lokit/exporters/html.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any, cast
+
+from lxml import html as lxml_html
+from lxml.html import HtmlElement, tostring
+
+from lokit.data.structure import BaseStructure, CodePart, Data, TextPart
+from lokit.data.tag_types import TieData, TieType
+
+
+def export_html(
+    document: BaseStructure,
+    filepath: str | Path,
+    source_html: str | Path | None = None,
+) -> None:
+    path = Path(filepath)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if source_html is not None:
+        _export_from_source(document, path, Path(source_html))
+    else:
+        _export_minimal(document, path)
+
+
+async def export_html_async(
+    document: BaseStructure,
+    filepath: str | Path,
+    source_html: str | Path | None = None,
+) -> None:
+    await asyncio.to_thread(export_html, document, filepath, source_html)
+
+
+def _export_from_source(
+    document: BaseStructure, output: Path, source: Path
+) -> None:
+    doc = lxml_html.parse(str(source))
+    root = doc.getroot()
+    if root is None:
+        _export_minimal(document, output)
+        return
+
+    if document.target_locale:
+        root.set("lang", document.target_locale)
+
+    unit_lookup = _build_unit_lookup(document)
+    index = 0
+
+    head = root.find(".//head")
+    if head is not None:
+        for meta_el in head.iterfind(".//meta"):
+            name = (meta_el.get("name") or "").lower()
+            if name in ("description", "keywords"):
+                key = f"html:meta.{name}:{index}"
+                unit = unit_lookup.get(key)
+                if unit is not None and unit.target:
+                    meta_el.set("content", unit.target)
+                index += 1
+
+    block_tags = {
+        "p", "h1", "h2", "h3", "h4", "h5", "h6",
+        "li", "td", "th", "dt", "dd", "caption",
+        "figcaption", "blockquote", "label", "option", "title",
+    }
+
+    for el in list(root.iter()):
+        tag = el.tag if isinstance(el.tag, str) else ""
+        tag_lower = tag.lower()
+
+        if tag_lower in block_tags:
+            key = f"html:{tag_lower}:{index}"
+            unit = unit_lookup.get(key)
+            if unit is not None and unit.target:
+                _replace_element_text(el, unit)
+            index += 1
+
+        if tag_lower == "img":
+            alt = el.get("alt")
+            if alt and alt.strip():
+                key = f"html:img.alt:{index}"
+                unit = unit_lookup.get(key)
+                if unit is not None and unit.target:
+                    el.set("alt", unit.target)
+                index += 1
+
+    result = tostring(root, encoding="unicode", doctype="<!DOCTYPE html>")
+    output.write_text(result, encoding="utf-8")
+
+
+def _export_minimal(document: BaseStructure, output: Path) -> None:
+    lang = document.target_locale or document.source_locale
+    lines: list[str] = [
+        "<!DOCTYPE html>",
+        f'<html lang="{_escape(lang)}">',
+        "<head>",
+        '<meta charset="utf-8">',
+    ]
+
+    for unit_id, unit in document.data.items():
+        if "meta." in unit_id:
+            name = unit.extensions.get("meta_name", "")
+            text = unit.target or unit.source
+            lines.append(f'<meta name="{_escape(name)}" content="{_escape(text)}">')
+
+    lines.append("</head>")
+    lines.append("<body>")
+
+    for unit_id, unit in document.data.items():
+        if "meta." in unit_id or "img.alt" in unit_id:
+            continue
+        text = unit.target or unit.source
+        tag = _extract_tag_from_id(unit_id)
+        if unit.tags and unit.tags.source_parts:
+            content = _rebuild_inline(unit, is_target=unit.target is not None)
+            lines.append(f"<{tag}>{content}</{tag}>")
+        else:
+            lines.append(f"<{tag}>{_escape(text)}</{tag}>")
+
+    lines.append("</body>")
+    lines.append("</html>")
+    output.write_text("\n".join(lines), encoding="utf-8")
+
+
+def _replace_element_text(element: HtmlElement, unit: Data) -> None:
+    if unit.tags and unit.tags.source_parts:
+        content = _rebuild_inline(unit, is_target=True)
+        for child in list(element):
+            element.remove(child)
+        element.text = None
+        fragment: list[Any] = cast("list[Any]", lxml_html.fragments_fromstring(content))
+        if isinstance(fragment[0], str):
+            element.text = fragment[0]
+            children = fragment[1:]
+        else:
+            children = fragment
+        for child in children:
+            if isinstance(child, HtmlElement):
+                element.append(child)
+            elif isinstance(child, str):
+                if len(element):
+                    last = element[-1]
+                    last.tail = (last.tail or "") + child
+                else:
+                    element.text = (element.text or "") + child
+    else:
+        for child in list(element):
+            element.remove(child)
+        element.text = unit.target
+
+
+def _rebuild_inline(unit: Data, is_target: bool) -> str:
+    if is_target and unit.tags and unit.tags.target_parts:
+        parts = unit.tags.target_parts
+        tag_map = unit.tags.target_tag_map
+    elif unit.tags:
+        parts = unit.tags.source_parts
+        tag_map = unit.tags.source_tag_map
+    else:
+        return _escape(unit.target or unit.source)
+
+    result: list[str] = []
+    for part in parts:
+        if isinstance(part, TextPart):
+            result.append(_escape(part.value))
+        elif isinstance(part, CodePart):
+            tie = tag_map.get(part.ref)
+            if tie is None:
+                continue
+            result.append(_tie_to_html(tie))
+    return "".join(result)
+
+
+def _tie_to_html(tie: TieData) -> str:
+    name = tie.original_name or ""
+    if tie.type.value.endswith(".open"):
+        attrs = _format_attrs(tie.attributes)
+        return f"<{name}{attrs}>"
+    if tie.type.value.endswith(".close"):
+        return f"</{name}>"
+    if tie.type == TieType.BR:
+        return "<br>"
+    if tie.type == TieType.WBR:
+        return "<wbr>"
+    if tie.type == TieType.IMG:
+        attrs = _format_attrs(tie.attributes)
+        return f"<img{attrs}>"
+    attrs = _format_attrs(tie.attributes)
+    return f"<{name}{attrs}/>"
+
+
+def _format_attrs(attributes: dict[str, str]) -> str:
+    if not attributes:
+        return ""
+    parts = [f' {k}="{_escape(v)}"' for k, v in attributes.items()]
+    return "".join(parts)
+
+
+def _build_unit_lookup(document: BaseStructure) -> dict[str, Data]:
+    return dict(document.data)
+
+
+def _extract_tag_from_id(unit_id: str) -> str:
+    parts = unit_id.split(":")
+    if len(parts) >= 2:
+        return parts[1]
+    return "p"
+
+
+def _escape(text: str) -> str:
+    return (
+        text.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )

lokit/exporters/idml.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import asyncio
+import shutil
+import zipfile
+from pathlib import Path
+
+from lxml import etree
+from lxml.etree import _Element
+
+from lokit.data.structure import BaseStructure, CodePart, Data, TextPart
+
+
+def export_idml(
+    document: BaseStructure,
+    filepath: str | Path,
+    source_idml: str | Path,
+) -> None:
+    output_path = Path(filepath)
+    source_path = Path(source_idml)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    story_units = _group_by_story(document)
+    shutil.copy2(str(source_path), str(output_path))
+
+    with zipfile.ZipFile(str(output_path), "a") as zf_out:
+        with zipfile.ZipFile(str(source_path), "r") as zf_in:
+            story_files = [
+                name for name in zf_in.namelist()
+                if name.startswith("Stories/Story_") and name.endswith(".xml")
+            ]
+            for story_file in story_files:
+                units = story_units.get(story_file)
+                if not units:
+                    continue
+
+                with zf_in.open(story_file) as stream:
+                    tree = etree.parse(stream)
+                    root = tree.getroot()
+                    _apply_translations(root, units)
+                    modified_xml = etree.tostring(
+                        root, xml_declaration=True, encoding="UTF-8"
+                    )
+
+                _replace_in_zip(zf_out, story_file, modified_xml)
+
+
+async def export_idml_async(
+    document: BaseStructure,
+    filepath: str | Path,
+    source_idml: str | Path,
+) -> None:
+    await asyncio.to_thread(export_idml, document, filepath, source_idml)
+
+
+def _group_by_story(
+    document: BaseStructure,
+) -> dict[str, dict[str, Data]]:
+    groups: dict[str, dict[str, Data]] = {}
+    for unit_id, unit in document.data.items():
+        story = unit.extensions.get("story", "")
+        if story:
+            groups.setdefault(story, {})[unit_id] = unit
+    return groups
+
+
+def _apply_translations(root: _Element, units: dict[str, Data]) -> None:
+    paragraph_index = 0
+    story_name = _story_name_from_units(units)
+
+    for psr in root.iter():
+        if _local_name(psr.tag) != "ParagraphStyleRange":
+            continue
+
+        unit_id = f"{story_name}:p{paragraph_index}"
+        unit = units.get(unit_id)
+        if unit is not None and unit.target:
+            _replace_paragraph_text(psr, unit)
+        paragraph_index += 1
+
+
+def _replace_paragraph_text(psr: _Element, unit: Data) -> None:
+    char_ranges = [
+        el for el in psr
+        if _local_name(el.tag) == "CharacterStyleRange"
+    ]
+    if not char_ranges:
+        return
+
+    if unit.tags and unit.tags.target_parts:
+        _replace_with_tagged_parts(char_ranges, unit)
+    else:
+        target_text = unit.target or ""
+        _distribute_text(char_ranges, target_text)
+
+
+def _replace_with_tagged_parts(
+    char_ranges: list[_Element], unit: Data
+) -> None:
+    if unit.tags is None:
+        return
+
+    parts = unit.tags.target_parts
+    tag_map = unit.tags.target_tag_map
+
+    range_texts: dict[str, str] = {}
+    current_style: str | None = None
+    current_text_parts: list[str] = []
+
+    for part in parts:
+        if isinstance(part, TextPart):
+            current_text_parts.append(part.value)
+        elif isinstance(part, CodePart):
+            tie = tag_map.get(part.ref)
+            if tie is None:
+                continue
+            if tie.type.value.endswith(".open"):
+                style = tie.attributes.get("style", "")
+                if current_text_parts and current_style is not None:
+                    range_texts[current_style] = "".join(current_text_parts)
+                    current_text_parts = []
+                current_style = style
+            elif tie.type.value.endswith(".close"):
+                if current_style is not None:
+                    range_texts[current_style] = "".join(current_text_parts)
+                    current_text_parts = []
+                    current_style = None
+
+    plain_text = "".join(current_text_parts) if current_text_parts else None
+
+    for csr in char_ranges:
+        style = csr.get("AppliedCharacterStyle") or ""
+        if style in range_texts:
+            _set_content_text(csr, range_texts[style])
+        elif plain_text is not None and (
+            not style or style == "CharacterStyle/$ID/[No character style]"
+        ):
+            _set_content_text(csr, plain_text)
+            plain_text = None
+        else:
+            _set_content_text(csr, "")
+
+
+def _distribute_text(char_ranges: list[_Element], text: str) -> None:
+    if len(char_ranges) == 1:
+        _set_content_text(char_ranges[0], text)
+        return
+
+    first = char_ranges[0]
+    _set_content_text(first, text)
+    for csr in char_ranges[1:]:
+        _set_content_text(csr, "")
+
+
+def _set_content_text(csr: _Element, text: str) -> None:
+    for child in csr.iter():
+        if _local_name(child.tag) == "Content":
+            child.text = text
+            text = ""
+
+
+def _replace_in_zip(zf: zipfile.ZipFile, name: str, data: bytes) -> None:
+    zf.writestr(name, data)
+
+
+def _story_name_from_units(units: dict[str, Data]) -> str:
+    for unit_id in units:
+        parts = unit_id.split(":")
+        if parts:
+            return parts[0]
+    return ""
+
+
+def _local_name(tag: str | bytes) -> str:
+    name = tag if isinstance(tag, str) else tag.decode("utf-8")
+    if "}" in name:
+        return name.split("}", 1)[1]
+    return name