g360-cli 1.13.1 → 1.15.0

package/src/assets/templates/python-flet-polished/src/app.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+import time
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+import flet as ft
+
+from src.config.theme import get_colors, load_theme_preference, save_theme_preference
+from src.core.constants import (
+    AUTO_REFRESH_INTERVAL,
+    CACHE_FILE,
+    VERSION_CACHE_FILE,
+    VERSION_CHECK_INTERVAL,
+    WINDOW_WIDTH,
+    WINDOW_HEIGHT,
+    WINDOW_MIN_WIDTH,
+    WINDOW_MIN_HEIGHT,
+    get_local_version,
+    get_app_name,
+)
+from src.ui.dashboard import Dashboard
+
+import logging
+_log_logger = logging.getLogger("g360.app")
+if not _log_logger.handlers:
+    from logging.handlers import RotatingFileHandler
+    _log_path = Path(__file__).resolve().parent.parent.parent / "run_log.txt"
+    _fmt = logging.Formatter("[%(asctime)s] %(message)s", datefmt="%H:%M:%S")
+    _handler = RotatingFileHandler(_log_path, maxBytes=2 * 1024 * 1024, backupCount=3, encoding="utf-8")
+    _handler.setFormatter(_fmt)
+    _log_logger.addHandler(_handler)
+    _log_logger.setLevel(logging.INFO)
+
+
+def _log(msg: str):
+    _log_logger.info(msg)
+
+
+def _load_cache() -> tuple[dict, str | None]:
+    """Carga el cache persistente. Retorna (raw_data, timestamp)."""
+    if not CACHE_FILE.exists():
+        return {}, None
+    try:
+        with open(CACHE_FILE, encoding="utf-8") as f:
+            data = json.load(f)
+        raw = data.get("raw_data", {})
+        ts = data.get("timestamp")
+        if raw:
+            return raw, ts
+    except (json.JSONDecodeError, UnicodeDecodeError) as ex:
+        _log(f"_load_cache: corrupt cache file, removing: {ex}")
+        try:
+            CACHE_FILE.unlink(missing_ok=True)
+        except Exception:
+            pass
+    except Exception:
+        pass
+    return {}, None
+
+
+def _hash_data(raw_data: dict) -> str:
+    """SHA-256 del raw_data para detectar cambios sin descargar dos veces."""
+    serialized = json.dumps(raw_data, sort_keys=True, ensure_ascii=False).encode()
+    return hashlib.sha256(serialized).hexdigest()[:16]
+
+
+def _data_changed(new_data: dict, last_hash: str | None) -> tuple[bool, str]:
+    """Retorna (changed, nuevo_hash)."""
+    h = _hash_data(new_data)
+    return h != last_hash, h
+
+
+def _save_cache(raw_data: dict, api_timestamp: str | None = None):
+    """Guarda raw_data completo."""
+    try:
+        CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "raw_data": raw_data,
+            "timestamp": api_timestamp or datetime.now().isoformat(),
+            "api_timestamp": api_timestamp,
+        }
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False)
+    except Exception as ex:
+        _log(f"_save_cache: ERROR {ex}")
+
+
+class G360App:
+    """
+    Clase principal de la aplicacion G360 con Flet.
+
+    Patrones implementados:
+    - Dual theme (dark/light) con persistencia en ~/.g360/
+    - Auto-refresh con lock thread-safe
+    - Cache con hash diff para evitar rebuild innecesarios
+    - Logger RotatingFileHandler
+    - Shutdown limpio via page.on_close
+    """
+
+    def __init__(self, page: ft.Page):
+        try:
+            self.page = page
+            self._raw_data: dict = {}
+            self._theme_mode = load_theme_preference()
+            self._setup_page()
+            self.dashboard = Dashboard(page, self._theme_mode)
+            if hasattr(self.dashboard, "set_on_theme_toggle"):
+                self.dashboard.set_on_theme_toggle(self._toggle_theme)
+            self.dashboard.set_on_refresh(self._on_refresh)
+            self._cache_timestamp: str | None = None
+            self._stale_data: bool = False
+            self._local_version = get_local_version()
+            self._last_auto_refresh: float = 0.0
+            self._auto_refresh_stop: threading.Event | None = None
+            self._download_lock = threading.Lock()
+            self._last_data_hash: str | None = None
+            self._build()
+        except Exception:
+            _log(f"[FATAL] G360App.__init__:\n{traceback.format_exc()}")
+            raise
+
+    def _setup_page(self):
+        app_name = get_app_name()
+        self.page.title = f"{app_name.title()} - G360"
+        self.page.theme_mode = ft.ThemeMode.DARK if self._theme_mode == "dark" else ft.ThemeMode.LIGHT
+        self.page.bgcolor = get_colors(self._theme_mode)["background"]
+        self.page.padding = 0
+        self.page.window_width = WINDOW_WIDTH
+        self.page.window_height = WINDOW_HEIGHT
+        self.page.window_min_width = WINDOW_MIN_WIDTH
+        self.page.window_min_height = WINDOW_MIN_HEIGHT
+        try:
+            self.page.window_center()
+        except AttributeError:
+            pass
+
+        fonts_dir = Path(__file__).resolve().parent.parent.parent / "assets" / "fonts"
+        self.page.fonts = {
+            "Inter": str(fonts_dir / "Inter-Variable.ttf"),
+            "JetBrains Mono": str(fonts_dir / "JetBrainsMono-Variable.ttf"),
+        }
+        self.page.theme = ft.Theme(font_family="Inter")
+
+    def _build(self):
+        _log("_build: starting dashboard.build()...")
+        view = self.dashboard.build()
+        _log("_build: dashboard.build() OK")
+        self.page.add(view)
+        self.page.update()
+        _log("_build: page.add + update OK")
+        self.dashboard.register_overlay()
+        _log("_build: overlay (FilePickers) registrado")
+
+        sample_path = Path(__file__).resolve().parent.parent / "assets" / "data" / "sample_data.json"
+        cache, ts = _load_cache()
+        if cache:
+            _log(f"_build: loading cached data...")
+            self._raw_data = cache
+            self._cache_timestamp = ts
+            _, initial_hash = _data_changed(cache, None)
+            self._last_data_hash = initial_hash
+            self.dashboard.update_data(cache, cache_timestamp=ts)
+            self.page.update()
+            _log(f"_build: cache loaded OK ({len(cache)} items)")
+        elif sample_path.exists():
+            _log("_build: cache empty, loading sample_data.json...")
+            with open(sample_path, encoding="utf-8") as f:
+                raw = json.load(f)
+            self._raw_data = raw
+            self.dashboard.update_data(raw)
+            self.page.update()
+            _log("_build: sample_data loaded OK")
+        else:
+            _log("_build: neither cache nor sample_data.json found")
+            self.dashboard._show_empty_state("Sin datos disponibles")
+            self.dashboard._set_empty_state_status("Esperando datos", self.dashboard.c["warning"])
+
+        _log("_build: scheduling _delayed_load...")
+        self.page.run_task(self._delayed_load)
+        self._start_auto_refresh()
+        _log("_build: done")
+
+    def _toggle_theme(self):
+        self._theme_mode = "light" if self._theme_mode == "dark" else "dark"
+        save_theme_preference(self._theme_mode)
+        self.page.theme_mode = ft.ThemeMode.DARK if self._theme_mode == "dark" else ft.ThemeMode.LIGHT
+        self.page.bgcolor = get_colors(self._theme_mode)["background"]
+        self.dashboard.update_theme(self._theme_mode)
+        self.page.update()
+
+    async def _delayed_load(self):
+        import asyncio
+        await asyncio.sleep(0.5)
+        await self._load_data()
+
+    async def _on_refresh(self):
+        await self._load_data(is_manual=True)
+
+    def _start_auto_refresh(self):
+        try:
+            self._auto_refresh_stop = threading.Event()
+            t = threading.Thread(
+                target=self._auto_refresh_loop,
+                daemon=True,
+                name="auto-refresh",
+            )
+            t.start()
+            self._auto_refresh_thread = t
+            _log(f"_start_auto_refresh: hilo iniciado ({AUTO_REFRESH_INTERVAL}s)")
+        except Exception as ex:
+            _log(f"_start_auto_refresh: ERROR {ex}")
+
+    def shutdown(self):
+        """Detiene el auto-refresh de forma limpia antes de cerrar."""
+        if self._auto_refresh_stop:
+            _log("_shutdown: deteniendo auto-refresh...")
+            self._auto_refresh_stop.set()
+            t = getattr(self, "_auto_refresh_thread", None)
+            if t and t.is_alive():
+                t.join(timeout=3)
+            _log("_shutdown: auto-refresh detenido")
+
+    def _auto_refresh_loop(self):
+        while not self._auto_refresh_stop.is_set():
+            time.sleep(1)
+            try:
+                self._on_auto_refresh_tick()
+            except Exception as ex:
+                _log(f"_auto_refresh_loop: ERROR {ex}")
+
+    def _on_auto_refresh_tick(self):
+        try:
+            if not self._cache_timestamp:
+                return
+            self.dashboard._update_refresh_status(self._cache_timestamp)
+            if time.time() - self._last_auto_refresh < AUTO_REFRESH_INTERVAL:
+                return
+            self._last_auto_refresh = time.time()
+            _log("_on_auto_refresh_tick: ejecutando auto-refresh")
+            self.page.run_task(self._load_data, is_manual=False)
+        except Exception as ex:
+            _log(f"_on_auto_refresh_tick: ERROR {ex}")
+
+    async def _load_data(self, is_manual=False):
+        import time
+        _t0 = time.time()
+        _log(f"_load_data: start is_manual={is_manual}")
+        self.dashboard.set_loading(True, "Descargando datos...")
+
+        if not self._download_lock.acquire(blocking=False):
+            _log("_load_data: otra descarga en curso, omitiendo")
+            self.dashboard.set_loading(False)
+            return
+
+        try:
+            import asyncio
+            loop = asyncio.get_running_loop()
+            _log("_load_data: calling _fetch_data in executor...")
+            raw = await loop.run_in_executor(None, self._fetch_data)
+            _log(f"_load_data: _fetch_data returned {type(raw).__name__}")
+
+            if not raw:
+                self.dashboard.set_loading(False)
+                self.dashboard.status_text.value = "No se obtuvieron datos"
+                self.dashboard.status_text.color = "#ef4444"
+                self.dashboard._show_snack("Error: No se obtuvieron datos", is_error=True)
+                if not self._raw_data:
+                    self.dashboard._set_empty_state_status("Sin datos - API no disponible", self.dashboard.c["error"])
+                _log("_load_data: no data, showing error")
+                return
+
+            changed, new_hash = _data_changed(raw, self._last_data_hash)
+            if not changed:
+                _log("_load_data: datos identicos, omitiendo UI refresh")
+                self.dashboard.set_loading(False)
+                self._download_lock.release()
+                return
+
+            self._raw_data = raw
+            self._last_data_hash = new_hash
+            _save_cache(raw)
+            self._cache_timestamp = datetime.now().isoformat()
+            self._last_auto_refresh = time.time()
+            _log("_load_data: cache saved")
+            self.dashboard.update_data(raw, cache_timestamp=self._cache_timestamp, stale=self._stale_data)
+            self.dashboard._hide_empty_state()
+            _log("_load_data: data updated in dashboard")
+            if is_manual:
+                self.dashboard._show_snack("Datos actualizados correctamente")
+        except Exception as ex:
+            _log(f"_load_data: EXCEPTION: {traceback.format_exc()}")
+            self.dashboard.status_text.value = f"Error: {str(ex)}"
+            self.dashboard.status_text.color = "#ef4444"
+            self.dashboard._show_snack(f"Fallo en la descarga: {str(ex)}", is_error=True)
+            self.dashboard.set_offline(True)
+            if not self._raw_data:
+                self.dashboard._set_empty_state_status("Error de conexión", self.dashboard.c["error"])
+        finally:
+            elapsed = time.time() - _t0
+            _log(f"_load_data: elapsed={elapsed:.1f}s")
+            self._download_lock.release()
+            if elapsed < 2:
+                self.dashboard.set_loading(True, "Actualizando vista...")
+                self.page.update()
+                import asyncio
+                await asyncio.sleep(2 - elapsed)
+            ts = self.dashboard.format_cache_timestamp(self._cache_timestamp) if not is_manual else ""
+            self.dashboard._ts_text.value = f"Ultima act. {ts}"
+            if self._stale_data:
+                self.dashboard._ts_text.color = self.dashboard.c["warning"]
+                self.dashboard._ts_text.value += " (caché)"
+                self.dashboard.status_text.value = "Datos en caché (fuera de horario)"
+                self.dashboard.status_text.color = self.dashboard.c["warning"]
+                self.dashboard._show_stale_warning()
+            else:
+                self.dashboard._ts_text.color = self.dashboard.c["accent"]
+                self.dashboard.status_text.value = "Datos actualizados"
+                self.dashboard.status_text.color = self.dashboard.c["accent"]
+                self.dashboard._hide_stale_warning()
+            self.dashboard._update_refresh_status(self._cache_timestamp)
+            self.dashboard.set_offline(False)
+            self.dashboard.set_loading(False)
+            self.page.update()
+            _log("_load_data: done")
+
+    def _fetch_data(self) -> dict | None:
+        """
+        Metodo que debe ser sobrescrito por subclases.
+        Implementa la logica de descarga/fetch de datos.
+        Retorna dict con los datos crudos o None si falla.
+        """
+        # Default: retorna None (no hay data)
+        # Subclases deben override这个方法
+        return None
+
+
+def main(page: ft.Page):
+    G360App(page)

package/src/assets/templates/python-flet-polished/src/config/theme.py

@@ -0,0 +1,122 @@
+import json
+from pathlib import Path
+
+ACCENT = "#10B981"
+ACCENT_DARK = "#047857"
+
+DARK_COLORS = {
+    "accent": "#10B981",
+    "accent_dark": "#047857",
+    "success": "#34D399",
+    "warning": "#F59E0B",
+    "error": "#EF4444",
+    "info": "#3B82F6",
+    "violet": "#8B5CF6",
+    "pink": "#EC4899",
+    "cyan": "#06B6D4",
+    "orange": "#F97316",
+    "kpis": {
+        "primary": "#06B6D4",
+        "secondary": "#8B5CF6",
+        "tertiary": "#0EA5E9",
+        "quaternary": "#6366F1",
+        "quinary": "#EC4899",
+        "senary": "#F59E0B",
+        "septenary": "#EF4444",
+        "octonary": "#F97316",
+    },
+    "surface": "#141D33",
+    "surface_variant": "#1B2740",
+    "surface_sunken": "#0E1627",
+    "background": "#0A0F1E",
+    "border": "#FFFFFF17",
+    "text_muted": "#8FA0BA",
+    "text_primary": "#F1F5FB",
+    "text_secondary": "#C9D4E6",
+}
+
+LIGHT_COLORS = {
+    "accent": "#047857",
+    "accent_dark": "#065F46",
+    "success": "#15803D",
+    "warning": "#B45309",
+    "error": "#DC2626",
+    "info": "#2563EB",
+    "violet": "#7C3AED",
+    "pink": "#DB2777",
+    "cyan": "#0891B2",
+    "orange": "#EA580C",
+    "kpis": {
+        "primary": "#0891B2",
+        "secondary": "#7C3AED",
+        "tertiary": "#0284C7",
+        "quaternary": "#4F46E5",
+        "quinary": "#DB2777",
+        "senary": "#B45309",
+        "septenary": "#DC2626",
+        "octonary": "#EA580C",
+    },
+    "surface": "#FFFFFF",
+    "surface_variant": "#F7F9FC",
+    "surface_sunken": "#EEF1F6",
+    "background": "#F3F5F9",
+    "border": "#E3E8F0",
+    "text_muted": "#64748B",
+    "text_primary": "#0F172A",
+    "text_secondary": "#334155",
+}
+
+
+def get_colors(mode: str) -> dict:
+    return dict(DARK_COLORS if mode == "dark" else LIGHT_COLORS)
+
+
+def rgba(color: str, opacity: float) -> str:
+    if color.startswith("#") and len(color) == 9:
+        return color
+    if color.startswith("#") and len(color) == 7:
+        hex_color = color[1:]
+        alpha = int(max(0.0, min(1.0, opacity)) * 255)
+        return f"#{alpha:02x}{hex_color}"
+    return color
+
+
+def get_theme_file() -> Path:
+    return Path.home() / ".g360" / f"{_get_app_name()}_config.json"
+
+
+def _get_app_name() -> str:
+    try:
+        from pathlib import Path as _P
+        _root = _P(__file__).resolve().parent.parent.parent.parent
+        _skill = _root / "skill.json"
+        if _skill.exists():
+            with open(_skill, encoding="utf-8") as _f:
+                _data = json.load(_f)
+                return _data.get("name", "g360-app").replace("-", "_")
+    except Exception:
+        pass
+    return "g360_app"
+
+
+def load_theme_preference() -> str:
+    try:
+        config_file = get_theme_file()
+        if config_file.exists():
+            with open(config_file, encoding="utf-8") as f:
+                config = json.load(f)
+                return config.get("theme_mode", "dark")
+    except Exception:
+        pass
+    return "dark"
+
+
+def save_theme_preference(mode: str):
+    try:
+        config_file = get_theme_file()
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+        config = {"theme_mode": mode}
+        with open(config_file, "w", encoding="utf-8") as f:
+            json.dump(config, f)
+    except Exception:
+        pass

