convert-stream 2.2.4__tar.gz → 2.2.6__tar.gz

{convert_stream-2.2.4 → convert_stream-2.2.6}/PKG-INFO

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

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/__init__.py

@@ -11,8 +11,9 @@ from convert_stream.enum_libs.modules import (
     DEFAULT_LIB_IMAGE_TO_PDF, ModPdfToImage, ModulePagePdf, ModuleImage,
     ModImageToPdf, MOD_FITZ, MOD_PYPDF, MOD_CANVAS, MOD_IMG_PIL, MOD_IMG_OPENCV,
 )
+from .text.terminal import print_title, print_line
 from .text.string import (
-    FindText, ArrayString,  print_line, print_title, MapText
+    FindText, ArrayString, MapText
 )
 from .text.date import ConvertStringDate
 from convert_stream.image.img_object import (

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/_version.py

@@ -5,5 +5,5 @@ __version__ = '2.2'
 __author__ = 'Bruno Chaves'
 __license__ = 'MIT'
 __module_name__ = 'convert_stream'
-__modify_date__ = '2025-08-23'
+__modify_date__ = '2025-08-24'
 

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/enum_libs/enums.py

@@ -67,4 +67,4 @@ class RotationAngle(Enum):
 
     ROTATION_90 = 90
     ROTATION_180 = 180
-    ROTATION_270 = 270
+    ROTATION_270 = 270

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/image/img_object.py

@@ -12,8 +12,8 @@ import numpy as np
 from scipy.ndimage import uniform_filter
 from convert_stream.enum_libs.enums import LibImage, RotationAngle
 from convert_stream.enum_libs.modules import (
-    MOD_IMG_OPENCV, MOD_IMG_PIL, ModuleImage, DEFAULT_LIB_IMAGE,
-    cv2, MatLike, Image, ImageOps, ImageFilter
+    MOD_IMG_PIL, ModuleImage, DEFAULT_LIB_IMAGE,
+    cv2, MatLike, Image, ImageFilter
 )
 
 
@@ -578,7 +578,3 @@ class CollectionImages(object):
     def set_pbar(self, p: ProgressBarAdapter) -> None:
         self.pbar = p
 
-
-
-
-

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/pdf/__init__.py

@@ -3,9 +3,10 @@
 from convert_stream.enum_libs.enums import LibPDF
 from convert_stream.enum_libs.modules import (
     DEFAULT_LIB_PDF, DEFAULT_LIB_PDF_TO_IMG, DEFAULT_LIB_IMAGE_TO_PDF,
-    ModulePagePdf, MOD_FITZ, MOD_PYPDF, ModPdfToImage, ModImageToPdf
+    ModulePagePdf, MOD_FITZ, MOD_PYPDF, ModPdfToImage, ModImageToPdf,
+    PdfWriter, PdfReader
 )
-from .pdf_page import PageDocumentPdf, fitz, PdfReader, PdfWriter
+from .pdf_page import PageDocumentPdf, fitz
 from .pdf_document import (
     DocumentPdf, DEFAULT_LIB_PDF, ModuleDocPdf, CollectionPagePdf
 )

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/pdf/image_to_pdf.py

@@ -9,7 +9,7 @@ from soup_files import File, Directory, ProgressBarAdapter
 from abc import ABC, abstractmethod
 from convert_stream.enum_libs.enums import LibImageToPdf
 from convert_stream.enum_libs.modules import (
-    ModImageToPdf, MOD_CANVAS, DEFAULT_LIB_IMAGE_TO_PDF, canvas, Canvas, letter, ImageReader
+    MOD_CANVAS, DEFAULT_LIB_IMAGE_TO_PDF, canvas, letter, ImageReader
 )
 from convert_stream.pdf import DocumentPdf
 from convert_stream.pdf.pdf_page import fitz
@@ -91,7 +91,7 @@ class ImplementImageToPdfCanvas(ABCConvertImageToPdf):
             c.drawImage(img_reader, 0, 0, width=first_img_width, height=first_img_height)
 
         # Processa as imagens restantes
-        for num, img_obj in enumerate(self.collection_images[1:], 1):
+        for num, img_obj in enumerate(self.collection_images.images[1:], 1):
 
             self.pbar.update(
                 ((num + 1) / max_num) * 100,
@@ -174,7 +174,7 @@ class ImplementImageToPdfPil(ABCConvertImageToPdf):
 
                 # Redimensiona a imagem
                 resized_image = original_pil_image.resize(
-                (scaled_width, scaled_height), Image.Resampling.LANCZOS
+                    (scaled_width, scaled_height), Image.Resampling.LANCZOS
                 )
 
                 # Cria uma nova imagem de fundo branca com o tamanho A4
@@ -237,8 +237,8 @@ class ImplementImageToPdfFitz(ABCConvertImageToPdf):
 
         for num, img_obj in enumerate(self.collection_images.images):
             self.pbar.update(
-                ((num+1)/max_num) * 100,
-                f'Convertendo: [{num+1} de {max_num}]'
+                ((num + 1) / max_num) * 100,
+                f'Convertendo: [{num + 1} de {max_num}]'
             )
             if land_scape:
                 img_obj.set_landscape()
@@ -294,11 +294,11 @@ class ConvertImageToPdf(object):
     """
 
     def __init__(
-                self,
-                collection_images: CollectionImages = CollectionImages(),
-                *,
-                lib_img_to_pdf: LibImageToPdf = DEFAULT_LIB_IMAGE_TO_PDF
-            ):
+            self,
+            collection_images: CollectionImages = CollectionImages(),
+            *,
+            lib_img_to_pdf: LibImageToPdf = DEFAULT_LIB_IMAGE_TO_PDF
+    ):
         if lib_img_to_pdf == LibImageToPdf.IMAGE_TO_PDF_CANVAS:
             self.convert: ABCConvertImageToPdf = ImplementImageToPdfCanvas(collection_images)
         elif lib_img_to_pdf == LibImageToPdf.IMAGE_TO_PDF_PIL:
@@ -347,4 +347,3 @@ class ConvertImageToPdf(object):
 
     def set_land_scape(self):
         self.convert.collection_images.set_land_scape()
-

{convert_stream-2.2.4 → convert_stream-2.2.6}/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):
@@ -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,7 +180,7 @@ 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:
@@ -102,7 +188,6 @@ class ImplementDocumentFitz(ABCDocument):
 
     def add_page(self, page: PageDocumentPdf):
         # Assume que page.mod_page é fitz.Page
-        # temp_doc = fitz.open()
         self.mod_doc_pdf.insert_pdf(
             page.implement_page_pdf.mod_page.parent,
             from_page=page.implement_page_pdf.mod_page.number,
@@ -114,7 +199,10 @@ class ImplementDocumentFitz(ABCDocument):
             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()
@@ -129,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)
 
@@ -172,7 +243,6 @@ 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())
         return cls.create_from_bytes(bt)
 
@@ -238,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
@@ -265,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
@@ -342,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.4 → convert_stream-2.2.6}/convert_stream/pdf/pdf_page.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from convert_stream.enum_libs.enums import LibPDF, ColumnsTable
 from convert_stream.enum_libs.modules import (
-    ModulePagePdf, PageObject, PdfWriter, PdfReader, fitz
+    ModulePagePdf, PageObject, fitz
 )
 from convert_stream.text.string import FindText, ArrayString, MapText
 

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/pdf/pdf_to_image.py

@@ -5,7 +5,7 @@
 """
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from soup_files import File, Directory, ProgressBarAdapter, CreatePbar
+from soup_files import Directory, ProgressBarAdapter, CreatePbar
 from convert_stream.enum_libs.enums import LibPdfToImage
 from convert_stream.enum_libs.modules import DEFAULT_LIB_PDF_TO_IMG, DEFAULT_LIB_IMAGE
 from convert_stream.image.img_object import ImageObject, LibImage, CollectionImages

{convert_stream-2.2.4 → convert_stream-2.2.6}/convert_stream/sheets/load.py

@@ -1,26 +1,23 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 from __future__ import annotations
-import sys
 from abc import ABC, abstractmethod
-from typing import Optional, List
 from openpyxl import Workbook, load_workbook
 from openpyxl.worksheet._read_only import ReadOnlyWorksheet
 from pandas.io.parsers import TextFileReader
 import pandas as pd
 import csv
-from soup_files import File, Directory, ProgressBarAdapter, CreatePbar
-from soup_files.files import ExtensionFiles
+from soup_files import File, ProgressBarAdapter, CreatePbar
 
 
 class ABCSheetReader(ABC):
     """Classe abstrata para leitura de planilhas CSV e EXCEL"""
 
     def __init__(
-                self,
-                file: File, *,
-                pbar: ProgressBarAdapter = CreatePbar().get()
-            ):
+            self,
+            file: File, *,
+            pbar: ProgressBarAdapter = CreatePbar().get()
+    ):
         self.pbar: ProgressBarAdapter = pbar
         self.file: File = file
         self.df = None
@@ -117,8 +114,8 @@ class ReaderCsv(ABCSheetReader):
         total_lines = self.get_total_rows()
         chunks_text: list[TextFileReader] = []
         for num, chunk in enumerate(
-                    pd.read_csv(self.file.absolute(), chunksize=1000, sep=self.separator),
-                ):
+                pd.read_csv(self.file.absolute(), chunksize=1000, sep=self.separator),
+        ):
             percent: float = (((num + 1) * 1000) / total_lines) * 100
             self.pbar.update(percent, f"Lendo CSV [{self.file.basename()}]")
             chunks_text.append(chunk)
