pyflutter-app 0.1.8__tar.gz → 0.2.1__tar.gz

{pyflutter_app-0.1.8 → pyflutter_app-0.2.1}/.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/pyflutter.iml" filepath="$PROJECT_DIR$/.idea/pyflutter.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/pyflutter_app.iml" filepath="$PROJECT_DIR$/.idea/pyflutter_app.iml" />
     </modules>
   </component>
 </project>

pyflutter_app-0.1.8/.idea/pyflutter.iml → pyflutter_app-0.2.1/.idea/pyflutter_app.iml

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
+<module external.system.id="pyproject.toml" type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/.venv" />
     </content>
-    <orderEntry type="jdk" jdkName="uv (pyflutter)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="~/GIT/pyflutter/.venv" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="PyDocumentationSettings">

{pyflutter_app-0.1.8 → pyflutter_app-0.2.1}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.5
 Name: pyflutter_app
-Version: 0.1.8
+Version: 0.2.1
 Summary: Bibliotecas Python para conversão de documentos, interface e processamento de tabelas.
 Requires-Python: >=3.14
 Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas-stubs~=3.0.3
 Requires-Dist: pandas>=3.0.0
 Description-Content-Type: text/markdown
 

{pyflutter_app-0.1.8 → pyflutter_app-0.2.1}/converter/config_app.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
-from typing import Any, Callable
 from dataclasses import dataclass
 
-from table_stream.sysfiles import File, Directory, UserFileSystem, JsonConvert, JsonData
+from table_stream.sysfiles import File, Directory, UserFileSystem, JsonConvert
 from table_stream import HashMapDict
 from pyflutter_ui.theme import ThemeMode
-from pyflutter_ui.core import ValueNotifier, ChangeNotifier
+from pyflutter_ui.ui.core import ValueNotifier
 
 
 @dataclass

{pyflutter_app-0.1.8 → pyflutter_app-0.2.1}/converter/home_page/_page_edit.py

@@ -1,21 +1,17 @@
 # converter/excel/page_edit.py
 from __future__ import annotations
 
