auto-i18n-lib 0.1.0__tar.gz

auto_i18n_lib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BONA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

auto_i18n_lib-0.1.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: auto-i18n-lib
+Version: 0.1.0
+Summary: Dynamic HTML translation with OpenAI
+Author-email: Your Name <you@example.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# autoi18n
+
+Runtime HTML i18n with OpenAI: translate the page on first request, cache results to JSON, reuse on subsequent requests, and auto-sync when the source changes.
+
+**PyPI name:** `autoi18n` | **Import:** `autoi18n`
+
+---
+
+## Features
+
+- 🔁 On-the-fly translation of raw HTML strings  
+- 🗂️ JSON cache per target language (on disk)  
+- 🔄 Auto-sync: stale entries removed when source changes  
+- 🧩 Chunking for model context limits (long pages split safely)  
+- 🛡️ Preserves `<script>`/`<style>` as-is  
+- 🎛️ Concise UI translation (e.g., buttons)  
+- 🌐 Helpers: detect browser lang, pick alternate lang
+
+---
+
+## Installation
+
+```bash
+    pip install autoi18n
+```
+## Quick start
+``` 
+from autoi18n import Translator
+
+html_in = "<h1>Добро пожаловать</h1><p>Это тест.</p>"
+tr = Translator(
+    source_lang="ru",
+    cache_dir="./translations",   # JSON cache folder
+    # api_key="sk-..."            # or use OPENAI_API_KEY env var
+)
+
+html_out = tr.translate_html(html_in, target_lang="en", page_name="page")
+print(html_out)
+First call translates via OpenAI and writes ./translations/page.en.json.
+Next calls reuse the cache and only translate new/changed strings.
+```
+## Environment
+``` 
+OPENAI_API_KEY — used if api_key not passed to Translator.
+```
+## API
+
+``` 
+Translator(source_lang="ru", cache_dir="./translations", api_key=None)
+translate_html(html: str, target_lang: str, page_name: str = "page") -> str
+```
+
+## Translates visible text nodes, preserves script/style, chunks long text, updates cache JSON.
+
+```
+translate_text(text: str, target_lang: str, page_name: str = "page") -> str
+```
+
+## Low-level single-string translation with caching.
+
+```
+
+detect_browser_lang(accept_language_header: str) -> str
+```
+
+## Parses Accept-Language → short code like ru, en, fr.
+
+```
+get_alternative_lang(current: str, browser_lang: str) -> str
+```
+
+## Returns alternate code for a language toggle.
+Cache layout
+
+translations/
+└─ page.en.json   # UTF-8 JSON: { "source": "translated", ... }
+Example:
+
+``` json (example)
+{
+  "Добро пожаловать": "Welcome",
+  "Выберите язык:": "Choose a language:"
+}
+```
+## Minimal FastAPI wiring (example) python
+```
+from fastapi import FastAPI, Request
+from autoi18n import Translator
+from pathlib import Path
+
+app = FastAPI()
+tr = Translator(source_lang="ru", cache_dir="./translations")
+HTML_PATH = Path("index.html")
+
+@app.get("/")
+def home():
+    return HTML_PATH.read_text(encoding="utf-8")
+
+@app.get("/detect_lang")
+def detect_lang(request: Request):
+    return {"lang": tr.detect_browser_lang(request.headers.get("accept-language", ""))}
+
+@app.get("/alt_lang")
+def alt_lang(request: Request, current: str = "ru"):
+    browser = tr.detect_browser_lang(request.headers.get("accept-language", ""))
+    return {"lang": tr.get_alternative_lang(current, browser)}
+
+@app.get("/translate")
+def translate(lang: str = "en"):
+    html = HTML_PATH.read_text(encoding="utf-8")
+    return tr.translate_html(html, target_lang=lang, page_name="page")
+```
+# Notes & limits
+You control OpenAI usage/billing.
+
+Chunking keeps requests within model limits; HTML structure preserved.
+
+Short labels (buttons) use a concise prompt to avoid verbose text.
+
+This package is for runtime translation with caching; static catalogs are out of scope.
+
+# Versioning
+Semantic Versioning: MAJOR.MINOR.PATCH.
+
+# License
+MIT © BONA
+
+# Support
+Issues & feature requests → GitHub Issues (see project URLs in metadata).
+

