convert-stream 1.2.3__tar.gz → 1.3.1__tar.gz

{convert_stream-1.2.3 → convert_stream-1.3.1}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 1.2.3
+Version: 1.3.1
 Summary: Manipulação de documentos PDF e Imagens. Converter, Ler, rotacionar exportar etc.
 Author: Bruno Chaves
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: soup_files
-Requires-Dist: PyPDF2==3.0.1
-Requires-Dist: PyMuPDF==1.25.5
-Requires-Dist: reportlab==4.3.1
-Requires-Dist: openpyxl==3.1.5
-Requires-Dist: pandas==2.2.3
-Requires-Dist: Pillow==11.2.1
-Requires-Dist: opencv-python==4.11.0.86
-Requires-Dist: requests==2.32.3
+Requires-Dist: PyPDF2
+Requires-Dist: PyMuPDF
+Requires-Dist: reportlab
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: Pillow>=11.3.0
+Requires-Dist: opencv-python
+Requires-Dist: requests>=2.32.4
 
 # Configuração instalação:
 pip3 install -r requirements.txt

{convert_stream-1.2.3 → convert_stream-1.3.1}/convert_stream/__init__.py

@@ -12,17 +12,16 @@ from .text import (
     LibraryDates, print_title, print_line, save_data
 )
 
-from convert_stream.progress.progress_bar import (
-    ProgressBarAdapter, ProgressBarSimple,
-    ProgressBarTqdm, ABCProgressBar
-)
-
+from .models import LibConvertPDF, LibraryPDF, LibImageToPDF
+from .progress.progress_bar import CreatePbar
 from .models.models_pdf import LibraryPDF
 from .imagelib import ImageObject, ImageInverColor, LibraryImage
 from .pdf_page import PageDocumentPdf, PagePdfFitz, PagePyPdf2
 from .pdf_document import DocumentPdf, FileDocumentPdf
 from .pdf_to_images import ConvertPdfToImage
-from .image_to_pdf import ImageConvertPdf
+from .image_to_pdf import ImageToPdf
 from .convert import PdfStream, ImageStream, get_data_from_pdfs
 from .pdf_compress import CompressDocument
+from .table_files import FileToTable
+
 

{convert_stream-1.2.3 → convert_stream-1.3.1}/convert_stream/__main__.py

@@ -18,23 +18,14 @@ this_file = os.path.abspath(os.path.relpath(__file__))
 dir_of_project = os.path.dirname(this_file)
 sys.path.insert(0, dir_of_project)
 
+
 from convert_stream import (
     version, __module_name__, __modify_date__, print_title
 )
 
 
 def test():
-    from convert_stream import (
-        FileDocumentPdf, CompressDocument, DocumentPdf, LibraryPDF,
-        PdfStream, ImageStream, PageDocumentPdf,
-    )
-    from soup_files import (
-        Directory, File, UserFileSystem, InputFiles
-    )
-
-    outdir: Directory = UserFileSystem().userDownloads.concat('output', create=True)
-    indir: Directory = UserFileSystem().userDownloads.concat('TESTE-PDF', create=True)
-    base = indir.join_file('base.pdf')
+    pass
 
 
 def main():

{convert_stream-1.2.3 → convert_stream-1.3.1}/convert_stream/_version.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-__version__ = '1.2.3'
+__version__ = '1.3'
 __author__ = 'Bruno Chaves'
 __license__ = 'MIT'
 __module_name__ = 'convert_stream'
-__modify_date__ = '2025-06-28'
+__modify_date__ = '2025-07-06'

{convert_stream-1.2.3 → convert_stream-1.3.1}/convert_stream/convert.py

@@ -2,22 +2,125 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 from typing import List
+from abc import ABC, abstractmethod
 import pandas
 
-from convert_stream.models import ABCDocumentStream, LibraryImage, LibraryPDF
+from convert_stream.models import LibraryImage, LibraryPDF, LibImageToPDF, LibConvertPDF
 from convert_stream.imagelib import ImageObject
