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

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 1.2
+Version: 1.2.3
 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==1.0.1
+Requires-Dist: soup_files
 Requires-Dist: PyPDF2==3.0.1
 Requires-Dist: PyMuPDF==1.25.5
 Requires-Dist: reportlab==4.3.1

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

@@ -2,7 +2,8 @@
 #
 from ._version import (
     __version__, __module_name__, 
-    __author__, __license__, __modify_date__
+    __author__, __license__,
+    __modify_date__
 )
 version = __version__
 
@@ -11,13 +12,17 @@ from .text import (
     LibraryDates, print_title, print_line, save_data
 )
 
-from .models.progress_bar import (
-    ProgressBarAdapter, ProgressBarSimple, ProgressBarTqdm, ABCProgressBar
+from convert_stream.progress.progress_bar import (
+    ProgressBarAdapter, ProgressBarSimple,
+    ProgressBarTqdm, ABCProgressBar
 )
+
 from .models.models_pdf import LibraryPDF
 from .imagelib import ImageObject, ImageInverColor, LibraryImage
 from .pdf_page import PageDocumentPdf, PagePdfFitz, PagePyPdf2
-from .pdf_document import DocumentPdf
-from .pdf_convert import ConvertPdfToImage, ImageConvertPdf
+from .pdf_document import DocumentPdf, FileDocumentPdf
+from .pdf_to_images import ConvertPdfToImage
+from .image_to_pdf import ImageConvertPdf
 from .convert import PdfStream, ImageStream, get_data_from_pdfs
+from .pdf_compress import CompressDocument
 

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

@@ -11,7 +11,9 @@
 + Incluir o método set_rotation() em ImageObject()
  
 """
-import sys, os
+import os
+import sys
+
 this_file = os.path.abspath(os.path.relpath(__file__))
 dir_of_project = os.path.dirname(this_file)
 sys.path.insert(0, dir_of_project)
@@ -22,13 +24,23 @@ from convert_stream import (
 
 
 def test():
-    from convert_stream import PageDocumentPdf, PdfStream, DocumentPdf
-    from soup_files import File, Directory, UserFileSystem
+    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')
 
 
 def main():
     print_title(f'{__module_name__} versão {version} - {__modify_date__}', char='-')
     test()
 
+
 if __name__ == '__main__':
-    main()
+    main()

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

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

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

@@ -6,47 +6,51 @@ import pandas
 
 from convert_stream.models import ABCDocumentStream, LibraryImage, LibraryPDF
 from convert_stream.imagelib import ImageObject
-from convert_stream.models.progress_bar import ProgressBarAdapter, ProgressBarSimple
+from convert_stream.progress.progress_bar import ProgressBarAdapter, ProgressBarSimple
 from convert_stream.pdf_page import PageDocumentPdf
 from convert_stream.pdf_document import DocumentPdf
-from convert_stream.pdf_convert import ConvertPdfToImage, ImageConvertPdf
+from convert_stream.pdf_to_images import ConvertPdfToImage
+from convert_stream.image_to_pdf import ImageConvertPdf
 from soup_files import File, Directory
  
 #==================================================================#
 # PDF
 #==================================================================#
 
+
 class PdfStream(ABCDocumentStream):
     """
         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 = ProgressBarAdapter(ProgressBarSimple())
+                self, *,
+                library_pdf: LibraryPDF = LibraryPDF.FITZ,
+                library_image: LibraryImage = LibraryImage.OPENCV,
+                progress_bar: ProgressBarAdapter = ProgressBarAdapter(ProgressBarSimple())
             ):
         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.convertPdfToImages: ConvertPdfToImage = ConvertPdfToImage(library_image=library_image)
+        self.convert_pdf_to_images: ConvertPdfToImage = ConvertPdfToImage(
+            library_image=library_image, progress_bar=progress_bar
+        )
         
         if self.library_pdf == LibraryPDF.CANVAS:
-            self.imagesToPdf:ImageConvertPdf = ImageConvertPdf.create_from_canvas(self.library_image)
+            self.convert_images_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_canvas(self.library_image)
         elif self.library_pdf == LibraryPDF.PILPDF:
-            self.imagesToPdf:ImageConvertPdf = ImageConvertPdf.create_from_pil(LibraryImage.PIL)
+            self.convert_images_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_pil(LibraryImage.PIL)
         else:
-            self.imagesToPdf:ImageConvertPdf = ImageConvertPdf.create_from_fitz(self.library_image)
+            self.convert_images_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_fitz(self.library_image)
         
     @property
     def num_pages(self) -> int:
         return self.document.num_pages
     
     @num_pages.setter
-    def num_pages(self, num:int):
+    def num_pages(self, num: int):
         pass
         
     @property
@@ -54,7 +58,7 @@ class PdfStream(ABCDocumentStream):
         return self.document.pages
     
     @pages.setter
-    def pages(self, new:List[PageDocumentPdf]):
+    def pages(self, new: List[PageDocumentPdf]):
         if not isinstance(new, list):
             return
         self.document.clear()
@@ -67,7 +71,7 @@ class PdfStream(ABCDocumentStream):
     def clear(self):
         self.document.clear()
         
-    def add_page(self, p:PageDocumentPdf):
+    def add_page(self, p: PageDocumentPdf):
         if not isinstance(p, PageDocumentPdf):
             return
         self.document.add_page(p)
@@ -77,12 +81,14 @@ class PdfStream(ABCDocumentStream):
             print(f'{__class__.__name__} Erro: Use lista de PageDocumentPdf, não {type(pages)}')
             return
         max_num: int = len(pages)
+        self.progress_bar.start()
         for num, p in enumerate(pages):
             self.progress_bar.update(
                 ((num+1)/max_num) * 100,
                 f'Adicionando página: [{num+1} de {max_num}]'
             )
             self.add_page(p)
+        self.progress_bar.stop()
 
     def add_page_pdf_bytes(self, bt: bytes):
         _page = PageDocumentPdf.create_from_page_bytes(bt, library=self.library_pdf)
@@ -101,110 +107,146 @@ class PdfStream(ABCDocumentStream):
         self.add_pages(doc.pages)
         
     def add_image(self, image: ImageObject):
-        pg: PageDocumentPdf = self.imagesToPdf.from_image(image)
+        pg: PageDocumentPdf = self.convert_images_to_pdf.from_image(image)
         self.add_page(pg)
+
+    def add_images(self, images: List[ImageObject]):
+        maxnum: int = len(images)
+        self.progress_bar.start()
+        for n, img in enumerate(images):
+            self.progress_bar.update(
+                ((n+1)/maxnum) * 100,
+                f'Adicionando imagens ao documento: [{n+1}] de {maxnum}'
+            )
+            self.add_image(img)
+        self.progress_bar.stop()
         
     def to_file_pdf(self, f: File):
         if self.is_null():
             print(
                 f'{__class__.__name__} Nenhuma página foi adiconada, adicione páginas ao documento para prosseguir!'
             )
-        docpdf: DocumentPdf = DocumentPdf(self.library_pdf, progress_bar=self.progress_bar)
-        docpdf.add_pages(self.pages)
+        docpdf: DocumentPdf = DocumentPdf(
+            self.library_pdf, progress_bar=self.progress_bar, pages=self.pages
+        )
         docpdf.to_file_pdf(f)
         
-    def to_files_pdf(self, outdir: Directory, *, prefix='pag'):
+    def to_files_pdf(self, outdir: Directory, *, prefix='documento-pag'):
         if self.is_null():
             print(
-                f'{__class__.__name__} Nenhuma página foi adiconada, adicione páginas ao documento para prosseguir!'
+                f'{__class__.__name__} Adicione páginas ao documento para prosseguir!'
             )
-            
+            return
         outdir.mkdir()
-        _document:DocumentPdf = DocumentPdf(self.library_pdf)
+        _document: DocumentPdf = DocumentPdf(self.library_pdf)
         for num, p in enumerate(self.pages):
