table-stream 0.1.4__tar.gz → 0.1.6__tar.gz

{table_stream-0.1.4 → table_stream-0.1.6}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.4
 Name: table_stream
-Version: 0.1.4
+Version: 0.1.6
 Summary: Tipos de dados e implementações para o uso em tabelas.
-Requires-Python: >=3.14
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: odfpy>=1.4.1
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=3.0.0
-Requires-Dist: soup-files>=1.4.2
 
 # table
 

table_stream-0.1.6/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "table_stream"
+version = "0.1.6"
+description = "Tipos de dados e implementações para o uso em tabelas."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "openpyxl>=3.1.5",
+    "pandas>=3.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "build>=1.4.0",
+    "twine>=6.2.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["table_stream*"]
+
+

table_stream-0.1.6/table_stream/__init__.py

@@ -0,0 +1,12 @@
+from .hash_map import HashMap, hashMapName, HashMapDataFrame, HashMapDict, ArrayList, K, T
+from .notifier import ValueNotifier, ChangeNotifier, Provider, Consumer
+from .thread import (
+    ControllerThread, ThreadStateContext, ConsumerThread, exceptionValue, stateName, 
+    EventState, InvalidStateTransition,
+)
+from .sheet import (
+    SheetLoader, InterfaceSheetLoad, ParserData, CsvOptions, SplitData,
+    csvEncoding, csvSeparator, OptionsIOSheet, SaveData,
+    FactorySaveData, FactorySheetLoader, SheetType,
+)
+from .state import ContextState, EventState

table_stream-0.1.4/table_stream/erros/__init__.py → table_stream-0.1.6/table_stream/erros.py

@@ -15,6 +15,18 @@ class CoreException(Exception):
         raise self
 
 
+class ValueNotifyNullError(CoreException):
+
+    def __init__(self, message: str = 'Notificação nula...') -> None:
+        super().__init__(message)
+        
+        
+class UnsuportedSheetError(CoreException):
+
+    def __init__(self, message: str = 'Planilha inválida...') -> None:
+        super().__init__(message)
+        
+        
 #============================================================#
 # Erros relacionados a HashMap
 #============================================================#

