convert-stream 2.2.1__tar.gz → 2.2.5__tar.gz

{convert_stream-2.2.1 → convert_stream-2.2.5}/PKG-INFO

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

{convert_stream-2.2.1 → convert_stream-2.2.5}/convert_stream/pdf/pdf_document.py

@@ -6,13 +6,107 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
 from io import BytesIO
-from soup_files import File, Directory, LibraryDocs, InputFiles, ProgressBarAdapter
-from convert_stream.enum_libs.enums import LibPDF
+
+import pandas as pd
+from soup_files import File, Directory, LibraryDocs, InputFiles, ProgressBarAdapter, JsonConvert
+from convert_stream.enum_libs.enums import LibPDF, ColumnsTable
 from convert_stream.enum_libs.modules import (
     DEFAULT_LIB_PDF, ModuleDocPdf, ModulePagePdf, PdfWriter, PdfReader, PageObject, fitz,
 )
 from convert_stream.image.img_object import get_hash_from_bytes
 from convert_stream.pdf.pdf_page import PageDocumentPdf
+from convert_stream.text import show_error, show_info, show_warning, MapText, FindText
+from convert_stream.sheets.save import save_data
+
+
+class SearchableTextPdf(object):
+    """
+        Esta classe serve para armazenar textos filtrados em documentos PDF
+    guardando o texto buscado e outros elementos como a página em que o texto foi
+    encontrado, linha e o nome do arquivo.
+    """
+    def __init__(self, silent: bool = False):
+        self.silent = silent
+        self.elements: dict[str, list[str]] = {
+            ColumnsTable.NUM_PAGE.value: [],
+            ColumnsTable.NUM_LINHA.value: [],
+            ColumnsTable.TEXT.value: [],
+            ColumnsTable.FILE.value: [],
+        }
+
+    def __repr__(self):
+        return f'SearchableTextPdf: {self.elements}'
+
+    def is_empty(self) -> bool:
+        return len(self.elements[ColumnsTable.TEXT.value]) == 0
+
+    @property
+    def first(self) -> dict[str, str]:
+        if self.is_empty():
+            return {}
+        return {
+            ColumnsTable.NUM_PAGE.value: self.elements[ColumnsTable.NUM_PAGE.value][0],
+            ColumnsTable.NUM_LINHA.value: self.elements[ColumnsTable.NUM_LINHA.value][0],
+            ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][0],
+            ColumnsTable.FILE.value: self.elements[ColumnsTable.FILE.value][0],
+        }
+
+    @property
+    def last(self) -> dict[str, str]:
+        if self.is_empty():
+            return {}
+        return {
+            ColumnsTable.NUM_PAGE.value: self.elements[ColumnsTable.NUM_PAGE.value][-1],
+            ColumnsTable.NUM_LINHA.value: self.elements[ColumnsTable.NUM_LINHA.value][-1],
+            ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][-1],
+            ColumnsTable.FILE.value: self.elements[ColumnsTable.FILE.value][-1],
+        }
+
+    @property
+    def length(self) -> int:
+        return len(self.elements[ColumnsTable.TEXT.value])
+
+    def get_item(self, idx: int) -> dict[str, str]:
+        try:
+            return {
+                ColumnsTable.NUM_PAGE.value: self.elements[ColumnsTable.NUM_PAGE.value][idx],
+                ColumnsTable.NUM_LINHA.value: self.elements[ColumnsTable.NUM_LINHA.value][idx],
+                ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][idx],
+                ColumnsTable.FILE.value: self.elements[ColumnsTable.FILE.value][idx],
+            }
+        except Exception as err:
+            if not self.silent:
+                print(err)
+            return {}
+
+    def add_line(self, text, *, num_page: str, num_line: str, file: str) -> None:
+        if not self.silent:
+            print(f'{file} => {text}')
+        self.elements[ColumnsTable.NUM_PAGE.value].append(num_page)
+        self.elements[ColumnsTable.NUM_LINHA.value].append(num_line)
+        self.elements[ColumnsTable.TEXT.value].append(text)
+        self.elements[ColumnsTable.FILE.value].append(file)
+
+    def clear(self) -> None:
+        for _k in self.elements.keys():
+            self.elements[_k].clear()
+
+    def to_string(self) -> str:
+        try:
+            return ' '.join(self.elements[ColumnsTable.TEXT.value])
+        except Exception as e:
+            print(e)
+            return 'nas'
+
+    def to_data_frame(self) -> pd.DataFrame:
+        return pd.DataFrame.from_dict(self.elements)
+
+    def to_file_json(self, file: File):
+        dt = JsonConvert.from_dict(self.elements).to_json_data()
+        dt.to_file(file)
+
+    def to_file_excel(self, file: File):
+        save_data(self.to_data_frame(), file=file)
 
 
 class ABCDocument(ABC):