package/src/assets/templates/python-flet-polished/src/core/constants.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+import os
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent
+ASSETS_DIR = BASE_DIR / "assets"
+DATA_DIR = ASSETS_DIR / "data"
+
+WINDOW_WIDTH = 1200
+WINDOW_HEIGHT = 800
+WINDOW_MIN_WIDTH = 900
+WINDOW_MIN_HEIGHT = 600
+
+AUTO_REFRESH_INTERVAL = 900
+
+CACHE_FILE = DATA_DIR / ".last_raw.json"
+VERSION_CACHE_FILE = DATA_DIR / ".version_check.json"
+VERSION_CHECK_INTERVAL = 86400
+
+LOG_PATH = BASE_DIR / "run_log.txt"
+
+
+def get_local_version() -> str:
+    pyproject = BASE_DIR / "pyproject.toml"
+    if not pyproject.exists():
+        return "0.0.0"
+    try:
+        with open(pyproject, "rb") as f:
+            data = tomllib.load(f)
+        return str(data.get("project", {}).get("version", "0.0.0"))
+    except Exception:
+        return "0.0.0"
+
+
+def get_app_name() -> str:
+    skill_path = BASE_DIR / "skill.json"
+    if skill_path.exists():
+        try:
+            with open(skill_path, encoding="utf-8") as f:
+                import json
+                data = json.load(f)
+                return data.get("name", "g360-app")
+        except Exception:
+            pass
+    return BASE_DIR.name

