g360-cli 1.13.0 → 1.14.0

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,41 @@
+{
+  "name": "flet-desktop",
+  "description": "G360 Flet Desktop Application",
+  "framework": "flet",
+  "version": "1.2.0",
+  "python": ">=3.11,<4.0",
+  "colors": {
+    "bg": "#0b1220",
+    "surface": "#1a2332",
+    "accent": "#00d084",
+    "text": "#f0f4f8",
+    "muted": "#94a3b8",
+    "success": "#22c55e",
+    "warning": "#f59e0b",
+    "error": "#ef4444"
+  },
+  "effects": {
+    "glassmorphism": true,
+    "blur": "12px",
+    "rounded": "12px"
+  },
+  "signature": {
+    "mode": "own",
+    "text": "G360 Desktop"
+  },
+  "build": {
+    "tool": "flet",
+    "target": "windows",
+    "name": "G360-App"
+  },
+  "dependencies": {
+    "flet": ">=0.25.0"
+  },
+  "guidelines": {
+    "architecture": "src/core (logica), src/ui (componentes), src/export (reportes)",
+    "naming": "PascalCase para clases UI, camelCase para metodos y variables",
+    "state_management": "Usar atributos de clase para estado, evitar globales",
+    "threading": "Usar threading.Thread para operaciones bloqueantes",
+    "window_config": "width=1350, height=900, resizable=True, theme_mode=DARK"
+  }
+}

package/src/assets/templates/python-flet-polished/src/ui/dashboard.py

