pyflutter-app 0.3.7__tar.gz → 0.3.10__tar.gz

{pyflutter_app-0.3.7 → pyflutter_app-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyflutter_app
-Version: 0.3.7
+Version: 0.3.10
 Summary: Bibliotecas Python para conversão de documentos, interface e processamento de tabelas.
 Requires-Python: >=3.12
 Requires-Dist: opencv-python>=5.0.0.93

{pyflutter_app-0.3.7 → pyflutter_app-0.3.10}/cartas/__init__.py

@@ -33,7 +33,7 @@ from table_stream import (
     load_file_hash,
 )
 
-from ocrlib import HeaderOcr, BuilderConfigOcr, CreateRelatorioOcr
+from ocr_stream import HeaderOcr, BuilderConfigOcr, CreateRelatorioOcr
 
 from whatsapp_files import (
     RowWhatsApp,

{pyflutter_app-0.3.7 → pyflutter_app-0.3.10}/cartas/origin.py

@@ -31,7 +31,7 @@ from table_stream import (
     load_file_hash,
 )
 
-from ocrlib import HeaderOcr, BuilderConfigOcr, CreateRelatorioOcr
+from ocr_stream import HeaderOcr, BuilderConfigOcr, CreateRelatorioOcr
 
 from whatsapp_files import (
     RowWhatsApp,

{pyflutter_app-0.3.7 → pyflutter_app-0.3.10}/converter/home_page/view.py

@@ -46,6 +46,7 @@ from converter.page_forms import PageRespondsForms
 from converter.page_forms import ControllerForms
 from converter.config_app import MapConfig, AppConfigNotifier
 from converter.page_image import PageImage
+from converter.page_circuit import PageCircuit
 
 
 class HomePage(StatelessWidget):
@@ -328,6 +329,10 @@ class _HomePageState(StatelessWidget):
                             "Renomear imagens",
                             lambda: context.navigator.push(PageImage()),
                         ),
+                        ElevatedButton(
+                            "Dividir base (QGIS)",
+                            lambda: context.navigator.push(PageCircuit()),
+                        ),
                     ],
                     main_axis_alignment=MainAxisAlignment.START,
                 ),

pyflutter_app-0.3.10/converter/page_circuit/__init__.py

@@ -0,0 +1,20 @@
+from .common import (
+    ItemStatus,
+    SplitConfig,
+    SplitEvent,
+    SplitEventType,
+    SplitSummary,
+)
+from .service import (
+    ConsoleObserver,
+    CsvExporter,
+    DataFrameSplitService,
+    ExcelExporter,
+    ReportObserver,
+    SplitGroup,
+    SplitObserver,
+    SplitPlanner,
+)
+from .model_circuit import ModelCircuit
+from .controller_circuit import ControllerCircuit
+from .view_circuit import PageCircuit

pyflutter_app-0.3.10/converter/page_circuit/common.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+import re
+from dataclasses import dataclass, field
+from enum import Enum, StrEnum
+from typing import Any
+
+from table_stream import CsvOptions, Directory
+
+
+# ============================================================
+# Status / eventos (Observer)
+# ============================================================
+class ItemStatus(StrEnum):
+    PENDING = "pendente"
+    DONE = "exportado"
+    SKIPPED = "pulado"
+    ERROR = "erro"
+
+
+class SplitEventType(Enum):
+    STARTED = "started"
+    ITEM = "item"  # um grupo (ex.: numliv = 5) foi processado
+    FINISHED = "finished"
+
+
+@dataclass(frozen=True)
+class SplitSummary:
+    total_groups: int = 0
+    exported_files: int = 0
+    skipped_files: int = 0
+    errors: int = 0
+    stopped: bool = False
+    elapsed_s: float = 0.0
+    output_dir: str = ""
+    period: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class SplitEvent:
+    """Evento enviado pelo service a todos os observadores."""
+
+    type: SplitEventType
+    done: int = 0
+    total: int = 0
+    group: str = ""
+    key: str = ""
+    period: str = ""
+    rows: int = 0
+    status: ItemStatus | None = None
+    files: tuple[str, ...] = ()
+    message: str = ""
+    summary: SplitSummary | None = None
+
+
+# ============================================================
+# Configuração
+# ============================================================
+@dataclass
+class SplitConfig:
+    column_split: str
+    output_dir: Directory
+    export_csv: bool = True
+    export_excel: bool = True
+
+    # Estrutura OUTPUT/<numano>/<nummes>/<CSV|EXCEL>/<grupo>.<ext>
+    use_period_dirs: bool = True
+    year_column: str = "numano"
+    month_column: str = "nummes"
+
+    replace: bool = False
+    csv_options: CsvOptions = field(default_factory=CsvOptions)
+
+    # Opcional: prefixo no nome do arquivo, vindo de outra coluna ("<prefixo>-<grupo>")
+    filename_prefix_column: str | None = None
+
+
+# ============================================================
+# Utilidades de texto
+# ============================================================
+_INVALID_NAME = re.compile(r'[\\/:*?"<>|\r\n\t]+')
+_NATURAL = re.compile(r"(\d+)")
+
+
+def clean_cell(value: Any) -> str:
+    """'2025.0' -> '2025'; nan/None -> ''."""
+    s = str(value).strip()
+    if s in ("", "nan", "NaN", "None", "NaT"):
+        return ""
+    return s[:-2] if s.endswith(".0") and s[:-2].isdigit() else s
+
+
+def safe_filename(name: str) -> str:
+    cleaned = _INVALID_NAME.sub("_", name).strip(" .")
+    return cleaned or "vazio"
+
+
+def natural_key(text: str) -> list[str | int]:
+    """Ordenação natural: 2 vem antes de 10."""
+    return [int(t) if t.isdecimal() else t.lower() for t in _NATURAL.split(text)]

