pyflutter-app 0.1.1__py3-none-any.whl

converter/__main__.py

@@ -0,0 +1,33 @@
+from pyflutter_ui import (
+    Provider, TkMaterialApp, run_app
+)
+from converter.excel.view import HomePage
+from converter.excel.controller import ControllerHomePage
+from converter.excel.model import ExcelModel
+
+from converter.page_forms import ControllerForms
+from converter.page_forms.model_forms import ModelForms
+import pandas as pd
+
+
+def main() -> None:
+    model = ExcelModel()
+    model_forms = ModelForms()
+    
+    controller_excel = ControllerHomePage(model)
+    controller_forms = ControllerForms(model_forms)
+    
+    app = TkMaterialApp(home=HomePage())
+    #app.register_notifier(controller)
+    Provider.add_state(controller_excel)
+    Provider.add_state(controller_excel.data_columns)
+    Provider.add_state(controller_forms)
+    
+    app.set_width(760)
+    app.set_height(480)
+    run_app(app)
+
+
+if __name__ == '__main__':
+    main()
+    

converter/assets/forms_config.json

@@ -0,0 +1,57 @@
+{
+    "form_url": "https://forms.office.com/pages/responsepage.aspx?id=hoDG-Fy5y0mdOO03lAq-9Q3te9L0aHxBnNMUUIYjxH9UMVFGS0ozVEVKVU84RlBDNTJXVlQ1UUZZRy4u",
+    "success_text": "Sua resposta foi enviada",
+    "wait_after_submit_ms": 2500,
+    "fields": [
+        {
+            "name": "uc",
+            "question_text": "uc",
+            "field_type": "text",
+            "column": null,
+            "options": [],
+            "multiple_files": false,
+            "date_format": "%d/%m/%Y",
+            "required": true
+        },
+        {
+            "name": "toi",
+            "question_text": "toi",
+            "field_type": "text",
+            "column": null,
+            "options": [],
+            "multiple_files": false,
+            "date_format": "%d/%m/%Y",
+            "required": true
+        },
+        {
+            "name": "local",
+            "question_text": "local de entrega",
+            "field_type": "radio",
+            "column": null,
+            "options": ["em mãos", "caixa de correios", "outro"],
+            "multiple_files": false,
+            "date_format": "%d/%m/%Y",
+            "required": true
+        },
+        {
+            "name": "tipo",
+            "question_text": "tipo de documento",
+            "field_type": "dropdown",
+            "column": null,
+            "options": ["carta calculo fatura", "via toi", "cumprimento sentença"],
+            "multiple_files": false,
+            "date_format": "%d/%m/%Y",
+            "required": true
+        },
+        {
+            "name": "data",
+            "question_text": "data",
+            "field_type": "date",
+            "column": null,
+            "options": [],
+            "multiple_files": false,
+            "date_format": "%d/%m/%Y",
+            "required": true
+        }
+    ]
+}

converter/excel/_page_edit.py

