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

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 1.2
+Version: 1.2.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==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.1}/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.1}/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,20 @@ 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
+    from soup_files import Directory, File, UserFileSystem
+
+    outdir = UserFileSystem().userDownloads.concat('output', create=True)
+    base = UserFileSystem().userDownloads.join_file('base.pdf')
+
+    comp = CompressDocument.create_from_file(base, dpi=100)
+    comp.to_file(outdir.join_file('teste.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.1}/convert_stream/_version.py

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

{convert_stream-1.2 → convert_stream-1.2.1}/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)
@@ -101,7 +105,7 @@ 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 to_file_pdf(self, f: File):
@@ -109,94 +113,112 @@ class PdfStream(ABCDocumentStream):
             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.OPENCV,
+                library_pdf = 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)
             
         # 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
@@ -204,7 +226,7 @@ class ImageStream(object):
         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,14 +234,14 @@ 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]):
+    def add_images(self, images: List[ImageObject]):
         for i in images:
             self.add_image(i)
     
@@ -227,7 +249,7 @@ class ImageStream(object):
         img = ImageObject.create_from_file(f, library=self.library_image)
         self.add_image(img)
         
-    def add_files_image(self, files:List[File]):
+    def add_files_image(self, files: List[File]):
         for f in files:
             self.add_file_image(f)
             
@@ -240,11 +262,14 @@ 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()
         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))
                 
     def to_pages_pdf(self) -> List[PageDocumentPdf]:
@@ -253,7 +278,7 @@ class ImageStream(object):
             return []
         new_pages = []
         for image in self.images:
-            new_pages.append(self.convertImagesToPdf.from_image(image))
+            new_pages.append(self.convert_image_to_pdf.from_image(image))
         return new_pages
     
     def set_paisagem(self):
@@ -281,15 +306,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)