table_stream-0.1.6/table_stream/hash_map.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+from abc import abstractmethod, ABCMeta
+from typing import Any, Callable, TypeVar, Union, Literal
+import json
+from pandas import DataFrame
+
+
+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
+    
+
+#========================================================#
+# Base para HashMap().
+#========================================================#
+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], DataFrame]:
+        pass
+    
+    @abstractmethod
+    def set_real_hash_map(self, hash_map: dict[K, T] | 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
+
+
+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 __repr__(self) -> str:
+        return f"<{__class__.__name__}()>\n{self.get_real_hash_map()}"
+
+    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, df: DataFrame=None) -> None:
+        super().__init__()
+        if df is None:
+            df = DataFrame()
+        self._df: DataFrame = df
+
+    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._df[key]
+
+    def __setitem__(self, key: K, value: Series) -> None:
+        self._df[key] = value
+
+    def get_hash_map_name(self) -> Literal['DATAFRAME']:
+        return "DATAFRAME"
+
+    def get_real_hash_map(self) -> DataFrame:
+        return self._df
+
+    def set_real_hash_map(self, hash_map: DataFrame) -> None:
+        self._df = hash_map
+
+    def clear(self) -> None:
+        self._df = DataFrame()
+
+    def get_first(self) -> Series:
+        return self._df[self.header().get_first()]
+
+    def set_first(self, value: Series) -> None:
+        self._df[self.header().get_first()] = value
+
+    def get_last(self) -> Series:
+        return self._df[self.header().get_last()]
+
+    def set_last(self, value: T) -> None:
+        raise NotImplementedError
+
+    def set_value(self, key: K, value: Series) -> None:
+        self._df[key] = value
+
+    def get_value(self, key: K) -> Series:
+        return self._df[key]
+
+    def header(self) -> ArrayList[K]:
+        return ArrayList(self._df.columns.tolist())
+
+    def values(self) -> ArrayList[Any]:
+        return ArrayList(self._df.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._df.drop(columns=keys, inplace=True, errors="ignore", )
+
+    def to_json(self) -> str:
+        """
+        Serializa o DataFrame para JSON.
+        Mantém estrutura por colunas.
+        """
+        return self._df.astype(str).to_json(orient="columns", force_ascii=False, indent=4)
+
+    def to_map_str(self) -> dict[str, Any]:
+        return self._df.astype('str').to_dict()

table_stream-0.1.6/table_stream/io.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from io import BufferedWriter, BufferedReader, BytesIO
+from table_stream.sysfiles import File
+
+
+#----------------------------------------------------#
+# Output Stream
+#----------------------------------------------------#
+class OutputStream(ABC):
+    
+    @abstractmethod
+    def get_buffer(self) -> BufferedWriter:
+        pass
+    
+    @abstractmethod
+    def write(self, b: bytes):
+        """Escreve bytes no destino."""
+        pass
+
+    @abstractmethod
+    def flush(self):
+        """Força a gravação dos dados pendentes."""
+        pass
+
+    @abstractmethod
+    def close(self):
+        """Fecha o recurso."""
+        pass
+
+    # Facilitador para o 'with' do Python
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        
+        
+class FileOutputStream(OutputStream):
+    
+    def __init__(self, file_path: File, append: bool = False):
+        mode = 'ab' if append else 'wb' # 'b' indica modo binário (bytes)
+        #self.file_path: File = file_path
+        self._file_buff = open(file_path.absolute(), mode)
+        
+    def get_buffer(self) -> BufferedWriter:
+        return self._file_buff
+
+    def write(self, b: bytes):
+        if not isinstance(b, bytes):
+            raise TypeError("O FileOutputStream só aceita bytes!")
+        self._file_buff.write(b)
+
+    def flush(self):
+        self._file_buff.flush()
+
+    def close(self):
+        self._file_buff.close()
+         
+           
+class BytesOutputStream(OutputStream):
+    
+    def __init__(self):
+        # Inicializa um buffer vazio na memória (lista de bytes)
+        self._buffer = bytearray()
+        self._closed = False
+        
+    def get_buffer(self) -> BufferedWriter:
+        pass
+
+    def write(self, b: bytes):
+        if self._closed:
+            raise ValueError("Operação de escrita em stream fechada.")
+        if not isinstance(b, (bytes, bytearray)):
+            raise TypeError("O stream só aceita objetos do tipo bytes ou bytearray!")
+        
+        # Adiciona os bytes ao buffer na memória
+        self._buffer.extend(b)
+
+    def flush(self):
+        # Em memória, o flush geralmente não faz nada, 
+        # pois não há buffer de sistema operacional envolvido.
+        pass
+
+    def close(self):
+        self._closed = True
+
+    def to_bytes(self) -> bytes:
+        """
+        Método específico desta classe para recuperar 
+        tudo o que foi gravado até agora.
+        """
+        return bytes(self._buffer)
+
+    def size(self) -> int:
+        """Retorna a quantidade de bytes acumulados."""
+        return len(self._buffer) 
+    
+    
+    
+#----------------------------------------------------#
+# Input Stream
+#----------------------------------------------------#
+
+class InputStream(ABC):
+    
+    def __init__(self) -> None:
+        super().__init__()
+    
+    @abstractmethod
+    def clear(self):
+        pass
+    
+    @abstractmethod
+    def to_io(self) -> BytesIO:
+        pass
+        
+    @abstractmethod
+    def get_buffer(self) -> BufferedReader:
+        pass
+
+    @abstractmethod
+    def read(self, size: int = -1) -> bytes:
+        """Lê bytes do stream."""
+        pass
+
+    @abstractmethod
+    def close(self):
+        """Fecha o recurso."""
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+#----------------------------------------------------#
+# File Input Stream
+#----------------------------------------------------#
+class FileInputStream(InputStream):
+    
+    def __init__(self, file_path: File):
+        super().__init__()
+        if not file_path.exists():
+            raise FileNotFoundError(f'{__class__.__name__} arquivo não encontrado')
+                        
+        self.file_path: File = file_path
+        self._file_buff: BufferedReader | None = None
+        
+    def to_io(self) -> BytesIO:
+        buff = self.get_buffer()
+        buff.seek(0)  # garante leitura desde o início
+        return BytesIO(buff.read())
+
+    def get_buffer(self) -> BufferedReader:
+        if self._file_buff is None:
+            self._file_buff = open(self.file_path.absolute(), 'rb')
+        return self._file_buff
+
+    def read(self, size: int = -1) -> bytes:
+        return self.get_buffer().read(size)
+
+    def close(self):
+        if self._file_buff is None:
+            return
+        self._file_buff.close()
+        
+    def clear(self):
+        if self._file_buff is not None:
+            self.close()
+        self._file_buff = None
+
+
+#----------------------------------------------------#
+# Bytes Input Stream (memória)
+#----------------------------------------------------#
+class BytesInputStream(InputStream):
+    
+    def __init__(self, data: bytes):
+        super().__init__()
+        if not isinstance(data, (bytes, bytearray)):
+            raise TypeError("BytesInputStream aceita apenas bytes ou bytearray!")
+        
+        data.seek(0)
+        self._buffer = memoryview(data)
+        self._position = 0
+        self._closed = False
+        
+    def to_io(self) -> BytesIO:
+        return BytesIO(self._buffer)
+        
+    def set_bytes(self, data: bytes | bytearray):
+        self._buffer = memoryview(data)
+
+    def get_buffer(self) -> BufferedReader:
+        # Não há um buffer real compatível com BufferedReader
+        # Mantemos None ou poderíamos lançar erro
+        return None
+
+    def read(self, size: int = -1) -> bytes:
+        if self._closed:
+            raise ValueError("Operação de leitura em stream fechada.")
+
+        if size < 0:
+            size = len(self._buffer) - self._position
+
+        start = self._position
+        end = min(start + size, len(self._buffer))
+
+        self._position = end
+        return self._buffer[start:end].tobytes()
+
+    def close(self):
+        self._closed = True
+
+    def available(self) -> int:
+        """Quantidade de bytes restantes para leitura."""
+        return len(self._buffer) - self._position    
+    
+    def clear(self):
+        if self._buffer is not None:
+            self.close()
+        self._buffer = None  
+    
+    
+