@@ -39,11 +133,11 @@ class ABCDocument(ABC):
         pass
 
     @abstractmethod
-    def add_page(self, page: ModulePagePdf):
+    def add_page(self, page: PageDocumentPdf):
         pass
 
     @abstractmethod
-    def add_pages(self, pages: list[ModulePagePdf]):
+    def add_pages(self, pages: list[PageDocumentPdf]):
         pass
 
     @abstractmethod
@@ -58,14 +152,6 @@ class ABCDocument(ABC):
     def to_pages(self) -> list[PageDocumentPdf]:
         pass
 
-    @abstractmethod
-    def to_list(self, separator: str = '\n') -> list[str]:
-        pass
-
-    @abstractmethod
-    def to_dict(self, separator: str = '\n') -> dict[str, list[str]]:
-        pass
-
     @classmethod
     def create_from_file(cls, file: File) -> ABCDocument:
         pass
@@ -79,7 +165,7 @@ class ImplementDocumentFitz(ABCDocument):
 
     def __init__(self, mod_doc_pdf: ModuleDocPdf, name: str):
         super().__init__(mod_doc_pdf, name)
-        self.mod_doc_pdf: fitz.Document = mod_doc_pdf
+        self.mod_doc_pdf: ModuleDocPdf = mod_doc_pdf
         self.lib_pdf: LibPDF = LibPDF.FITZ
 
     def get_first_page(self) -> PageDocumentPdf:
@@ -94,22 +180,29 @@ class ImplementDocumentFitz(ABCDocument):
         if 0 <= idx < self.mod_doc_pdf.page_count:
             pg = self.mod_doc_pdf.load_page(idx)  # retorna fitz.Page
             if pg is not None:
-                _page_pdf = PageDocumentPdf.create_from_page_fitz(pg, idx)
+                _page_pdf = PageDocumentPdf.create_from_page_fitz(pg)
         return _page_pdf
 
     def get_number_pages(self) -> int:
         return self.mod_doc_pdf.page_count
 
-    def add_page(self, page: fitz.Page):
+    def add_page(self, page: PageDocumentPdf):
         # Assume que page.mod_page é fitz.Page
-        self.mod_doc_pdf.insert_pdf(page, from_page=page.number, to_page=page.number)
+        self.mod_doc_pdf.insert_pdf(
+            page.implement_page_pdf.mod_page.parent,
+            from_page=page.implement_page_pdf.mod_page.number,
+            to_page=page.implement_page_pdf.mod_page.number
+        )
 
-    def add_pages(self, pages: list[fitz.Page]):
+    def add_pages(self, pages: list[PageDocumentPdf]):
         for page in pages:
             self.add_page(page)
 
     def to_file(self, file: File):
-        self.mod_doc_pdf.save(file.path)
+        try:
+            self.mod_doc_pdf.save(file.path)
+        except Exception as e:
+            show_warning(f'{e}')
 
     def to_bytes(self) -> BytesIO:
         buf = BytesIO()
@@ -124,27 +217,10 @@ class ImplementDocumentFitz(ABCDocument):
             pages.append(page_pdf)
         return pages
 
-    def to_list(self, separator: str = '\n') -> list[str]:
-        pages: list[PageDocumentPdf] = self.to_pages()
-        values = []
-        for pg in pages:
-            values.extend(pg.to_list(separator))
-        return values
-
-    def to_dict(self, separator: str = '\n') -> dict[str, list[str]]:
-        pages_pdf = self.to_pages()
-        document_dict = PageDocumentPdf.DEFAULT_DICT
-        for pg in pages_pdf:
-            page_dict = pg.to_dict(separator)
-            document_dict['TEXTO'].extend(page_dict['TEXTO'])
-            document_dict['NUM_PAGE'].extend(page_dict['NUM_PAGE'])
-            document_dict['NUM_LINHA'].extend(page_dict['NUM_LINHA'])
-        return document_dict
-
     @classmethod
     def create_from_bytes(cls, bt: BytesIO) -> ImplementDocumentFitz:
         # Cria documento a partir de BytesIO
