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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table_stream
-Version: 0.1.9
+Version: 0.2.2
 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.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "table_stream"
-version = "0.1.9"
+version = "0.2.2"
 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.2}/table_stream/__init__.py

@@ -66,11 +66,12 @@ from .table import (
     TableEmptyError,
     EmptyRowError,
     ColumnNotFoundError,
-    HeaderNotFoundError,
+    ColumnNotFoudError,
     HeadersSizeNotIqualError,
     concat_tables,
     RowNotExistError,
     TableData,
+    Table,
     ListTablesEmptyError,
 )
 
@@ -84,8 +85,8 @@ from .erros import (
     ListTablesEmptyError,
     LoadWorkbookError,
     NotImplementedModuleError,
-    HeaderNotFoundError,
+    ColumnNotFoudError,
     HeadersSizeNotIqualError,
 )
 
-__version__ = "0.1.9"
+__version__ = "0.2.2"

{table_stream-0.1.9 → table_stream-0.2.2}/table_stream/erros.py

@@ -1,6 +1,6 @@
 class CoreException(Exception):
 
-    def __init__(self, message: str = f'Erro') -> None:
+    def __init__(self, message: str = f"Erro") -> None:
         super().__init__(message)
         self._message = message
 
@@ -17,13 +17,13 @@ class CoreException(Exception):
 
 class ValueNotifyNullError(CoreException):
 
-    def __init__(self, message: str = 'Notificação nula...') -> None:
+    def __init__(self, message: str = "Notificação nula...") -> None:
         super().__init__(message)
 
 
 class UnsuportedSheetError(CoreException):
 
-    def __init__(self, message: str = 'Planilha inválida...') -> None:
+    def __init__(self, message: str = "Planilha inválida...") -> None:
         super().__init__(message)
 
 
@@ -31,21 +31,22 @@ class UnsuportedSheetError(CoreException):
 # Erros relacionados a HashMap
 # ============================================================#
 
+
 class InvalidHashMapTableError(CoreException):
 
-    def __init__(self, message: str = 'HashMap inválido') -> None:
+    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:
+    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:
+    def __init__(self, message: str = "Tamanho de tabela inválido") -> None:
         super().__init__(message)
 
 
@@ -54,21 +55,22 @@ class SizeTableError(InvalidHashMapTableError):
 # ============================================================#
 class UndefinedSheetIndex(CoreException):
 
-    def __init__(self, message: str = 'SheetIndexNames não foi definido') -> None:
+    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:
+    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:
+    def __init__(self, message: str = "Erro, use bytes de imagem") -> None:
         super().__init__(message)
 
 
@@ -77,56 +79,60 @@ class InvalidSourceImageError(CoreException):
 # ============================================================#
 class NotImplementedModuleError(CoreException):
 
-    def __init__(self, message: str = 'Erro, módulo não implementado') -> None:
+    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:
+    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:
+    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:
+    def __init__(
+        self, message: str = "Adaptador InvertColor não implementado..."
+    ) -> None:
         super().__init__(message)
 
+
 # ============================================================#
 # Erros relacionados a tabelas
 # ============================================================#
 
 
 class ColumnNotFoudError(ValueError):
-    
+
     def __init__(self, *args: object) -> None:
         super().__init__(*args)
 
-class ColumnNotIqualSizeError(ValueError):
+
+class ColumnExistsError(ValueError):
 
     def __init__(self, *args: object) -> None:
         super().__init__(*args)
 
 
-class EmptyRowError(Exception):
+class ColumnNotIqualSizeError(ValueError):
 
     def __init__(self, *args: object) -> None:
         super().__init__(*args)
 
 
-class TableEmptyError(Exception):
+class EmptyRowError(Exception):
 
     def __init__(self, *args: object) -> None:
         super().__init__(*args)
 
 
-class HeaderNotFoundError(Exception):
+class TableEmptyError(Exception):
 
     def __init__(self, *args: object) -> None:
         super().__init__(*args)