pyflutter_app-0.3.10/converter/page_circuit/controller_circuit.py

@@ -0,0 +1,359 @@
+from __future__ import annotations
+import os
+import subprocess
+import sys
+import time
+from typing import Callable
+
+import pandas as pd
+
+from pyflutter_ui import ChangeNotifier, Provider
+from pyflutter_ui.scheduler import MainThreadScheduler
+from table_stream import ArrayList, CsvOptions, Directory, File
+
+from converter.config_app import AppConfigNotifier
+from converter.page_circuit.common import (
+    ItemStatus,
+    SplitConfig,
+    SplitEvent,
+    SplitEventType,
+    SplitSummary,
+)
+from converter.page_circuit.model_circuit import ModelCircuit
+from converter.page_circuit.service import ReportObserver, SplitGroup, SplitObserver
+
+DEFAULT_SPLIT_COLUMN = "numliv"
+MAX_VIEW_ROWS = 1000
+
+CSV_SEPARATORS: dict[str, str] = {
+    "tabulação": "\t",
+    "ponto_virgula": ";",
+    "virgula": ",",
+    "pipe": "|",
+}
+CSV_ENCODINGS: dict[str, str] = {
+    "utf8": "utf-8",
+    "cp1252": "cp1252",
+    "iso-8859-1": "iso-8859-1",
+    "latin": "latin1",
+}
+
+
+def _ui(fn: Callable[[], None]) -> None:
+    """Executa fn na thread da UI (os eventos vêm da worker thread)."""
+    try:
+        MainThreadScheduler.run(fn)
+    except RuntimeError:
+        fn()
+
+
+class _UiObserver(SplitObserver):
+    """Observer que leva os eventos do service para o controller, na thread da UI."""
+
+    def __init__(self, controller: ControllerCircuit) -> None:
+        super().__init__()
+        self._controller = controller
+
+    def update(self, value: SplitEvent) -> None:
+        _ui(lambda: self._controller.on_event(value))
+
+
+class ControllerCircuit(ChangeNotifier):
+
+    def __init__(self, model: ModelCircuit) -> None:
+        super().__init__()
+        self.model: ModelCircuit = model
+
+        self.file: File | None = None
+        self.df: pd.DataFrame = pd.DataFrame()
+        self.columns: ArrayList[str] = ArrayList()
+        self.split_column: str | None = None
+
+        self._output_dir: Directory | None = None
+        self.export_csv: bool = True
+        self.export_excel: bool = True
+        self.use_period_dirs: bool = True
+        self.replace: bool = False
+        self.separator_name: str = "tabulação"
+        self.encoding_name: str = "utf8"
+
+        self.plan: list[SplitGroup] = []
+        self.group_state: dict[str, tuple[ItemStatus, str]] = {}
+        self.summary: SplitSummary | None = None
+
+        self.loading: bool = False
+        self.exporting: bool = False
+        self.progress: tuple[int, int] = (0, 0)
+        self.status_text: str = "Importe a base exportada do sistema para começar."
+
+        self._last_notify: float = 0.0
+        self._observer = _UiObserver(self)
+        self._report = ReportObserver()
+
+        self.fn_show_error: Callable[[str], None] | None = None
+        self.fn_show_info: Callable[[str], None] | None = None
+
+    # ------------------------------------------------------------------ infra
+    def get_config(self) -> AppConfigNotifier:
+        return Provider.read(AppConfigNotifier)
+
+    def show_error(self, msg: str) -> None:
+        if self.fn_show_error is not None:
+            self.fn_show_error(msg)
+
+    def show_info(self, msg: str) -> None:
+        if self.fn_show_info is not None:
+            self.fn_show_info(msg)
+
+    @property
+    def busy(self) -> bool:
+        return self.loading or self.exporting
+
+    @property
+    def progress_fraction(self) -> float:
+        done, total = self.progress
+        return (done / total) if total > 0 else 0.0
+
+    @property
+    def output_dir(self) -> Directory:
+        if self._output_dir is None:
+            self._output_dir = self.get_config().value.work_dir.concat("Circuitos")
+        return self._output_dir
+
+    def set_output_dir(self, d: Directory) -> None:
+        self._output_dir = d
+        self.notify_listeners()
+
+    @property
+    def file_label(self) -> str:
+        return self.file.basename() if self.file else "Nenhuma base importada"
+
+    @property
+    def info_text(self) -> str:
+        if self.df.empty:
+            return "-"
+        periods = sorted({g.period for g in self.plan if g.period})
+        period = f"Período: {', '.join(periods)} | " if periods else ""
+        return f"{period}{len(self.df)} linhas | {len(self.plan)} grupos"
+
+    # ------------------------------------------------------------------ opções
+    def build_config(self) -> SplitConfig:
+        return SplitConfig(
+            column_split=self.split_column or "",
+            output_dir=self.output_dir,
+            export_csv=self.export_csv,
+            export_excel=self.export_excel,
+            use_period_dirs=self.use_period_dirs,
+            replace=self.replace,
+            csv_options=CsvOptions(
+                encoding=CSV_ENCODINGS[self.encoding_name],
+                separator=CSV_SEPARATORS[self.separator_name],
+            ),
+        )
+
+    def set_export_csv(self, v: bool) -> None:
+        self.export_csv = v
+
+    def set_export_excel(self, v: bool) -> None:
+        self.export_excel = v
+
+    def set_replace(self, v: bool) -> None:
+        self.replace = v
+
+    def set_separator(self, name: str) -> None:
+        if name in CSV_SEPARATORS:
+            self.separator_name = name
+
+    def set_encoding(self, name: str) -> None:
+        if name in CSV_ENCODINGS:
+            self.encoding_name = name
+
+    def set_use_period(self, v: bool) -> None:
+        self.use_period_dirs = v
+        self.refresh_plan()
+        self.notify_listeners()
+
+    def set_split_column(self, col: str) -> None:
+        if self.busy or col == self.split_column:
+            return
+        self.split_column = col
+        self.refresh_plan()
+        self.notify_listeners()
+
+    # ------------------------------------------------------------------ plano
+    def refresh_plan(self) -> None:
+        self.group_state.clear()
+        self.summary = None
+        self.progress = (0, 0)
+
+        if self.df.empty or not self.split_column:
+            self.plan = []
+            return
+        try:
+            self.plan = self.model.plan(self.df, self.build_config())
+        except Exception as e:
+            self.plan = []
+            self.show_error(str(e))
+            return
+        self.status_text = (
+            f"Pronto: {len(self.plan)} arquivos por formato "
+            f"(coluna '{self.split_column}')."
+        )
+
+    def view_data(self) -> pd.DataFrame:
+        if not self.plan:
+            return pd.DataFrame({"-": ["Sem dados"]})
+
+        records = []
+        for n, g in enumerate(self.plan[:MAX_VIEW_ROWS], start=1):
+            status, files = self.group_state.get(g.key, (ItemStatus.PENDING, ""))
+            records.append(
+                {
+                    "#": n,
+                    "PERÍODO": g.period or "-",
+                    "GRUPO": g.name or "(vazio)",
+                    "LINHAS": g.rows,
+                    "STATUS": status.value,
+                    "ARQUIVOS": files,
+                }
+            )
+        return pd.DataFrame(records)
+
+    # ------------------------------------------------------------------ importação
+    def import_file(self, f: File) -> None:
+        if self.busy:
+            self.show_info("Existe outra operação em andamento.")
+            return
+
+        self.loading = True
+        self.status_text = f"Lendo {f.basename()} ..."
+        self.notify_listeners()
+
+        try:
+            self.model.start_load(
+                f,
+                CSV_ENCODINGS[self.encoding_name],
+                lambda df, err: _ui(lambda: self._on_loaded(f, df, err)),
+            )
+        except Exception as e:
+            self.loading = False
+            self.show_error(str(e))
+
+    def _on_loaded(self, f: File, df: pd.DataFrame | None, err: Exception | None) -> None:
+        self.loading = False
+
+        if err is not None or df is None:
+            self.status_text = f"Erro ao ler a base: {err}"
+            self.notify_listeners()
+            self.show_error(f"Não foi possível ler a base:\n{err}")
+            return
+
+        self.file = f
+        self.df = df
+        self.columns = ArrayList(df.columns.astype(str).tolist())
+        self.split_column = (
+            DEFAULT_SPLIT_COLUMN if self.columns.contains(DEFAULT_SPLIT_COLUMN)
+            else (self.columns.get_first() if not self.columns.empty() else None)
+        )
+        self.refresh_plan()
+        self.notify_listeners()
+
+    # ------------------------------------------------------------------ exportação
+    def start_export(self) -> None:
+        if self.busy:
+            self.show_info("Existe outra operação em andamento.")
+            return
+        if self.df.empty or not self.split_column:
+            self.show_error("Importe uma base antes de exportar.")
+            return
+        if not (self.export_csv or self.export_excel):
+            self.show_error("Selecione ao menos um formato (CSV ou Excel).")
+            return
+
+        self.refresh_plan()
+        if not self.plan:
+            return
+
+        self.exporting = True
+        self.progress = (0, len(self.plan))
+        self.status_text = "Iniciando exportação..."
+        self.notify_listeners()
+
+        try:
+            self.model.start_export(
+                self.df,
+                self.build_config(),
+                [self._observer, self._report],
+                lambda e: _ui(lambda: self._on_export_error(e)),
+            )
+        except Exception as e:
+            self.exporting = False
+            self.show_error(str(e))
+
+    def stop_export(self) -> None:
+        if not self.exporting:
+            return
+        self.model.request_stop()
+        self.status_text = "Parando após o grupo atual..."
+        self.notify_listeners()
+
+    def _on_export_error(self, e: Exception) -> None:
+        self.exporting = False
+        self.status_text = f"Erro: {e}"
+        self.notify_listeners()
+        self.show_error(str(e))
+
+    # ------------------------------------------------------------------ eventos (thread da UI)
+    def on_event(self, ev: SplitEvent) -> None:
+        if ev.type == SplitEventType.STARTED:
+            self.progress = (0, ev.total)
+            self.notify_listeners()
+            return
+
+        if ev.type == SplitEventType.ITEM:
+            files = ", ".join(os.path.basename(p) for p in ev.files) or ev.message
+            self.group_state[ev.key] = (ev.status or ItemStatus.PENDING, files)
+            self.progress = (ev.done, ev.total)
+            self.status_text = f"Exportando {ev.done}/{ev.total} | {ev.group or '(vazio)'}"
+
+            now = time.monotonic()  # evita piscar a tela: no máx. ~5 atualizações/s
+            if ev.done == ev.total or now - self._last_notify > 0.2:
+                self._last_notify = now
+                self.notify_listeners()
+            return
+
+        if ev.type == SplitEventType.FINISHED and ev.summary is not None:
+            s = ev.summary
+            self.exporting = False
+            self.summary = s
+            self.progress = (s.total_groups, s.total_groups) if not s.stopped else self.progress
+            head = "Interrompido" if s.stopped else "Concluído"
+            self.status_text = (
+                f"{head} | arquivos: {s.exported_files} | pulados: {s.skipped_files} "
+                f"| erros: {s.errors} | {s.elapsed_s:.1f}s"
+            )
+            self.notify_listeners()
+
+            if s.errors:
+                self.show_error(
+                    f"{s.errors} grupo(s) com erro. Veja a coluna STATUS e o relatório."
+                )
+            else:
+                report = self._report.last_report
+                extra = f"\n\nRelatório: {report.absolute()}" if report else ""
+                self.show_info(f"{head}.\n\nSaída: {s.output_dir}{extra}")
+
+    # ------------------------------------------------------------------ utilidades
+    def open_output_dir(self) -> None:
+        d = self.output_dir
+        d.mkdir()
+        path = d.absolute()
+        try:
+            if sys.platform == "win32":
+                os.startfile(path)  # type: ignore[attr-defined]
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", path])
+            else:
+                subprocess.Popen(["xdg-open", path])
+        except Exception as e:
+            self.show_error(f"Não foi possível abrir a pasta:\n{e}")