-        doc = fitz.open(stream=bt.getvalue(), filetype="pdf")
+        doc: ModuleDocPdf = fitz.open(stream=bt.getvalue(), filetype="pdf")
         name = get_hash_from_bytes(bt)
         return cls(doc, name)
 
@@ -156,7 +232,6 @@ class ImplementDocumentFitz(ABCDocument):
 
     @classmethod
     def create_from_pages(cls, pages: list[PageDocumentPdf]) -> ImplementDocumentFitz:
-
         pdf_document = fitz.Document()  # Criar novo documento PDF.
         for page in pages:
             # Verifica se a página é do tipo fitz.Page
@@ -168,13 +243,7 @@ class ImplementDocumentFitz(ABCDocument):
                 from_page=page.implement_page_pdf.mod_page.number,
                 to_page=page.implement_page_pdf.mod_page.number
             )
-
         bt = BytesIO(pdf_document.write())
-        #name = get_hash_from_bytes(bt)
-        #bt.seek(0)
-        #bt.close()
-        #del bt
-        #return cls(pdf_document, name)
         return cls.create_from_bytes(bt)
 
 
@@ -215,10 +284,10 @@ class ImplementDocumentPyPdf(ABCDocument):
     def get_number_pages(self) -> int:
         return len(self.mod_doc_pdf.pages)
 
-    def add_page(self, page: PageObject):
-        self.mod_doc_pdf.add_page(page)
+    def add_page(self, page: PageDocumentPdf):
+        self.mod_doc_pdf.add_page(page.implement_page_pdf.mod_page)
 
-    def add_pages(self, pages: list[PageObject]):
+    def add_pages(self, pages: list[PageDocumentPdf]):
         for page in pages:
             self.add_page(page)
 
@@ -239,23 +308,6 @@ class ImplementDocumentPyPdf(ABCDocument):
             pages_pdf.append(pg)
         return pages_pdf
 
-    def to_list(self, separator: str = '\n') -> list[str]:
-        pages: list[PageDocumentPdf] = self.to_pages()
-        values = []
-        for pg in pages:
-            values.extend(pg.to_list(separator))
-        return values
-
-    def to_dict(self, separator: str = '\n') -> dict[str, list[str]]:
-        pages_pdf = self.to_pages()
-        document_dict = PageDocumentPdf.DEFAULT_DICT
-        for pg in pages_pdf:
-            page_dict = pg.to_dict(separator)
-            document_dict['TEXTO'].extend(page_dict['TEXTO'])
-            document_dict['NUM_PAGE'].extend(page_dict['NUM_PAGE'])
-            document_dict['NUM_LINHA'].extend(page_dict['NUM_LINHA'])
-        return document_dict
-
     @classmethod
     def create_from_bytes(cls, bt: BytesIO) -> ImplementDocumentPyPdf:
         # Usa PdfReader diretamente de BytesIO
@@ -266,7 +318,6 @@ class ImplementDocumentPyPdf(ABCDocument):
         pdf_writer = PdfWriter()
         for page in reader.pages:
             pdf_writer.add_page(page)
-
         bt.close()
         del bt
         del reader
@@ -327,10 +378,10 @@ class DocumentPdf(object):
     def get_number_pages(self) -> int:
         return self.doc_pdf.get_number_pages()
 
-    def add_page(self, page: ModulePagePdf):
+    def add_page(self, page: PageDocumentPdf):
         self.doc_pdf.add_page(page)
 
-    def add_pages(self, pages: list[ModulePagePdf]):
+    def add_pages(self, pages: list[PageDocumentPdf]):
         self.doc_pdf.add_pages(pages)
 
     def to_file(self, file: File):
@@ -343,36 +394,130 @@ class DocumentPdf(object):
         return self.doc_pdf.to_pages()
 
     def to_list(self, separator: str = '\n') -> list[str]:
-        return self.doc_pdf.to_list(separator)
+        _pages = self.to_pages()
+        _values = []
+        for page in _pages:
+            try:
+                _values.extend(page.to_string().split(separator))
+            except Exception as e:
+                show_warning(f'{e}')
+        return _values
 
     def to_dict(self, separator: str = '\n') -> dict[str, list[str]]:
-        return self.doc_pdf.to_dict(separator)
-
-    def find(self, text_find: str, *, separator: str = '\n', iqual: bool = False, case: bool = False) -> str | None:
-        _find_item = None
-        pages = self.to_pages()
-        for pg in pages:
-            page_text_str = pg.find(text_find, separator=separator, iqual=iqual, case=case)
-            if page_text_str is not None:
-                _find_item = page_text_str
-                break
-        pages.clear()
-        del pages
-        return _find_item
-
-    def find_all(self, text: str, *, separator: str = '\n', iqual: bool = False, case: bool = True) -> list[str]:
-        if text is None:
-            raise ValueError(f'{__class__.__name__}: o texto de pesquisa {text} é nulo!')
-        elements = []
+        dict_doc = {
+            ColumnsTable.NUM_PAGE.value: [],
+            ColumnsTable.NUM_LINHA.value: [],
+            ColumnsTable.TEXT.value: [],
+            ColumnsTable.FILENAME.value: [],
+        }
         pages = self.to_pages()
-        for pg in pages:
-            page_text_str = pg.find(text, separator=separator, iqual=iqual, case=case)
-            if page_text_str is not None:
-                elements.append(text)
-                break
-        pages.clear()
-        del pages
-        return elements
+        for page in pages:
+            try:
+                _mp = MapText(page.to_list(separator))
+                _mp.add_column(ColumnsTable.NUM_PAGE.value, [f'{page.number_page}'] * _mp.length)
+                _mp.add_column(ColumnsTable.NUM_PAGE.value, [self.name] * _mp.length)
+            except Exception as e:
+                show_warning(f'{e}')
+            else:
+                dict_doc[ColumnsTable.NUM_PAGE.value].extend(_mp.map_elements[ColumnsTable.NUM_PAGE.value])
+                dict_doc[ColumnsTable.NUM_LINHA.value].extend(_mp.map_elements[ColumnsTable.NUM_LINHA.value])
+                dict_doc[ColumnsTable.TEXT.value].extend(_mp.map_elements[ColumnsTable.TEXT.value])
+                dict_doc[ColumnsTable.FILENAME.value].extend(_mp.map_elements[ColumnsTable.FILENAME.value])
+                del _mp
+        return dict_doc
+
+    def find(
+            self, text: str,
+            separator: str = '\n',
+            iqual: bool = False,
+            case: bool = False,
+            silent: bool = False,
+            ) -> SearchableTextPdf:
+        """
+            Filtrar texto retornando a primeira ocorrência do Documento PDF.
+        """
+        _searchable = SearchableTextPdf(silent)
+        pages_pdf = self.to_pages()
+        for page_pdf in pages_pdf:
+            text_str_in_page = page_pdf.to_string()
+            if (text_str_in_page == 'nas') or (text_str_in_page is None):
+                continue
+            try:
+                fd = FindText(text_str_in_page, separator=separator)
+                idx = fd.index(text, iqual=iqual, case=case)
+                if idx is None:
+                    continue
+                math_text = fd.get_index(idx)
+            except:
+                pass
+            else:
+                _searchable.add_line(
+                    math_text,
+                    num_page=str(page_pdf.number_page),
+                    num_line=str(idx + 1),
+                    file=self.name,
+                )
+                return _searchable
+        return _searchable
+
+    def find_all(
+                self, text: str,
+                separator: str = '\n',
+                iqual: bool = False,
+                case: bool = False,
+                silent: bool = False,
+            ) -> SearchableTextPdf:
+        """
+            Filtrar texto em documento PDF e retorna todas as ocorrências do texto
+        encontradas no documento, incluindo o número da linha, página e nome do arquivo
+        em cada ocorrência.
+        """
+        _searchable = SearchableTextPdf(silent)
+        _pages_pdf = self.to_pages()
+        for page_pdf in _pages_pdf:
+            text_str_in_page = page_pdf.to_string()
+            if (text_str_in_page == 'nas') or (text_str_in_page is None):
+                continue
+            try:
+                _values = text_str_in_page.split(separator)
+                for num, item in enumerate(_values):
+                    if case:
+                        if iqual:
+                            if text == item:
+                                _searchable.add_line(
+                                    item,
+                                    num_page=str(page_pdf.number_page),
+                                    num_line=str(num + 1),
+                                    file=self.name,
+                                )
+                        else:
+                            if text in item:
+                                _searchable.add_line(
+                                    item,
+                                    num_page=str(page_pdf.number_page),
+                                    num_line=str(num + 1),
+                                    file=self.name,
+                                )
+                    else:
+                        if iqual:
+                            if text.lower() == item.lower():
+                                _searchable.add_line(
+                                    item,
+                                    num_page=str(page_pdf.number_page),
+                                    num_line=str(num + 1),
+                                    file=self.name,
+                                )
+                        else:
+                            if text.lower() in item.lower():
+                                _searchable.add_line(
+                                    item,
+                                    num_page=str(page_pdf.number_page),
+                                    num_line=str(num + 1),
+                                    file=self.name,
+                                )
+            except Exception as e:
+                show_warning(f'{__class__.__name__} {e}')
+        return _searchable
 
     @classmethod
     def create_from_bytes(cls, bt: BytesIO, *, lib_pdf: LibPDF = LibPDF.FITZ) -> DocumentPdf:

{convert_stream-2.2.1 → convert_stream-2.2.5}/convert_stream/stream.py

@@ -42,8 +42,7 @@ class ImageStream(CollectionImages):
 class PdfStream(object):
 
     def __init__(
-                self,
-                collection_pages: CollectionPagePdf = CollectionPagePdf(), *,
+                self, *,
                 pbar: ProgressBarAdapter = ProgressBarAdapter(),
                 lib_pdf: LibPDF = DEFAULT_LIB_PDF,
                 lib_img: LibImage = DEFAULT_LIB_IMAGE,
@@ -51,7 +50,7 @@ class PdfStream(object):
                 lib_pdf_to_img: LibPdfToImage = DEFAULT_LIB_PDF_TO_IMG,
             ) -> None:
         self.progress: ProgressBarAdapter = pbar
-        self.collection_pages: CollectionPagePdf = collection_pages
+        self.collection_pages: CollectionPagePdf = CollectionPagePdf()
         self.collection_images: CollectionImages = CollectionImages()
         self.collection_images.set_pbar(pbar)
         self.collection_pages.set_pbar(pbar)
@@ -59,9 +58,10 @@ class PdfStream(object):
         self.lib_img: LibImage = lib_img
         self.lib_img_to_pdf: LibImageToPdf = lib_img_to_pdf
         self.lib_pdf_to_img: LibPdfToImage = lib_pdf_to_img
+        self.clear()
 
     @property
-    def is_null(self) -> bool:
+    def is_empty(self) -> bool:
         return self.collection_pages.is_null
 
     def set_land_scape(self):
@@ -79,7 +79,7 @@ class PdfStream(object):
         self.collection_pages.add_page(page)
 
     def add_pages(self, pages: list[PageDocumentPdf]) -> None:
-        self.add_pages(pages)
+        self.collection_pages.add_pages(pages)
 
     def add_file_image(self, f: File) -> None:
         self.collection_images.add_file_image(f)
@@ -111,13 +111,17 @@ class PdfStream(object):
     def to_document(self) -> DocumentPdf:
         if self.collection_pages.is_null and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
-
-        _doc = DocumentPdf.create_from_pages(self.collection_pages.pages)
+        _doc = None
+        if not self.collection_pages.is_null:
+            _doc = DocumentPdf.create_from_pages(self.collection_pages.pages)
         if not self.collection_images.is_empty:
             _convert_img_to_pdf = ConvertImageToPdf(self.collection_images)
             _pages = _convert_img_to_pdf.to_document().to_pages()
             self.collection_images.clear()