{table_stream-0.1.9 → table_stream-0.2.2}/table_stream/sysfiles.py

@@ -687,7 +687,6 @@ def create_void_table_files() -> TableData[HeaderMetaData]:
     """
 
     tb = TableData()
-
     tb.add(ColumnV(HeaderMetaData.HASH_FILE))
     tb.add(ColumnV(HeaderMetaData.FILE_NAME))
     tb.add(ColumnV(HeaderMetaData.FILE_EXTENSION))

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

@@ -6,9 +6,15 @@ 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,
+    ColumnExistsError,
+    RowNotExistError,
+    EmptyRowError,
+    ColumnNotFoundError,
+    HeadersSizeNotIqualError,
+    ColumnNotFoudError,
+    TableEmptyError,
+    ListTablesEmptyError,
 )
 from typing import Any, TypeVar, Callable
 import pandas as pd
@@ -20,25 +26,27 @@ 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
 
     def __repr__(self) -> str:
-        default = f"{__class__.__name__}():"
+        sep = "->"
+        default_text = f"<{__class__.__name__}()>"
+
         if len(self.map) == 0:
-            return f"{default} Size: 0"
-        
+            return f"{default_text} Size 0 {sep} []"
+
         _values = ArrayList()
         for k, v in self.map.items():
             _values.add(f"{k} -> {v}")
-        
-        return f"{default}\n{_values}"
-    
+
+        return f"{default_text} Size {len(self.map)} {sep} {_values}"
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, RowH):
             raise NotImplementedError()
@@ -46,30 +54,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 +92,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}"
-    
-    #---------------------------------------------------#
+        txt = f"Head {self.head}; Size {self.size()}; Type {self.get_type()} -> {self._elements}"
+        return f"{__class__.__name__}(): {txt}"
+
+    # ---------------------------------------------------#
     # 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 +109,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 +174,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 +232,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 +251,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()))
@@ -281,7 +291,7 @@ class Table[HEAD](ABC):
         Adiciona uma nova coluna com texto padrão NULL_TEXT.
         """
 
-        if self.empty():
+        if self.is_empty():
             self.add(ColumnV(h))
             return
 
@@ -289,29 +299,14 @@ class Table[HEAD](ABC):
         values = [Table.NULL_STRING] * total
         self.add(ColumnV(h, ArrayList(values)))
 
+    @abstractmethod
     def merge(self, tb: Table) -> None:
-        if tb.empty():
-            raise TableEmptyError(f"Não é possível unir uma tabela vazia!")
-
-        if self.header().size() != tb.header().size():
-            raise HeadersSizeNotIqualError(
-                "Não é possível juntar tabelas com cabeçalhos diferentes!"
-            )
-
-        header = self.header()
-        # print(f"[UNINDO TABELAS] Atual: {self} Incrementando: {tb}")
-
-        for h in header:
-            if not tb.contains_header(h):
-                raise ColumnNotFoundError(f"Coluna inexistente ... {h}")
-
-            current_col: ColumnV = tb.get(h)
-            self.get(h).add_all(current_col._elements)
+        pass
 
     @abstractmethod
     def set(self, col: ColumnV[HEAD, ArrayList[T]]):
         pass
-    
+
     @abstractmethod
     def set_data(self, df: pd.DataFrame) -> None:
         pass
@@ -319,53 +314,31 @@ class Table[HEAD](ABC):
     @abstractmethod
     def add(self, col: ColumnV) -> None:
         """
-            Adiciona uma coluna na tabela.
+        Adiciona uma coluna na tabela, se já existir uma coluna com o mesmo nome lança uma
+        exceção ColumnExistsError()
         """
         pass
 
+    @abstractmethod
     def add_row(self, row: RowH[HEAD, Any]):
         """
         Adiciona uma linha a tabela se a linha não estiver vazia.
         """