convert_stream-1.2.1/convert_stream/image_to_pdf.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+from typing import List
+from io import BytesIO
+from PIL import Image
+from reportlab.pdfgen import canvas
+from reportlab.pdfgen.canvas import Canvas
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.utils import ImageReader
+from soup_files import File
+
+from convert_stream.models import ABCImageObject, ABCPagePdf
+from convert_stream.imagelib import ImageObject, LibraryImage
+from convert_stream.models.models_pdf import ABCConvertPdf, ABCImageConvertPdf, LibraryPDF
+from convert_stream.progress.progress_bar import ProgressBarAdapter, ProgressBarSimple
+
+from convert_stream.pdf_page import (
+    PageDocumentPdf, MODULE_PYPDF2, MODULE_FITZ
+)
+
+if MODULE_PYPDF2:
+    from PyPDF2 import PdfReader, PdfWriter, PageObject
+if MODULE_FITZ:
+    try:
+        import fitz
+    except:
+        try:
+            import pymupdf
+        except:
+            pass
+
+
+#########################################################################
+# Converter IMAGEM para Arquivo ou página PDF.
+#########################################################################
+
+
+class ImplementImageConvertPdfFitz(ABCImageConvertPdf):
+    """
+        Implementação para converter imagens em PDF.
+    """
+    def __init__(
+            self,
+            library_image, *,
+            progress_bar: ProgressBarAdapter = ProgressBarAdapter(ProgressBarSimple())
+            ):
+        super().__init__(library_image, progress_bar=progress_bar)
+        self._library_pdf = LibraryPDF.FITZ
+        
+    def from_image_file(self, file: File) -> PageDocumentPdf:
+        # https://pymupdf.readthedocs.io/en/latest/recipes-images.html
+        doc = fitz.Document()
+        img_document: fitz.Document = fitz.Document(file.absolute())  # open pic as document
+        rect = img_document[0].rect  # pic dimension
+        pdfbytes = img_document.convert_to_pdf()  # make a PDF stream
+        img_document.close()  # no longer needed
+        image_doc_pdf = fitz.Document("pdf", pdfbytes)  # open stream as PDF
+        
+        page = doc.new_page(
+                    width=rect.width,  # new page with ...
+                    height=rect.height # pic dimension
+            )  
+        page.show_pdf_page(rect, image_doc_pdf, 0)  # image fills the page
+        return PageDocumentPdf.create_from_page_fitz(page)
+        
+    def from_image(self, img: ImageObject) -> PageDocumentPdf:
+        return self.from_image_bytes(img.to_bytes())
+    
+    def from_image_bytes(self, image_bytes: bytes) -> PageDocumentPdf:
+        doc: fitz.Document = fitz.Document()
+        
+        # Criar um Pixmap diretamente dos bytes da imagem
+        pix = fitz.Pixmap(BytesIO(image_bytes))
+
+        # Criar uma nova página do tamanho da imagem
+        page = doc.new_page(width=pix.width, height=pix.height)
+
+        # Inserir a imagem na página
+        page.insert_image(page.rect, pixmap=pix)
+        return PageDocumentPdf.create_from_page_fitz(page)
+
+
+class ImplementImageConvertPdfCanvas(ABCImageConvertPdf):
+    """
+        Implementação para converter uma imagem em página PDF (canvas).
+    """
+    def __init__(self, library_image):
+        super().__init__(library_image)
+        self._library_pdf = LibraryPDF.FITZ
+        
+    def from_image(self, img: ImageObject) -> PageDocumentPdf:
+        # Cria um buffer de memória para o PDF
+        buffer_pdf = BytesIO()
+
+        # Cria o canvas associado ao buffer
+        c: Canvas = canvas.Canvas(buffer_pdf, pagesize=letter)
+        # Adicionar a imagem.
+        c.drawImage(
+                ImageReader(img.to_image_pil()), 
+                0, 
+                0, 
+                width=letter[0], 
+                height=letter[1], 
+                preserveAspectRatio=True, 
+                anchor='c'
+            )
+        c.showPage()
+    
+        # Finaliza o PDF
+        c.save()
+
+        # Move o ponteiro do buffer para o início
+        buffer_pdf.seek(0)
+
+        # Obtém os bytes do PDF
+        pdf_bytes = buffer_pdf.getvalue()
+
+        # Fecha o buffer (opcional, mas recomendado)
+        buffer_pdf.close()
+        
+        # Gerar a página PDF
+        return PageDocumentPdf.create_from_page_bytes(pdf_bytes, library=self._library_pdf)
+        
+    def from_image_file(self, file:File) -> PageDocumentPdf:
+        """
+            Converter um arquivo de imagem em páginas PDF
+        """
+        img = ImageObject.create_from_file(file, library=self.library_image)
+        return self.from_image(img)
+    
+    def from_image_bytes(self, img_bytes:bytes) -> PageDocumentPdf:
+        return self.from_image(
+                ImageObject.create_from_bytes(img_bytes, library=self.library_image)
+            )
+
+
+class ImplementImageConvertToPdfPIL(ABCImageConvertPdf):
+    """
+        Implementação para converter uma imagem em página PDF (PIL).
+    """
+    def __init__(self, library_image):
+        super().__init__(library_image)
+        self._library_pdf: LibraryPDF = LibraryPDF.FITZ
+        
+    def from_image(self, img:ImageObject) -> PageDocumentPdf:
+        img_pil = img.to_image_pil()
+        buff = BytesIO()
+        # Converter e salvar como PDF
+        img_pil.save(buff, "PDF")
+        pdf_bytes: bytes = buff.getvalue()
+        buff.close()
+        return PageDocumentPdf.create_from_page_bytes(pdf_bytes, library=self._library_pdf)
+        
+    def from_image_file(self, file: File) -> PageDocumentPdf:
+        """
+            Converter um arquivo de imagem em páginas PDF
+        """
+        # Carregar a imagem
+        imagem:Image.Image = Image.open(file.absolute())
+        buff = BytesIO()
+        # Converter e salvar como PDF
+        imagem.save(buff, "PDF")
+        pdf_bytes: bytes = buff.getvalue()
+        buff.close()
+        return PageDocumentPdf.create_from_page_bytes(pdf_bytes, library=self._library_pdf)
+    
+    def from_image_bytes(self, img_bytes:bytes) -> PageDocumentPdf:
+        img_pil = Image.open(BytesIO(img_bytes))
+        buff_pdf = BytesIO()
+        # Converter e salvar como PDF
+        img_pil.save(buff_pdf, "PDF")
+        pdf_bytes: bytes = buff_pdf.getvalue()
+        buff_pdf.close()
+        return PageDocumentPdf.create_from_page_bytes(pdf_bytes, library=self._library_pdf)
+         
+         
+class ImageConvertPdf(ABCImageConvertPdf):
+    """
+        Converter Imagem em páginas PDF.
+    """
+    def __init__(self, convert_image_to_pdf: ABCImageConvertPdf):
+        super().__init__(convert_image_to_pdf.library_image)
+        self.convert_image_to_pdf: ABCImageConvertPdf = convert_image_to_pdf
+            
+    def from_image_file(self, file: File) -> PageDocumentPdf:
+        return self.convert_image_to_pdf.from_image_file(file)
+    
+    def from_image(self, img: ImageObject) -> PageDocumentPdf:
+        if not isinstance(img, ImageObject):
+            raise ValueError(f'{__class__.__name__}\nUser: ImageObject(), não {type(img)}')
+        return self.convert_image_to_pdf.from_image(img)
+    
+    def from_image_bytes(self, img_bytes) -> PageDocumentPdf:
+        return self.convert_image_to_pdf.from_image_bytes(img_bytes)
+    
+    @classmethod
+    def create_from_pil(cls, library_image:LibraryImage=LibraryImage.OPENCV) -> ImageConvertPdf:
+        img_convert: ABCImageConvertPdf = ImplementImageConvertToPdfPIL(library_image)
+        return cls(img_convert)
+    
+    @classmethod
+    def create_from_canvas(
+                cls,
+                library_image: LibraryImage = LibraryImage.OPENCV
+            ) -> ImageConvertPdf:
+        img_convert = ImplementImageConvertPdfCanvas(library_image)
+        return cls(img_convert)
+    
+    @classmethod
+    def create_from_fitz(
+                cls,
+                library_image: LibraryImage = LibraryImage.OPENCV
+            ) -> ImageConvertPdf:
+        img_convert = ImplementImageConvertPdfFitz(library_image)
+        return cls(img_convert)
+
+