-import pandas as pd
-from pyflutter_ui import (
+from converter.util import (
     BuildContext, FlutterWidget, StatelessWidget,
     Consumer, Column, Row, Expanded, Divider,
-    ElevatedButton, Text, SizedBox, Scaffold, AppBar,
-    MainAxisAlignment, CrossAxisAlignment,
-    SnackBar, SnackBarType, TableView, ValueNotifier,
-    ValueListenableBuilder, Provider, DropdownButton
+    Text, SizedBox, Scaffold, MainAxisAlignment, SnackBar, SnackBarType, TableView, ValueNotifier,
+    ValueListenableBuilder, Provider, DropdownButton, ElevatedButton, ArrayList,
 )
-from pyflutter_ui.widgets import ElevatedButton
 
-from converter.home_page.controller import ControllerHomePage, DataNotifer, CommandEditColumns
+from converter.home_page.controller import ControllerHomePage, CommandEditColumns
 from converter.table_widget import TableOrProgress
-from table_stream import ArrayList
 
+import pandas as pd
 
 class PageEditExcel(StatelessWidget):
     """

{pyflutter_app-0.1.8 → pyflutter_app-0.2.1}/converter/home_page/controller.py

@@ -1,32 +1,60 @@
 from __future__ import annotations
-from typing import Any, Callable
+from typing import Callable, TypeVar
 
 import pandas as pd
 from pandas import DataFrame
 
-from table_stream import (
+from converter.util import (
     SheetLoader, SheetType, SaveData, csvEncoding, csvSeparator,
     CsvOptions, OptionsIOSheet, ParserData, FactorySaveData,
-    FactorySheetLoader, ArrayList, HashMapDict, ControllerThread, 
-    ConsumerThread, ThreadStateContext, ContextState
+    FactorySheetLoader, ControllerThread, ArrayList, HashMapDict,
+    Directory, File, NotInicializedState, StateValue, EventState,
+    ThreadStateValue
 )
-from table_stream.sysfiles import Directory, File
-from table_stream.state import NotInicializedState
 
 from pyflutter_ui import ChangeNotifier, CommandNotifier, ValueNotifier, Provider
 from converter.home_page.model import ExcelModel
 from converter.config_app import AppConfigNotifier, MapConfig
     
+T = TypeVar('T')
+
+    
+class ValueNotifierEvent[T](ValueNotifier):
+    
+    def __init__(self, value: T) -> None:
+        super().__init__(value)
+        self.state_value: StateValue[T] = StateValue()
+        
+    @property
+    def running(self) -> bool:
+        return self.state_value.is_running()
+    
+    @property
+    def state(self) -> EventState:
+        return self.state_value.get_state()    
+    
+    def get_controller(self) -> ControllerHomePage:
+        return Provider.read(ControllerHomePage)
     
-class FileNotifier(ValueNotifier[HashMapDict[str, File]]):
+    
+class FileNotifier(ValueNotifierEvent[HashMapDict[str, File]]):
     """
         Controller/Notificador
         
     Notifica sobre a alteração de arquivos selecionados/adicionados pelo usuário.        
     """
     
-    def __init__(self, value: Any) -> None:
+    def __init__(self, value: HashMapDict[str, File]) -> None:
         super().__init__(value)
+        self.file: File = None
+        
+    def set_selected_file(self, f: File):
+        if not self.value.header().contains(f.basename()):
+            self._value.set_value(f.basename(), f)
+            
+        self.file = f
+        print(f'Arquivo alterado ... {f.absolute()}')
+        self.notify_listeners()
         
     def get_file_from_name(self, name: str) -> File:
         if not self.value.header().contains(name):
@@ -52,14 +80,21 @@ class FileNotifier(ValueNotifier[HashMapDict[str, File]]):
         self.notify_listeners()
         
         
-class DataNotifer(ValueNotifier[pd.DataFrame]):
+class DataNotifer(ValueNotifierEvent[pd.DataFrame]):
+    """
+    Controller/Notificador
     
+    Notifica sobre a alteração de um 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 controller(self) -> ControllerHomePage:
+        return self.get_controller()
+        
     @property
     def value(self) -> DataFrame:
         return self._value
@@ -77,22 +112,24 @@ class DataNotifer(ValueNotifier[pd.DataFrame]):
         
     def set_selected_column_sheet(self, col: str):
         self.selectedColumnSheet = col
-        print(f'{__class__.__name__} coluna alterada: {col}')
+        print(f'{__class__.__name__} Coluna selecionada: {col}')
         
     def clear(self):
-        self.running = False
-        self.value = pd.DataFrame()
+        self._result = pd.DataFrame()
+        self.state_value.reset_state()
         
         
-class CommandEditColumns(ValueNotifier[ArrayList[str]]):
+class CommandEditColumns(ValueNotifierEvent[ArrayList[str]]):
     
-    def __init__(self, value: ArrayList[str], controller: ControllerHomePage) -> None:
+    def __init__(self, value: ArrayList[str]) -> None:
         super().__init__(value)
-        self.running: bool = False
-        self.controller: ControllerHomePage = controller
         self._columnsEdit: ArrayList[str] = value
         self.selectedColumn: str | None = None
         
+    @property
+    def controller(self) -> ControllerHomePage:
+        return self.get_controller()
+        
     @property
     def columns(self) -> ArrayList[str]:
         return ArrayList(self.controller.data_notifier.value.columns.tolist())
@@ -129,23 +166,22 @@ class CommandEditColumns(ValueNotifier[ArrayList[str]]):
                 remove_list.append(col)
         
         if remove_list.size() < 1: 
-            self.running = False
+            self.state_value.reset_state()
             self.notify_listeners()
             return
         
-        self.running = True
+        self.state_value.start()
         self.notify_listeners()
         self.controller.model.delete_columns(self.data, cols)
         
-    def _action_finish_delete_cols(self, c: ThreadStateContext[pd.DataFrame]):
+    def _action_finish_delete_cols(self, c: ThreadStateValue[pd.DataFrame]):
         if c.state.is_error():
-            self.running = False
+            self.state_value = c
             self.notify_listeners()
             return
         
-        self.data = c.value
-        self.running = False
-        
+        self.data = c.get_result()
+        self.state_value.reset_state()
         self.notify_listeners()
   
 
@@ -153,56 +189,50 @@ class ControllerTextOperations(ValueNotifier[str]):
     
     def __init__(self, controller: ControllerHomePage) -> None:
         super().__init__("-")  
-        self.context_state: ContextState = ContextState()
+        self.context_state: StateValue = StateValue()
         self.controller: ControllerHomePage = controller
         
     def set_value(self, v: str):
         self.value = v
         
         
-class ControllerHomePage(ValueNotifier[DataFrame]):
+class ControllerHomePage(ChangeNotifier):
     
-    def __init__(self, model: ExcelModel, *, value: pd.DataFrame = None) -> None:
-        if value is None:
-            value = pd.DataFrame()
-        super().__init__(value)
+    def __init__(self, model: ExcelModel) -> None:
+        super().__init__()
         self.model: ExcelModel = model
-        self.context_state: ThreadStateContext = ThreadStateContext()
-        
-        # Opções para leitura de uma planilha 
+        self.state_value: ThreadStateValue = ThreadStateValue()
+        self.show_msg: Callable[[str], None] = None
+        self.show_error: Callable[[str], None] = None
+
+        # Opções para leitura de CSV
         self.csv_options = CsvOptions()
-        self._file: File = None
-        self._sheet_name: str = None
         
-        self.sheet_names: ArrayList[str] = ArrayList()
+        #======================================================#
+        # Comando para leitura do DataFrame()
+        #======================================================#
+        self.data_notifier = DataNotifer(pd.DataFrame())
         
+        #======================================================#
         # Mapa de arquivos importados pelo usuário
+        #======================================================#
         self.files_notifier: FileNotifier = FileNotifier(HashMapDict())
+             
+        # Nomes das ABAS de uma planilha.
+        self._sheet_name: str = None
+        self.sheet_names: ArrayList[str] = ArrayList()
         
         # Opções de exportação
         self._options_save: OptionsIOSheet = OptionsIOSheet(SheetType.EXCEL)
         
-        #======================================================#
-        # Comandos notificadores
-        #======================================================#
-        self.data_notifier = DataNotifer(pd.DataFrame())
-        self.data_columns = CommandEditColumns(ArrayList(), self)
+        self.data_columns = CommandEditColumns(ArrayList())
         self.controller_text: ControllerTextOperations = ControllerTextOperations(self)
-        
-        # Consumer para notificar sobre a leitura de planilha
-        self._consumer_load_data: ConsumerThread = self._create_consumer(self.on_finish_load_data)
-        self._consumer_load_data.on_error = self.on_error_load_data
-        
-        # Consumer para a leitura das abas de uma planilha
-        self._consumer_load_sheet_names: ConsumerThread = self._create_consumer(self.on_finish_load_sheet_names)
-       
-        # Consumer para exportação de mapas
-        self._consumer_export_maps: ConsumerThread = self._create_consumer(self.on_finish_export_maps)
-        
-        # Menssagens
-        self.msg_erro_operation = None
-        self.msg_init_operation = None
-        
+        self._counter_operation: int = 0    
+
+    @property
+    def state_event(self) -> EventState:
+        return  self.state_value.state
+
     @property
     def sheet_name(self) -> str:
         return self._sheet_name
@@ -210,150 +240,206 @@ class ControllerHomePage(ValueNotifier[DataFrame]):
     @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}')
