table-stream 0.1.0__py3-none-any.whl

table_stream/__init__.py

@@ -0,0 +1,8 @@
+from .base import HashMap, hashMapName, HashMapDataFrame, HashMapDict, ArrayList, K, T
+from .types import (
+    WorkbookData, MessageNotification, Provider, Listener, EVENT_TYPE, VALUE, 
+    Mediator, ComponentMediator
+)
+from .thread import ControlledThread, ThreadConsumer
+from .sheet import SheetLoader, InterfaceSheetLoad, ParserData
+

table_stream/base/__init__.py

@@ -0,0 +1,2 @@
+from .mapping import HashMap, K, T, hashMapName, ArrayList
+from .hash_map import HashMapDict, HashMapDataFrame

table_stream/base/hash_map.py

@@ -0,0 +1,160 @@
+from typing import Any, Literal
+from pandas.core.api import DataFrame
+from table_stream.base.mapping import ArrayList, HashMap, T
+import json
+
+
+class HashMapDict[K, T](HashMap):
+    
+    def __init__(self, _mapping: dict[K, T] | None = None) -> None:
+        super().__init__()
+        if _mapping is None:
+            _mapping = dict()
+        self._mapping: dict[K, T] = _mapping
+    
+    def size_values(self) -> int:
+        return len(self._mapping.values())
+
+    def size_header(self) -> int:
+        return self.header().size()
+
+    def __getitem__(self, key: K) -> T:
+        return self._mapping[key]
+
+    def __setitem__(self, key: K, value: T) -> None:
+        self._mapping[key] = value
+
+    def get_hash_map_name(self) -> Literal['DICT']:
+        return "DICT"
+
+    def get_real_hash_map(self) -> dict[K, T]:
+        return self._mapping
+
+    def set_real_hash_map(self, hash_map: dict[K, T]) -> None:
+        self._mapping = hash_map
+
+    def clear(self) -> None:
+        self._mapping.clear()
+
+    def get_first(self) -> T:
+        return self._mapping[self.header().get_first()]
+
+    def set_first(self, value: T) -> None:
+        self._mapping[self.header().get_first()] = value
+
+    def get_last(self) -> T:
+        return self._mapping[self.header().get_last()]
+
+    def set_last(self, value: T) -> None:
+        self._mapping[self.header().get_last()] = value
+
+    def set_value(self, key: K, value: T) -> None:
+        self._mapping[key] = value
+
+    def get_value(self, key: K) -> T:
+        return self._mapping[key]
+
+    def header(self) -> ArrayList[K]:
+        return ArrayList(list(self._mapping.keys()))
+
+    def values(self) -> ArrayList[T]:
+        return ArrayList(list(self._mapping.values()))
+
+    def delete_items(self, keys: list[K]) -> None:
+        for k in keys:
+            self._mapping.pop(k)
+
+    def to_json(self) -> str:
+        """
+        Converte o mapa real para uma string JSON.
+        Nota: As chaves e valores devem ser serializáveis pelo módulo json.
+        """
+        return json.dumps(self.to_map_str(), ensure_ascii=False, indent=4)
+
+    def to_map_str(self) -> dict[str, Any]:
+        final = dict()
+        for i in self.header():
+            final[str(i)] = str(self.get_value(i))
+        return final
+
+    
+class HashMapDataFrame[K, Series](HashMap):
+    
+    def __init__(self, data: DataFrame | None) -> None:
+        super().__init__()
+        if data is None:
+            data = DataFrame()
+        self._data: DataFrame = data
+    
+    def size_values(self) -> int:
+        return len(self.values())
+
+    def size_header(self) -> int:
+        return len(self.header())
+
+    def __getitem__(self, key: K) -> Series:
+        return self._data[key]
+
+    def __setitem__(self, key: K, value: Series) -> None:
+        self._data[key] = value
+
+    def get_hash_map_name(self) -> Literal['DATAFRAME']:
+        return "DATAFRAME"
+
+    def get_real_hash_map(self) -> DataFrame:
+        return self._data
+
+    def set_real_hash_map(self, hash_map: DataFrame) -> None:
+        self._data = hash_map
+
+    def clear(self) -> None:
+        self._data = DataFrame()
+
+    def get_first(self) -> Series:
+        return self._data[self.header().get_first()]
+
+    def set_first(self, value: Series) -> None:
+        self._data[self.header().get_first()] = value
+
+    def get_last(self) -> Series:
+        return self._data[self.header().get_last()]
+
+    def set_last(self, value: T) -> None:
+        raise NotImplementedError
+
+    def set_value(self, key: K, value: Series) -> None:
+        self._data[key] = value
+
+    def get_value(self, key: K) -> Series:
+        return self._data[key]
+
+    def header(self) -> ArrayList[K]:
+        return ArrayList(self._data.columns.tolist())
+
+    def values(self) -> ArrayList[Any]:
+        return ArrayList(self._data.values.tolist())
+
+    def delete_items(self, keys: list[K]) -> None:
+        """
+        Remove as colunas informadas.
+        """
+        # axis=1 indica que queremos remover colunas (as chaves do seu mapa)
+        # errors='ignore' evita que o código quebre caso uma chave não exista
+        #self._data.drop(columns=keys, axis=1, inplace=True, errors='ignore'
+        self._data.drop(columns=keys, inplace=True, errors="ignore",)
+
+    def to_json(self) -> str:
+        """
+        Serializa o DataFrame para JSON.
+        Mantém estrutura por colunas.
+        """
+        return self._data.astype(str).to_json(orient="columns", force_ascii=False, indent=4)
+
+    def to_map_str(self) -> dict[str, Any]:
+        return self._data.astype('str').to_dict()
+
+    
+     
+   
+
+    