-        if row.is_empty():
-            return None
-
-        if self.empty():
-            for row_header in row.header():
-                self.add(ColumnV(row_header))
-
-        header: ArrayList[HEAD] = self.header()
-
-        if row.header().size() < header.size():
-            raise HeadersSizeNotIqualError(
-                "A linha que você está tentando adicionar tem cabeçalho menor que o da tabela!!!"
-            )
-
-        for h in header:
-            if not row.header().contains(h):
-                msg = f"Você está tentando adicionar uma linha que não possui o cabeçalho >> [{h}] <<"
-
-                raise HeaderNotFoundError(
-                    f"{msg} \nCabeçalhos existentes na linha => {row.header()}\n\nCabeçalhos da tabela => {header}"
-                )
-
-            # self.tb_map[h].add(row.get(h))
-            self.get(h).add(row.get(h))
-        return None
+        pass
 
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     # Leitura de dados - READ
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     @abstractmethod
     def get_data(self) -> pd.DataFrame:
         pass
-    
+
     @abstractmethod
     def get(self, h: HEAD) -> ColumnV[HEAD, Any]:
         pass
 
     def get_row_at(self, idx: int) -> RowH[HEAD, Any]:
-        if self.empty():
+        if self.is_empty():
             raise TableEmptyError("A tabela está vazia")
 
         total = self.get_first().size()
@@ -390,7 +363,7 @@ class Table[HEAD](ABC):
     def rows(self) -> ArrayList[RowH[HEAD, Any]]:
         final = ArrayList[RowH]()
 
-        if self.empty():
+        if self.is_empty():
             return final
 
         total = self.get(self.header().get_first()).size()
@@ -405,7 +378,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
@@ -418,7 +391,7 @@ class Table[HEAD](ABC):
         header = self.header()
         h: HEAD
 
-        if self.empty():
+        if self.is_empty():
             if header.empty():
                 print(f"{self}")
             else:
@@ -450,14 +423,21 @@ class Table[HEAD](ABC):
     def search(self, h: HEAD, value: Any) -> Table[HEAD]:
         pass
 
-    #---------------------------------------------------#
+    @abstractmethod
+    def search_all(self, h: HEAD, values: list[T]) -> Table[HEAD] | None:
+        pass
+
+    # ---------------------------------------------------#
     # Verificação/validação de dados
-    #---------------------------------------------------#
+    # ---------------------------------------------------#
     def size(self) -> int:
-        if self.empty():
+        if self.is_empty():
             return 0
         return self.get_first().size()
 
+    def size_header(self) -> int:
+        return self.header().size()
+
     def contains_header(self, h: HEAD) -> bool:
         return self.header().contains(h)
 
@@ -468,23 +448,33 @@ class Table[HEAD](ABC):
         return self.get(h).contains(value)
 
     @abstractmethod
-    def empty(self) -> bool:
+    def is_empty(self) -> bool:
+        """
+        Retorna True se a tabela não tiver linhas, mesmo que o cabeçalho exista.
+        """
         pass
 
-    #---------------------------------------------------#
+    @abstractmethod
+    def is_void(self) -> bool:
+        """
+        Retorna True se o cabeçalho estiver vazio. False se a tabela tiver pelo menos uma coluna
+        mesmo que esteja vazia.
+        """
+
+    # ---------------------------------------------------#
     # 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))
 
@@ -533,13 +523,27 @@ class TableData[HEAD](Table):
         self._table_data: pd.DataFrame = data
 
     def __repr__(self) -> str:
-        return f"{__class__.__name__}(): Size {self.size()}; Columns {self.header().size()}"
+        msg = f"{__class__.__name__}(): Size {self.size()}; Columns {self.header().size()};"
+
+        if self.size() > 0:
+            row = self.get_row_at(0)
+            msg = f"{msg}\n{row}"
+
+        return f"{msg}"
 
     # ---------------------------------------------------------- #
     # Verificação/Validação de dados.
     # ---------------------------------------------------------- #