-            _doc.add_pages(_pages)
+            if _doc is None:
+                _doc = DocumentPdf.create_from_pages(_pages)
+            else:
+                _doc.add_pages(_pages)
         return _doc
 
     def to_files_images(

{convert_stream-2.2.1 → convert_stream-2.2.5}/convert_stream/table_files.py

@@ -2,15 +2,14 @@
 
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from enum import Enum
-
 from soup_files import (
     File, Directory, ProgressBarAdapter, CreatePbar,
     InputFiles, LibraryDocs, JsonConvert, JsonData
 )
 from convert_stream.enum_libs.enums import ColumnsTable
-from convert_stream import FindText, ArrayString, save_data, MapText
-from convert_stream.stream import PdfStream, DocumentPdf, CollectionPagePdf
+from convert_stream.text.string import FindText, ArrayString, MapText
+from convert_stream.pdf.pdf_document import SearchableTextPdf, DocumentPdf
+from convert_stream.stream import PdfStream, CollectionPagePdf
 import pandas as pd
 
 
@@ -209,97 +208,6 @@ class FileToTable(object):
         return cls(TableFilesPdf())
 
 
-class SearchableTextPdf(object):
-    """
-        Esta classe serve para armazenar textos filtrados em documentos PDF
-    guardando o texto buscado e outros elementos como a página em que o texto foi
-    encontrado, linha e o nome do arquivo.
-
-    """
-    def __init__(self, silent: bool = False):
-        self.silent = silent
-        self.elements: dict[str, list[str]] = {
-            ColumnsTable.NUM_PAGE.value: [],
-            ColumnsTable.NUM_LINHA.value: [],
-            ColumnsTable.TEXT.value: [],
-            ColumnsTable.FILE.value: [],
-        }
-
-    def __repr__(self):
-        return f'SearchableTextPdf: {self.elements}'
-
-    def is_empty(self) -> bool:
-        return len(self.elements[ColumnsTable.TEXT.value]) == 0
-
-    @property
-    def first(self) -> dict[str, str]:
-        if self.is_empty():
-            return {}
-        return {
-            ColumnsTable.NUM_PAGE.value: self.elements[ColumnsTable.NUM_PAGE.value][0],
-            ColumnsTable.NUM_LINHA.value: self.elements[ColumnsTable.NUM_LINHA.value][0],
-            ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][0],
-            ColumnsTable.FILE.value: self.elements[ColumnsTable.FILE.value][0],
-        }
-
-    @property
-    def last(self) -> dict[str, str]:
-        if self.is_empty():
-            return {}
-        return {
-            ColumnsTable.NUM_PAGE.value: self.elements[ColumnsTable.NUM_PAGE.value][-1],
-            ColumnsTable.NUM_LINHA.value: self.elements[ColumnsTable.NUM_LINHA.value][-1],
-            ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][-1],
-            ColumnsTable.FILE.value: self.elements[ColumnsTable.FILE.value][-1],
-        }
-
-    @property
-    def length(self) -> int:
-        return len(self.elements[ColumnsTable.TEXT.value])
-
-    def get_item(self, idx: int) -> dict[str, str]:
-        try:
-            return {
-                ColumnsTable.NUM_PAGE.value: self.elements[ColumnsTable.NUM_PAGE.value][idx],
-                ColumnsTable.NUM_LINHA.value: self.elements[ColumnsTable.NUM_LINHA.value][idx],
-                ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][idx],
-                ColumnsTable.FILE.value: self.elements[ColumnsTable.FILE.value][idx],
-            }
-        except Exception as err:
-            if not self.silent:
-                print(err)
-            return {}
-
-    def add_line(self, text, *, num_page: str, num_line: str, file: str) -> None:
-        if not self.silent:
-            print(f'{file} => {text}')
-        self.elements[ColumnsTable.NUM_PAGE.value].append(num_page)
-        self.elements[ColumnsTable.NUM_LINHA.value].append(num_line)
-        self.elements[ColumnsTable.TEXT.value].append(text)
-        self.elements[ColumnsTable.FILE.value].append(file)
-
-    def clear(self) -> None:
-        for _k in self.elements.keys():
-            self.elements[_k].clear()
-
-    def to_string(self) -> str:
-        try:
-            return ' '.join(self.elements[ColumnsTable.TEXT.value])
-        except Exception as e:
-            print(e)
-            return 'nas'
-
-    def to_data_frame(self) -> pd.DataFrame:
-        return pd.DataFrame.from_dict(self.elements)
-
-    def to_file_json(self, file: File):
-        dt = JsonConvert.from_dict(self.elements).to_json_data()
-        dt.to_file(file)
-
-    def to_file_excel(self, file: File):
-        save_data(self.to_data_frame(), file=file)
-
-
 class PdfFinder(object):
     """
         Classe para Filtrar texto em documentos PDF,
@@ -328,15 +236,14 @@ class PdfFinder(object):
             self.add_files_pdf(files)
 
     def find(
-                self, text: str,
-                separator: str = '\n',
-                iqual: bool = False,
-                case: bool = False,
-                silent: bool = False,
+            self, text: str,
+            separator: str = '\n',
+            iqual: bool = False,
+            case: bool = False,
+            silent: bool = False,
             ) -> SearchableTextPdf:
         """
             Filtrar texto retornando a primeira ocorrência do Documento PDF.