package/src/assets/templates/python-flet-polished/src/core/processor.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+"""
+G360 Processor - Motor de logica de negocio.
+
+Este modulo debe ser heredado y extendido por cada app G360.
+Contiene los patrones base para:
+- Calcular KPIs agregados
+- Generar metricas por linea/categoria
+- Sugiere transferencias entre almacenes
+- Exporta reportes a Excel con formato profesional
+
+Heredar y sobrescribir los metodos segun el dominio de cada app.
+"""
+
+from datetime import datetime
+from pathlib import Path
+
+
+APP_AUTHOR = "g360-app-polished"
+APP_NAME = "G360"
+
+
+def _make_report_name(title: str) -> str:
+    """Genera nombre de archivo con timestamp: G360_{slug}_{YYYYMMDD}_{HHMMSS}.xlsx"""
+    now = datetime.now()
+    ts = now.strftime("%Y%m%d_%H%M%S")
+    import re
+    slug = re.sub(r"[^a-zA-Z0-9]+", "_", title).strip("_").upper()
+    if len(slug) > 40:
+        slug = slug[:40]
+    if not slug:
+        slug = "REPORTE"
+    return f"{APP_NAME}_{slug}_{ts}"
+
+
+class BaseProcessor:
+    """
+    Procesador base que debe heredarse.
+
+    Ejemplo de uso:
+        class MiProcessor(BaseProcessor):
+            def calcular_kpis(self, raw_data):
+                # Implementar logica especifica
+                return kpis_dict
+    """
+
+    def __init__(self):
+        self._last_kpis = None
+        self._last_hash = None
+
+    def calcular_kpis(self, raw_data: dict) -> dict:
+        """
+        Calcula KPIs a partir de datos crudos.
+        Debe ser sobrescrito por subclases.
+
+        Args:
+            raw_data: Datos crudos del dominio (dict por almacén/entidad)
+
+        Returns:
+            dict con KPIs calculados
+        """
+        raise NotImplementedError("Subclase debe implementar calcular_kpis()")
+
+    def obtener_metricas(self, kpis: dict) -> tuple[list[dict], list[dict]]:
+        """
+        Genera metricas agrupadas (por linea, categoria, etc).
+        Debe ser sobrescrito por subclases.
+
+        Returns:
+            (metricas_principales, metricas_secundarias)
+        """
+        raise NotImplementedError("Subclase debe implementar obtener_metricas()")
+
+    def sugerir_acciones(self, raw_data: dict, kpis: dict) -> list[dict]:
+        """
+        Sugiere acciones (transferencias, alertas, etc).
+        Debe ser sobrescrito por subclases.
+
+        Returns:
+            lista de dicts con sugerencias
+        """
+        return []
+
+    def export_to_excel(self, data: list, file_path: str, title: str = "Reporte"):
+        """
+        Exporta datos a Excel con formato profesional.
+        Metodo base reutilizable.
+
+        Args:
+            data: Lista de filas [(col1, col2, ...), ...]
+            file_path: Ruta del archivo de salida
+            title: Titulo del reporte
+        """
+        from openpyxl import Workbook
+        from openpyxl.styles import PatternFill, Font, Alignment
+
+        wb = Workbook()
+        wb.properties.creator = APP_AUTHOR
+        wb.properties.description = f"Reporte generado por {APP_NAME} — {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+
+        ws = wb.active
+        ws.title = title[:31]
+
+        # Headers
+        if data:
+            headers = [f"Col {i+1}" for i in range(len(data[0]))]
+            ws.append(headers)
+            for cell in ws[1]:
+                cell.fill = PatternFill(start_color="10B981", end_color="10B981", fill_type="solid")
+                cell.font = Font(color="FFFFFF", bold=True)
+                cell.alignment = Alignment(horizontal="center")
+
+            for row in data:
+                ws.append([str(v) if v is not None else "" for v in row])
+
+        ws.column_dimensions['A'].width = 35
+        for col in "BCD":
+            ws.column_dimensions[col].width = 16
+
+        wb.save(file_path)
+
+    def hash_data(self, data: dict) -> str:
+        """Hash SHA-256 para deteccion de cambios."""
+        import hashlib
+        import json
+        serialized = json.dumps(data, sort_keys=True, ensure_ascii=False).encode()
+        return hashlib.sha256(serialized).hexdigest()[:16]

