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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "table_stream"
-version = "0.2.0"
+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.2.0 → 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.2.0"
+__version__ = "0.2.2"

{table_stream-0.2.0 → 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.2.0 → 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.2.0 → table_stream-0.2.2}/table_stream/table.py

@@ -7,11 +7,12 @@ from abc import abstractmethod, ABC
 from table_stream.hash_map import ArrayList, HashMapDict, HashMap, HashMapDataFrame
 from table_stream.erros import (
     ColumnNotFoudError,
+    ColumnExistsError,
     RowNotExistError,
     EmptyRowError,
     ColumnNotFoundError,
     HeadersSizeNotIqualError,
-    HeaderNotFoundError,
+    ColumnNotFoudError,
     TableEmptyError,
     ListTablesEmptyError,
 )
@@ -34,15 +35,17 @@ class RowH[HEAD, T]:
         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):
@@ -89,8 +92,8 @@ 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.
@@ -288,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
 
@@ -296,24 +299,9 @@ 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]]):
@@ -326,39 +314,17 @@ 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
@@ -372,7 +338,7 @@ class Table[HEAD](ABC):
         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()
@@ -397,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()
@@ -425,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:
@@ -457,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)
 
@@ -475,9 +448,19 @@ 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
     # ---------------------------------------------------#
@@ -540,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)
@@ -559,14 +556,14 @@ class TableData[HEAD](Table):
         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}")
+        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)
@@ -602,8 +599,10 @@ class TableData[HEAD](Table):
         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()
 
@@ -616,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}"
                 )
 
@@ -632,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)]
 
@@ -654,32 +662,44 @@ 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()
@@ -714,13 +734,27 @@ class TableData[HEAD](Table):
         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}\nColunas disponiveis -> {self.header()}"
-            )
+            raise ColumnNotFoundError(f"Coluna não encontrada: {h}")
 
         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
     # ---------------------------------------------------------- #
@@ -728,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)
@@ -738,7 +772,7 @@ class TableData[HEAD](Table):
         """
         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):
@@ -778,9 +812,12 @@ class TableData[HEAD](Table):
         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().
     """
@@ -788,29 +825,11 @@ def concat_tables(
     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.2.0 → table_stream-0.2.2}/table_stream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table_stream
-Version: 0.2.0
+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