strx-precommit 0.1.1__tar.gz

strx_precommit-0.1.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: strx-precommit
+Version: 0.1.1
+Summary: Pre-commit hooks para conversión de strings y traducción de archivos PO
+Home-page: https://github.com/straconxsa/strx_tools/
+Author: Tu Nombre
+Author-email: Initium Team <info@straconx.com>
+Project-URL: Homepage, https://github.com/straconxsa/strx_tools/
+Project-URL: Bug Tracker, https://github.com/straconxsa/strx_tools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python

strx_precommit-0.1.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "strx-precommit"
+version = "0.1.1"
+description = "Pre-commit hooks para conversión de strings y traducción de archivos PO"
+readme = "README.md"
+requires-python = ">=3.6"
+authors = [
+    { name = "Initium Team", email = "info@straconx.com" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/straconxsa/strx_tools/"
+"Bug Tracker" = "https://github.com/straconxsa/strx_tools/issues"
+
+[tool.black]
+line-length = 88
+target-version = ["py36", "py37", "py38", "py39"]
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+
+[tool.mypy]
+python_version = "3.6"
+warn_return_any = true
+warn_unused_configs = true
+mypy_path = "src"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests",
+]

strx_precommit-0.1.1/setup.cfg

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

strx_precommit-0.1.1/setup.py

@@ -0,0 +1,49 @@
+# Estructura de directorios:
+# strx_precommit/
+# ├── src/
+# │   └── strx_precommit/
+# │       ├── __init__.py
+# │       ├── strx_convert_string.py
+# │       └── strx_translate_po.py
+# ├── setup.py
+# ├── pyproject.toml
+# └── README.md
+
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name="strx-precommit",
+    version="0.1.1",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    entry_points={
+        "console_scripts": [
+            "strx-precommit=strx_precommit.strx_convert_string:main",
+            "strx-convert-string=strx_precommit.strx_convert_string:main",
+            "strx-translate-po=strx_precommit.strx_translate_po:main",
+            "strx-update-po=strx_precommit.strx_update_po:main",
+        ],
+    },
+    install_requires=[
+        "pre-commit",
+        "polib",
+        "translate",
+        "GitPython",
+    ],
+    author="Tu Nombre",
+    author_email="tu@email.com",
+    description="Pre-commit hooks para conversión de strings y traducción de archivos PO",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/straconxsa/strx_tools/",
+    project_urls={
+        "Bug Tracker": "https://github.com/straconxsa/strx_tools/issues",
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)

strx_precommit-0.1.1/src/strx_precommit/__init__.py

@@ -0,0 +1,5 @@
+from .strx_convert_string import StringFormatConverter
+from .strx_translate_po import OdooPoTranslator
+
+__version__ = "0.1.0"
+__all__ = ["StringFormatConverter", "OdooPoTranslator"]

strx_precommit-0.1.1/src/strx_precommit/strx_convert_string.py

@@ -0,0 +1,172 @@
+
+import os
+import re
+import logging
+import argparse
+import subprocess
+from dataclasses import dataclass
+from typing import List, Dict, Set, Optional
+
+_logger = logging.getLogger(__name__)
+
+# Pattern for multiline string formatting (e.g., "hello %s" % var)
+STRING_MODULO_PATTERN = r'(\_\()?\s*(["\'])(.*?%s.*?)\2\)?\s*%\s*([^)\n,]+?|\([^)]+\))(?=\n|\)|$)'
+
+# Default blacklist for files and directories
+DEFAULT_BLACKLIST = {
+    "venv",
+    "__pycache__",
+    "migrations",
+    "test_*.py",
+    "setup.py",
+    ".*env.*",
+}
+
+@dataclass
+class FileChange:
+    """Stores information about a single string format change."""
+    file_path: str
+    original_line: str
+    modified_line: str
+    line_number: int
+
+class ChangeTracker:
+    """Tracks changes made during the conversion process."""
+    def __init__(self):
+        self.changes: Dict[str, List[FileChange]] = {}
+        self.files_reviewed: Set[str] = set()
+        self.files_modified: Set[str] = set()
+        self.files_skipped: Set[str] = set()
+        self.total_modifications = 0
+
+    def add_change(self, file_path: str, original: str, modified: str, line_number: int):
+        if file_path not in self.changes:
+            self.changes[file_path] = []
+        self.changes[file_path].append(FileChange(file_path, original, modified, line_number))
+        self.files_modified.add(file_path)
+        self.total_modifications += 1
+
+    def add_reviewed_file(self, file_path: str):
+        self.files_reviewed.add(file_path)
+
+class StringFormatConverter:
+    """Class for converting string formats from %s to f-strings or .format()."""
+    def __init__(self, blacklist: Optional[Set[str]] = None, use_fstrings: bool = True):
+        self.blacklist = blacklist or DEFAULT_BLACKLIST
+        self.use_fstrings = use_fstrings
+        self.tracker = ChangeTracker()
+
+    def convert_to_fstring(self, string_content: str, variable: str) -> str:
+        """Convert a string with %s and its variable to an f-string."""
+        # Clean variable if it's a tuple (var,)
+        clean_var = variable.strip()
+        if clean_var.startswith('(') and clean_var.endswith(')'):
+            clean_var = clean_var[1:-1].strip().rstrip(',')
+        
+        # Replace %s with {var}
+        # Note: This handles single %s. 
+        if string_content.count('%s') == 1:
+            # Check if variable is simple enough for f-string (no complex logic)
+            # Actually f-strings handle expressions, so it's mostly fine
+            return string_content.replace('%s', '{' + clean_var + '}')
+        return None
+
+    def process_file(self, file_path: str) -> None:
+        try:
+            self.tracker.add_reviewed_file(file_path)
+            with open(file_path, "r", encoding="utf-8") as file:
+                content = file.read()
+
+            def replace_logic(match):
+                has_translation = bool(match.group(1))
+                quote = match.group(2)
+                string_content = match.group(3)
+                variable = match.group(4).strip()
+
+                line_number = content[:match.start()].count("\n") + 1
+
+                # If it's a translation, we MUST use .format() because f-strings are not translatable
+                if has_translation:
+                    # Note: Simplified variable name mapping for .format()
+                    # We use the variable name itself as the key if it's simple
+                    safe_var = re.sub(r'[^a-zA-Z0-9_]', '_', variable.split('.')[-1].strip('()'))
+                    if not safe_var or safe_var[0].isdigit(): safe_var = "var_" + safe_var
+                    
+                    new_str = string_content.replace('%s', '{' + safe_var + '}')
+                    result = f"_({quote}{new_str}{quote}).format({safe_var}={variable})"
+                else:
+                    # If not translated, try f-string
+                    f_content = self.convert_to_fstring(string_content, variable)
+                    if f_content and self.use_fstrings:
+                        # Ensure we don't duplicate f prefix if already there (though regex doesn't match it)
+                        result = f"f{quote}{f_content}{quote}"
+                    else:
+                        # Fallback to .format() if f-string logic fails or disabled
+                        safe_var = re.sub(r'[^a-zA-Z0-9_]', '_', variable.split('.')[-1].strip('()'))
+                        if not safe_var or safe_var[0].isdigit(): safe_var = "var_" + safe_var
+                        new_str = string_content.replace('%s', '{' + safe_var + '}')
+                        result = f"{quote}{new_str}{quote}.format({safe_var}={variable})"
+
+                self.tracker.add_change(file_path, match.group(0), result, line_number)
+                return result
+
+            new_content = re.sub(STRING_MODULO_PATTERN, replace_logic, content, flags=re.MULTILINE | re.DOTALL)
+
+            if new_content != content:
+                with open(file_path, "w", encoding="utf-8") as file:
+                    file.write(new_content)
+        except Exception as e:
+            _logger.error(f"Error processing {file_path}: {e}")
+
+    def run(self, directory: str):
+        directory = os.path.abspath(directory)
+        for root, dirs, files in os.walk(directory):
+            # Apply blacklist to directories
+            dirs[:] = [d for d in dirs if not any(re.match(b.replace('*', '.*'), d) for b in self.blacklist)]
+            
+            for file in files:
+                if file.endswith(".py"):
+                    file_path = os.path.join(root, file)
+                    if any(re.match(b.replace('*', '.*'), file) for b in self.blacklist):
+                        continue
+                    self.process_file(file_path)
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Python string formats from %s to f-strings.")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--all", action="store_true", help="Procesar todo el repositorio (global)")
+    group.add_argument("--path", "-p", help="Procesar un directorio específico")
+    
+    args = parser.parse_args()
+
+    # Determine base directory
+    if args.all:
+        try:
+            root = subprocess.run(["git", "rev-parse", "--show-toplevel"], 
+                               capture_output=True, text=True, check=True).stdout.strip()
+            directory = root
+        except:
+            directory = os.getcwd()
+        print(f"Modo GLOBAL: Procesando desde {directory}")
+    elif args.path:
+        directory = os.path.abspath(args.path)
+        print(f"Modo DIRECTORIO: Procesando {directory}")
+    else:
+        directory = os.getcwd()
+        print(f"Modo LOCAL: Procesando directorio actual {directory}")
+
+    if not os.path.exists(directory):
+        print(f"Error: La ruta no existe: {directory}")
+        return
+
+    converter = StringFormatConverter()
+    converter.run(directory)
+    
+    summary = converter.tracker
+    print(f"\nResumen de Conversión (a f-strings):")
+    print(f" - Archivos revisados: {len(summary.files_reviewed)}")
+    print(f" - Archivos modificados: {len(summary.files_modified)}")
+    print(f" - Total cambios realizados: {summary.total_modifications}")
+
+if __name__ == "__main__":
+    main()