@@ -138,9 +135,9 @@ class ReaderCsv(ABCSheetReader):
 class ReaderExcel(ABCSheetReader):
 
     def __init__(
-                self, file: File, *,
-                pbar: ProgressBarAdapter = CreatePbar().get()
-            ):
+            self, file: File, *,
+            pbar: ProgressBarAdapter = CreatePbar().get()
+    ):
         super().__init__(file, pbar=pbar)
         self.df = pd.DataFrame()
 
@@ -315,10 +312,10 @@ class ReaderOds(ABCSheetReader):
 class ReadFileSheet(object):
 
     def __init__(
-                self, file: File, *,
-                separator: str = '\t',
-                pbar: ProgressBarAdapter = CreatePbar().get()
-            ):
+            self, file: File, *,
+            separator: str = '\t',
+            pbar: ProgressBarAdapter = CreatePbar().get()
+    ):
         if file.is_csv():
             self.sheet_reader: ABCSheetReader = ReaderCsv(file, pbar=pbar, separator=separator)
         elif file.is_excel():
@@ -345,5 +342,3 @@ class ReadFileSheet(object):
 
     def get_dataframe(self, sheet_name: str = None, *, progress: bool = True) -> pd.DataFrame:
         return self.sheet_reader.get_dataframe(sheet_name, progress=progress)
-
-

{convert_stream-2.2.4 → convert_stream-2.2.6}/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):
@@ -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.4 → convert_stream-2.2.6}/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.6/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.4 → convert_stream-2.2.6}/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.6/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.4 → convert_stream-2.2.6}/convert_stream.egg-info/PKG-INFO

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

{convert_stream-2.2.4 → convert_stream-2.2.6}/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.4 → convert_stream-2.2.6}/pyproject.toml

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

convert_stream-2.2.4/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
-)
-