auto_i18n_lib-0.1.0/README.md

@@ -0,0 +1,130 @@
+# autoi18n
+
+Runtime HTML i18n with OpenAI: translate the page on first request, cache results to JSON, reuse on subsequent requests, and auto-sync when the source changes.
+
+**PyPI name:** `autoi18n` | **Import:** `autoi18n`
+
+---
+
+## Features
+
+- 🔁 On-the-fly translation of raw HTML strings  
+- 🗂️ JSON cache per target language (on disk)  
+- 🔄 Auto-sync: stale entries removed when source changes  
+- 🧩 Chunking for model context limits (long pages split safely)  
+- 🛡️ Preserves `<script>`/`<style>` as-is  
+- 🎛️ Concise UI translation (e.g., buttons)  
+- 🌐 Helpers: detect browser lang, pick alternate lang
+
+---
+
+## Installation
+
+```bash
+    pip install autoi18n
+```
+## Quick start
+``` 
+from autoi18n import Translator
+
+html_in = "<h1>Добро пожаловать</h1><p>Это тест.</p>"
+tr = Translator(
+    source_lang="ru",
+    cache_dir="./translations",   # JSON cache folder
+    # api_key="sk-..."            # or use OPENAI_API_KEY env var
+)
+
+html_out = tr.translate_html(html_in, target_lang="en", page_name="page")
+print(html_out)
+First call translates via OpenAI and writes ./translations/page.en.json.
+Next calls reuse the cache and only translate new/changed strings.
+```
+## Environment
+``` 
+OPENAI_API_KEY — used if api_key not passed to Translator.
+```
+## API
+
+``` 
+Translator(source_lang="ru", cache_dir="./translations", api_key=None)
+translate_html(html: str, target_lang: str, page_name: str = "page") -> str
+```
+
+## Translates visible text nodes, preserves script/style, chunks long text, updates cache JSON.
+
+```
+translate_text(text: str, target_lang: str, page_name: str = "page") -> str
+```
+
+## Low-level single-string translation with caching.
+
+```
+
+detect_browser_lang(accept_language_header: str) -> str
+```
+
+## Parses Accept-Language → short code like ru, en, fr.
+
+```
+get_alternative_lang(current: str, browser_lang: str) -> str
+```
+
+## Returns alternate code for a language toggle.
+Cache layout
+
+translations/
+└─ page.en.json   # UTF-8 JSON: { "source": "translated", ... }
+Example:
+
+``` json (example)
+{
+  "Добро пожаловать": "Welcome",
+  "Выберите язык:": "Choose a language:"
+}
+```
+## Minimal FastAPI wiring (example) python
+```
+from fastapi import FastAPI, Request
+from autoi18n import Translator
+from pathlib import Path
+
+app = FastAPI()
+tr = Translator(source_lang="ru", cache_dir="./translations")
+HTML_PATH = Path("index.html")
+
+@app.get("/")
+def home():
+    return HTML_PATH.read_text(encoding="utf-8")
+
+@app.get("/detect_lang")
+def detect_lang(request: Request):
+    return {"lang": tr.detect_browser_lang(request.headers.get("accept-language", ""))}
+
+@app.get("/alt_lang")
+def alt_lang(request: Request, current: str = "ru"):
+    browser = tr.detect_browser_lang(request.headers.get("accept-language", ""))
+    return {"lang": tr.get_alternative_lang(current, browser)}
+
+@app.get("/translate")
+def translate(lang: str = "en"):
+    html = HTML_PATH.read_text(encoding="utf-8")
+    return tr.translate_html(html, target_lang=lang, page_name="page")
+```
+# Notes & limits
+You control OpenAI usage/billing.
+
+Chunking keeps requests within model limits; HTML structure preserved.
+
+Short labels (buttons) use a concise prompt to avoid verbose text.
+
+This package is for runtime translation with caching; static catalogs are out of scope.
+
+# Versioning
+Semantic Versioning: MAJOR.MINOR.PATCH.
+
+# License
+MIT © BONA
+
+# Support
+Issues & feature requests → GitHub Issues (see project URLs in metadata).
+