package/src/assets/templates/python-flet-polished/src/core/skill.json

@@ -0,0 +1,40 @@
+{
+  "name": "flet-desktop-polished",
+  "description": "G360 Flet Polished - Plantilla base con patrones de UI avanzada",
+  "framework": "flet",
+  "version": "1.0.0",
+  "python": ">=3.11",
+  "colors": {
+    "bg": "#0b1220",
+    "surface": "#1a2333",
+    "accent": "#34d399",
+    "text": "#f0f6fc",
+    "muted": "#8b949e",
+    "success": "#34d399",
+    "warning": "#f59e0b",
+    "error": "#ef4444"
+  },
+  "effects": {
+    "glassmorphism": true,
+    "blur": "12px",
+    "rounded": "12px"
+  },
+  "signature": {
+    "mode": "powered",
+    "text": "powered by G360"
+  },
+  "build": {
+    "tool": "flet",
+    "target": "windows",
+    "name": "G360-App"
+  },
+  "dependencies": {
+    "flet": ">=0.28.3"
+  },
+  "guidelines": {
+    "architecture": "src/core (logica), src/ui (componentes), src/config (theme)",
+    "naming": "PascalCase para clases UI, camelCase para metodos",
+    "state_management": "Usar atributos de clase, hash diff para cache",
+    "threading": "Usar threading.Lock() para operaciones concurrentes"
+  }
+}