@@ -0,0 +1,199 @@
+# converter/excel/page_edit.py
+from __future__ import annotations
+
+import pandas as pd
+from pyflutter_ui import (
+    BuildContext, FlutterWidget, StatelessWidget,
+    Consumer, Column, Row, Expanded, Divider,
+    ElevatedButton, Text, SizedBox, Scaffold, AppBar,
+    MainAxisAlignment, CrossAxisAlignment,
+    SnackBar, SnackBarType, TableView, ValueNotifier,
+    ValueListenableBuilder, Provider, DropdownButton
+)
+from pyflutter_ui.widgets import ElevatedButton
+
+from converter.excel.controller import ControllerHomePage, DataNotifer, CommandEditColumns
+from converter.table_widget import TableOrProgress
+from table_stream import ArrayList
+
+
+class PageEditExcel(StatelessWidget):
+    """
+    Página de edição de dados — acessada via Navigator.push().
+    Exibe o DataFrame carregado e permite operações básicas.
+    """
+
+    def __init__(self, key: str | None = None) -> None:
+        super().__init__(key)
+
+    def build(self, context: BuildContext) -> FlutterWidget:
+        return _PageEditState()
+
+
+class _PageEditState(StatelessWidget):
+
+    def __init__(self) -> None:
+        super().__init__()
+        
+    @property
+    def controller(self) -> ControllerHomePage:
+        return Provider.read(ControllerHomePage)
+    
+    def add_work_col(self):
+        """
+            Ação do botão que adiciona uma coluna a lista de trabalho
+        """
+        
+        _selected: str = self.controller.data_notifier.selectedColumnSheet
+        self.controller.data_columns.add_column_edit(_selected)
+        
+        print(f'{__class__.__name__} [DEBUG] coluna adicionada ... {_selected}')
+
+    def action_back_page(self, context: BuildContext) -> None:
+        print(context.name)
+        context.navigator.pop()
+
+    def action_drop_column(self, context: BuildContext, columns: list[str]) -> None:
+        """
+            Ação para apagar uma lista de colunas.
+        """
+        self.controller.data_columns.delete_columns(ArrayList(columns))
+        
+    def action_load_data(self, context: BuildContext) -> None:
+        
+        if self.controller.get_file_sheet() is None:
+            SnackBar.of(context).show(
+            "Importe um arquivo na página anterior para prosseguir!",
+            type=SnackBarType.INFO,
+            )
+            return
+        
+        self.controller.command_load_data()
+        
+    def action_change_selected_column(self, col: str):
+        self.controller.data_columns.selectedColumn = col
+    
+    def build_selected_columns(self, context: BuildContext, controller: ControllerHomePage):
+        """
+            Colunas para edição apagar/concatenar etc.
+        """
+        columns: ArrayList[str] = controller.data_columns.value
+        current = columns.get_first() if columns.size() > 0 else "-"
+        
+        return DropdownButton(
+                    columns,
+                    current,
+                    on_changed=self.action_change_selected_column
+                )
+        
+    def build_value_selected_columns(self, context: BuildContext, columns: ArrayList[str]):
+        """
+            Colunas para edição apagar/concatenar etc.
+        """
+        current = columns.get_first() if columns.size() > 0 else "-"
+        
+        return DropdownButton(
+                    columns,
+                    current,
+                    on_changed=self.action_change_selected_column
+                )
+
+    def build_edit_options(self, context: BuildContext, controller_columns: CommandEditColumns) -> FlutterWidget:
+        """
+            Botões para editar o DataFrame()
+        """
+        
+        df: pd.DataFrame = controller_columns.controller.data_notifier.value
+        if df.empty:
+            return Text("Nenhum dado carregado")
+        
+        cols: ArrayList[str] = ArrayList(df.columns.tolist())
+         
+        return Row(
+            children=[
+                ElevatedButton("Adicionar coluna", on_pressed=self.add_work_col),
+                SizedBox(width=8),
+                DropdownButton(
+                    cols,
+                    on_changed=lambda x: controller_columns.controller.data_notifier.set_selected_column_sheet(x),
+                ),
+                Divider(),
+                #Consumer(ExcelController, self.build_selected_columns,),
+                ValueListenableBuilder[ArrayList[str]](
+                    controller_columns, self.build_value_selected_columns
+                ),
+            ],
+            main_axis_alignment=MainAxisAlignment.START,
+        )
+
+    def build_table(self, context: BuildContext, ctrl: ControllerHomePage) -> FlutterWidget:
+        
+        df = ctrl.data_notifier.value
+        if df.empty:
+            df = pd.DataFrame({"A": ["Sem dados"]})
+        return TableOrProgress(
+            running=ctrl.data_notifier.running,
+            df=df,
+        )
+
+    def build_info_sheet(self, context: BuildContext, controller: ControllerHomePage) -> FlutterWidget:
+        print(f'_build_info: {context.name}')
+        
+        df = controller.data_notifier.value
+        if df.empty:
+            return Text("Nenhum dado disponível")
+        
+        linhas, colunas = df.shape
+        arquivo = controller.get_file_sheet()
+        nome = arquivo.basename() if arquivo else "—"
+        
+        return Row(
+            children=[
+                Text(f"Arquivo: {nome}"),
+                Divider(orientation="horizontal"),
+                Text(f"{linhas} linhas"),
+                Divider(orientation="horizontal"),
+                Text(f"{colunas} colunas"),
+            ],
+            main_axis_alignment=MainAxisAlignment.START,
+        )
+
+    def build_body_app(self, context: BuildContext, ctrl: ControllerHomePage) -> FlutterWidget:
+        
+        return Column(
+            children=[
+                # ── barra de ações ──────────────────────────
+                Row(
+                    children=[
+                        ElevatedButton(
+                            "← Voltar",
+                            on_pressed=lambda: self.action_back_page(context),
+                        ),
+                        Divider(orientation="horizontal"),
+                        ElevatedButton(
+                            "Recarregar dados",
+                            on_pressed=lambda: self.action_load_data(context),
+                        ),
+                        # ── info do dataset ─────────────────────────
+                        Consumer(ControllerHomePage, self.build_info_sheet),
+                    ],
+                    main_axis_alignment=MainAxisAlignment.START,
+                ),
+                Divider(),
+                
+                Divider(),
+                # ── seletor de coluna para remoção ──────────
+                Consumer(CommandEditColumns, self.build_edit_options),
+                Divider(),
+                # ── tabela ──────────────────────────────────
+                Expanded(Consumer(ControllerHomePage, self.build_table)),
+            ],
+        )
+
+    def build(self, context: BuildContext) -> FlutterWidget:
+        context.name = "Build do Edit"
+        
+        return Scaffold(
+            Consumer(ControllerHomePage, builder=self.build_body_app),
+            #app_bar=AppBar("Edição de dados"),
+        )