auto_i18n_lib-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "auto-i18n-lib"
+version = "0.1.0"
+description = "Dynamic HTML translation with OpenAI"
+authors = [{name = "Your Name", email = "you@example.com"}]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.9"

auto_i18n_lib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

auto_i18n_lib-0.1.0/src/auto_i18n_lib.egg-info/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: auto-i18n-lib
+Version: 0.1.0
+Summary: Dynamic HTML translation with OpenAI
+Author-email: Your Name <you@example.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# autoi18n
+
+Runtime HTML i18n with OpenAI: translate the page on first request, cache results to JSON, reuse on subsequent requests, and auto-sync when the source changes.
+
+**PyPI name:** `autoi18n` | **Import:** `autoi18n`
+
+---
+
+## Features
+
+- 🔁 On-the-fly translation of raw HTML strings  
+- 🗂️ JSON cache per target language (on disk)  
+- 🔄 Auto-sync: stale entries removed when source changes  
+- 🧩 Chunking for model context limits (long pages split safely)  
+- 🛡️ Preserves `<script>`/`<style>` as-is  
+- 🎛️ Concise UI translation (e.g., buttons)  
+- 🌐 Helpers: detect browser lang, pick alternate lang
+
+---
+
+## Installation
+
+```bash
+    pip install autoi18n
+```
+## Quick start
+``` 
+from autoi18n import Translator
+
+html_in = "<h1>Добро пожаловать</h1><p>Это тест.</p>"
+tr = Translator(
+    source_lang="ru",
+    cache_dir="./translations",   # JSON cache folder
+    # api_key="sk-..."            # or use OPENAI_API_KEY env var
+)
+
+html_out = tr.translate_html(html_in, target_lang="en", page_name="page")
+print(html_out)
+First call translates via OpenAI and writes ./translations/page.en.json.
+Next calls reuse the cache and only translate new/changed strings.
+```
+## Environment
+``` 
+OPENAI_API_KEY — used if api_key not passed to Translator.
+```
+## API
+
+``` 
+Translator(source_lang="ru", cache_dir="./translations", api_key=None)
+translate_html(html: str, target_lang: str, page_name: str = "page") -> str
+```
+
+## Translates visible text nodes, preserves script/style, chunks long text, updates cache JSON.
+
+```
+translate_text(text: str, target_lang: str, page_name: str = "page") -> str
+```
+
+## Low-level single-string translation with caching.
+
+```
+
+detect_browser_lang(accept_language_header: str) -> str
+```
+
+## Parses Accept-Language → short code like ru, en, fr.
+
+```
+get_alternative_lang(current: str, browser_lang: str) -> str
+```
+
+## Returns alternate code for a language toggle.
+Cache layout
+
+translations/
+└─ page.en.json   # UTF-8 JSON: { "source": "translated", ... }
+Example:
+
+``` json (example)
+{
+  "Добро пожаловать": "Welcome",
+  "Выберите язык:": "Choose a language:"
+}
+```
+## Minimal FastAPI wiring (example) python
+```
+from fastapi import FastAPI, Request
+from autoi18n import Translator
+from pathlib import Path
+
+app = FastAPI()
+tr = Translator(source_lang="ru", cache_dir="./translations")
+HTML_PATH = Path("index.html")
+
+@app.get("/")
+def home():
+    return HTML_PATH.read_text(encoding="utf-8")
+
+@app.get("/detect_lang")
+def detect_lang(request: Request):
+    return {"lang": tr.detect_browser_lang(request.headers.get("accept-language", ""))}
+
+@app.get("/alt_lang")
+def alt_lang(request: Request, current: str = "ru"):
+    browser = tr.detect_browser_lang(request.headers.get("accept-language", ""))
+    return {"lang": tr.get_alternative_lang(current, browser)}
+
+@app.get("/translate")
+def translate(lang: str = "en"):
+    html = HTML_PATH.read_text(encoding="utf-8")
+    return tr.translate_html(html, target_lang=lang, page_name="page")
+```
+# Notes & limits
+You control OpenAI usage/billing.
+
+Chunking keeps requests within model limits; HTML structure preserved.
+
+Short labels (buttons) use a concise prompt to avoid verbose text.
+
+This package is for runtime translation with caching; static catalogs are out of scope.
+
+# Versioning
+Semantic Versioning: MAJOR.MINOR.PATCH.
+
+# License
+MIT © BONA
+
+# Support
+Issues & feature requests → GitHub Issues (see project URLs in metadata).
+