-from convert_stream.progress.progress_bar import ProgressBarAdapter, ProgressBarSimple
+from convert_stream.progress.progress_bar import CreatePbar
 from convert_stream.pdf_page import PageDocumentPdf
 from convert_stream.pdf_document import DocumentPdf
 from convert_stream.pdf_to_images import ConvertPdfToImage
-from convert_stream.image_to_pdf import ImageConvertPdf
-from soup_files import File, Directory
- 
+from convert_stream.image_to_pdf import ImageToPdf
+from soup_files import File, Directory, ProgressBarAdapter, InputFiles, LibraryDocs
+
+
 #==================================================================#
 # PDF
 #==================================================================#
 
 
+class ABCDocumentStream(ABC):
+    """
+        Objeto para manipular a exportação de dados PDF    
+    """
+
+    def __init__(
+            self, *,
+            library_pdf: LibraryPDF = LibraryPDF.FITZ,
+            library_image: LibraryImage = LibraryImage.OPENCV,
+            progress_bar: ProgressBarAdapter = CreatePbar().get(),
+    ):
+        self.library_pdf: LibraryPDF = library_pdf
+        self.liabrary_image: LibraryImage = library_image
+        self.progress_bar: ProgressBarAdapter = progress_bar
+
+    @abstractmethod
+    def is_null(self) -> bool:
+        pass
+
+    @abstractmethod
+    def clear(self):
+        pass
+
+    @abstractmethod
+    def to_file_pdf(self, f: File):
+        """
+            Exporta os dados para um arquivo PDF no disco.
+        """
+        pass
+
+    @abstractmethod
+    def to_files_pdf(self, outdir: Directory, *, prefix='pag'):
+        """Exporta cada página para um novo arquivo PDF no disco"""
+        pass
+
+    @abstractmethod
+    def to_files_image(self, d: Directory, *, prefix: str = 'página-para-imagem'):
+        """
+            Exporta cada página PDF como um arquivo de imagem.
+        """
+        pass
+
+    @abstractmethod
+    def to_images(self) -> List[ImageObject]:
+        """Retorna uma lista de imagens, dos documentos adicionados."""
+        pass
+
+    @abstractmethod
+    def to_document(self) -> DocumentPdf:
+        """Converte os itens adicionados em documento"""
+        pass
+
+    def inner_images(self) -> List[ImageObject]:
+        """
+            Retorna uma lista com todas as imagens presentes em todas as páginas
+        """
+        pass
+
+    @abstractmethod
+    def inner_images_to_files(self, d: Directory, prefix: str = 'página-para-imagens') -> None:
+        """
+            Salva todas as imagens presentes nas páginas em arquivos de imagem.
+        """
+        pass
+
+    @abstractmethod
+    def add_page(self, p: PageDocumentPdf):
+        """Adiciona uma página PDF"""
+        pass
+
+    @abstractmethod
+    def add_pages(self, pages: List[PageDocumentPdf]):
+        pass
+
+    @abstractmethod
+    def add_page_pdf_bytes(self, bt: bytes):
+        """Adicona os bytes de uma página PDF."""
+        pass
+
+    @abstractmethod
+    def add_file_pdf(self, f: File):
+        pass
+
+    @abstractmethod
+    def add_files_pdf(self, files: List[File]):
+        pass
+
+    @abstractmethod
+    def add_document(self, doc: DocumentPdf):
+        pass
+
+    @abstractmethod
+    def add_image(self, image: ImageObject):
+        pass
+
+    @abstractmethod
+    def set_paisagem(self):
+        """Define todas as páginas como paisagem."""
+        pass
+
+
 class PdfStream(ABCDocumentStream):
     """
         Objeto para manipular a exportação de dados PDF    
@@ -27,35 +130,43 @@ class PdfStream(ABCDocumentStream):
                 self, *,
                 library_pdf: LibraryPDF = LibraryPDF.FITZ,
                 library_image: LibraryImage = LibraryImage.OPENCV,
-                progress_bar: ProgressBarAdapter = ProgressBarAdapter(ProgressBarSimple())
+                lib_image_to_pdf: LibImageToPDF = LibImageToPDF.PILPDF,
+                progress_bar: ProgressBarAdapter = CreatePbar().get(),
+                maximum_pages: int = 3500
             ):
         super().__init__(library_pdf=library_pdf, library_image=library_image, progress_bar=progress_bar)
-        self.num_pages: int = 0
         self.library_pdf: LibraryPDF = library_pdf
         self.library_image: LibraryImage = library_image
-        self.document: DocumentPdf = DocumentPdf(self.library_pdf, progress_bar=progress_bar)
-        self.convert_pdf_to_images: ConvertPdfToImage = ConvertPdfToImage(
-            library_image=library_image, progress_bar=progress_bar
+        self.lib_image_to_pdf: LibImageToPDF = lib_image_to_pdf
+        self.document: DocumentPdf = DocumentPdf(
+            self.library_pdf, progress_bar=progress_bar,  maximum_pages=maximum_pages
         )
-        
-        if self.library_pdf == LibraryPDF.CANVAS:
-            self.convert_images_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_canvas(self.library_image)
-        elif self.library_pdf == LibraryPDF.PILPDF:
-            self.convert_images_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_pil(LibraryImage.PIL)
+        #
+        self.convert_pdf_to_images = ConvertPdfToImage.create(
+            self.library_image,
+            pbar=self.progress_bar,
+            lib_convert_pdf=LibConvertPDF.FITZ
+        )
+        if self.lib_image_to_pdf == LibImageToPDF.CANVAS:
+            self.convert_images_to_pdf: ImageToPdf = ImageToPdf.create_from_canvas(self.library_image)
+        elif self.lib_image_to_pdf == LibImageToPDF.PILPDF:
+            self.convert_images_to_pdf: ImageToPdf = ImageToPdf.create_from_pil(LibraryImage.PIL)
+        elif self.lib_image_to_pdf == LibImageToPDF.FITZ:
+            self.convert_images_to_pdf: ImageToPdf = ImageToPdf.create_from_fitz(LibraryImage.PIL)
         else:
-            self.convert_images_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_fitz(self.library_image)
+            self.convert_images_to_pdf: ImageToPdf = ImageToPdf.create_from_pil(self.library_image)
         
     @property
     def num_pages(self) -> int:
-        return self.document.num_pages
+        return self.document.get_num_pages()
     
     @num_pages.setter
     def num_pages(self, num: int):
-        pass
+        self.document.set_num_pages(num)
         
     @property
     def pages(self) -> List[PageDocumentPdf]:
-        return self.document.pages
+        return self.document.get_pages()
     
     @pages.setter
     def pages(self, new: List[PageDocumentPdf]):
@@ -90,21 +201,30 @@ class PdfStream(ABCDocumentStream):
             self.add_page(p)
         self.progress_bar.stop()
 
+    def add_folder(
+                    self, d: Directory, *,
+                    file_type: LibraryDocs = LibraryDocs.PDF,
+                    max_files: int = 4000
+            ):
+        files = InputFiles(d, maxFiles=max_files).get_files(file_type=file_type)
+        if file_type == LibraryDocs.PDF:
+            self.add_files_pdf(files)
+        elif file_type == LibraryDocs.IMAGE:
+            self.add_images([ImageObject.create_from_file(f) for f in files])
+
     def add_page_pdf_bytes(self, bt: bytes):
         _page = PageDocumentPdf.create_from_page_bytes(bt, library=self.library_pdf)
         self.add_page(_page)
             
     def add_file_pdf(self, f: File):
-        doc: DocumentPdf = DocumentPdf(self.library_pdf)
-        doc.add_file_pdf(f)
-        self.add_pages(doc.pages)
-        
+        self.document.add_file_pdf(f)
+
     def add_files_pdf(self, files: List[File]):
         for f in files:
             self.add_file_pdf(f)
             
-    def add_document(self, doc:DocumentPdf):
-        self.add_pages(doc.pages)
+    def add_document(self, doc: DocumentPdf):
+        self.add_pages(doc.get_pages())
         
     def add_image(self, image: ImageObject):
         pg: PageDocumentPdf = self.convert_images_to_pdf.from_image(image)
@@ -131,35 +251,33 @@ class PdfStream(ABCDocumentStream):
         )
         docpdf.to_file_pdf(f)
         
-    def to_files_pdf(self, outdir: Directory, *, prefix='documento-pag'):
+    def to_files_pdf(self, outdir: Directory, *, prefix='documento', replace: bool = False):
         if self.is_null():
             print(
                 f'{__class__.__name__} Adicione páginas ao documento para prosseguir!'
             )
             return
-        outdir.mkdir()
-        _document: DocumentPdf = DocumentPdf(self.library_pdf)
-        for num, p in enumerate(self.pages):
-            filename: str = f'{prefix}-{num+1}.pdf'
-            self.progress_bar.update_text(
-                f'Exportando página: {p.page_number} de {self.num_pages} | [{filename}]'
-            )
-            _document.add_page(p)
-            _document.to_file_pdf(outdir.join_file(filename))
-            _document.clear()
-            
-    def to_files_image(self, d: Directory, *, prefix: str = 'pdf-para-imagem'):
+        self.document.to_files_pdf(outdir, prefix, replace=replace)
+
+    def to_files_image(self, d: Directory, *, prefix: str = 'pdf-para-imagem', replace: bool = False):
         """
             Exporta cada página PDF como um arquivo de imagem.
         """
         d.mkdir()
+        self.progress_bar.start()
         for num, page in enumerate(self.pages):
-            filename = f'{prefix}-{page.page_number}.png'
+            output_file: File = d.join_file(f'{prefix}_{page.page_number}.png')
+            if not replace:
+                if output_file.exists():
+                    print(f'[A IMAGEM JÁ EXISTE]: {output_file.absolute()}')
+                    continue
             img = self.convert_pdf_to_images.from_page_pdf(page)
             self.progress_bar.update_text(
-                f'Exportando página PDF para imagem: [{num+1} de {self.num_pages}] {filename}'
+                f'Exportando página PDF para imagem: [{num+1} de {self.num_pages}] {output_file.basename()}'
             )
-            img.to_file(d.join_file(filename))
+            img.to_file(output_file)
+        print()
+        self.progress_bar.stop()
             
     def to_images(self) -> List[ImageObject]:
         images_obj: List[ImageObject] = []
@@ -170,7 +288,10 @@ class PdfStream(ABCDocumentStream):
     
     def to_document(self) -> DocumentPdf:
         return DocumentPdf(
-                    self.library_pdf, progress_bar=self.progress_bar, pages=self.pages
+                    self.library_pdf,
+                    progress_bar=self.progress_bar,
+                    pages=self.pages,
+                    maximum_pages=self.document.get_maximum_pages(),
                 )
     
     def inner_images(self) -> List[ImageObject]:
@@ -206,36 +327,39 @@ class PdfStream(ABCDocumentStream):
 # Imagens
 #==================================================================#
 
+
 class ImageStream(object):
+    """
+        Conversão de imagens.
+    """
     def __init__(
                 self, *,
                 library_image: LibraryImage = LibraryImage.OPENCV,
-                library_pdf: LibraryPDF = LibraryPDF.PILPDF,
-                progress_bar: ProgressBarAdapter = ProgressBarAdapter(ProgressBarSimple()),
+                library_pdf: LibraryPDF = LibraryPDF.FITZ,
+                lib_image_to_pdf: LibImageToPDF = LibImageToPDF.FITZ,
+                progress_bar: ProgressBarAdapter = CreatePbar().get(),
             ):
-        self.__images: List[ImageObject] = []
-        self.num_images: int = len(self.__images)
-        #self.progress_bar: ProgressBarAdapter = progress_bar
+        self._images: List[ImageObject] = []
+        self.num_images: int = len(self._images)
         self.library_image: LibraryImage = library_image
         self.library_pdf: LibraryPDF = library_pdf
+        self.lib_image_to_pdf: LibImageToPDF = lib_image_to_pdf
+
+        self.convert_pdf_to_images = ConvertPdfToImage.create(
+            self.library_image,
+            pbar=progress_bar,
+            lib_convert_pdf=LibConvertPDF.FITZ
+        )
 
-        # Objeto para converter IMAGEM em pdf.
-        if library_pdf == LibraryPDF.FITZ:
-            self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_fitz(library_image)
-        elif library_pdf == LibraryPDF.CANVAS:
-            self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_canvas(library_image)
-        elif library_pdf == LibraryPDF.PILPDF:
-            self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_pil(library_image)
+        # Objeto para converter PDF em imagem.
+        if self.lib_image_to_pdf == LibImageToPDF.PILPDF:
+            self.convert_image_to_pdf: ImageToPdf = ImageToPdf.create_from_pil(library_image)
+        elif self.lib_image_to_pdf == LibImageToPDF.FITZ:
+            self.convert_image_to_pdf: ImageToPdf = ImageToPdf.create_from_fitz(library_image)
+        elif self.lib_image_to_pdf == LibImageToPDF.CANVAS:
+            self.convert_image_to_pdf: ImageToPdf = ImageToPdf.create_from_canvas(library_image)
         else:
-            raise ValueError(f'PYPDF não pode converter imagens em PDF!!')
-            
-        # Objeto para converter PDF em imagem
-        self.convert_pdf_to_images: ConvertPdfToImage = ConvertPdfToImage(
-                library_pdf=LibraryPDF.FITZ,
-                library_image=library_image,
-                dpi=150,
-                progress_bar=progress_bar,
-            )
+            raise NotImplementedError()
 
     @property
     def progress_bar(self) -> ProgressBarAdapter:
@@ -243,7 +367,7 @@ class ImageStream(object):
         
     @property
     def images(self) -> List[ImageObject]:
-        return self.__images
+        return self._images
     
     @images.setter
     def images(self, imgs: List[ImageObject]) -> None:
@@ -257,17 +381,13 @@ class ImageStream(object):
     def add_image(self, img: ImageObject) -> None:
         if not isinstance(img, ImageObject):
             return
-        self.__images.append(img)
+        self._images.append(img)
         self.num_images += 1
         
     def add_images(self, images: List[ImageObject]):
         maxnum: int = len(images)
         self.progress_bar.start()
         for num, i in enumerate(images):
-            self.progress_bar.update(
-                ((num+1)/maxnum) * 100,
-                f'Adicionando imagens: [{num+1} de {maxnum}]'
-            )
             self.add_image(i)
         self.progress_bar.stop()
     
@@ -278,11 +398,9 @@ class ImageStream(object):
     def add_files_image(self, files: List[File]):
         maxnum: int = len(files)
         for num, f in enumerate(files):
-            p = ((num + 1) / maxnum) * 100
-            #print(p)
             self.progress_bar.update(
-                p,
-                f'Adicionando arquivos: [{num + 1} de {maxnum}]'
+                ((num + 1) / maxnum) * 100,
+                f'Adicionando imagens: [{num + 1} de {maxnum}] {f.basename()}'
             )
             self.add_file_image(f)
             
@@ -292,60 +410,98 @@ class ImageStream(object):
         return False
         
     def clear(self):
-        self.__images.clear()
+        self._images.clear()
         self.num_images = 0
         
-    def to_files_image(self, d: Directory, prefix: str = 'imagem'):
+    def to_files_image(self, d: Directory, prefix: str = 'imagem', *, replace: bool = False):
+        """
+        @param replace: substituir arquivos existentes no destino.
+        @param d: Diretório para exportar as imagens
+        @param prefix: prefixo para o nome das imagens
+        @return: None
+
+        @type d: Directory
+        @type prefix: str
+        @rtype: None
+        """
         d.mkdir()
         self.progress_bar.start()
         for num, image in enumerate(self.images):
             filename = f'{prefix}-{num+1}.png'
+            output_file: File = d.join_file(filename)
+            if not replace:
+                if output_file.exists():
+                    continue
             self.progress_bar.update(
                 ((num+1)/self.num_images) * 100,
                 f'Exportando imagem: {num+1} de {self.num_images} [{filename}]'
             )
-            image.to_file(d.join_file(filename))
+            image.to_file(output_file)
         self.progress_bar.stop()
                 
     def to_pages_pdf(self) -> List[PageDocumentPdf]:
         if self.is_null():
             print(f'{__class__.__name__} Adicione imagens para prosseguir!')
             return []
-        new_pages = []
+        new_pages: List[PageDocumentPdf] = []
         maxnum: int = len(self.images)
         self.progress_bar.start()
         for num, image in enumerate(self.images):
             self.progress_bar.update(
                 ((num + 1) / maxnum) * 100,
-                f'Adicionando imagens: [{num + 1} de {maxnum}]'
+                f'Criando páginas PDF: [{num + 1} de {maxnum}]'
             )
-            new_pages.append(self.convert_image_to_pdf.from_image(image))
+            im = self.convert_image_to_pdf.from_image(image)
+            new_pages.append(im)
         self.progress_bar.stop()
         return new_pages
-    
+
+    def to_documet(self) -> DocumentPdf:
+        return DocumentPdf(progress_bar=self.progress_bar, pages=self.to_pages_pdf())
+
     def set_paisagem(self):
         for num, img in enumerate(self.images):
             self.images[num].set_paisagem()
             
     def set_gaussian_blur(self):
+        self.progress_bar.start()
         for num, img in enumerate(self.images):
-            print(f'Removendo ruido de imagem: [{num+1} de {self.num_images}]')
+            self.progress_bar.update(
+                ((num+1) / self.num_images) * 100,
+                f'Removendo o ruido [{num+1} de {self.num_images}]'
+            )
             self.images[num].set_gaussian()
+        self.progress_bar.stop()
             
     def set_backgroud_black(self):
+        self.progress_bar.start()
         for num, img in enumerate(self.images):
-            print(f'Escurecendo imagem: [{num+1} de {self.num_images}]')
+            self.progress_bar.update(
+                ((num + 1) / self.num_images) * 100,
+                f'Removendo o ruido [{num + 1} de {self.num_images}]'
+            )
             self.images[num].set_background_black()
-            
+        self.progress_bar.stop()
+
     def set_background_gray(self):
+        self.progress_bar.start()
         for num, img in enumerate(self.images):
-            print(f'Escurecendo imagem: [{num+1} de {self.num_images}]')
+            self.progress_bar.update(
+                ((num + 1) / self.num_images) * 100,
+                f'Removendo o ruido [{num + 1} de {self.num_images}]'
+            )
             self.images[num].set_background_gray()
+        self.progress_bar.stop()
     
     def set_optimize(self):
+        self.progress_bar.start()
         for num, img in enumerate(self.images):
-            print(f'Otimizando imagem: [{num+1} de {self.num_images}]')
+            self.progress_bar.update(
+                ((num + 1) / self.num_images) * 100,
+                f'Otimizando imagem [{num + 1} de {self.num_images}]'
+            )
             self.images[num].set_optimize()
+        self.progress_bar.stop()
     
 
 def get_data_from_pdfs(*, files_pdf: List[File]) -> pandas.DataFrame:
@@ -361,7 +517,7 @@ def get_data_from_pdfs(*, files_pdf: List[File]) -> pandas.DataFrame:
     for file in files_pdf:
         doc.add_file_pdf(file)
         for page in doc.pages:
-            text =  page.to_string()
+            text = page.to_string()
             if (text is not None) and (text != ''):
                 values.extend(text.split('\n'))
                 data.append(