+            m = f'ABA ... {new} não está disponível para o arquivo: {self.get_file_sheet()}'
+            self.ui_message_error(m)
             return
         
         self._sheet_name = new
-        self.msg_init_operation = 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:
+        if self.get_file_sheet() is None:
             return None
         
-        opt_load = OptionsIOSheet(SheetType.EXCEL if self._file.is_excel() else SheetType.CSV)
+        opt_load = OptionsIOSheet(SheetType.EXCEL if self.get_file_sheet().is_excel() else SheetType.CSV)
         
-        if self._file.is_ods():
+        if self.get_file_sheet().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 running(self) -> bool:
-        return self.context_state.is_running()
+        return self.state_value.is_running()
          
     @property
     def files(self) -> ArrayList[File]:
         return self.files_notifier.value.values()
-    
-    def command_start_operation(self, c: ThreadStateContext) -> None:
-        if self.context_state.is_running():
-            print(f'{__class__.__name__} [DEBUG] .. existe outra operação em andamento.')
+
+    def ui_message(self, m: str):
+        if self.show_msg is None:
             return
+        self.show_msg(m)
+
+    def ui_message_error(self, e: str):
+        if self.show_error is None:
+            return
+        self.show_error(e)
+
+    def get_file_sheet(self) -> File:
+        """
+        """
+        return self.files_notifier.file 
+
+    def set_file_sheet(self, file: File):
+        """
+        """
+        self.files_notifier.set_selected_file(file)
+        options: OptionsIOSheet = self.options_load
+
+        if options is None:
+            return
+
+        if self.model.is_running():
+            self.ui_message(
+                "Existe outra operação em andamento. \nO arquvo foi atualizado mas não foi possível carregar as abas"
+            )
+
+            return
+        
+        self.command_load_sheet_names()
+
+    def reset_state(self):
+        self.state_value.reset_state()
+        self.msg_error = None
+        self.msg_success = None
+        self.msg_init_operation = None
+        #self.data_notifier.state_value.reset_state()
+        
+        print(f'{__class__.__name__} Estado resetado com sucesso ... {self.state_event.state_name}')
+        self.notify_listeners()
+        
+    def on_init_operation(self) -> None:
+        
+        if self.running:
+            print('-' * 60)
+            print(f'{__class__.__name__} [ATENÇÃO] ... existe outra operação em andamento.')
         