auto_i18n_lib-0.1.0/src/auto_i18n_lib.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/auto_i18n_lib.egg-info/PKG-INFO
+src/auto_i18n_lib.egg-info/SOURCES.txt
+src/auto_i18n_lib.egg-info/dependency_links.txt
+src/auto_i18n_lib.egg-info/top_level.txt
+src/autoi18n/__init__.py
+src/autoi18n/cache.py
+src/autoi18n/cli.py
+src/autoi18n/glossary.py
+src/autoi18n/translator.py
+src/autoi18n/utils.py

auto_i18n_lib-0.1.0/src/auto_i18n_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

auto_i18n_lib-0.1.0/src/auto_i18n_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+autoi18n

auto_i18n_lib-0.1.0/src/autoi18n/__init__.py

@@ -0,0 +1,2 @@
+# autoi18n package
+from .translator import Translator

auto_i18n_lib-0.1.0/src/autoi18n/translator.py

@@ -0,0 +1,206 @@
+import os
+import json
+from html.parser import HTMLParser
+from openai import OpenAI
+
+
+class SimpleHTMLTranslator(HTMLParser):
+    def __init__(self, translate_callback):
+        super().__init__()
+        self.result = []
+        self.translate_callback = translate_callback
+        self._current_tag = None
+        self._inside_skip = False
+
+    def handle_starttag(self, tag, attrs):
+        self._current_tag = tag
+        self._inside_skip = False
+
+        if tag in ("script", "style"):
+            self._inside_skip = True
+
+        # Кнопка langSwitch: пропускаем содержимое, но сам тег сохраняем
+        for attr, value in attrs:
+            if attr == "id" and value == "langSwitch":
+                self._inside_skip = True
+
+        self.result.append(self.get_starttag_text())
+
+    def handle_endtag(self, tag):
+        if tag in ("script", "style") and self._inside_skip:
+            self._inside_skip = False
+        if tag == "button" and self._inside_skip:
+            self._inside_skip = False
+        self.result.append(f"</{tag}>")
+
+    def handle_data(self, data):
+        if self._inside_skip:
+            # ⚡ Сохраняем содержимое <script> и <style> без изменений
+            self.result.append(data)
+        elif self._current_tag == "button":
+            # Переводим обычные кнопки
+            translated = self.translate_callback(data, prompt_type="button")
+            self.result.append(translated)
+        else:
+            # Переводим обычный текст
+            translated = self.translate_callback(data)
+            self.result.append(translated)
+
+    def get_html(self):
+        return "".join(self.result)
+
+
+
+
+class Translator:
+    def __init__(self, cache_dir="./translations", api_key=None):
+        # ⚡ Берём язык исходника из .env
+        self.source_lang = os.getenv("SOURCE_LANG", "ru")
+        self.cache_dir = cache_dir
+        self.client = OpenAI(api_key=api_key)
+        self._current_file = None
+        self._cache = {}
+
+    def _file_path(self, page_name: str, lang: str) -> str:
+        filename = f"{page_name}.{lang}.json"
+        return os.path.join(self.cache_dir, filename)
+
+    def _load_storage(self, page_name: str, lang: str):
+        path = self._file_path(page_name, lang)
+        if os.path.exists(path):
+            print(f"[CACHE] Загружаем переводы из {path}")
+            with open(path, "r", encoding="utf-8") as f:
+                self._cache = json.load(f)
+        else:
+            print(f"[CACHE] Файл {path} не найден — создаём новый")
+            self._cache = {}
+        self._current_file = path
+
+    def _save_storage(self):
+        if self._current_file:
+            # ⚡ Создаём папку только при сохранении
+            os.makedirs(self.cache_dir, exist_ok=True)
+            with open(self._current_file, "w", encoding="utf-8") as f:
+                json.dump(self._cache, f, ensure_ascii=False, indent=2)
+            print(f"[CACHE] Переводы сохранены в {self._current_file}")
+
+    def translate_text(self, text: str, target_lang: str, page_name="page", prompt_type="normal") -> str:
+        text = text.strip()
+        if not text:
+            return text
+
+        if target_lang == self.source_lang:
+            return text
+
+        if not self._current_file:
+            self._load_storage(page_name, target_lang)
+
+        if text in self._cache:
+            return self._cache[text]
+
+        # ⚡ Разные подсказки для кнопок и для обычного текста
+        if prompt_type == "button":
+            prompt = f"Translate this button label briefly from {self.source_lang} to {target_lang}:\n\n{text}"
+        else:
+            prompt = f"Translate this text from {self.source_lang} to {target_lang}:\n\n{text}"
+
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+        )
+        translated = response.choices[0].message.content.strip()
+
+        self._cache[text] = translated
+        self._save_storage()
+
+        return translated
+
+    def translate_html(self, html: str, target_lang: str, page_name="page") -> str:
+        # ⚡ Если язык совпадает с исходным — возвращаем как есть
+        if target_lang == self.source_lang:
+            print(f"[SKIP] {self.source_lang} → {target_lang}: язык совпадает, возвращаем исходную страницу")
+            return html
+
+        # Загружаем кэш
+        self._load_storage(page_name, target_lang)
+
+        current_texts = []  # все тексты из текущей HTML-страницы
+
+        def translate_with_chunks(text: str, prompt_type: str = "normal") -> str:
+            text = text.strip()
+            if not text:
+                return text
+
+            current_texts.append(text)
+
+            # Проверяем кэш
+            if text in self._cache:
+                print(f"[CACHE-HIT] {self.source_lang} → {target_lang}: «{text[:40]}...»")
+                return self._cache[text]
+
+            # Если текст длинный — режем
+            if len(text) > 2000:
+                print(f"[SPLIT] Текст длинный ({len(text)} символов), режем на чанки")
+                step = 1500
+                chunks = [text[i:i + step] for i in range(0, len(text), step)]
+            else:
+                chunks = [text]
+
+            translated_parts = []
+            for chunk in chunks:
+                if prompt_type == "button":
+                    prompt = f"Translate this button label to {target_lang}. Keep it short, return only the translated label:\n\n{chunk}"
+                else:
+                    prompt = f"Translate to {target_lang}. Return only the translated text, no explanations:\n\n{chunk}"
+
+                print(f"[OPENAI] {self.source_lang} → {target_lang}: «{chunk[:40]}...»")
+                response = self.client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[{"role": "user", "content": prompt}],
+                )
+                translated_parts.append(response.choices[0].message.content.strip())
+
+            translated_text = " ".join(translated_parts)
+
+            self._cache[text] = translated_text
+            self._save_storage()
+            print(f"[OPENAI-RESULT] «{translated_text[:60]}...»")
+
+            return translated_text
+
+        # Парсим HTML
+        parser = SimpleHTMLTranslator(
+            translate_callback=translate_with_chunks
+        )
+        parser.feed(html)
+
+        # ⚡ Синхронизация — удаляем устаревшие строки
+        removed = []
+        for old_key in list(self._cache.keys()):
+            if old_key not in current_texts:
+                removed.append(old_key)
+                self._cache.pop(old_key)
+
+        if removed:
+            print(f"[SYNC] Удалены устаревшие строки: {len(removed)}")
+            self._save_storage()
+
+        return parser.get_html()
+
+    def _collect_and_translate(self, text, target_lang, page_name, current_texts):
+        text = text.strip()
+        if text:
+            current_texts.append(text)
+        return self.translate_text(text, target_lang, page_name)
+
+    def detect_browser_lang(self, accept_language: str) -> str:
+        """Определяем язык браузера из заголовка Accept-Language"""
+        if not accept_language:
+            return self.source_lang
+        return accept_language.split(",")[0].split("-")[0]
+
+    def get_alternative_lang(self, current_lang: str, browser_lang: str) -> str:
+        """Определяем какой язык должен быть на кнопке"""
+        if current_lang == browser_lang:
+            return "en"  # если мы на языке браузера → кнопка EN
+        return browser_lang  # если мы на EN → кнопка = язык браузера