convert-stream 2.3.8__tar.gz → 2.4__tar.gz

{convert_stream-2.3.8 → convert_stream-2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 2.3.8
+Version: 2.4
 Summary: Manipulação de documentos PDF e Imagens. Converter, Ler, rotacionar exportar etc.
 Author: Bruno Chaves
 Requires-Python: >=3.11

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/__init__.py

@@ -10,13 +10,14 @@ from ._version import (
 from .mod_types import (
     MetaDataFile, MetaDataItem, create_metadata, ColumnsTable, ListString, ArrayString,
     HeadCell, HeadValues, ColumnBody, TextTable, LibDate, LibPDF, LibImage, LibPdfToImage,
-    LibImageToPdf, create_dict_map_from_file, create_void_dict_map, RotationAngle
+    LibImageToPdf, DictTextTable, RotationAngle,
 )
 from .image import ImageObject, CollectionImages
 from .pdf import DocumentPdf, PageDocumentPdf, CollectionPagePdf, ConvertPdfToImages, ConvertImageToPdf
 from .pdf.pdf_document import SearchableTextPdf
 from .doc_stream import PdfStream, SplitPdf
 from .table_files import PdfFinder
+from .text import ConvertStringDate, fmt_col_to_date
 
 
 def __create_stream() -> PdfStream:
@@ -79,7 +80,7 @@ __all__ = [
     'PdfFinder', 'SplitPdf', 'LibImageToPdf',  'RotationAngle', 'ConvertImageToPdf', 'ConvertPdfToImages',
     'MetaDataFile', 'MetaDataItem', 'ColumnsTable', 'ListString', 'ArrayString',
     'HeadCell', 'HeadValues', 'ColumnBody', 'TextTable', 'LibDate', 'LibPDF', 'LibImage', 'LibPdfToImage',
-    'read_pdf', 'read_files_pdf', 'read_image', 'create_dict_map_from_file', 'create_void_dict_map',
-    'create_metadata',
+    'read_pdf', 'read_files_pdf', 'read_image', 'DictTextTable',
+    'create_metadata', 'fmt_col_to_date',
 ]
 

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/image/img_object.py

@@ -508,7 +508,7 @@ class CollectionImages(ListItems):
         self.__count: int = 0
 
     def clear(self) -> None:
-        self.clear()
+        super().clear()
         self.__count = 0
 
     def add_image(self, image: ImageObject) -> None:

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/mod_types/__init__.py

@@ -10,8 +10,7 @@ from .enums import (
 
 from .table_types import (
     TextTable, ListString, ArrayString, HeadCell, HeadValues,
-    ColumnBody, create_void_dict_map, create_dict_map_values, create_void_df_map,
-    create_dict_map_from_file, concat_maps, contains, get_text_from_file
+    ColumnBody, DictTextTable, concat_maps, contains,
 )
 
 
@@ -92,8 +91,7 @@ def create_metadata(file: str | File) -> MetaDataFile:
 
 __all__ = [
     'get_hash_from_bytes', 'get_void_metadata', 'get_void_metadata', 'contains',
-    'concat_maps', 'create_dict_map_from_file', 'create_dict_map_values',
-    'create_void_df_map', 'create_void_dict_map', 'ColumnBody', 'ColumnsTable',
+    'concat_maps', 'DictTextTable', 'ColumnBody', 'ColumnsTable',
     'ListString', 'HeadCell', 'HeadValues', 'TextTable', 'RotationAngle', 'LibPDF',
     'LibImageToPdf', 'LibPdfToImage', 'LibImage', 'LibDate', 'ArrayString',
     'MetaDataFile', 'MetaDataItem', 'create_metadata',

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/mod_types/table_types.py

@@ -292,110 +292,129 @@ class TextTable(dict):
         self[col.col_name] = col
 
 
-def create_void_dict_map() -> dict[str, ColumnBody]:
-
-    return {
-            ColumnsTable.KEY.value: ColumnBody(ColumnsTable.KEY.value, ListString([])),
-            ColumnsTable.NUM_PAGE.value: ColumnBody(ColumnsTable.NUM_PAGE.value, ListString([])),
-            ColumnsTable.NUM_LINE.value: ColumnBody(ColumnsTable.NUM_LINE.value, ListString([])),
-            ColumnsTable.TEXT.value: ColumnBody(ColumnsTable.TEXT.value, ListString([])),
-            ColumnsTable.FILE_NAME.value: ColumnBody(ColumnsTable.FILE_NAME.value, ListString([])),
-            ColumnsTable.FILETYPE.value: ColumnBody(ColumnsTable.FILETYPE.value, ListString([])),
-            ColumnsTable.FILE_PATH.value: ColumnBody(ColumnsTable.FILE_PATH.value, ListString([])),
-            ColumnsTable.DIR.value: ColumnBody(ColumnsTable.DIR.value, ListString([])),
-        }
-
-
-def create_void_df_map() -> pd.DataFrame:
-    """
-        Retorna um DataFrame() vazio, apenas com as colunas formatadas
-    para tabela de arquivos.
-    @rtype: pd.DataFrame
-    """
-    return pd.DataFrame.from_dict(create_void_dict_map())
-
-
-def create_dict_map_values(
-            values: list[str], *,
-            page_num: str = 'nan',
-            file_path: str = 'nan',
-            dir_path: str = 'nan',
-            file_type: str = 'nan',
-        ) -> dict[str, ColumnBody]:
-    """
-    Criar um DataFrame() a partir do mapa de um texto list[str]
-    :param values: texto list[str]
-    :param page_num: numero da página PDF caso o texto seja de uma página PDF.
-    :param file_path: path do arquivo.
-    :param dir_path: diretório pai do arquivo.
-    :param file_type: tipo do arquivo.
-    :return: DataFrame
-    @rtype: pd.DataFrame
-    """
-    max_num = len(values)
-    if max_num < 1:
-        return create_void_dict_map()
-
-    _map: dict[str, ColumnBody] = create_void_dict_map()
-    _map[ColumnsTable.KEY.value].extend([f'{x}' for x in range(0, max_num)])
-    _map[ColumnsTable.NUM_PAGE.value].extend([page_num] * max_num)
-    _map[ColumnsTable.NUM_LINE.value].extend([f'{x+1}' for x in range(0, max_num)])
-    _map[ColumnsTable.TEXT.value].extend(values)
-    _map[ColumnsTable.FILE_NAME.value].extend([os.path.basename(file_path)] * max_num)
-    _map[ColumnsTable.FILETYPE.value].extend([file_type] * max_num)
-    _map[ColumnsTable.FILE_PATH.value].extend([file_path] * max_num)
-    _map[ColumnsTable.DIR.value].extend([dir_path] * max_num)
-    return _map
-
-
-def create_dict_map_from_file(
-            file: File,
-            values: list[str], *,
-            page_num: str = 'nan'
-        ) -> dict[str, ColumnBody]:
-    """
-    Criar um DataFrame() a partir do mapa de um texto list[str]
-    :param file: arquivo no disco do qual o texto (list[str]) foi extraído
-    :param values: texto list[str]
-    :param page_num: numero da página PDF caso o texto seja de uma página PDF.
-
-    """
-    max_num = len(values)
-    if max_num < 1:
-        return create_void_dict_map()
-    return create_dict_map_values(
-        values, page_num=page_num, file_path=file.absolute(), dir_path=file.dirname(), file_type=file.extension()
-    )
+class DictTextTable(TextTable):
+
+    default_columns = [
+        ColumnBody(ColumnsTable.KEY.value, ListString([])),
+        ColumnBody(ColumnsTable.NUM_PAGE.value, ListString([])),
+        ColumnBody(ColumnsTable.NUM_LINE.value, ListString([])),
+        ColumnBody(ColumnsTable.TEXT.value, ListString([])),
+        ColumnBody(ColumnsTable.FILE_NAME.value, ListString([])),
+        ColumnBody(ColumnsTable.FILETYPE.value, ListString([])),
+        ColumnBody(ColumnsTable.FILE_PATH.value, ListString([])),
+        ColumnBody(ColumnsTable.DIR.value, ListString([])),
+    ]
 
+    def __init__(self, body_list: list[ColumnBody]):
+        super().__init__(body_list)
 
-def get_text_from_file(file: str | File) -> ListString:
-    """
-        Retorna o texto de um arquivo .txt em formato de lista
-    """
-    if isinstance(file, File):
-        file = file.absolute()
-
-    try:
-        with open(file, 'rt') as f:
-            lines = ListString(f.readlines())
-    except Exception as e:
-        print(e)
-        return ListString([])
-    else:
-        return lines
-
-
-def concat_maps(list_map: list[dict[str, ColumnBody]]) -> dict[str, ColumnBody]:
-    if len(list_map) == 0:
-        return {}
-    columns: list[str] = list(list_map[0].keys())
-    final_dict: dict[str, ColumnBody] = {}
-    for col in columns:
-        final_dict[col] = ColumnBody(col, [])
-    for current_map in list_map:
-        for c in columns:
-            final_dict[c].extend(current_map[c])
-    return final_dict
+    @property
+    def columns(self) -> HeadValues:
+        _cols = list(self.keys())
+        return HeadValues([HeadCell(x) for x in _cols])
+
+    def to_data(self) -> pd.DataFrame:
+        return pd.DataFrame.from_dict(self)
+
+    @classmethod
+    def create_void_dict(cls) -> DictTextTable:
+
+        _default = [
+            ColumnBody(ColumnsTable.KEY.value, ListString([])),
+            ColumnBody(ColumnsTable.NUM_PAGE.value, ListString([])),
+            ColumnBody(ColumnsTable.NUM_LINE.value, ListString([])),
+            ColumnBody(ColumnsTable.TEXT.value, ListString([])),
+            ColumnBody(ColumnsTable.FILE_NAME.value, ListString([])),
+            ColumnBody(ColumnsTable.FILETYPE.value, ListString([])),
+            ColumnBody(ColumnsTable.FILE_PATH.value, ListString([])),
+            ColumnBody(ColumnsTable.DIR.value, ListString([])),
+        ]
+        return cls(_default)
+
+    @classmethod
+    def create_void_df(cls) -> pd.DataFrame:
+        return pd.DataFrame.from_dict(cls.create_void_dict())
+
+    @classmethod
+    def create_from_values(
+                cls,
+                values: list[str], *,
+                page_num: str = 'nan',
+                file_path: str = 'nan',
+                dir_path: str = 'nan',
+                file_type: str = 'nan',
+            ) -> DictTextTable:
+        max_num = len(values)
+        if max_num < 1:
+            return cls.create_void_dict()
+
+        _items = [
+            ColumnBody(
+                ColumnsTable.KEY.value, ListString([f'{x}' for x in range(0, max_num)])
+            ),
+            ColumnBody(
+                ColumnsTable.NUM_PAGE.value, ListString([page_num] * max_num)
+            ),
+            ColumnBody(
+                ColumnsTable.NUM_LINE.value, ListString([f'{x+1}' for x in range(0, max_num)])
+            ),
+            ColumnBody(
+                ColumnsTable.TEXT.value, ListString(values)
+            ),
+            ColumnBody(
+                ColumnsTable.FILE_NAME.value, ListString([os.path.basename(file_path)] * max_num)
+            ),
+            ColumnBody(
+                ColumnsTable.FILETYPE.value, ListString([file_type] * max_num)
+            ),
+            ColumnBody(
+                ColumnsTable.FILE_PATH.value, ListString([file_path] * max_num)
+            ),
+            ColumnBody(
+                ColumnsTable.DIR.value, ListString([dir_path] * max_num)
+            ),
+        ]
+        return cls(_items)
+
+    @classmethod
+    def create_from_file_text(cls, file: File) -> DictTextTable:
+        if not isinstance(file, File):
+            return cls.create_void_dict()
+
+        try:
+            with open(file.absolute(), 'rt') as f:
+                lines = ListString(f.readlines())
+        except Exception as e:
+            print(e)
+            return cls.create_void_dict()
+        else:
+            return cls.create_from_values(
+                lines,
+                file_type=file.extension(),
+                file_path=file.absolute(),
+                dir_path=file.dirname(),
+            )
+
+
+def concat_maps(list_map: list[DictTextTable]) -> DictTextTable:
+    if len(list_map) < 1:
+        return DictTextTable.create_void_dict()
+    _columns: HeadValues = list_map[0].columns
+    list_values: list[ColumnBody] = []
+    text_table: DictTextTable
+    col: ColumnBody
+    i: HeadCell
+
+    for i in _columns:
+        list_values.append(
+            ColumnBody(i, ListString([]))
+        )
+    for text_table in list_map:
+        for col in list_values:
+            col.extend(
+                text_table[col.col_name]
+            )
+    return DictTextTable(list_values)
 
 
 

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/pdf/pdf_document.py

@@ -13,7 +13,7 @@ from convert_stream.mod_types import (
     get_hash_from_bytes, create_metadata, MetaDataFile, MetaDataItem
 )
 from convert_stream.mod_types.table_types import (
-    ListItems, create_dict_map_values, concat_maps, create_void_dict_map, ColumnBody,
+    ListItems, concat_maps, DictTextTable, ColumnBody,
     HeadCell, HeadValues, ColumnsTable
 )
 from convert_stream.mod_types.enums import LibPDF
@@ -42,7 +42,7 @@ class SearchableTextPdf(object):
     """
     def __init__(self, silent: bool = False):
         self.silent = silent
-        self.elements: dict[str, ColumnBody] = create_void_dict_map()
+        self.elements: dict[str, ColumnBody] = DictTextTable.create_void_dict()
 
     def __repr__(self):
         return f'SearchableTextPdf: {self.elements}'
@@ -533,7 +533,7 @@ class DocumentPdf(object):
                 show_warning(f'{e}')
         return _values
 
-    def _create_map(self, page: PageDocumentPdf, *, separator: str = '\n') -> dict[str, ColumnBody]:
+    def _create_map(self, page: PageDocumentPdf, *, separator: str = '\n') -> DictTextTable:
         """
         @rtype: pd.DataFrame
         """
@@ -544,11 +544,15 @@ class DocumentPdf(object):
             _values = txt_page.split(separator)
 
         if not self.metadata.file_path.is_empty:
-            return create_dict_map_values(
-                _values, page_num=f'{page.number_page}', file_type='.pdf',
+            return DictTextTable.create_from_values(
+                _values,
+                page_num=f'{page.number_page}',
+                file_type='.pdf',
+                file_path=self.metadata.file_path,
+                dir_path=self.metadata.dir_path,
             )
         else:
-            return create_dict_map_values(
+            return DictTextTable.create_from_values(
                 _values,
                 page_num=f'{page.number_page}',
                 file_type='.pdf',
@@ -556,15 +560,15 @@ class DocumentPdf(object):
                 dir_path=self.metadata.dir_path,
             )
 
-    def to_dict(self, separator: str = '\n') -> dict[str, ColumnBody]:
-        list_data: list[dict[str, ColumnBody]] = []
+    def to_dict(self, separator: str = '\n') -> DictTextTable:
+        list_data: list[DictTextTable] = []
         pages: list[PageDocumentPdf] = self.to_pages()
 
         for page_pdf in pages:
-            _mp: dict[str, ColumnBody] = self._create_map(page_pdf, separator=separator)
+            _mp: DictTextTable = self._create_map(page_pdf, separator=separator)
             list_data.append(_mp)
         if len(list_data) == 0:
-            return create_void_dict_map()
+            return DictTextTable.create_void_dict()
         return concat_maps(list_data)
 
     def to_data(self, separator: str = '\n') -> pd.DataFrame:

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/pdf/pdf_page.py

@@ -9,7 +9,7 @@ import pandas as pd
 
 from convert_stream.mod_types.enums import LibPDF
 from convert_stream.mod_types.table_types import (
-    create_dict_map_values, ListString, ColumnBody
+    DictTextTable, ListString, ColumnBody
 )
 from convert_stream.mod_types.modules import (
     ModPagePdf, PageObject, fitz
@@ -230,9 +230,11 @@ class PageDocumentPdf(object):
             return ListString([])
         return ListString(txt.split(separator))
 
-    def to_dict(self, separator: str = '\n') -> dict[str, ColumnBody]:
+    def to_dict(self, separator: str = '\n') -> DictTextTable:
         _values = self.to_list(separator)
-        return create_dict_map_values(_values, page_num=f'{self.number_page}', file_type='.pdf')
+        return DictTextTable.create_from_values(
+            _values, page_num=f'{self.number_page}', file_type='.pdf'
+        )
 
     def to_map(self, separator: str = '\n') -> pd.DataFrame:
         return pd.DataFrame.from_dict(self.to_dict(separator=separator)).astype('str')

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/text/__init__.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
-from .date import ConvertStringDate
-from .find_text import ArrayString, FindText
+from .date import ConvertStringDate, fmt_col_to_date
+from .find_text import FindText
 from .terminal import (
     print_line, print_title, show_error, show_warning, show_info, Colors, msg
 )
 
 __all__ = [
-    'ConvertStringDate', 'print_title', 'print_line',
+    'ConvertStringDate', 'print_title', 'print_line', 'fmt_col_to_date',
     'show_info', 'Colors', 'show_error', 'show_warning', 'FindText',
-]
+]

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream/text/date.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 from datetime import datetime
-from pandas import Timestamp
+import pandas as pd
 from convert_stream.mod_types.enums import LibDate
 
 
@@ -112,7 +112,7 @@ class ConvertStringDate(object):
         """
             Verifica se o objeto atual é timestamp
         """
-        if isinstance(d, Timestamp):
+        if isinstance(d, pd.Timestamp):
             return True
         for current_format in self.date_valid_times_tamp:
             try:
@@ -214,3 +214,40 @@ class ConvertStringDate(object):
                 return date_timestamp.strftime(fmt.value)
         return None
 
+
+def fmt_col_to_date(
+            df: pd.DataFrame,
+            nome_coluna: str, *,
+            date_fmt: LibDate = LibDate.DMY
+        ) -> pd.DataFrame:
+    """
+    Formata uma coluna específica de um DataFrame como data, preservando valores que não puderem ser convertidos.
+
+    Parâmetros:
+        df (pd.DataFrame): DataFrame de entrada.
+        nome_coluna (str): Nome da coluna a ser formatada.
+        formato (str): Tipo de formatação de data. Pode ser:
+            - "dia/mes/ano" → "%d/%m/%Y"
+            - "mes/dia/ano" → "%m/%d/%Y"
+            - "ano-mes-dia" → "%Y-%m-%d"
+            - ou um formato customizado válido do datetime.
+
+    Retorna:
+        pd.DataFrame: O mesmo DataFrame, com a coluna formatada.
+    """
+    # Copia o DataFrame para não modificar o original
+    df_resultado = df.copy().astype('str')
+
+    def try_converter(valor) -> str:
+        """Tenta converter o valor para data, preservando o original se falhar."""
+        try:
+            _new = ConvertStringDate().convert_date(valor, fmt=date_fmt)
+        except Exception as e:
+            return valor
+        else:
+            if _new is not None:
+                return _new
+            return valor
+
+    df_resultado[nome_coluna] = df_resultado[nome_coluna].apply(try_converter)
+    return df_resultado

{convert_stream-2.3.8 → convert_stream-2.4}/convert_stream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 2.3.8
+Version: 2.4
 Summary: Manipulação de documentos PDF e Imagens. Converter, Ler, rotacionar exportar etc.
 Author: Bruno Chaves
 Requires-Python: >=3.11

{convert_stream-2.3.8 → convert_stream-2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "convert_stream"
-version = "2.3.8"
+version = "2.4"
 authors = [
   { name="Bruno Chaves"},
 ]