-    def empty(self) -> bool:
-        return self._table_data.empty
+    def is_empty(self) -> bool:
+        if self.size_header() == 0:
+            return True
+        return len(self._table_data[self.header().get_first()]) == 0
+
+    def is_void(self) -> bool:
+        return self.size_header() == 0
+
+    def size_header(self) -> int:
+        return self.header().size()
 
     def size(self) -> int:
         return len(self._table_data)
@@ -547,25 +551,25 @@ 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")
 
-        if idx < 0 or idx >= len(self._table_data):
-            raise RowNotExistError(f"A linha ... {idx} não existe na tabela {self}")
+    def get_row_at(self, idx: int) -> RowH[HEAD, Any]:
+        total = self.size()
+        if idx >= total:
+            raise RowNotExistError(f"A linha {idx} não existe ... Total {total}")
 
-        values = self._table_data.iloc[idx].tolist()
-        return RowH(idx, dict(zip(self.header(), values)))
+        row = RowH(idx)
+        header = self.header()
+        header.for_each(lambda h: row.set(h, self.get(h).get(idx)))
+        return row
 
     def get_data_columns(self) -> pd.Index:
         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 +577,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,13 +594,15 @@ 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
 
-        if self.header().empty():
+        # Tabela completamente vazia, criar o cabeçalho com base na linha recebida.
+        if self.is_void():
             self._table_data = pd.DataFrame(columns=row.header())
+            row.index = 0
 
         header: ArrayList[HEAD] = self.header()
 
@@ -611,7 +615,7 @@ class TableData[HEAD](Table):
             if not row.header().contains(h):
                 msg = f"Você está tentando adicionar uma linha que não possui o cabeçalho >> [{h}] <<"
 