converter/excel/controller.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+from typing import Any, Callable
+
+import pandas as pd
+from pandas import DataFrame
+
+from table_stream import (
+    SheetLoader, SheetType, SaveData, csvEncoding, csvSeparator,
+    CsvOptions, OptionsIOSheet, ParserData, FactorySaveData,
+    FactorySheetLoader, ArrayList, HashMapDict, ControllerThread, 
+    ConsumerThread, ThreadStateContext, ContextState
+)
+from table_stream.sysfiles import Directory, File
+
+
+from pyflutter_ui import ChangeNotifier, CommandNotifier, ValueNotifier
+from converter.excel.model import ExcelModel
+    
+    
+class FileNotifier(ValueNotifier[HashMapDict[str, File]]):
+    """
+        Controller/Notificador
+        
+    Notifica sobre a alteração de arquivos selecionados/adicionados pelo usuário.        
+    """
+    
+    
+    def __init__(self, value: Any) -> None:
+        super().__init__(value)
+        
+    def get_file_from_name(self, name: str) -> File:
+        if not self.value.header().contains(name):
+            raise ValueError()
+        return self.value.get_value(name)
+    
+    def clear(self) -> None:
+        self._value.clear()
+        
+    def delete_file(self, name: str):
+        self._value.delete_items([name])
+    
+    def add_files(self, files: list[File]) -> None:
+        """
+            Adiciona apenas arquivos NÃO EXISTENTES. Se o basename de um 
+        arquivo da lista for igual o basename de outro arquivo já existente
+        tal arquivo será ignorado, mantendo-se apenas o arquivo já existente.
+        """
+        file: File
+        for file in files:
+            if not self._value.header().contains(file.basename()):
+                self._value.set_value(file.basename(), file)
+        self.notify_listeners()
+        
+        
+class DataNotifer(ValueNotifier[pd.DataFrame]):
+    
+    def __init__(self, value: DataFrame) -> None:
+        super().__init__(value)
+        self.running: bool = False
+        cols = ArrayList(value.columns.tolist())
+        self.selectedColumnSheet: str = cols.get_first() if cols.size() > 0 else "-"
+        
+    @property
+    def value(self) -> DataFrame:
+        return self._value
+    
+    @value.setter
+    def value(self, value: pd.DataFrame) -> None:
+        self._value = value
+        
+        if (self.selectedColumnSheet is None) or (self.selectedColumnSheet == "-"):
+            columns = self.value.columns.tolist()
+            if len(columns) > 0:
+                self.selectedColumnSheet = columns[0]
+                
+        self.notify_listeners()
+        
+    def set_selected_column_sheet(self, col: str):
+        self.selectedColumnSheet = col
+        print(f'{__class__.__name__} coluna alterada: {col}')
+        
+    def clear(self):
+        self.running = False
+        self.value = pd.DataFrame()
+        
+        
+class CommandEditColumns(ValueNotifier[ArrayList[str]]):
+    
+    def __init__(self, value: ArrayList[str], controller: ControllerHomePage) -> None:
+        super().__init__(value)
+        self.running: bool = False
+        self.controller: ControllerHomePage = controller
+        self._columnsEdit: ArrayList[str] = value
+        self.selectedColumn: str | None = None
+        
+    @property
+    def columns(self) -> ArrayList[str]:
+        return ArrayList(self.controller.data_notifier.value.columns.tolist())
+    
+    @property
+    def data(self) -> pd.DataFrame:
+        return self.controller.data_notifier.value
+    
+    @data.setter
+    def data(self, data: pd.DataFrame):
+        self.controller.data_notifier.value = data
+    
+    def get_columns_edit(self) -> ArrayList[str]:
+        return self._columnsEdit
+    
+    def set_columns_edit(self, cols: ArrayList[str]):
+        self._columnsEdit = cols
+        
+    def add_column_edit(self, col: str):
+        if col is None:
+            return
+        if not self.columns.contains(col):
+            return
+        
+        if not self.get_columns_edit().contains(col):
+            self._columnsEdit.append(col)
+            self.notify_listeners()
+            print(f'* [DEBUG] coluna adicionada ==> {col}')
+            
+    def delete_columns(self, cols: ArrayList[str]):
+        self.running = True
+        self.notify_listeners()
+        
+        remove_list = ArrayList()
+        for col in cols:
+            if self.columns.contains(col):
+                remove_list.append(col)
+        
+        if remove_list.size() < 1: 
+            self.running = False
+            self.notify_listeners()
+            return
+        
+        parser = ParserData(self.data)
+        parser.delete_columns(remove_list)
+        self.data = parser.get_data()
+        self.running = False
+        self.notify_listeners()
+        
+        
+class ControllerHomePage(ValueNotifier[DataFrame]):
+    
+    def __init__(self, model: ExcelModel, *, value: pd.DataFrame = None) -> None:
+        if value is None:
+            value = pd.DataFrame()
+        super().__init__(value)
+        self.model: ExcelModel = model
+        self.operation_state: ContextState = ContextState()
+        
+        # Opções para leitura de uma planilha 
+        self.csv_options = CsvOptions()
+        self._file: File = None
+        self._sheet_name: str = None
+        self.sheet_names: ArrayList[str] = ArrayList()
+        
+        # Mapa de arquivos importados pelo usuário
+        self.files_notifier: FileNotifier = FileNotifier(HashMapDict())
+        
+        # Opções de exportação
+        self._options_save: OptionsIOSheet = OptionsIOSheet(SheetType.EXCEL)
+        
+        #======================================================#
+        # Leitura dos dados
+        #======================================================#
+        self.data_notifier = DataNotifer(pd.DataFrame())
+        self.data_columns = CommandEditColumns(ArrayList(), self)
+        
+        # Thread
+        self._currentThread: ControllerThread = None
+        self.thread_context: ThreadStateContext = ThreadStateContext()
+        # Menssagens
+        self.msg_erro = None
+        self.msg_info = None
+        
+    @property
+    def sheet_name(self) -> str:
+        return self._sheet_name
+    
+    @sheet_name.setter
+    def sheet_name(self, new: str):
+        if not self.sheet_names.contains(new):
+            print(f'[DEBUG] Aba ... {new} não está disponível para o arquivo: {self._file}')
+            return
+        self._sheet_name = new
+        self.msg_info = f"Aba atualizada ... {self._sheet_name}"
+        self.notify_listeners()
+        self.command_load_data()
+        
+    @property
+    def options_load(self) -> OptionsIOSheet | None:
+        if self._file is None:
+            return None
+        
+        opt_load = OptionsIOSheet(SheetType.EXCEL if self._file.is_excel() else SheetType.CSV)
+        
+        if self._file.is_ods():
+            opt_load.sheet_type = SheetType.ODS
+        if self._sheet_name is not None:
+            opt_load.sheet_name = self._sheet_name
+            
+        return opt_load
+        
+    @property
+    def sheet_loader(self) -> SheetLoader:
+        if self._file is None:
+            raise ValueError('Nenhum arquivo disponível') 
+        return SheetLoader.create(self.options_load, self._file)
+    
+    @property
+    def running(self) -> bool:
+        return self.operation_state.state.is_running()
+         
+    @property
+    def files(self) -> ArrayList[File]:
+        return self.files_notifier.value.values()
+    
+    def create_consumer(self, on_finish: Callable[[ThreadStateContext]]) -> ConsumerThread:
+        consumer = ConsumerThread(ThreadStateContext, on_finish=on_finish)
+        self.thread_context.add_listener(consumer)
+        return consumer
+        
+    def init_thread(self) -> None:
+        self._currentThread._state_context = self.thread_context
+        self._currentThread.start()
+        self.operation_state.start()
+        self.notify_listeners()
+    
+    def set_file_sheet(self, file: File):
+        self._file = file
+        self.sheet_names = self.sheet_loader.get_sheet_names()
+        self.notify_listeners()
+        self.sheet_name = self.sheet_names.get_first()
+        
+    def get_file_sheet(self) -> File:
+        return self._file  
+        
+    def add_files(self, files: ArrayList[File]):
+        self.files_notifier.add_files(files)
+        self.notify_listeners()
+        
+    def command_delete_columns(self):
+        if self.running:
+            raise RuntimeError("Já existe outra operação de leitura em andamento...")
+        
+        self._currentThread = ControllerThread(
+            target=self.data_columns.delete_columns, args=self.data_columns.value
+        )
+        self.create_consumer(lambda context: self.operation_state.finish(context.is_error()))
+        
+        self.init_thread()
+        
+    def action_finish_delete_columns(self, result: ThreadStateContext[None]):
+        self.operation_state.finish(result.is_error())
+        self.notify_listeners()
+        
+    def command_load_data(self) -> None:
+        if self.running:
+            raise RuntimeError("Já existe outra operação de leitura em andamento...")
+        
+        loader = self.sheet_loader
+        self._currentThread = ControllerThread(target=loader.load)
+        c = self.create_consumer(self.action_finish_load) 
+        c.on_error = self._action_error_load_data
+        
+        self.data_notifier.running = True
+        self.data_notifier.value = pd.DataFrame()
+        self.msg_info = "Carregando dados..."
+        self.init_thread()
+        
+    def _action_error_load_data(self, result: ThreadStateContext):
+        self.data_notifier.running = False
+        self.msg_erro = f'{result.get_exception()}'
+    
+    def action_finish_load(self, result: ThreadStateContext[pd.DataFrame]) -> None:
+        self.data_notifier.running = False
+        self.data_notifier.value = result.value
+        self._currentThread = None
+        
+        if not self.data_notifier.value.empty:
+            self.msg_info = "Planilha carregada com sucesso..."
+        
+        self.operation_state.finish(result.is_error())
+        self.notify_listeners()
+    
+    def init_state(self, data: HashMapDict = None):
+        if data is not None:
+            pass
+    
+    def dispose(self):
+        self._options_load = None
+        self._options_save = None
+        self.files_notifier.value.clear()

converter/excel/model.py

@@ -0,0 +1,14 @@
+import pandas as pd
+from pandas import DataFrame
+from table_stream.hash_map import ArrayList, HashMapDict
+from table_stream.sheet import (
+    SheetLoader, SheetType, SaveData, csvEncoding, csvSeparator,
+    CsvOptions, OptionsIOSheet, ParserData, FactorySaveData,
+    FactorySheetLoader,
+)
+
+
+class ExcelModel(object):
+    
+    def __init__(self) -> None:
+        pass