strx_precommit-0.1.1/src/strx_precommit/strx_translate_po.py

@@ -0,0 +1,179 @@
+
+import os
+import re
+import glob
+import polib
+import logging
+import sys
+import subprocess
+import argparse
+from datetime import datetime
+from babel.messages.catalog import Catalog
+from babel.core import UnknownLocaleError, Locale
+from pathlib import Path
+from typing import Set, Dict, List, Optional, Tuple
+from time import sleep
+from translate import Translator
+
+# Configuración de logging
+logging.basicConfig(
+    level=logging.INFO, format="%(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+)
+logger = logging.getLogger(__name__)
+
+class OdooPoTranslator:
+    """Gestiona la traducción de archivos PO en módulos Odoo"""
+
+    ODOO_LANGUAGE_CODES = {
+        "es": "es_ES",
+        "es_ES": "es_ES",
+        "es_CO": "es_CO",
+        "en": "en_US",
+        "en_US": "en_US",
+        "fr": "fr_FR",
+        "pt": "pt_PT",
+        "pt_BR": "pt_BR",
+        "de": "de_DE",
+        "it": "it_IT",
+        "nl": "nl_NL",
+        "pl": "pl_PL",
+        "ru": "ru_RU",
+        "zh": "zh_CN",
+        "ja": "ja_JP",
+        "ko": "ko_KR",
+    }
+
+    def __init__(self, source_dir: str, locale: str = "es"):
+        self.source_dir = os.path.abspath(source_dir)
+        self.locale = self._normalize_locale(locale)
+
+        if not self.locale:
+            raise ValueError(f"Idioma no soportado: {locale}")
+
+        try:
+            self.catalog = Catalog(locale=self.locale)
+        except UnknownLocaleError:
+            base_locale = self.locale.split("_")[0]
+            self.catalog = Catalog(locale=base_locale)
+
+        self.current_strings = set()
+        self.translation_markers = [r'_\([\'"](.+?)[\'"]\)', r'_lt\([\'"](.+?)[\'"]\)', r'_t\([\'"](.+?)[\'"]\)']
+        self.xml_patterns = [r'string="([^"]+)"', r'help="([^"]+)"', r'placeholder="([^"]+)"', r'title="([^"]+)"']
+
+    def _normalize_locale(self, locale: str) -> Optional[str]:
+        locale = locale.lower()
+        if locale in self.ODOO_LANGUAGE_CODES.values(): return locale
+        if locale in self.ODOO_LANGUAGE_CODES: return self.ODOO_LANGUAGE_CODES[locale]
+        return None
+
+    def scan_directory(self) -> None:
+        logger.info(f"🔍 Escaneando: {self.source_dir}")
+        for root, _, files in os.walk(self.source_dir):
+            for file in files:
+                filepath = os.path.join(root, file)
+                if file.endswith(".py"): self.scan_python_file(filepath)
+                elif file.endswith(".xml"): self.scan_xml_file(filepath)
+
+    def scan_python_file(self, filepath: str) -> None:
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                content = f.read()
+            for pattern in self.translation_markers:
+                for match in re.finditer(pattern, content):
+                    text = match.group(1)
+                    if text and not text.isspace():
+                        line_no = content[:match.start()].count("\n") + 1
+                        self.catalog.add(text, locations=[(filepath, line_no)])
+                        self.current_strings.add(text)
+        except: pass
+
+    def scan_xml_file(self, filepath: str) -> None:
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                content = f.read()
+            for pattern in self.xml_patterns:
+                for match in re.finditer(pattern, content):
+                    text = match.group(1).strip()
+                    if text and not text.isspace() and len(text) > 1:
+                        line_no = content[:match.start()].count("\n") + 1
+                        self.catalog.add(text, locations=[(filepath, line_no)])
+                        self.current_strings.add(text)
+        except: pass
+
+    def translate_pending_strings(self) -> None:
+        untranslated = [m.id for m in self.catalog if not m.string]
+        if not untranslated: return
+        
+        logger.info(f"🔄 Traduciendo {len(untranslated)} strings...")
+        translator = Translator(to_lang=self.locale.split("_")[0], from_lang="en")
+        
+        for text in untranslated:
+            try:
+                translation = translator.translate(text)
+                if translation and translation != text:
+                    self.catalog.get(text).string = translation
+                    logger.info(f"  ✅ {text} -> {translation}")
+                sleep(0.1)
+            except: pass
+
+    def save(self):
+        po_path = os.path.join(self.source_dir, "i18n", f"{self.locale}.po")
+        os.makedirs(os.path.dirname(po_path), exist_ok=True)
+        
+        po = polib.POFile()
+        po.metadata = {"Content-Type": "text/plain; charset=UTF-8"}
+        for msg in self.catalog:
+            entry = polib.POEntry(msgid=msg.id, msgstr=msg.string or "", occurrences=msg.locations)
+            po.append(entry)
+        po.save(po_path)
+        logger.info(f"💾 Guardado: {po_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Traducción automática de módulos Odoo.")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--all", action="store_true", help="Procesar todo el repositorio (global)")
+    group.add_argument("--path", "-p", help="Procesar un directorio específico")
+    parser.add_argument("--locale", default="es", help="Idioma (default: es)")
+    
+    args = parser.parse_args()
+
+    if args.all:
+        try:
+            root = subprocess.run(["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True, check=True).stdout.strip()
+            directory = root
+        except: directory = os.getcwd()
+    elif args.path: directory = os.path.abspath(args.path)
+    else: directory = os.getcwd()
+
+    if not os.path.exists(directory):
+        print(f"Error: {directory} no existe")
+        return
+
+    # Si es global, buscamos módulos (carpetas con __manifest__.py)
+    modules = []
+    if args.all:
+        for root, dirs, files in os.walk(directory):
+            if "__manifest__.py" in files:
+                modules.append(root)
+                dirs[:] = [] # No buscar sub-módulos
+    else:
+        if os.path.exists(os.path.join(directory, "__manifest__.py")):
+            modules.append(directory)
+        else:
+            # Quizás es un directorio de módulos
+            for d in os.listdir(directory):
+                dpath = os.path.join(directory, d)
+                if os.path.isdir(dpath) and os.path.exists(os.path.join(dpath, "__manifest__.py")):
+                    modules.append(dpath)
+
+    for mod in modules:
+        try:
+            t = OdooPoTranslator(mod, args.locale)
+            t.scan_directory()
+            t.translate_pending_strings()
+            t.save()
+        except Exception as e:
+            logger.error(f"Error en {mod}: {e}")
+
+if __name__ == "__main__":
+    main()

strx_precommit-0.1.1/src/strx_precommit/strx_update_po.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python3
+import os
+import git
+import sys
+import logging
+from pathlib import Path
+from typing import Set, Dict, List, Optional, Tuple
+from .strx_translate_po import OdooPoTranslator
+import argparse
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger(__name__)
+
+DEFAULT_DIR = "/home/initium16/odoo16/initium"
+
+
+class GitModuleDetector:
+    """Detecta módulos Odoo modificados en git usando comandos directos"""
+
+    def __init__(self, repo_path: str = "."):
+        self.repo_path = os.path.abspath(repo_path) if repo_path != "." else DEFAULT_DIR
+        try:
+            self.repo = git.Repo(self.repo_path)
+            os.chdir(self.repo_path)
+        except git.InvalidGitRepositoryError:
+            logger.debug(f"No es un repositorio git válido: {repo_path}")
+            self.repo = None
+
+    def _is_odoo_module(self, path: str) -> bool:
+        """Verifica si una ruta es un módulo Odoo válido"""
+        manifest_path = os.path.join(
+            path, "__manifest__.py"
+        )  # Nombre correcto del manifest
+        return os.path.isfile(manifest_path)
+
+    def get_modified_files(self) -> Set[str]:
+        """Obtiene lista de archivos modificados usando comandos git directos"""
+        if not self.repo:
+            return set()
+
+        changed_files = set()
+
+        try:
+            # Obtener cambios usando git status
+            status_output = self.repo.git.status("--porcelain", "--untracked-files=all")
+
+            if status_output:
+                for line in status_output.split("\n"):
+                    if line:
+                        status = line[:2]
+                        file_path = line[3:]
+                        if status.strip() != "D":  # Ignorar archivos eliminados
+                            changed_files.add(file_path)
+                            logger.debug(f"Archivo detectado ({status}): {file_path}")
+
+            # Si no hay cambios en el status, verificar el último commit
+            if not changed_files and self.repo.head.is_valid():
+                try:
+                    last_commit = self.repo.head.commit
+                    if last_commit.parents:
+                        changed_files.update(
+                            item.a_path
+                            for item in last_commit.diff(last_commit.parents[0])
+                        )
+                except Exception as e:
+                    logger.debug(f"Error verificando último commit: {e}")
+
+        except Exception as e:
+            logger.error(f"Error obteniendo archivos modificados: {e}")
+
+        return changed_files
+
+    def find_module_from_file(self, file_path: str) -> Optional[str]:
+        """
+        Encuentra el módulo Odoo que contiene un archivo, buscando __manifest__.py
+        """
+        try:
+            current_path = os.path.dirname(os.path.join(self.repo_path, file_path))
+
+            while (
+                current_path
+                and os.path.commonpath([current_path, self.repo_path]) == self.repo_path
+            ):
+                if self._is_odoo_module(current_path):
+                    logger.debug(f"Módulo Odoo encontrado en: {current_path}")
+                    return current_path
+                parent_path = os.path.dirname(current_path)
+                if parent_path == current_path:  # Llegamos a la raíz
+                    break
+                current_path = parent_path
+
+        except Exception as e:
+            logger.debug(f"Error buscando módulo para {file_path}: {e}")
+
+        return None
+
+    def get_modified_modules(self) -> Dict[str, Dict]:
+        """Obtiene información de todos los módulos Odoo modificados"""
+        modules = {}
+        changed_files = self.get_modified_files()
+
+        logger.debug(f"Archivos modificados encontrados: {len(changed_files)}")
+
+        for file_path in changed_files:
+            # Solo procesar archivos Python
+            if not file_path.endswith(".py"):
+                continue
+
+            logger.debug(f"Procesando archivo: {file_path}")
+            module_path = self.find_module_from_file(file_path)
+
+            if module_path and module_path not in modules:
+                module_info = self._get_module_info(module_path)
+                if module_info:
+                    modules[module_path] = module_info
+                    logger.info(
+                        f"✓ Módulo detectado: {module_info['name']} ({module_info['technical_name']})"
+                    )
+                    logger.debug(f"  Ruta: {module_path}")
+
+        return modules
+
+    def _get_module_info(self, module_path: str) -> Optional[Dict]:
+        """Lee la información del módulo desde __manifest__.py"""
+        manifest_path = os.path.join(module_path, "__manifest__.py")
+
+        try:
+            if not os.path.isfile(manifest_path):
+                logger.debug(f"No se encontró __manifest__.py en: {manifest_path}")
+                return None
+
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                manifest_content = f.read()
+                manifest_dict = eval(manifest_content)
+
+                module_info = {
+                    "name": manifest_dict.get("name", os.path.basename(module_path)),
+                    "version": manifest_dict.get("version", "1.0"),
+                    "technical_name": os.path.basename(module_path),
+                    "path": module_path,
+                    "manifest_path": manifest_path,
+                    "summary": manifest_dict.get("summary", ""),
+                    "category": manifest_dict.get("category", "Uncategorized"),
+                    "author": manifest_dict.get("author", ""),
+                    "depends": manifest_dict.get("depends", []),
+                    "website": manifest_dict.get("website", ""),
+                    "license": manifest_dict.get("license", "LGPL-3"),
+                }
+
+                logger.debug(f"Información del módulo leída: {module_info['name']}")
+                return module_info
+
+        except Exception as e:
+            logger.error(f"Error leyendo __manifest__.py en {manifest_path}: {e}")
+            return None
+
+    def print_module_summary(self, modules: Dict[str, Dict]):
+        """Imprime un resumen de los módulos encontrados"""
+        if not modules:
+            logger.info("No se encontraron módulos modificados")
+            return
+
+        logger.info("\n📦 Módulos modificados encontrados:")
+        for module_path, info in modules.items():
+            logger.info(f"\n▶ {info['name']} ({info['technical_name']})")
+            logger.info(f"  📍 Ruta: {module_path}")
+            if info["version"]:
+                logger.info(f"  📌 Versión: {info['version']}")
+            if info["depends"]:
+                logger.info(f"  🔗 Dependencias: {', '.join(info['depends'])}")
+
+
+class ModuleDetector:
+    """Detecta módulos Odoo en un directorio o en cambios de git"""
+
+    def __init__(self, default_dir: Optional[str] = None, repo_path: str = "."):
+        self.default_dir = os.path.abspath(default_dir) if default_dir else None
+        self.repo_path = os.path.abspath(repo_path)
+        self.git_detector = GitModuleDetector(repo_path)
+
+    def _is_odoo_module(self, path: str) -> bool:
+        """Verifica si una ruta es un módulo Odoo válido"""
+        manifest_path = os.path.join(path, "__manifest__.py")
+        return os.path.isfile(manifest_path)
+
+    def _read_manifest(self, manifest_path: str) -> Optional[Dict]:
+        """Lee y retorna la información del manifest"""
+        try:
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                manifest_content = f.read()
+                return eval(manifest_content)
+        except Exception as e:
+            logger.debug(f"Error leyendo manifest {manifest_path}: {e}")
+            return None
+
+    def _get_module_info(self, module_path: str) -> Optional[Dict]:
+        """Obtiene información detallada de un módulo"""
+        manifest_path = os.path.join(module_path, "__manifest__.py")
+
+        try:
+            if not os.path.isfile(manifest_path):
+                logger.debug(f"No se encontró __manifest__.py en: {manifest_path}")
+                return None
+
+            manifest_data = self._read_manifest(manifest_path)
+            if not manifest_data:
+                return None
+
+            module_info = {
+                "name": manifest_data.get("name", os.path.basename(module_path)),
+                "version": manifest_data.get("version", "1.0"),
+                "technical_name": os.path.basename(module_path),
+                "path": module_path,
+                "manifest_path": manifest_path,
+                "summary": manifest_data.get("summary", ""),
+                "author": manifest_data.get("author", ""),
+                "depends": manifest_data.get("depends", []),
+                "category": manifest_data.get("category", "Uncategorized"),
+                "website": manifest_data.get("website", ""),
+                "license": manifest_data.get("license", "LGPL-3"),
+            }
+
+            logger.debug(f"Información del módulo leída: {module_info['name']}")
+            return module_info
+
+        except Exception as e:
+            logger.error(f"Error procesando módulo en {module_path}: {e}")
+            if logger.getEffectiveLevel() == logging.DEBUG:
+                import traceback
+
+                logger.debug(traceback.format_exc())
+            return None
+
+    def find_modules(self) -> Dict[str, Dict]:
+        """Encuentra módulos Odoo basado en directorio predeterminado y/o cambios git"""
+        modules = {}
+
+        # 1. Buscar en directorio predeterminado si está configurado
+        if self.default_dir and os.path.exists(self.default_dir):
+            logger.debug(f"Buscando en directorio predeterminado: {self.default_dir}")
+            for item in os.listdir(self.default_dir):
+                module_path = os.path.join(self.default_dir, item)
+                if os.path.isdir(module_path) and self._is_odoo_module(module_path):
+                    module_info = self._get_module_info(module_path)
+                    if module_info:
+                        modules[module_path] = module_info
+                        logger.debug(
+                            f"Módulo encontrado en directorio: {module_info['name']}"
+                        )
+
+        # 2. Buscar en cambios git
+        logger.debug("Buscando módulos en cambios git...")
+        git_modules = self.git_detector.get_modified_modules()
+
+        # Combinar resultados, priorizando información de git para módulos duplicados
+        modules.update(git_modules)
+
+        if modules:
+            self._print_module_summary(modules)
+        else:
+            logger.info("No se encontraron módulos para procesar")
+
+        return modules
+
+    def _print_module_summary(self, modules: Dict[str, Dict]):
+        """Imprime un resumen de los módulos encontrados"""
+        logger.info("\n📦 Módulos encontrados:")
+
+        for module_path, info in modules.items():
+            logger.info(f"\n▶ {info['name']} ({info['technical_name']})")
+            logger.info(f"  📍 Ruta: {module_path}")
+
+            if info["version"]:
+                logger.info(f"  📌 Versión: {info['version']}")
+
+            if info["category"] != "Uncategorized":
+                logger.info(f"  📑 Categoría: {info['category']}")
+
+            if info["author"]:
+                logger.info(f"  👤 Autor: {info['author']}")
+
+            if info["depends"]:
+                logger.info(f"  🔗 Dependencias: {', '.join(info['depends'])}")
+
+            if info["website"]:
+                logger.info(f"  🌐 Website: {info['website']}")
+
+            logger.info(f"  ⚖️  Licencia: {info['license']}")
+
+    def get_module_dependencies(self, module_path: str) -> List[str]:
+        """Obtiene la lista de dependencias de un módulo"""
+        module_info = self._get_module_info(module_path)
+        if module_info and module_info["depends"]:
+            return module_info["depends"]
+        return []
+
+    def is_module_installable(self, module_path: str) -> bool:
+        """Verifica si un módulo está marcado como instalable"""
+        manifest_path = os.path.join(module_path, "__manifest__.py")
+        if os.path.isfile(manifest_path):
+            manifest_data = self._read_manifest(manifest_path)
+            return manifest_data.get("installable", True) if manifest_data else False
+        return False
+
+
+class TranslationChecker:
+    """Verifica traducciones en módulos Odoo"""
+
+    def __init__(self, lang: str = "es", default_dir: Optional[str] = None):
+        self.lang = lang
+        self.module_detector = ModuleDetector(default_dir)
+
+    def check_translations(self) -> bool:
+        """Verifica y actualiza traducciones en módulos"""
+        modules = self.module_detector.find_modules()
+
+        if not modules:
+            logger.info("✅ No se encontraron módulos para verificar")
+            return True
+
+        logger.info(f"\n🔍 Verificando traducciones ({self.lang}):")
+
+        all_ok = True
+        modules_with_issues = {}
+        new_modules = []
+
+        for module_path, module_info in modules.items():
+            logger.info(
+                f"\n📦 Verificando módulo: {module_info['name']} ({module_info['technical_name']})"
+            )
+
+            po_path = os.path.join(module_path, "i18n", f"{self.lang}.po")
+
+            if not os.path.exists(po_path):
+                new_modules.append(module_info)
+                all_ok = False
+                logger.error(f"❌ No se encontró archivo {self.lang}.po")
+                continue
+
+            # Crear instancia del traductor
+            translator = OdooPoTranslator(module_path, self.lang)
+
+            # Escanear y procesar el módulo
+            translator.scan_directory()
+
+            # Verificar strings sin traducir antes de la traducción
+            untranslated_before = translator.get_untranslated_strings()
+
+            if untranslated_before:
+                logger.info(
+                    f"Encontrados {len(untranslated_before)} strings sin traducir"
+                )
+
+                # Realizar la traducción
+                logger.info("Iniciando proceso de traducción...")
+                translator.translate_pending_strings()
+
+                # Guardar las traducciones
+                translator.save_po_file()
+
+                # Verificar strings sin traducir después de la traducción
+                untranslated_after = translator.get_untranslated_strings()
+
+                if untranslated_after:
+                    all_ok = False
+                    modules_with_issues[module_path] = untranslated_after
+                    logger.error("❌ Strings que no se pudieron traducir:")
+                    for string in sorted(untranslated_after):
+                        logger.error(f"  - {string}")
+                else:
+                    logger.info("✅ Todas las cadenas fueron traducidas exitosamente")
+
+        if not all_ok:
+            self._show_error_summary(new_modules, modules_with_issues)
+            return False
+
+        logger.info("\n✅ Todas las traducciones están actualizadas")
+        return True
+
+    def _show_error_summary(self, new_modules: List[Dict], modules_with_issues: Dict):
+        """Muestra resumen de errores encontrados"""
+        logger.error("\n❌ Se encontraron problemas de traducción")
+
+        if new_modules:
+            logger.error("\n📋 Módulos que requieren traducción inicial:")
+            for module in new_modules:
+                logger.error(f"  - {module['name']} ({module['technical_name']})")
+            logger.error("\nPara generar traducciones iniciales desde Odoo:")
+            logger.error("1. Instala el módulo en Odoo")
+            logger.error("2. Ve a Ajustes > Traducciones > Cargar una traducción")
+            logger.error(f"3. Selecciona el idioma ({self.lang})")
+            logger.error("4. Marca 'Sobreescribir términos existentes'")
+            logger.error("5. Selecciona los módulos listados arriba")
+
+        if modules_with_issues:
+            logger.error("\n📝 Resumen de strings que no se pudieron traducir:")
+            for module_path, strings in modules_with_issues.items():
+                module_name = os.path.basename(module_path)
+                logger.error(f"\nMódulo: {module_name}")
+                for string in sorted(strings):
+                    logger.error(f"  - {string}")
+
+        logger.error("\n⚠️  Por favor, verifica las traducciones pendientes manualmente")
+
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        description="Verifica traducciones en módulos Odoo"
+    )
+    parser.add_argument("--lang", default="es", help="Código de idioma (default: es)")
+    parser.add_argument(
+        "--dir", dest="default_dir", help="Directorio predeterminado de módulos Odoo"
+    )
+    parser.add_argument(
+        "--git-only",
+        action="store_true",
+        help="Solo verificar módulos con cambios en git",
+    )
+    parser.add_argument("--debug", action="store_true", help="Activa logs de debug")
+    parser.add_argument(
+        "--no-translate", action="store_true", help="No realizar traducción automática"
+    )
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    try:
+        # Si se especifica --git-only, no usar directorio predeterminado
+        GIT_ONLY = args.git_only or True
+        default_dir = DEFAULT_DIR if GIT_ONLY else args.default_dir
+
+        checker = TranslationChecker(lang=args.lang, default_dir=default_dir)
+
+        if not checker.check_translations():
+            sys.exit(1)
+
+    except Exception as e:
+        logger.error(f"\n❌ Error: {e}")
+        if args.debug:
+            import traceback
+
+            logger.debug(traceback.format_exc())
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

strx_precommit-0.1.1/src/strx_precommit.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: strx-precommit
+Version: 0.1.1
+Summary: Pre-commit hooks para conversión de strings y traducción de archivos PO
+Home-page: https://github.com/straconxsa/strx_tools/
+Author: Tu Nombre
+Author-email: Initium Team <info@straconx.com>
+Project-URL: Homepage, https://github.com/straconxsa/strx_tools/
+Project-URL: Bug Tracker, https://github.com/straconxsa/strx_tools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python

strx_precommit-0.1.1/src/strx_precommit.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+src/strx_precommit/__init__.py
+src/strx_precommit/strx_convert_string.py
+src/strx_precommit/strx_translate_po.py
+src/strx_precommit/strx_update_po.py
+src/strx_precommit.egg-info/PKG-INFO
+src/strx_precommit.egg-info/SOURCES.txt
+src/strx_precommit.egg-info/dependency_links.txt
+src/strx_precommit.egg-info/top_level.txt

strx_precommit-0.1.1/src/strx_precommit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

strx_precommit-0.1.1/src/strx_precommit.egg-info/top_level.txt

@@ -0,0 +1 @@
+strx_precommit