-                raise HeaderNotFoundError(
+                raise ColumnNotFoudError(
                     f"{msg} \nCabeçalhos existentes na linha => {row.header()}\nCabeçalhos da tabela => {header}"
                 )
 
@@ -627,19 +631,28 @@ class TableData[HEAD](Table):
         return None
 
     def merge(self, tb: Table) -> None:
-        if tb.empty():
+        if tb.is_empty():
             raise TableEmptyError("Não é possível unir uma tabela vazia!")
 
-        if self.header().size() != tb.header().size():
-            msg = f"Cabeçalho da tabela -> {self.header().size()} | Cabeçalho da tabela externa -> {tb.header().size()}"
+        header = self.header()
+        size_header_table = self.size_header()
+        size_header_other = header.size()
+
+        if size_header_table == 0:
+            cols = tb.header()
+            cols.for_each(lambda c: self.add(ColumnV(c)))
+
+        if size_header_table != size_header_other:
+            msg = f"Cabeçalho da tabela -> {self.header().size()} | Cabeçalho externo -> {tb.header().size()}"
             raise HeadersSizeNotIqualError(
                 f"Não é possível juntar tabelas com cabeçalhos diferentes.\n{msg}"
             )
 
-        header = self.header()
         for h in header:
             if not tb.contains_header(h):
-                raise ColumnNotFoundError(f"Coluna inexistente ... {h}")
+                raise ColumnNotFoundError(
+                    f"Coluna inexistente ... {h} ... Colunas disponíveis ... {self.header()}"
+                )
 
         other = tb.to_dataframe()[list(header)]
 
@@ -649,36 +662,48 @@ class TableData[HEAD](Table):
             self._table_data = pd.concat([self._table_data, other], ignore_index=True)
 
     def add(self, col: ColumnV) -> None:
-        """
-            Faz o mesmo que .set()
-        """
-        self.set(col)
+        if self.header().contains(col.head):
+            raise ColumnExistsError(f"Já existe uma coluna com o nome: {col.head}")
+
+        if self.is_void():
+            self._table_data = pd.DataFrame({col.head: col.get_elements()})
+            return
+
+        current_size = col.size()
+        cols_size = self.get_first().size()
+
+        if cols_size != current_size:
+            raise HeadersSizeNotIqualError(
+                f"Não é possível adicionar uma coluna com tamanho {current_size} ... Tamanho da tabela ... {cols_size}!"
+            )
+
+        self._table_data[col.head] = pd.Series(col.get_elements())
 
     def set(self, col: ColumnV[HEAD, ArrayList[T]]) -> None:
+
         values: ArrayList = col.get_elements()
 
-        if self.size() == 0:
+        if self.header().empty():
             # Tabela sem colunas: cria o DataFrame a partir da primeira coluna.
             self._table_data = pd.DataFrame({col.head: values})
+            self._table_data.columns = self.get_data_columns()
             return
 
         total = self.size()
         total_values = values.size()
 
         if total == 0 and total_values > 0:
-            # Tabela só com cabeçalho (0 linhas): estende o índice.
             self._table_data = self._table_data.reindex(range(total_values))
             total = total_values
 
         if total_values != total:
-
             raise HeadersSizeNotIqualError(
                 f"{__class__.__name__}() Não é possível adicionar uma coluna com tamanho "
-                f"diferente da tabela. Tabela {total} | Coluna {len(values)} {col.head}"
+                f"diferente da tabela. Tabela {total} | Coluna {total_values} {col.head}"
             )
         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,7 +729,6 @@ 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.
@@ -715,6 +739,22 @@ class TableData[HEAD](Table):
         df = self._table_data[self._table_data[h] == value].reset_index(drop=True)
         return TableData(df)
 
+    def search_all(self, h: Any, values: list[T]) -> Table | None:
+        if len(values) == 0:
+            return None
+
+        content = ArrayList[Table]()
+
+        for v in values:
+            found = self.search(h, v)
+
+            if not found.is_empty():
+                content.add(found)
+
+        if content.empty():
+            return None
+        return concat_tables(content)
+
     # ---------------------------------------------------------- #
     # Exclusão de dados - DELETE
     # ---------------------------------------------------------- #
@@ -722,7 +762,7 @@ class TableData[HEAD](Table):
         self._table_data = pd.DataFrame()
 
     def drop_duplicates(self) -> TableData:
-        if self.empty():
+        if self.is_empty():
             raise TableEmptyError()
 
         df = self._table_data.drop_duplicates().reset_index(drop=True)
@@ -730,9 +770,9 @@ 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():
+        if self.is_empty():
             raise TableEmptyError(f"A tabela está vazia e não possui a coluna {header}")
 
         if not self.contains_header(header):
@@ -771,7 +811,13 @@ 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:
+
+TB_TYPE = TypeVar("TB_TYPE", bound="Table")
+
+
+def concat_tables[TB_TYPE](
+    values: list[Table], *, rt_type: type[Table | TB_TYPE] = TableData
+) -> TableData | Table | TB_TYPE:
     """
     Concatenar uma lista de tabelas, se receber uma lista vazia gera a exceção ListTablesEmptyError().
     """
@@ -779,27 +825,11 @@ def concat_tables(values: list[Table], *, rt_type: type[TableData | TableMap] =
     if len(values) == 0:
         raise ListTablesEmptyError("Não é possível concatenar uma lista vazia")
 
-    final: TableData | TableMap = rt_type()
-    
-    first = values[0]
-    header = first.header()
-
-    for h in header:
-        final.add(ColumnV(h))
+    header = values[0].header()
+    final: Table = rt_type()
+    header.for_each(lambda h: final.add(ColumnV(h)))
 
     current_table: Table
-
     for current_table in values:
-        if current_table.empty():
-            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!")
-
-        for h in header:
-            if not current_table.header().contains(h):
-                raise ColumnNotFoundError(f'Coluna não encontrada: {h}')
-
-            final.get(h).add_all(current_table.get(h).get_elements())
-
+        final.merge(current_table)
     return final

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

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