table-stream 0.2.8__tar.gz → 0.2.9__tar.gz

{table_stream-0.2.8 → table_stream-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table_stream
-Version: 0.2.8
+Version: 0.2.9
 Summary: Tipos de dados e implementações para o uso em tabelas.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{table_stream-0.2.8 → table_stream-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "table_stream"
-version = "0.2.8"
+version = "0.2.9"
 description = "Tipos de dados e implementações para o uso em tabelas."
 readme = "README.md"
 requires-python = ">=3.12"

{table_stream-0.2.8 → table_stream-0.2.9}/table_stream/__init__.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
-#from collections.abc import Iterable
 
-from abc import abstractmethod, ABC #ABCMeta
+# from collections.abc import Iterable
+
+from abc import abstractmethod, ABC  # ABCMeta
 from typing import (
     Any,
     Callable,
@@ -26,10 +27,11 @@ from zipfile import ZipFile
 
 import json
 from pandas import DataFrame
-#from pandas import Series
+
+# from pandas import Series
 import pandas as pd
 
-__version__ = "0.2.8"
+__version__ = version = "0.2.8"
 
 T = TypeVar("T")
 K = TypeVar("K")
@@ -644,7 +646,9 @@ class HashMapDict[K, T](HashMap):
 
     def to_map_str(self) -> dict[str, Any]:
         final = dict()
-        for i in self.header():
+        _header = self.header()
+
+        for i in _header:
             final[str(i)] = str(self.get_value(i))
         return final
 
@@ -895,7 +899,9 @@ class Listener[NOTIFIER](ABC):
 
     def _read_notifier(self, type_notifier: type[NOTIFIER]) -> NOTIFIER:
         if self.type_notifier is None:
-            raise ValueError(f"Nenhum notificador foi definido em ... {__class__.__name__}()")
+            raise ValueError(
+                f"Nenhum notificador foi definido em ... {__class__.__name__}()"
+            )
         return self._watched[type_notifier]
 
     def read(self) -> NOTIFIER:
@@ -3039,12 +3045,15 @@ def create_table_from_file(
         md5 = load_file_hash(file)
 
     tb: TableData[HeaderMetaData] = create_void_table_files()
+    row = RowH(0)
 
-    tb.get(HeaderMetaData.FILE_NAME).add(file.name())
-    tb.get(HeaderMetaData.FILE_EXTENSION).add(file.extension() or ".nan")
-    tb.get(HeaderMetaData.FILE_PATH).add(file.absolute())
-    tb.get(HeaderMetaData.PARENT_DIR).add(file.parent().absolute())
-    tb.get(HeaderMetaData.HASH_FILE).add(md5)
+    row.set(HeaderMetaData.FILE_NAME, file.name())
+    row.set(HeaderMetaData.FILE_EXTENSION, file.extension() or ".nan")
+    row.set(HeaderMetaData.FILE_PATH, file.absolute())
+    row.set(HeaderMetaData.PARENT_DIR, file.parent().absolute())
+    row.set(HeaderMetaData.HASH_FILE, md5)
+
+    tb.add_row(row)
     return tb
 
 
@@ -3212,9 +3221,16 @@ class DataStorage(Observable[pd.DataFrame]):
 
 
 class DataReader(object):
+    """
+    Faz a leitura de uma planilha e retorna um Map de DataFrame()
+
+    """
 
-    def __init__(self, store: DataStorage) -> None:
+    def __init__(self, store: DataStorage | None = None) -> None:
         super().__init__()
+        if store is None:
+            store = DataStorage()
+
         self._store = store
 
     def read(self, path: File) -> pd.DataFrame:
@@ -3233,9 +3249,9 @@ class DataSave(Observer[pd.DataFrame]):
     Salvar o DataFrame() em um arquivo sempre receber uma notificação.
     """
 
-    def __init__(self, path_sheet: File) -> None:
+    def __init__(self, path_sheet: File | None = None) -> None:
         super().__init__()
-        self.path_sheet: File = path_sheet
+        self.path_sheet: File | None = path_sheet
         self.csv_options: CsvOptions = CsvOptions()
         self.debug: bool = True
 
@@ -3246,6 +3262,9 @@ class DataSave(Observer[pd.DataFrame]):
 
     def update(self, value: pd.DataFrame) -> None:
 
+        if self.path_sheet is None:
+            raise ValueError(f"{__class__.__name__} o arquivo de destino é nulo.")
+
         self._show(f"Salvando ... {self.path_sheet.absolute()}")
 
         if self.path_sheet.is_csv():
@@ -3282,6 +3301,7 @@ class SplitterData(Notifier):
     def split(self, df: pd.DataFrame, output: Directory) -> None:
         if df.empty:
             return None
+        df = df.astype(str)
 
         self.output_dir = output
         values_split = Set(df[self.col_split].drop_duplicates().values.tolist())
@@ -3306,16 +3326,42 @@ class SplitterData(Notifier):
         return super().notify_listeners()
 
 
-class DataExport(Listener):
+class ListenerSplitter(Listener[SplitterData]):
 
     def __init__(self) -> None:
         super().__init__()
-        self.saver = DataSave(None)
+        self.saver = DataSave()
+
+    def set_csv_options(self, opt: CsvOptions):
+        self.saver.csv_options = opt
 
     def receiver_notifier(self) -> None:
         sp = self.read()
         self.update(sp)
 
+    def create_export_files(self, d: Directory, filename: str) -> Set[File]:
+        dir_excel = d.concat("EXCEL", True)
+        dir_csv = d.concat("CSV", True)
+
+        path_excel = dir_excel.join_file(f"{filename}.xlsx")
+        path_csv = dir_csv.join_file(f"{filename}.csv")
+        return Set([path_excel, path_csv])
+
+    def _run_export(self, df: pd.DataFrame, files: Set[File]) -> None:
+        """
+        Exporta o mesmo DataFrame() para varios caminhos/arquivos
+
+        util para exportar csv/excel
+        """
+
+        if files.empty():
+            return None
+
+        f: File
+        for f in files:
+            self.saver.path_sheet = f
+            self.saver.update(df)
+
     def update(self, value: SplitterData) -> None:
         if value.output_dir is None:
             return
@@ -3325,12 +3371,128 @@ class DataExport(Listener):
         d = value.output_dir
         d.mkdir()
 
-        final_name = f"{value.current_file_name}.xlsx"
+        final_filename: str = str(value.current_file_name)
 
         if value.current_prefix is not None:
-            final_name = f"{value.current_prefix}-{final_name}"
+            final_filename = f"{value.current_prefix}-{final_filename}"
+
+        print(f"Progresso: [{value.done}/{value.total_export}]")
+
+        files = self.create_export_files(d, final_filename)
+        df = value.storage.get_data()
+        self._run_export(df, files)
+
+
+class ListenerSplitterQgiz(ListenerSplitter):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def create_export_files(self, d: Directory, filename: str) -> Set[File]:
+        sp = self.read()
+        current_data = sp.storage.get_data()
+        cols = ArrayList(current_data.columns.to_list())
+
+        dir_excel = d.concat("EXCEL", True)
+        dir_csv = d.concat("CSV", True)
+
+        col_ano = "numano"
+        col_mes = "nummes"
+
+        if cols.contains(col_ano):
+            ano = str(current_data[col_ano].values.tolist()[0])
+
+            dir_excel = dir_excel.concat(ano, True)
+            dir_csv = dir_csv.concat(ano, True)
+
+        if cols.contains(col_mes):
+            mes = str(current_data[col_mes].values.tolist()[0])
+
+            dir_excel = dir_excel.concat(mes, True)
+            dir_csv = dir_csv.concat(mes, True)
+
+        return Set.from_list(
+            [
+                dir_excel.join_file(f"{filename}.xlsx"),
+                dir_csv.join_file(f"{filename}.csv"),
+            ]
+        )
+
+
+class ListenerStorage(Observer[pd.DataFrame]):
+
+    def __init__(
+        self,
+        output_dir: Directory,
+        col_name: str,
+        *,
+        cols_subdirs: ArrayList[str] = None,
+    ) -> None:
+        super().__init__()
+        if cols_subdirs is None:
+            cols_subdirs = Set[str]()
+        self.cols_subdirs: ArrayList[str] = cols_subdirs
+        self.output_dir: Directory = output_dir
+        self.col_name: str = col_name
+
+    def get_current_export_dir(self, df: pd.DataFrame) -> Directory:
+        if self.cols_subdirs.empty():
+            return self.output_dir
+
+        concat_dirs = ArrayList()
+
+        for c in self.cols_subdirs:
+            first = df[c].astype(str).values.tolist()[0]
+            concat_dirs.append(first)
+
+        final_dir = Directory(self.output_dir.absolute())
+        for item in concat_dirs:
+            final_dir = final_dir.concat(item)
+
+        final_dir.mkdir()
+        return final_dir
+
+    def update(self, value: pd.DataFrame) -> None:
+
+        path_dir = self.get_current_export_dir(value)
+        filename = value[self.col_name].astype(str).values.tolist()[0]
+
+        csv_file = path_dir.concat("CSV", True).join_file(f"{filename}.csv")
+        excel_file = path_dir.concat("EXCEL", True).join_file(f"{filename}.xlsx")
+
+        saver = DataSave(excel_file)
+        saver.update(value)
+
+        saver.path_sheet = csv_file
+        saver.update(value)
+
+
+def fmt_dataframe_circuit(df: pd.DataFrame) -> pd.DataFrame:
+    rmnull = ["vlr_coordenada_longitude"]
+    select = [
+        "numano",
+        "nummes",
+        "numliv",
+        "codlcd",
+        "numrota",
+        "numcta",
+        "numcdc",
+        "vlr_coordenada_latitude",
+        "vlr_coordenada_longitude",
+    ]
+
+    df.dropna(subset=rmnull, inplace=True)
+    df = df[select]
+    return df
+
+
+def split_dataframe(df: pd.DataFrame, col_split: str, *, storage: DataStorage) -> None:
+    df = fmt_dataframe_circuit(df)
+    values_split = Set(df[col_split].drop_duplicates().values.tolist())
+
+    total = len(values_split)
+    for num, item in enumerate(values_split):
+        print(f"Progresso: {num+1}/{total}", end=" ")
 
-        path = d.join_file(final_name)
-        print(f"Exportando [{value.done}/{value.total_export}] ... {path}")
-        self.saver.path_sheet = path
-        self.saver.update(value.storage.get_data())
+        current = df[df[col_split] == item]
+        storage.set_data(current)

{table_stream-0.2.8 → table_stream-0.2.9}/table_stream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table_stream
-Version: 0.2.8
+Version: 0.2.9
 Summary: Tipos de dados e implementações para o uso em tabelas.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown