table-stream 0.1.9__tar.gz → 0.2.0__tar.gz

{table_stream-0.1.9 → table_stream-0.2.0}/PKG-INFO

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

{table_stream-0.1.9 → table_stream-0.2.0}/pyproject.toml

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

{table_stream-0.1.9 → table_stream-0.2.0}/table_stream/__init__.py

@@ -88,4 +88,4 @@ from .erros import (
     HeadersSizeNotIqualError,
 )
 
-__version__ = "0.1.9"
+__version__ = "0.2.0"

{table_stream-0.1.9 → table_stream-0.2.0}/table_stream/table.py

@@ -6,9 +6,14 @@ from __future__ import annotations
 from abc import abstractmethod, ABC
 from table_stream.hash_map import ArrayList, HashMapDict, HashMap, HashMapDataFrame
 from table_stream.erros import (
-    ColumnNotFoudError, RowNotExistError, EmptyRowError,
-    ColumnNotFoundError, HeadersSizeNotIqualError, HeaderNotFoundError,
-    TableEmptyError, ListTablesEmptyError, 
+    ColumnNotFoudError,
+    RowNotExistError,
+    EmptyRowError,
+    ColumnNotFoundError,
+    HeadersSizeNotIqualError,
+    HeaderNotFoundError,
+    TableEmptyError,
+    ListTablesEmptyError,
 )
 from typing import Any, TypeVar, Callable
 import pandas as pd
@@ -20,11 +25,11 @@ TP = TypeVar("TP")
 
 
 class RowH[HEAD, T]:
-    
+
     def __init__(self, index: int, map: dict[HEAD, T] | None = None) -> None:
-        if map is None: 
+        if map is None:
             map = dict()
-            
+
         self.map: dict[HEAD, T] = map
         self.index: int = index
 
@@ -32,13 +37,13 @@ class RowH[HEAD, T]:
         default = f"{__class__.__name__}():"
         if len(self.map) == 0:
             return f"{default} Size: 0"
-        
+
         _values = ArrayList()
         for k, v in self.map.items():
             _values.add(f"{k} -> {v}")
-        
+
         return f"{default}\n{_values}"
-    
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, RowH):
             raise NotImplementedError()
@@ -46,30 +51,30 @@ class RowH[HEAD, T]:
 
     def __hash__(self) -> int:
         return hash(tuple(self.map.items()))
-    
+
     def hash(self) -> int:
         return self.__hash__()
-    
+
     def is_empty(self) -> bool:
         return self.header().empty()
-    
+
     def get_first(self) -> T:
         if self.is_empty():
             raise EmptyRowError(f"Linha vazia, adicione elementos...")
         return self.get(self.header().get_first())
-    
+
     def get_row_index(self) -> int:
         return self.index
-        
-    def get(self, head: HEAD) ->  T:
+
+    def get(self, head: HEAD) -> T:
         return self.map[head]
-        
+
     def set(self, head: HEAD, v: T) -> None:
         self.map[head] = v
-        
+
     def header(self) -> ArrayList[HEAD]:
         return ArrayList(list(self.map.keys()))
-        
+
     def values(self) -> ArrayList[T]:
         return ArrayList(list(self.map.values()))
 
@@ -84,15 +89,15 @@ class ColumnV[HEAD, T]:
         self.head: HEAD = head
 
     def __repr__(self) -> str:
-        
+
         return f"{__class__.__name__}(): Head {self.head}; Size {self.size()}; Type {self.get_type()};\n{self._elements}"
-    
-    #---------------------------------------------------#
+
+    # ---------------------------------------------------#
     # Leitura de Dados.
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def get_type(self) -> type[T] | None:
         return None if self.is_empty() else type(self.get_first())
-    
+
     def get_elements(self) -> ArrayList[T]:
         return self._elements
 
@@ -101,60 +106,62 @@ class ColumnV[HEAD, T]:
             Retorna um elemento da coluna apartir de seu índice, se o
         índice do elemento não existir, lança a exceção RowNotExistError()
         """
-        
+
         if idx >= self.size():
-            raise RowNotExistError(f"{__class__.__name__} Linha não encontrada ... {idx}")
+            raise RowNotExistError(
+                f"{__class__.__name__} Linha não encontrada ... {idx}"
+            )
         return self._elements.get_element_at(idx)
-    
+
     def get_first(self) -> T:
         total = self.size()
-        
+
         if total == 0:
             raise ValueError(f"A coluna {self.head} está vazia")
         return self._elements[0]
-    
+
     def add(self, item: T) -> None:
-            self._elements.append(item)
-    
+        self._elements.append(item)
+
     def add_all(self, items: ArrayList[T]) -> None:
         items.for_each(self.add)
-    
-    #---------------------------------------------------#
+
+    # ---------------------------------------------------#
     # Inserção/Edição de dados.
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def set(self, idx: int, value: T) -> None:
         self._elements[idx] = value
-        
+
     def set_elements(self, e: ArrayList[T]) -> None:
-            self._elements = e
+        self._elements = e
 
     def astype[TP](self, new_type: type[TP]) -> ArrayList[TP]:
-        new = ArrayList[TP]() 
+        new = ArrayList[TP]()
         for e in self._elements:
             new.append(new_type(e))
         return new
-    
+
     def replace_value(self, old: T, new: T) -> None:
-            """
-                Substitui old por new em todas as ocorrências.
-            """
-            list_index = self.find_all(old)
-            
-            if list_index.empty():
-                return
-    
-            for num in list_index:
-                self._elements.replace(num, new)
-    
+        """
+        Substitui old por new em todas as ocorrências.
+        """
+        list_index = self.find_all(old)
+
+        if list_index.empty():
+            return
+
+        for num in list_index:
+            self._elements.replace(num, new)
+
     def replace_at(self, idx: int, new: T) -> None:
         self._elements.replace(idx, new)
-        
+
     def merge(self, col: ColumnV) -> None:
         self.add_all(col.get_elements())
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Verificação/Validação de dados.
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def is_empty(self) -> bool:
         return self._elements.empty()
 
@@ -164,37 +171,39 @@ class ColumnV[HEAD, T]:
     def contains(self, element: T) -> bool:
         return self._elements.contains(element)
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Exclusão de dados.
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def remove(self, v: T) -> None:
         self._elements.remove(v)
-        
-    def remove_all(self, values: ArrayList[T], *, inplace: bool = False) -> ColumnV[HEAD, T]:
-        
+
+    def remove_all(
+        self, values: ArrayList[T], *, inplace: bool = False
+    ) -> ColumnV[HEAD, T]:
+
         new_elements = ArrayList[T]()
-        
+
         for e in self._elements:
             if not values.contains(e):
                 new_elements.add(e)
-        
+
         if inplace:
             self.set_elements(new_elements)
-            
+
         return ColumnV(self.head, new_elements)
-    
-    #---------------------------------------------------#
+
+    # ---------------------------------------------------#
     # Comandos
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def for_each(self, fn: Callable[[T], None]) -> None:
         self._elements.for_each(fn)
 
-    def apply_command(self, fn: Callable[[T], None]) -> ColumnV[HEAD, Any]: 
+    def apply_command(self, fn: Callable[[T], None]) -> ColumnV[HEAD, Any]:
         return ColumnV(self.head, self._elements.apply_command(fn))
-    
-    #---------------------------------------------------#
+
+    # ---------------------------------------------------#
     # Pesquisar/Buscar informações.
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def select(self, list_index: ArrayList[int]) -> ColumnV[HEAD, T]:
         new_col = ColumnV[HEAD, T](self.head)
         list_index.for_each(lambda num: new_col.add(self.get(num)))
@@ -220,7 +229,7 @@ class ColumnV[HEAD, T]:
         return final
 
     def filter_value(self, value: T, iqual: bool = False) -> ColumnV[HEAD, T]:
-        list_index: ArrayList[int] 
+        list_index: ArrayList[int]
 
         if iqual:
             list_index = self.find_all(value)
@@ -239,27 +248,25 @@ class ColumnV[HEAD, T]:
         for idx in list_index:
             final_elements.append(self._elements[idx])
         return ColumnV(self.head, final_elements)
-    
+
     def filter_all(self, values: ArrayList[T]) -> ColumnV[HEAD, T]:
         final = ColumnV[HEAD, T](self.head)
-        
-        values.for_each(
-            lambda item: final.merge(self.filter_value(item))
-        )
+
+        values.for_each(lambda item: final.merge(self.filter_value(item)))
         return final
 
     def drop_duplicates(self) -> ColumnV[HEAD, T]:
         final_list = ArrayList()
-        
+
         for e in self._elements:
             if not final_list.contains(e):
                 final_list.append(e)
         return ColumnV(self.head, final_list)
-    
+
     @classmethod
     def create_from_list(cls, h: HEAD, values: list[T]) -> ColumnV:
         return cls(h, ArrayList(values))
-    
+
     @classmethod
     def create_from_series(cls, h: HEAD, s: pd.Series) -> ColumnV:
         return cls(h, ArrayList(s.values.tolist()))
@@ -311,7 +318,7 @@ class Table[HEAD](ABC):
     @abstractmethod
     def set(self, col: ColumnV[HEAD, ArrayList[T]]):
         pass
-    
+
     @abstractmethod
     def set_data(self, df: pd.DataFrame) -> None:
         pass
@@ -319,7 +326,7 @@ class Table[HEAD](ABC):
     @abstractmethod
     def add(self, col: ColumnV) -> None:
         """
-            Adiciona uma coluna na tabela.
+        Adiciona uma coluna na tabela.
         """
         pass
 
@@ -353,13 +360,13 @@ class Table[HEAD](ABC):
             self.get(h).add(row.get(h))
         return None
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Leitura de dados - READ
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     @abstractmethod
     def get_data(self) -> pd.DataFrame:
         pass
-    
+
     @abstractmethod
     def get(self, h: HEAD) -> ColumnV[HEAD, Any]:
         pass
@@ -405,7 +412,7 @@ class Table[HEAD](ABC):
 
     def get_last(self) -> ColumnV:
         return self.get(self.header().get_last())
-    
+
     @abstractmethod
     def select_columns(self, header: list[HEAD]) -> Table:
         pass
@@ -450,9 +457,9 @@ class Table[HEAD](ABC):
     def search(self, h: HEAD, value: Any) -> Table[HEAD]:
         pass
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Verificação/validação de dados
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def size(self) -> int:
         if self.empty():
             return 0
@@ -471,20 +478,20 @@ class Table[HEAD](ABC):
     def empty(self) -> bool:
         pass
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Exclusão de dados - DELETE
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     @abstractmethod
     def clear(self) -> None:
         pass
-    
+
     @abstractmethod
     def remove_null(self, header: HEAD) -> Table:
         pass
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Conversão de dados
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def to_string(self, h: HEAD) -> str:
         return " ".join(self.get(h).astype(str))
 
@@ -547,10 +554,10 @@ class TableData[HEAD](Table):
     # ---------------------------------------------------------- #
     # Leitura de dados - READ
     # ---------------------------------------------------------- #
-    
+
     def get_data(self) -> pd.DataFrame:
         return self._table_data
-    
+
     def get_row_at(self, idx: int) -> RowH[HEAD, Any]:
         if self.empty():
             raise TableEmptyError("A tabela está vazia")
@@ -565,7 +572,7 @@ class TableData[HEAD](Table):
         return TableData._object_index(self._table_data.columns)
 
     def header(self) -> ArrayList[HEAD]:
-        return ArrayList(self._table_data.columns.tolist()) # type: ignore > não falha apartir do pandas 3.x
+        return ArrayList(self._table_data.columns.tolist())  # type: ignore > não falha apartir do pandas 3.x
 
     def select_columns(self, header: list[HEAD]) -> TableData:
         current = self.header()
@@ -573,9 +580,7 @@ class TableData[HEAD](Table):
             if not current.contains(h):
                 raise ColumnNotFoundError(f"Coluna não encontrada: {h}")
 
-        return TableData(
-                self._table_data[list(header)].copy()
-        )
+        return TableData(self._table_data[list(header)].copy())
 
     def get(self, h: HEAD) -> ColumnV[HEAD, Any]:
         """
@@ -592,7 +597,7 @@ class TableData[HEAD](Table):
     # ---------------------------------------------------------- #
     def add_row(self, row: RowH[HEAD, Any]) -> None:
         """
-            Adiciona uma linha a tabela se a linha não estiver vazia.
+        Adiciona uma linha a tabela se a linha não estiver vazia.
         """
         if row.is_empty():
             return None
@@ -650,7 +655,7 @@ class TableData[HEAD](Table):
 
     def add(self, col: ColumnV) -> None:
         """
-            Faz o mesmo que .set()
+        Faz o mesmo que .set()
         """
         self.set(col)
 
@@ -678,7 +683,7 @@ class TableData[HEAD](Table):
             )
         self._table_data[col.head] = values
         self._table_data.columns = self.get_data_columns()
-        
+
     def set_data(self, df: pd.DataFrame) -> None:
         self._table_data = df
 
@@ -704,13 +709,14 @@ class TableData[HEAD](Table):
     # Pesquisar/Buscar dados - SEARCH
     # ---------------------------------------------------------- #
     def search(self, h: HEAD, value: Any) -> TableData[HEAD]:
-
         """
             Retorna uma nova tabela apenas com as linhas onde a coluna `h` == value.
         Se nada for encontrado, retorna uma tabela com o mesmo cabeçalho e 0 linhas.
         """
         if not self.contains_header(h):
-            raise ColumnNotFoundError(f"Coluna não encontrada: {h}")
+            raise ColumnNotFoundError(
+                f"Coluna não encontrada: {h}\nColunas disponiveis -> {self.header()}"
+            )
 
         df = self._table_data[self._table_data[h] == value].reset_index(drop=True)
         return TableData(df)
@@ -730,7 +736,7 @@ class TableData[HEAD](Table):
 
     def remove_null(self, header: HEAD) -> TableData[HEAD]:
         """
-            Remove as linhas em que a coluna `header` seja NaN, "", "nan" ou "NaN".
+        Remove as linhas em que a coluna `header` seja NaN, "", "nan" ou "NaN".
         """
         if self.empty():
             raise TableEmptyError(f"A tabela está vazia e não possui a coluna {header}")
@@ -771,7 +777,10 @@ class TableData[HEAD](Table):
     def create_from_map(cls, hash_map: HashMap[HEAD, list[Any]]) -> TableData:
         return cls(hash_map.to_data_frame())
 
-def concat_tables(values: list[Table], *, rt_type: type[TableData | TableMap] = TableData) -> TableData | TableMap:
+
+def concat_tables(
+    values: list[Table], *, rt_type: type[TableData | TableMap] = TableData
+) -> TableData | TableMap:
     """
     Concatenar uma lista de tabelas, se receber uma lista vazia gera a exceção ListTablesEmptyError().
     """
@@ -780,7 +789,7 @@ def concat_tables(values: list[Table], *, rt_type: type[TableData | TableMap] =
         raise ListTablesEmptyError("Não é possível concatenar uma lista vazia")
 
     final: TableData | TableMap = rt_type()
-    
+
     first = values[0]
     header = first.header()
 
@@ -794,11 +803,13 @@ def concat_tables(values: list[Table], *, rt_type: type[TableData | TableMap] =
             raise TableEmptyError(f"Não é possível concatenar uma tabela vazia!")
 
         if current_table.header().size() != header.size():
-            raise HeadersSizeNotIqualError("As tabelas precisam ter colunas de tamanhos iguais para concatenar!")
+            raise HeadersSizeNotIqualError(
+                "As tabelas precisam ter colunas de tamanhos iguais para concatenar!"
+            )
 
         for h in header:
             if not current_table.header().contains(h):
-                raise ColumnNotFoundError(f'Coluna não encontrada: {h}')
+                raise ColumnNotFoundError(f"Coluna não encontrada: {h}")
 
             final.get(h).add_all(current_table.get(h).get_elements())
 

{table_stream-0.1.9 → table_stream-0.2.0}/table_stream.egg-info/PKG-INFO

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