table_stream/base/mapping.py

@@ -0,0 +1,153 @@
+
+from __future__ import annotations
+from abc import abstractmethod, ABC, ABCMeta
+from collections.abc import Iterator
+from typing import Any, Callable, TypeVar, Generic, Union, Literal
+#import pandas as pd
+#from pandas import Series
+
+
+T = TypeVar('T')
+K = TypeVar('K')
+hashMapName = Literal['DATAFRAME', 'DICT']
+
+
+class ArrayList[T](list):
+    
+    def __init__(self, items: list[T] | None = None):
+        if items is None:
+            items = list()
+        super().__init__(items)
+        
+    def set_items(self, items: list[T]):
+        self.clear()
+        super().__init__(items)
+        
+    def for_each(self, func: Callable[[T], Any | None]) -> None:
+        for x in self: func(x)
+    
+    def apply_command(self, func: Callable[[T], Any]) -> ArrayList[Any]:
+        return ArrayList([func(x) for x in self])
+    
+    def size(self) -> int:
+        return len(self)
+        
+    def empty(self) -> bool:
+        return self.size() == 0
+        
+    def get_first(self) -> T:
+        return self[0]
+
+    def get_last(self) -> T:
+        return self[-1]
+    
+    def hash(self) -> int:
+        return hash(tuple(self))
+    
+    def contains(self, _o: T) -> bool:
+        for i in self:
+            if i == _o:
+                return True
+        return False
+    
+
+class HashMap[K, T](metaclass=ABCMeta):
+    
+    def __repr__(self) -> str:
+        return f"<HashMap()> {self.header()}"
+    
+    @abstractmethod
+    def size_values(self) -> int:
+        pass
+    
+    @abstractmethod
+    def size_header(self) -> int:
+        pass
+    
+    @abstractmethod
+    def __getitem__(self, key: K) -> T:
+        pass
+    
+    @abstractmethod
+    def __setitem__(self, key: K, value: T) -> None:
+        pass
+    
+    @abstractmethod
+    def get_hash_map_name(self) -> hashMapName:
+        pass
+    
+    @abstractmethod
+    def get_real_hash_map(self) -> Union[dict[K, T], pd.DataFrame]:
+        pass
+    
+    @abstractmethod
+    def set_real_hash_map(self, hash_map: dict[K, T] | pd.DataFrame) -> None:
+        pass
+
+    @abstractmethod
+    def clear(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_first(self) -> T:
+        pass
+
+    @abstractmethod
+    def set_first(self, value: T) -> None:
+        pass
+
+    @abstractmethod
+    def get_last(self) -> T:
+        pass
+
+    @abstractmethod
+    def set_last(self, value: T) -> None:
+        pass
+
+    @abstractmethod
+    def set_value(self, key: K, value: T) -> None:
+        pass
+
+    @abstractmethod
+    def get_value(self, key: K) -> T:
+        pass
+
+    @abstractmethod
+    def header(self) -> ArrayList[K]:
+        """
+            Retornar as chaves de um dicionário ou columns de um DataFrame()
+        """
+        pass
+
+    @abstractmethod
+    def values(self) -> ArrayList[T]:
+        pass
+
+    @abstractmethod
+    def delete_items(self, keys: list[K]) -> None:
+        """
+            Apaga chaves e valores, semelhante ao método pop().
+        """
+        pass
+
+    @abstractmethod
+    def to_json(self) -> str:
+        """
+            Converte o HashMap() para uma representação no formato json.
+        """
+        pass
+
+    @abstractmethod
+    def to_map_str(self) -> dict[str, Any]:
+        """
+            Converte o HashMap() para uma representação no formato dict() python.
+        """
+        pass
+
+    @classmethod
+    def from_json(cls, data: str) -> HashMap:
+        pass
+
+    @classmethod
+    def from_map(cls, data: Any) -> HashMap:
+        pass

table_stream/erros/__init__.py

@@ -0,0 +1,90 @@
+class CoreException(Exception):
+
+    def __init__(self, message: str = f'Erro') -> None:
+        super().__init__(message)
+        self._message = message
+
+    def get_message(self) -> str:
+        return self._message
+
+    def set_message(self, message: str) -> None:
+        self._message = message
+        super().__init__(f"{__class__.__name__}: {message}")
+
+    def launch_exception_handler(self) -> None:
+        raise self
+
+
+#============================================================#
+# Erros relacionados a HashMap
+#============================================================#
+class InvalidHashMapTableError(CoreException):
+
+    def __init__(self, message: str = 'HashMap inválido') -> None:
+        super().__init__(message)
+
+
+class InvalidBodyTableError(InvalidHashMapTableError):
+
+    def __init__(self, message: str = 'Erro corpo de tabela inválido') -> None:
+        super().__init__(message)
+
+
+class SizeTableError(InvalidHashMapTableError):
+
+    def __init__(self, message: str = 'Tamanho de tabela inválido') -> None:
+        super().__init__(message)
+
+
+#============================================================#
+# Erros relacionados a planilhas
+#============================================================#
+class UndefinedSheetIndex(CoreException):
+
+    def __init__(self, message: str = 'SheetIndexNames não foi definido') -> None:
+        super().__init__(message)
+
+
+class LoadWorkbookError(CoreException):
+
+    def __init__(self, message: str = 'Erro ao tentar ler Workbook') -> None:
+        super().__init__(message)
+
+#============================================================#
+# Erros relacionados a arquivos/bytes de imagem (.png, .jpg, ...)
+#============================================================#
+class InvalidSourceImageError(CoreException):
+
+    def __init__(self, message: str = 'Erro, use bytes de imagem') -> None:
+        super().__init__(message)
+
+
+#============================================================#
+# Erros relacionados a módulos
+#============================================================#
+class NotImplementedModuleError(CoreException):
+
+    def __init__(self, message: str = 'Erro, módulo não implementado') -> None:
+        super().__init__(message)
+
+
+class NotImplementedModuleImageError(NotImplementedModuleError):
+
+    def __init__(self, message: str = 'Erro, módulo IMAGEM não implementado') -> None:
+        super().__init__(message)
+
+
+class NotImplementedModulePdfError(NotImplementedModuleError):
+
+    def __init__(self, message: str = 'Erro, módulo PDF não implementado') -> None:
+        super().__init__(message)
+
+
+class NotImplementedInvertColor(NotImplementedError):
+
+    def __init__(self, message: str = 'Adaptador InvertColor não implementado...') -> None:
+        super().__init__(message)
+
+
+
+

table_stream/sheet/__init__.py

@@ -0,0 +1,10 @@
+from .excel import ExcelLoadPandasInterface
+from .ods import ODSLoadPandasInterface
+from .csv import (
+    CsvLoadPandasInterface, csvEncoding, CsvMapping, csvSeparator, create_csv_mapping,
+    CsvSeparatorList, CsvEncodingList,
+)
+from .parse import FilterData, ParserData
+from .interface import InterfaceSheetLoad
+from .load_adapter import SheetLoader
+

table_stream/sheet/csv/__init__.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+from io import BytesIO
+import pandas as pd
+from typing import Literal, Union, TypedDict
+
+from table_stream import ArrayList
+from table_stream.erros import LoadWorkbookError
+from table_stream.types.workbook import WorkbookData
+from table_stream.sheet.interface import InterfaceSheetLoad
+
+csvEncoding = Literal['utf-8', 'iso-8859-1', 'latin1', 'cp1252']
+CsvEncodingList: list[str] = ['utf-8', 'iso-8859-1', 'latin1',  'cp1252']  # ["utf-8", "latin1", "cp1252"]
+csvSeparator = Literal[',', ';', '|', '\t', '_', ' ']
+CsvSeparatorList: list[str] = [';', ',', '|', '\t', '_', ' ']  # [";", ",", "\\t", "|", "-"]
+
+
+class CsvMapping(TypedDict, total=True):
+
+    encoding: csvEncoding
+    separator: csvSeparator
+    virgula: csvSeparator
+    ponto_virgula: csvSeparator
+    pipe: csvSeparator
+    tab: csvSeparator
+    esp: csvSeparator
+    under: csvSeparator
+
+
+def create_csv_mapping() -> CsvMapping:
+
+    return {
+        'encoding': 'utf-8',
+        'separator': ';',
+        'virgula': ',',
+        'ponto_virgula': ';',
+        'pipe': '|',
+        'tab': '\t',
+        'esp': ' ',
+        'under': '_',
+    }
+
+
+class CsvLoadPandasInterface(InterfaceSheetLoad):
+    """Leitura de CSV usando a biblioteca Pandas."""
+
+    def __init__(
+                self,
+                file_csv: Union[str, BytesIO] | None,
+                delimiter: csvSeparator = "\t",
+                encoding: csvEncoding = 'utf-8'
+            ):
+        super().__init__()
+        self._file_csv: Union[str, BytesIO] | None = file_csv
+        self.delimiter: csvSeparator = delimiter
+        self.encoding: csvEncoding = encoding
+
+    def get_sheet_names(self) -> ArrayList[str]:
+        return ArrayList(["Sheet1"])
+
+    def _check_file_csv(self):
+        self.check_file()
+
+    def set_file_sheet(self, f: str | BytesIO) -> None:
+        self._file_csv = f
+
+    def get_file_sheet(self) -> str | BytesIO:
+        return self._file_csv
+
+    def hash(self) -> int:
+        self._check_file_csv()
+        return hash(self._file_csv)
+
+    def get_workbook_data(self, sheet_name: str = None) -> WorkbookData:
+        self._check_file_csv()
+        df: pd.DataFrame
+        workbook_data = WorkbookData()
+        try:
+            # Forçar a leitura como str.
+            workbook_data.set_value(
+                "Sheet1",
+                pd.read_csv(self._file_csv, sep=self.delimiter, encoding=self.encoding, dtype=str).fillna('')
+            )
+        except Exception as e:
+            raise LoadWorkbookError(f"{__class__.__name__} Error: {e}")
+        else:
+            return workbook_data
+
+    def get_type_load(self) -> Literal[".csv"]:
+        return ".csv"
+
+
+__all__ = [
+    'csvEncoding', 'CsvMapping', 'csvSeparator', 'CsvLoadPandasInterface',
+    'create_csv_mapping', 'CsvEncodingList', 'CsvSeparatorList',
+]
+
+

table_stream/sheet/excel/__init__.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+from io import BytesIO
+from typing import Union, Literal
+import pandas as pd
+from table_stream.base.hash_map import ArrayList
+from table_stream.types.workbook import WorkbookData
+from table_stream.sheet.interface import InterfaceSheetLoad
+
+
+class ExcelLoadPandasInterface(InterfaceSheetLoad):
+
+    def __init__(self, xlsx_file: Union[str, BytesIO] | None):
+        self._xlsx_file: Union[str, BytesIO] | None = xlsx_file
+
+    def get_sheet_names(self) -> ArrayList[str]:
+        self._check_file()
+        rd: pd.ExcelFile = pd.ExcelFile(self._xlsx_file)
+        return ArrayList([str(x) for x in rd.sheet_names])
+
+    def _check_file(self) -> None:
+        self.check_file()
+
+    def set_file_sheet(self, f: str | BytesIO) -> None:
+        self._xlsx_file = f
+
+    def get_file_sheet(self) -> str | BytesIO:
+        return self._xlsx_file
+
+    def hash(self) -> int:
+        self.check_file()
+        return hash(self.get_file_sheet())
+
+    def get_workbook_data(self, sheet_name: str = None) -> WorkbookData:
+        if sheet_name is None:
+            return WorkbookData(pd.read_excel(self.get_file_sheet(), sheet_name=None))
+        return WorkbookData({
+            sheet_name: pd.read_excel(self.get_file_sheet(), sheet_name=sheet_name),
+        })
+
+    def get_type_load(self) -> Literal[".xlsx"]:
+        return ".xlsx"
+
+
+__all__ = ['ExcelLoadPandasInterface']
+

table_stream/sheet/excel/_col_index.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+import re
+
+
+#===========================================================#
+# Funções Auxiliares de Leitura XML
+#===========================================================#
+
+def column_coord_to_index(coord: str) -> int:
+    """
+    Converte coordenada de célula (ex: 'AZ25') para o índice da coluna (AZ=52).
+    """
+    match = re.match(r'([A-Za-z]+)', coord)
+    if not match:
+        raise ValueError(f"Coordenada inválida: {coord}")
+
+    coluna_letras: str = match.group(1)
+    idx: int = 0
+    for char in coluna_letras.upper():
+        col_valor = ord(char) - ord('A') + 1
+        idx = (idx * 26) + col_valor
+    return idx
+
+
+

table_stream/sheet/interface/__init__.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+import os
+from abc import ABCMeta, abstractmethod
+from typing import Literal
+from io import BytesIO
+from table_stream.types.workbook import  WorkbookData
+from table_stream.base.hash_map import ArrayList
+from pandas import DataFrame
+
+
+sheetExtension = Literal['.csv', '.xlsx', '.ods']
+
+
+class InterfaceSheetLoad(metaclass=ABCMeta):
+
+    def check_file(self):
+        if self.get_file_sheet() is None:
+            raise FileNotFoundError()
+        if isinstance(self.get_file_sheet(), str):
+            if not os.path.exists(self.get_file_sheet()):
+                raise FileNotFoundError()
+
+    @abstractmethod
+    def get_type_load(self) -> sheetExtension:
+        pass
+
+    @abstractmethod
+    def set_file_sheet(self, f: str | BytesIO) -> None:
+        pass
+
+    @abstractmethod
+    def get_file_sheet(self) -> str | BytesIO:
+        pass
+
+    @abstractmethod
+    def hash(self) -> int:
+        pass
+
+    @abstractmethod
+    def get_workbook_data(self, sheet_name: str = None) -> WorkbookData:
+        """
+            Retorna um conjunto de chave:valor com os nomes de cada ABA da planilha
+        apontando para o DataFrame() correspondente.
+        """
+        pass
+
+    @abstractmethod
+    def get_sheet_names(self) -> ArrayList[str]:
+        pass
+
+    def get_sheet_at(self, idx: int) -> DataFrame:
+        sheet_name = self.get_sheet_names()[idx]
+        return self.get_sheet(sheet_name)
+
+    def get_sheet(self, sheet_name: str) -> DataFrame:
+        return self.get_workbook_data(sheet_name).get_first()
+
+
+__all__ = ['InterfaceSheetLoad', 'sheetExtension']
+
+
+
+