-            filename:str = f'{prefix}-{num+1}.pdf'
-            print(f'Exportando página: {p.page_number} de {self.num_pages} | [{filename}]')
+            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='página-para-imagem'):
+    def to_files_image(self, d: Directory, *, prefix: str = 'pdf-para-imagem'):
         """
             Exporta cada página PDF como um arquivo de imagem.
         """
         d.mkdir()
         for num, page in enumerate(self.pages):
             filename = f'{prefix}-{page.page_number}.png'
-            img = self.convertPdfToImages.from_page_pdf(page)
-            print(f'Exportando página PDF para imagem: [{num+1} de {self.num_pages}] {filename}')
+            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}'
+            )
             img.to_file(d.join_file(filename))
             
     def to_images(self) -> List[ImageObject]:
-        images_obj:List[ImageObject] = []
+        images_obj: List[ImageObject] = []
         for page in self.pages:
-            images_obj.append(self.convertPdfToImages.from_page_pdf(page))
+            _image: ImageObject = self.convert_pdf_to_images.from_page_pdf(page)
+            images_obj.append(_image)
         return images_obj
     
     def to_document(self) -> DocumentPdf:
-        doc = DocumentPdf(self.library_pdf)
-        doc.add_pages(self.pages)
-        return doc
+        return DocumentPdf(
+                    self.library_pdf, progress_bar=self.progress_bar, pages=self.pages
+                )
     
     def inner_images(self) -> List[ImageObject]:
-        inner_images:List[ImageObject] = []
-        for p in self.pages:
-            inner_images.extend(
-                self.convertPdfToImages.inner_images(p.to_bytes())
+        inner_images: List[ImageObject] = []
+        for num, p in enumerate(self.pages):
+            self.progress_bar.update(
+                ((num+1)/self.num_pages) * 100,
+                f'Convertendo página [{num+1} de {self.num_pages}]'
             )
+            imgs: List[ImageObject] = self.convert_pdf_to_images.inner_images(p.to_bytes())
+            inner_images.extend(imgs)
         return inner_images
     
-    def inner_images_to_files(self, d:Directory, prefix:str='página-para-imagens') -> None:
+    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.
+            Salva todas as imagens presentes nas páginas PDF, em arquivos de imagem.
         """
-        outdir = d #.concat(f'{num+1}')
-        outdir.mkdir()
+        d.mkdir()
         for num, page in enumerate(self.pages):
-            images = self.convertPdfToImages.inner_images(page.to_bytes())
+            images = self.convert_pdf_to_images.inner_images(page.to_bytes())
             if len(images) < 1:
                 continue
             for n, img in enumerate(images):
                 filename = f'{prefix}-{page.page_number}-img-{n+1}.png' 
-                img.to_file(outdir.join_file(filename))
+                img.to_file(d.join_file(filename))
     
     def set_paisagem(self):
         for page in self.pages:
             page.set_paisagem()
-             
+
+
 #==================================================================#
 # Imagens
 #==================================================================#
 
 class ImageStream(object):
-    def __init__(self, *, library_image=LibraryImage.OPENCV, library_pdf=LibraryPDF.PILPDF):
-        self.__images:List[ImageObject] = []
-        self.num_images:int = len(self.__images)
-        self.library_image:LibraryImage = library_image
-        self.library_pdf:LibraryPDF = library_pdf
+    def __init__(
+                self, *,
+                library_image: LibraryImage = LibraryImage.OPENCV,
+                library_pdf: LibraryPDF = LibraryPDF.PILPDF,
+                progress_bar: ProgressBarAdapter = ProgressBarAdapter(ProgressBarSimple()),
+            ):
+        self.__images: List[ImageObject] = []
+        self.num_images: int = len(self.__images)
+        #self.progress_bar: ProgressBarAdapter = progress_bar
+        self.library_image: LibraryImage = library_image
+        self.library_pdf: LibraryPDF = library_pdf
+
         # Objeto para converter IMAGEM em pdf.
         if library_pdf == LibraryPDF.FITZ:
-            self.convertImagesToPdf:ImageConvertPdf = ImageConvertPdf.create_from_fitz(library_image)
+            self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_fitz(library_image)
         elif library_pdf == LibraryPDF.CANVAS:
-            self.convertImagesToPdf:ImageConvertPdf = ImageConvertPdf.create_from_canvas(library_image)
+            self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_canvas(library_image)
         elif library_pdf == LibraryPDF.PILPDF:
-            self.convertImagesToPdf:ImageConvertPdf = ImageConvertPdf.create_from_pil(library_image)
+            self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_pil(library_image)
+        else:
+            raise ValueError(f'PYPDF não pode converter imagens em PDF!!')
             
         # Objeto para converter PDF em imagem
-        self.convertPdfToImages:ConvertPdfToImage = ConvertPdfToImage(
-                library_pdf=LibraryPDF.FITZ, library_image=library_image, dpi=200,
+        self.convert_pdf_to_images: ConvertPdfToImage = ConvertPdfToImage(
+                library_pdf=LibraryPDF.FITZ,
+                library_image=library_image,
+                dpi=150,
+                progress_bar=progress_bar,
             )
+
+    @property
+    def progress_bar(self) -> ProgressBarAdapter:
+        return self.convert_pdf_to_images.pbar
         
     @property
     def images(self) -> List[ImageObject]:
         return self.__images
     
     @images.setter
-    def images(self, imgs:List[ImageObject]) -> None:
+    def images(self, imgs: List[ImageObject]) -> None:
         if not isinstance(imgs, list):
             print(f'Erro: Use: list() não {type(imgs)}')
             return
@@ -212,23 +254,36 @@ class ImageStream(object):
         for img in imgs:
             self.add_image(img)
         
-    def add_image(self, img:ImageObject) -> None:
+    def add_image(self, img: ImageObject) -> None:
         if not isinstance(img, ImageObject):
             return
-        print(f'{__class__.__name__} Adicionando imagem {self.num_images+1}')
         self.__images.append(img)
         self.num_images += 1
         
-    def add_images(self, images:List[ImageObject]):
-        for i in images:
+    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()
     
-    def add_file_image(self, f:File):
+    def add_file_image(self, f: File):
         img = ImageObject.create_from_file(f, library=self.library_image)
         self.add_image(img)
         
-    def add_files_image(self, files:List[File]):
-        for f in files:
+    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}]'
+            )
             self.add_file_image(f)
             
     def is_null(self) -> bool:
@@ -240,20 +295,32 @@ class ImageStream(object):
         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'):
         d.mkdir()
+        self.progress_bar.start()
         for num, image in enumerate(self.images):
             filename = f'{prefix}-{num+1}.png'
-            print(f'Exportando imagem: {num+1} de {self.num_images} [{filename}]')
+            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))
+        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 = []
-        for image in self.images:
-            new_pages.append(self.convertImagesToPdf.from_image(image))
+        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}]'
+            )
+            new_pages.append(self.convert_image_to_pdf.from_image(image))
+        self.progress_bar.stop()
         return new_pages
     
     def set_paisagem(self):
@@ -281,15 +348,15 @@ class ImageStream(object):
             self.images[num].set_optimize()
     
 
-def get_data_from_pdfs(*, files_pdf:List[File]) -> pandas.DataFrame:
+def get_data_from_pdfs(*, files_pdf: List[File]) -> pandas.DataFrame:
     """
         Recebe uma lista de arquivos PDF e retorna um DataFrame com os dados das cartas.
     """
     if not isinstance(files_pdf, list):
         raise ValueError(f'Erro: Use: list() não {type(files_pdf)}')
     
-    data:List[pandas.DataFrame] = []
-    values:List[str] = []
+    data: List[pandas.DataFrame] = []
+    values: List[str] = []
     doc = DocumentPdf()
     for file in files_pdf:
         doc.add_file_pdf(file)