-        :param text: texto a ser filtrado no documento
         """
         _searchable = SearchableTextPdf(silent)
         if self.is_empty():

convert_stream-2.2.5/convert_stream/text/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+from .date import ConvertStringDate
+from .string import ArrayString, FindText, MapText
+from .terminal import (
+    print_line, print_title, show_error, show_warning, show_info, Colors, msg
+)
+

{convert_stream-2.2.1 → convert_stream-2.2.5}/convert_stream/text/string.py

@@ -1,33 +1,8 @@
 #!/usr/bin/env python3
 from __future__ import annotations
-import os
 import pandas as pd
 
 
-def print_line(char: str = '='):
-    """
-        Imprime uma linha na tela.
-    """
-    try:
-        num_size = os.get_terminal_size().columns
-    except:
-        num_size = 80
-    print(char * num_size)
-
-
-def print_title(title: str, char: str = '='):
-    """
-        Imprime um título na tela.
-    """
-    try:
-        num_size = os.get_terminal_size().columns
-    except:
-        num_size = 80
-
-    # print_line(char)
-    print(title.center(num_size, char))
-
-
 class MapText(object):
 
     def __init__(

convert_stream-2.2.5/convert_stream/text/terminal.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+import os
+from enum import Enum
+
+
+class Colors(Enum):
+
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    DARK_RED = '\033[91m'
+    DARK_GREEN = '\033[92m'
+    DARK_YELLOW = '\033[93m'
+    VOID = '\033[0m'
+    END = '\033[0m'
+
+
+def print_line(char: str = '=', *, color: Colors = Colors.VOID):
+    """
+        Imprime uma linha na tela.
+    """
+    try:
+        num_size = os.get_terminal_size().columns
+    except:
+        num_size = 80
+    print(f'{color.value}{char}{Colors.END.value}' * num_size)
+
+
+def print_title(title: str, char: str = '='):
+    """
+        Imprime um título na tela.
+    """
+    try:
+        num_size = os.get_terminal_size().columns
+    except:
+        num_size = 80
+
+    # print_line(char)
+    print(title.center(num_size, char))
+
+
+def msg(text: str, *, color: Colors = Colors.VOID):
+    print(f'{color.value}{text}{Colors.END.value}')
+
+
+def show_warning(text: str, *, line: bool = True):
+    if line:
+        print_line('-')
+    print(f'{Colors.DARK_YELLOW}[?] WARNING:{Colors.END.value} {text}')
+
+
+def show_error(text: str, *, line: bool = True):
+    if line:
+        print_line('-')
+    print(f'{Colors.DARK_YELLOW}[!] ERRO:{Colors.END.value} {text}')
+
+
+def show_info(text: str, *, line: bool = True):
+    if line:
+        print_line('-')
+    print(f'{Colors.DARK_YELLOW}[+] INFO:{Colors.END.value} {text}')

{convert_stream-2.2.1 → convert_stream-2.2.5}/convert_stream.egg-info/PKG-INFO

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

{convert_stream-2.2.1 → convert_stream-2.2.5}/convert_stream.egg-info/SOURCES.txt

@@ -25,4 +25,5 @@ convert_stream/sheets/parse.py
 convert_stream/sheets/save.py
 convert_stream/text/__init__.py
 convert_stream/text/date.py
-convert_stream/text/string.py
+convert_stream/text/string.py
+convert_stream/text/terminal.py

{convert_stream-2.2.1 → convert_stream-2.2.5}/pyproject.toml

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

convert_stream-2.2.1/convert_stream/text/__init__.py

@@ -1,6 +0,0 @@
-#!/usr/bin/env python3
-from .date import ConvertStringDate
-from .string import (
-    ArrayString, FindText, print_line, print_title, MapText
-)
-