-        print(f'{__class__.__name__} => INICIANDO OPERAÇÃO -> Estado ... {self.context_state.state.name}')
-        self.context_state = c
+        print('*' * 60)
+        self._counter_operation += 1
+        print(f'{__class__.__name__} [INICIANDO OPERAÇÃO {self._counter_operation}] ... {self.state_value.state.state_name}')
+        
+        self.state_value.start()
         self.notify_listeners()
     
-    def _create_consumer(self, on_finish: Callable[[ThreadStateContext]]) -> ConsumerThread:
-        consumer = ConsumerThread(ThreadStateContext, on_finish=on_finish)
-        consumer.on_start = self.command_start_operation
-        return consumer
+    def _create_state_value(self, on_finish: Callable[[ThreadStateValue], None]) -> ThreadStateValue:
+        state = ThreadStateValue()
+        state.on_finish = on_finish
+        return state
     
     def command_delete_columns(self):
-        if self.running:
-            raise RuntimeError("Já existe outra operação de leitura em andamento...")
         self.data_columns.delete_columns(self.data_columns.value)
         
     def command_load_data(self) -> None:
-        if self.running:
-            raise RuntimeError("Já existe outra operação de leitura em andamento...")
-        
+        """
+            Metódo chamado pela VIEW para ler um DataFrame()
+        """
+
         options = self.options_load
         if options is None:
             return
         
-        self.data_notifier.running = True
+        self.state_value = self._create_state_value(self.on_finish_load_data)
+        
+        self.data_notifier.state_value = self.state_value
         self.data_notifier.value = pd.DataFrame()
-        self.msg_init_operation = "Carregando dados..."
-            
-        self.model.load_dataframe(self._file, options, consumer=self._consumer_load_data)
+        self.on_init_operation()
+        
+        print(f'{__class__.__name__} Iniciando a leitura do DataFrame()')
+        
+        self.model.load_dataframe(
+            self.get_file_sheet(), options, state_value=self.state_value,
+        )
         
     def command_load_sheet_names(self) -> None:
-        options: OptionsIOSheet = self.options_load
+
+        options: OptionsIOSheet = self.options_load # type: ignore
         if options is None:
             return
         
-        self.context_state.start()
-        self.notify_listeners()
+        self.state_value = self._create_state_value(self.on_finish_load_sheet_names)
+        self.on_init_operation()
+        
+        print(f'{__class__.__name__} Iniciando a leitura das abas do arquivo {self.get_file_sheet().basename()}')
         
         self.model.load_sheet_names(
-                self._file, 
-                options, 
-                consumer=self._consumer_load_sheet_names
+                self.get_file_sheet(), 
+                options,
+                state_value=self.state_value
             )
         
     def command_export_maps(self):