@@ -0,0 +1,308 @@
+"""
+G360 Dashboard - Template base con patrones pulidos.
+
+Patrones disponibles:
+- Sidebar colapsable con chips de filtro
+- KPIs con glow backlight por color
+- Buscador flotante con debounce
+- Tablas paginadas con sort en headers
+- Export a Excel con openpyxl
+- Health filter por umbrales configurables
+- Stale data detection
+"""
+from __future__ import annotations
+
+import threading
+from datetime import datetime
+
+import flet as ft
+from src.config.theme import get_colors, rgba
+from src.ui.kpi_card import KPICard
+from src.ui.search_overlay import SearchOverlay
+
+
+class Dashboard:
+    def __init__(self, page: ft.Page, theme_mode: str = "dark"):
+        self.page = page
+        self._theme_mode = theme_mode
+        self.c = get_colors(self._theme_mode)
+        self._search_timer = None
+        self._theme_button: ft.IconButton | None = None
+
+        # State
+        self._raw_data: dict | None = None
+        self._kpis: dict | None = None
+        self._cache_timestamp: str | None = None
+        self._stale_data: bool = False
+
+        # UI refs
+        self._kpi_row: ft.Row | None = None
+        self._main_content: ft.Container | None = None
+        self._sidebar: ft.Container | None = None
+        self._status_text = ft.Text(
+            "Cargue datos para comenzar",
+            size=13, color=self.c["text_muted"], weight=ft.FontWeight.W_500,
+        )
+        self._ts_text = ft.Text("", size=11, color=self.c["text_muted"], weight=ft.FontWeight.W_500)
+        self._stale_badge = ft.Container(
+            content=ft.Row([
+                ft.Icon(ft.Icons.WARNING_AMBER, size=14, color=self.c["warning"]),
+                ft.Text("Datos en caché", size=11, color=self.c["warning"], weight=ft.FontWeight.W_500),
+            ], spacing=4, vertical_alignment=ft.CrossAxisAlignment.CENTER),
+            visible=False,
+            padding=ft.Padding(left=10, right=10, top=5, bottom=5),
+            bgcolor=rgba(self.c["warning"], 0.07),
+            border_radius=8,
+        )
+        self._empty_state = ft.Container(
+            visible=False,
+            content=ft.Column([
+                ft.Icon(ft.Icons.CLOUD_OFF, size=48, color=rgba(self.c["text_muted"], 0.35)),
+                ft.Text("Sin datos disponibles", size=16, color=self.c["text_muted"], weight=ft.FontWeight.W_600),
+                ft.Text("Verificando conexión...", size=13, color=rgba(self.c["text_muted"], 0.65)),
+            ], horizontal_alignment=ft.CrossAxisAlignment.CENTER, spacing=12),
+        )
+        self._loading_overlay = ft.Container(
+            visible=False,
+            content=ft.Column([
+                ft.ProgressRing(width=40, height=40, color=self.c["accent"]),
+                ft.Container(height=12),
+                ft.Text("Cargando...", size=14, color=self.c["text_primary"]),
+            ], horizontal_alignment=ft.CrossAxisAlignment.CENTER, spacing=0),
+            bgcolor=rgba(self.c["background"], 0.85),
+            expand=True,
+            alignment=ft.alignment.center,
+        )
+
+        # Callbacks
+        self._on_theme_toggle = None
+        self._on_refresh = None
+        self._file_picker = ft.FilePicker()
+
+    def set_on_theme_toggle(self, cb):
+        self._on_theme_toggle = cb
+
+    def set_on_refresh(self, cb):
+        self._on_refresh = cb
+
+    def register_overlay(self):
+        self.page.overlay.append(self._file_picker)
+
+    def build(self) -> ft.Container:
+        self._sidebar = self._build_sidebar()
+        self._main_content = self._build_main_content()
+
+        return ft.Row(
+            controls=[
+                self._sidebar,
+                ft.VerticalDivider(width=1, color=self.c["border"]),
+                self._main_content,
+            ],
+            expand=True,
+        )
+
+    def _build_header(self) -> ft.Container:
+        theme_icon = ft.Icons.DARK_MODE if self._theme_mode == "dark" else ft.Icons.LIGHT_MODE
+        self._theme_button = ft.IconButton(
+            icon=theme_icon,
+            icon_size=18,
+            tooltip="Cambiar tema",
+            on_click=lambda _: self._on_theme_toggle() if self._on_theme_toggle else None,
+        )
+
+        return ft.Container(
+            content=ft.Row([
+                ft.Text("G360 Dashboard", size=16, weight=ft.FontWeight.W_700, color=self.c["text_primary"]),
+                ft.Container(expand=True),
+                self._ts_text,
+                ft.Container(width=16),
+                self._stale_badge,
+                ft.Container(width=16),
+                self._status_text,
+                ft.Container(width=16),
+                self._theme_button,
+            ], vertical_alignment=ft.CrossAxisAlignment.CENTER),
+            padding=ft.Padding(left=20, right=20, top=12, bottom=12),
+            bgcolor=self.c["surface"],
+            border_bottom=ft.BorderSide(1, self.c["border"]),
+        )
+
+    def _build_kpi_row(self, kpis: dict) -> ft.Row:
+        kpi_keys = ["almacenes", "skus", "disponible", "predespacho", "sin_catalogo", "alertas", "criticos", "alto_stock"]
+        kpi_colors = self.c.get("kpis", {})
+
+        controls = []
+        for i, key in enumerate(kpi_keys):
+            data = kpis.get(key, {})
+            card = KPICard(
+                label=key.replace("_", " ").title(),
+                value=str(data.get("value", "-")),
+                color=kpi_colors.get(key, list(kpi_colors.values())[0]),
+                subtext=data.get("subtext", ""),
+            )
+            controls.append(card)
+            if i < len(kpi_keys) - 1:
+                controls.append(ft.Container(width=8))
+
+        return ft.Row(
+            controls=controls,
+            wrap=True,
+            spacing=0,
+            run_spacing=8,
+        )
+
+    def _build_sidebar(self) -> ft.Container:
+        search_field = ft.TextField(
+            hint_text="Buscar SKU, descripción...",
+            border_radius=8,
+            height=36,
+            text_size=12,
+            dense=True,
+            border=ft.InputBorder.OUTLINE,
+            border_color=self.c["border"],
+            focused_border_color=self.c["accent"],
+            cursor_color=self.c["accent"],
+            hint_style=ft.TextStyle(size=11, color=self.c["text_muted"]),
+            suffix_icon=ft.Icon(ft.Icons.KEYBOARD_RETURN, size=14, color=rgba(self.c["text_muted"], 0.5)),
+        )
+
+        return ft.Container(
+            content=ft.Column([
+                ft.Container(height=16),
+                ft.Text("Filtros", size=12, weight=ft.FontWeight.W_600, color=self.c["text_muted"]),
+                ft.Container(height=8),
+                search_field,
+                ft.Container(height=16),
+                ft.Divider(color=self.c["border"]),
+                ft.Container(height=8),
+                ft.Text("Almacenes", size=12, weight=ft.FontWeight.W_600, color=self.c["text_muted"]),
+                ft.Container(height=8),
+                ft.Column([], scroll=ft.ScrollMode.AUTO, expand=True, id="sidebar_alms"),
+            ], spacing=0, expand=True),
+            width=220,
+            bgcolor=self.c["surface"],
+            padding=ft.Padding(left=12, right=12, top=16, bottom=12),
+        )
+
+    def _build_main_content(self) -> ft.Container:
+        return ft.Container(
+            content=ft.Column([
+                self._build_header(),
+                ft.Container(content=self._kpi_row if self._kpi_row else self._build_kpi_row({}), expand=False),
+                ft.Container(height=12),
+                ft.Container(
+                    content=ft.Column([], scroll=ft.ScrollMode.AUTO, expand=True, id="main_cards"),
+                    expand=True,
+                ),
+                self._empty_state,
+                self._loading_overlay,
+            ], spacing=0, expand=True),
+            expand=True,
+            bgcolor=self.c["background"],
+            padding=ft.Padding(left=16, right=16, top=16, bottom=16),
+        )
+
+    # --- Update methods ---
+
+    def update_data(self, raw_data: dict, cache_timestamp: str | None = None, api_timestamp: str | None = None, stale: bool = False):
+        self._raw_data = raw_data
+        self._cache_timestamp = cache_timestamp
+        self._stale_data = stale
+        # Subclases implementan la logica de renderizado
+        self._render()
+
+    def _render(self):
+        # Implementar en subclase segun el dominio
+        pass
+
+    def update_theme(self, mode: str):
+        self._theme_mode = mode
+        self.c = get_colors(mode)
+        # Reconstruir UI con nuevos colores
+        self.page.bgcolor = self.c["background"]
+        self._rebuild_ui()
+
+    def _rebuild_ui(self):
+        if self._main_content:
+            self._main_content.content = self._build_main_content().content
+            self.page.update()
+
+    def set_loading(self, loading: bool, message: str = "Cargando..."):
+        self._loading_overlay.visible = loading
+        if loading:
+            self._loading_overlay.content.controls[2].value = message
+        self.page.update()
+
+    def set_offline(self, offline: bool):
+        if offline:
+            self._status_text.value = "Sin conexión"
+            self._status_text.color = self.c["error"]
+        else:
+            self._status_text.value = "Conectado"
+            self._status_text.color = self.c["success"]
+        self.page.update()
+
+    def _show_snack(self, msg: str, is_error: bool = False):
+        self.page.snack_bar = ft.SnackBar(
+            content=ft.Text(msg, size=13),
+            bgcolor=self.c["error"] if is_error else self.c["accent"],
+            duration=3000,
+        )
+        self.page.open(self.page.snack_bar)
+
+    def _show_empty_state(self, title: str, subtitle: str = ""):
+        self._empty_state.content.controls[1].value = title
+        if subtitle:
+            if len(self._empty_state.content.controls) > 2:
+                self._empty_state.content.controls[2].value = subtitle
+            else:
+                self._empty_state.content.controls.append(
+                    ft.Text(subtitle, size=13, color=rgba(self.c["text_muted"], 0.65))
+                )
+        self._empty_state.visible = True
+        self.page.update()
+
+    def _hide_empty_state(self):
+        self._empty_state.visible = False
+        self.page.update()
+
+    def _set_empty_state_status(self, msg: str, color: str):
+        for ctrl in self._empty_state.content.controls:
+            if isinstance(ctrl, ft.Text) and ctrl.size == 13:
+                ctrl.value = msg
+                ctrl.color = color
+                break
+        self.page.update()
+
+    def _update_refresh_status(self, cache_ts: str | None):
+        if cache_ts:
+            try:
+                dt = datetime.fromisoformat(cache_ts)
+                age_min = (datetime.now() - dt).total_seconds() / 60
+                self._ts_text.value = f"Hace {int(age_min)} min"
+            except Exception:
+                self._ts_text.value = ""
+        else:
+            self._ts_text.value = ""
+
+    def format_cache_timestamp(self, ts: str | None) -> str:
+        if not ts:
+            return ""
+        try:
+            return datetime.fromisoformat(ts).strftime("%H:%M:%S")
+        except Exception:
+            return ts[:19]
+
+    def _show_stale_warning(self):
+        self._stale_badge.visible = True
+        self.page.update()
+
+    def _hide_stale_warning(self):
+        self._stale_badge.visible = False
+        self.page.update()
+
+    def show_search_overlay(self):
+        """Abre el buscador flotante."""
+        overlay = SearchOverlay(self.page, self.c)
+        self.page.overlay.append(overlay)
+        self.page.open(overlay)