{convert_stream-1.2 → convert_stream-1.2.1}/convert_stream/imagelib.py

@@ -267,7 +267,7 @@ class ImageObjectPIL(ABCImageObject):
     def set_optimize(self):
         optimized_bytes = BytesIO()
         img = self.to_image_pil()
-        img.save(optimized_bytes, format='PNG', optimize=True, quality=80)
+        img.save(optimized_bytes, format='PNG', optimize=True, quality=70)
         self.image_bytes = optimized_bytes.getvalue()
         
     def set_background_black(self):

{convert_stream-1.2 → convert_stream-1.2.1}/convert_stream/models/models_image.py

@@ -15,8 +15,7 @@ class LibraryImage(Enum):
     ROTATION_90 = 90
     ROTATION_180 = 180
     ROTATION_270 = 270
-  
-    
+
 
 class ABCInvertColor(ABC):
     
@@ -49,7 +48,7 @@ class ABCImageObject(ABC):
         super().__init__()
         self.current_library: LibraryImage = None
         
-    @classmethod
+    @abstractmethod
     def is_paisagem(self) -> bool:
         """
         Retorna True se a imagem estiver em modo paisagem.
@@ -99,8 +98,5 @@ class ABCImageObject(ABC):
         """
         pass
     
-    
-    
-    
-    
+