pyflutter_app-0.3.10/converter/page_circuit/model_circuit.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+import threading
+from typing import Callable
+
+import pandas as pd
+
+from table_stream import File
+
+from converter.page_circuit.common import SplitConfig
+from converter.page_circuit.service import (
+    DataFrameSplitService,
+    SplitGroup,
+    SplitObserver,
+)
+
+
+class ModelCircuit:
+    """Model: sem UI. Lê a base, calcula o plano e roda a exportação em worker thread."""
+
+    def __init__(self) -> None:
+        self.service = DataFrameSplitService()
+        self._export_thread: threading.Thread | None = None
+        self._load_thread: threading.Thread | None = None
+
+    # ------------------------------------------------------------------ estado
+    def is_exporting(self) -> bool:
+        return self._export_thread is not None and self._export_thread.is_alive()
+
+    def is_loading(self) -> bool:
+        return self._load_thread is not None and self._load_thread.is_alive()
+
+    def request_stop(self) -> None:
+        self.service.stop()
+
+    # ------------------------------------------------------------------ leitura
+    @staticmethod
+    def read_dataframe(file: File, encoding: str) -> pd.DataFrame:
+        """Tudo como texto (dtype=str): preserva zeros à esquerda e evita 5 -> 5.0."""
+        if file.is_excel():
+            return pd.read_excel(file.absolute(), dtype=str, keep_default_na=False)
+        if file.is_ods():
+            return pd.read_excel(
+                file.absolute(), dtype=str, keep_default_na=False, engine="odf"
+            )
+        if file.is_csv():
+            last: Exception | None = None
+            for enc in dict.fromkeys([encoding, "utf-8", "latin1"]):
+                try:
+                    return pd.read_csv(
+                        file.absolute(),
+                        dtype=str,
+                        keep_default_na=False,
+                        sep=None,  # detecta o separador sozinho
+                        engine="python",
+                        encoding=enc,
+                    )
+                except UnicodeDecodeError as e:
+                    last = e
+            raise ValueError(f"Não foi possível decodificar o CSV: {last}")
+        raise ValueError(f"Tipo de planilha inválido: {file.basename()}")
+
+    def start_load(
+        self,
+        file: File,
+        encoding: str,
+        on_done: Callable[[pd.DataFrame | None, Exception | None], None],
+    ) -> None:
+        if self.is_loading():
+            raise RuntimeError("Já existe uma leitura em andamento")
+
+        def work() -> None:
+            df: pd.DataFrame | None = None
+            err: Exception | None = None
+            try:
+                df = self.read_dataframe(file, encoding)
+            except Exception as e:
+                err = e
+            finally:
+                on_done(df, err)
+
+        self._load_thread = threading.Thread(target=work, daemon=True, name="circuit-load")
+        self._load_thread.start()
+
+    # ------------------------------------------------------------------ plano / exportação
+    def plan(self, df: pd.DataFrame, config: SplitConfig) -> list[SplitGroup]:
+        return self.service.plan(df, config)
+
+    def start_export(
+        self,
+        df: pd.DataFrame,
+        config: SplitConfig,
+        observers: list[SplitObserver],
+        on_error: Callable[[Exception], None],
+    ) -> None:
+        if self.is_exporting():
+            raise RuntimeError("Já existe uma exportação em andamento")
+
+        def work() -> None:
+            for o in observers:
+                self.service.attach(o)
+            try:
+                self.service.run(df, config)
+            except Exception as e:
+                on_error(e)
+            finally:
+                for o in observers:
+                    self.service.detach(o)
+
+        self._export_thread = threading.Thread(target=work, daemon=True, name="circuit-export")
+        self._export_thread.start()