+
         self.controller_text.value = "Exportando mapas aguarde"
-        self.data_notifier.running = True
-        self.notify_listeners()
+        self.state_value = self._create_state_value(self.on_finish_export_maps)
         
         config: AppConfigNotifier = Provider.read(AppConfigNotifier)
         col = self.data_notifier.selectedColumnSheet
         work_dir = config.value.work_dir
         
+        self.on_init_operation()
+        self.data_notifier.state_value = self.state_value
+        
         self.model.export_maps(
             self.data_notifier.value,
             work_dir.concat("Mapas", True).concat(col, True),
             self.data_notifier.selectedColumnSheet,
-            consumer=self._consumer_export_maps,
+            state_value=self.state_value,
             receiver_progress=self.controller_text.set_value,
         )
+
+    def check_running(self) -> bool:
+        if self.running:
+            print(f'{__class__.__name__} existe outra operação em andamento!!!')
+            return False
+        return True
+
+    def on_finish_export_maps(self, context: ThreadStateValue):
+        self.state_value = context
         
-    def on_finish_export_maps(self, context: ThreadStateContext):
-        self.context_state = context
-        self.data_notifier.running = False
-        self.controller_text.value = "Mapas exportados com sucesso."
-        self.notify_listeners()
-        self.context_state.set_state(NotInicializedState())
+        if self.state_value.is_error():
+            self.notify_listeners()
+            return
         
-    def on_error_load_data(self, result: ThreadStateContext):
-        self.data_notifier.running = False
-        self.msg_erro_operation = f'{result.get_exception()}'
-    
-    def on_finish_load_data(self, result: ThreadStateContext[pd.DataFrame]) -> None:
-        self.data_notifier.running = False
-        self.data_notifier.value = result.value
-       
-        if not self.data_notifier.value.empty:
-            self.msg_init_operation = "Planilha carregada com sucesso..."
-        
-        self.context_state = result
+        self.data_notifier.state_value = ThreadStateValue()
+        self.controller_text.value = "Mapas exportados com sucesso."
+
+    def on_finish_load_data(self, result: ThreadStateValue[pd.DataFrame]) -> None:
+        self.data_notifier.state_value = ThreadStateValue()
+
+        if result.is_error():
+            self.state_value.fail(result.get_exception())
+            self.data_notifier.value = pd.DataFrame()
+            self.ui_message_error(f"{self.state_value.get_exception()}")
+            self.notify_listeners()
+            return
+
+        self.data_notifier.value = result.get_result()
+        self.reset_state()
         self.notify_listeners()
-        self.context_state.set_state(NotInicializedState())
+
+    def on_finish_load_sheet_names(self, element: ThreadStateValue[ArrayList[str]]) -> None:
         
-    def on_finish_load_sheet_names(self, c: ThreadStateContext[ArrayList[str]]) -> None:
-        self.sheet_names = c.value
-        self.context_state = c
-        self.notify_listeners()
+        if element.is_error():
+            self.state_value.fail(element.get_exception())
+            self.ui_message_error(f"{self.state_value.get_exception()}")
+            self.notify_listeners()
+            return
         
-        self.context_state.set_state(NotInicializedState())
+        self.sheet_names = element.get_result()
         self.sheet_name = self.sheet_names.get_first()
+        self.notify_listeners()
         
-    def get_file_sheet(self) -> File:
-            return self._file  
-        
-    def set_file_sheet(self, file: File):
-        if self.context_state.state.is_running():
-            return
-
-        self._file = file
-        options: OptionsIOSheet = self.options_load
-
-        if options is None:
-            return
-        self.command_load_sheet_names()
-            
     def add_files(self, files: ArrayList[File]):
         self.files_notifier.add_files(files)
-        if self._file is not None:
+        
+        if self.files_notifier.value.header().size() < 0:
             return
         
-        if self.files_notifier.value.header().size() > 0:
+        if self.data_notifier.value.empty:
             self.set_file_sheet(self.files_notifier.value.get_first())
     
     def init_state(self, data: HashMapDict = None):