convert-stream 2.5__tar.gz → 2.5.1__tar.gz

{convert_stream-2.5 → convert_stream-2.5.1}/PKG-INFO

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

convert_stream-2.5.1/convert_stream/convert/__init__.py

@@ -0,0 +1,6 @@
+from .image_to_pdf import (
+    ABCConvertImageToPdf, ConvertImageToPdf, DEFAULT_LIB_IMAGE_TO_PDF, LibImageToPdf,
+)
+from .pdf_to_image import (
+    ABCConvertPdf, ConvertPdfToImages, DEFAULT_LIB_PDF_TO_IMG, LibPdfToImage
+)

convert_stream-2.5.1/convert_stream/convert/image_to_pdf.py

@@ -0,0 +1,349 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+    Módulo para trabalhar com imagens
+"""
+
+from __future__ import annotations
+from io import BytesIO
+from soup_files import File, Directory, ProgressBarAdapter
+from abc import ABC, abstractmethod
+from convert_stream.mod_types.enums import LibImageToPdf
+from convert_stream.mod_types.modules import (
+    MOD_CANVAS, DEFAULT_LIB_IMAGE_TO_PDF, canvas, letter, ImageReader
+)
+from convert_stream.pdf import DocumentPdf
+from convert_stream.pdf.pdf_page import fitz
+from convert_stream.image.img_object import MOD_IMG_PIL, Image, ImageObject, CollectionImages
+
+
+class ABCConvertImageToPdf(ABC):
+
+    def __init__(self, collection_images: CollectionImages):
+        self.collection_images: CollectionImages = collection_images
+        self.pbar: ProgressBarAdapter = ProgressBarAdapter()
+
+    @abstractmethod
+    def set_pbar(self, p: ProgressBarAdapter):
+        pass
+
+    @abstractmethod
+    def to_document(self, land_scape: bool = True, a4: bool = False) -> DocumentPdf:
+        pass
+
+    @abstractmethod
+    def to_file_pdf(self, output_file: File, *, land_scape: bool = True, a4: bool = False) -> None:
+        pass
+
+
+class ImplementImageToPdfCanvas(ABCConvertImageToPdf):
+
+    def __init__(self, collection_images: CollectionImages):
+        super().__init__(collection_images)
+
+    def set_pbar(self, p: ProgressBarAdapter):
+        self.pbar = p
+        self.collection_images.set_pbar(p)
+
+    def to_document(self, land_scape: bool = True, a4: bool = False) -> DocumentPdf:
+        if not MOD_CANVAS:
+            raise RuntimeError("A biblioteca 'reportlab' não está disponível.")
+
+        if self.collection_images.is_empty:
+            raise ValueError("A lista de imagens não pode estar vazia.")
+
+        buffer = BytesIO()
+        max_num: int = self.collection_images.length
+        self.pbar.start()
+        if land_scape:
+            self.collection_images.set_land_scape()
+
+        # Lógica para determinar o tamanho inicial da página
+        first_img_obj = self.collection_images[0]
+        first_img_width, first_img_height = first_img_obj.get_dimensions()
+
+        if a4:
+            # Se for A4, o tamanho da página é fixo desde o início
+            c = canvas.Canvas(buffer, pagesize=letter)
+        else:
+            # Se não for A4, o canvas é inicializado com as dimensões da primeira imagem
+            c = canvas.Canvas(buffer, pagesize=(first_img_width, first_img_height))
+
+        # Processa a primeira imagem
+        self.pbar.update(
+            (1 / max_num) * 100,
+            f'Adicionando imagem ao Documento [1 de {max_num}]'
+        )
+        img_bytes: BytesIO = first_img_obj.to_bytes()
+        img_bytes.seek(0)
+        img_reader = ImageReader(img_bytes)
+
+        if a4:
+            # Lógica de redimensionamento e centralização para A4
+            page_width, page_height = letter
+            scale_factor = min(page_width / first_img_width, page_height / first_img_height)
+            scaled_width = first_img_width * scale_factor
+            scaled_height = first_img_height * scale_factor
+            x_pos = (page_width - scaled_width) / 2
+            y_pos = (page_height - scaled_height) / 2
+            c.drawImage(img_reader, x_pos, y_pos, width=scaled_width, height=scaled_height)
+        else:
+            # Desenha a imagem preenchendo a página que já tem o tamanho correto
+            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):
+
+            self.pbar.update(
+                ((num + 1) / max_num) * 100,
+                f'Adicionando imagem ao Documento [{num + 1} de {max_num}]'
+            )
+            img_bytes = img_obj.to_bytes()
+            img_bytes.seek(0)
+            img_reader = ImageReader(img_bytes)
+            img_width, img_height = img_obj.get_dimensions()
+            # Cria nova página
+            c.showPage()
+
+            if a4:
+                # O tamanho da página é fixo, apenas desenha a imagem centralizada e redimensionada
+                page_width, page_height = letter
+                scale_factor = min(page_width / img_width, page_height / img_height)
+                scaled_width = img_width * scale_factor
+                scaled_height = img_height * scale_factor
+                x_pos = (page_width - scaled_width) / 2
+                y_pos = (page_height - scaled_height) / 2
+                c.drawImage(img_reader, x_pos, y_pos, width=scaled_width, height=scaled_height)
+            else:
+                # Ajusta o tamanho da nova página para as dimensões da imagem atual
+                c.setPageSize((img_width, img_height))
+                c.drawImage(img_reader, 0, 0, width=img_width, height=img_height)
+
+        c.save()
+        buffer.seek(0)
+        self.pbar.stop()
+        return DocumentPdf.create_from_bytes(buffer)
+
+    def to_file_pdf(self, output_file: File, *, land_scape: bool = True, a4: bool = False) -> None:
+        self.to_document(land_scape=land_scape, a4=a4).to_file(output_file)
+
+
+class ImplementImageToPdfPil(ABCConvertImageToPdf):
+    """
+        Classe para converter uma lista de ImageObject em um DocumentPdf
+        usando a biblioteca Pillow (PIL).
+    """
+
+    def __init__(self, collection_images: CollectionImages):
+        super().__init__(collection_images)
+
+    def set_pbar(self, p: ProgressBarAdapter):
+        self.pbar = p
+        self.collection_images.set_pbar(p)
+
+    def to_document(self, land_scape: bool = True, a4: bool = False) -> DocumentPdf:
+        if not MOD_IMG_PIL:
+            raise RuntimeError("A biblioteca 'Pillow' não está disponível.")
+
+        if self.collection_images.length == 0:
+            raise ValueError("A lista de imagens não pode estar vazia.")
+
+        if land_scape:
+            self.collection_images.set_land_scape()
+
+        pil_images_to_save = []
+        if a4:
+            # Obtém as dimensões da página A4 em píxels
+            # Usando uma resolução de 100 DPI para consistência
+            page_width, page_height = letter  # Padrão do reportlab
+            page_size = (int(page_width), int(page_height))
+
+            self.pbar.start()
+            max_num = self.collection_images.length
+            for num, img_obj in enumerate(self.collection_images):
+                self.pbar.update(
+                    ((num + 1) / max_num) * 100,
+                    f'Redimensionando e ajustando imagem para A4 [{num + 1} de {max_num}]'
+                )
+                original_pil_image = img_obj.to_pil()
+                img_width, img_height = original_pil_image.size
+
+                # Calcula o fator de escala para ajustar a imagem à página, mantendo a proporção
+                scale_factor = min(page_size[0] / img_width, page_size[1] / img_height)
+                scaled_width = int(img_width * scale_factor)
+                scaled_height = int(img_height * scale_factor)
+
+                # Redimensiona a imagem
+                resized_image = original_pil_image.resize(
+                    (scaled_width, scaled_height), Image.Resampling.LANCZOS
+                )
+
+                # Criar imagem de fundo branca com o tamanho A4
+                new_image = Image.new('RGB', page_size, 'white')
+
+                # Centraliza a imagem redimensionada na nova imagem
+                x_pos = (page_size[0] - scaled_width) // 2
+                y_pos = (page_size[1] - scaled_height) // 2
+                new_image.paste(resized_image, (x_pos, y_pos))
+
+                pil_images_to_save.append(new_image)
+            self.pbar.stop()
+        else:
+            # Para a4 = False, não precisa redimensionar. Pillow ajusta o tamanho da página.
+            pil_images_to_save = [img.to_pil() for img in self.collection_images]
+
+        buffer = BytesIO()
+        try:
+            first_image_pil = pil_images_to_save[0]
+            other_images_pil = pil_images_to_save[1:]
+
+            first_image_pil.save(
+                buffer,
+                'PDF',
+                resolution=140.0,
+                save_all=True,
+                append_images=other_images_pil
+            )
+        except Exception as e:
+            raise RuntimeError(f"Erro ao criar o PDF com Pillow: {e}") from e
+
+        buffer.seek(0)
+        return DocumentPdf.create_from_bytes(buffer)
+
+    def to_file_pdf(self, output_file: File, *, land_scape: bool = True, a4: bool = False) -> None:
+        self.to_document(land_scape=land_scape, a4=a4).to_file(output_file)
+
+
+class ImplementImageToPdfFitz(ABCConvertImageToPdf):
+    """
+        Classe para converter uma lista de ImageObject em um DocumentPdf
+        usando a biblioteca PyMuPDF (fitz).
+    """
+
+    def __init__(self, collection_images: CollectionImages):
+        super().__init__(collection_images)
+
+    def set_pbar(self, p: ProgressBarAdapter):
+        self.pbar = p
+        self.collection_images.set_pbar(p)
+
+    def to_document(self, land_scape: bool = True, a4: bool = False) -> DocumentPdf:
+        max_num: int = self.collection_images.length
+        if max_num == 0:
+            raise ValueError('Adicione imagens para prosseguir')
+        self.pbar.start()
+        self.pbar.update(0, f'Convertendo {max_num} imagens em Documento PDF')
+        buffer = BytesIO()
+        doc = fitz.open()  # Cria um novo documento PDF vazio
+
+        for num, img_obj in enumerate(self.collection_images):
+            self.pbar.update(
+                ((num + 1) / max_num) * 100,
+                f'Convertendo: [{num + 1} de {max_num}]'
+            )
+            if land_scape:
+                img_obj.set_landscape()
+
+            # Converte a imagem para bytes
+            img_bytes_obj = img_obj.to_bytes()
+            # Obtém as dimensões da imagem e da página
+            img_width, img_height = img_obj.get_dimensions()
+
+            # Adiciona uma nova página ao documento
+            if a4:
+                page = doc.new_page()
+            else:
+                page = doc.new_page(width=img_width, height=img_height)
+
+            # Cria um retângulo que preenche a página
+            rect = page.rect
+            page_width, page_height = rect.width, rect.height
+
+            # Calcula o fator de escala para ajustar a imagem à página
+            scale_factor_w = page_width / img_width
+            scale_factor_h = page_height / img_height
+            scale_factor = min(scale_factor_w, scale_factor_h)
+
+            # Ajusta o retângulo de inserção para centralizar a imagem
+            scaled_width = img_width * scale_factor
+            scaled_height = img_height * scale_factor
+            x0 = (page_width - scaled_width) / 2
+            y0 = (page_height - scaled_height) / 2
+
+            # Insere a imagem no retângulo calculado
+            page.insert_image(
+                fitz.Rect(x0, y0, x0 + scaled_width, y0 + scaled_height),
+                stream=img_bytes_obj
+            )
+
+        # Salva o documento no buffer de memória
+        doc.save(buffer)
+        doc.close()
+        buffer.seek(0)
+        self.pbar.update(100, 'Conversão concluída')
+        print()
+        self.pbar.stop()
+        return DocumentPdf.create_from_bytes(buffer)
+
+    def to_file_pdf(self, output_file: File, *, land_scape: bool = True, a4: bool = False) -> None:
+        self.to_document(land_scape=land_scape).to_file(output_file)
+
+
+class ConvertImageToPdf(object):
+    """
+        Classe com padrão ADAPTER para converter Imagens em documento(s) PDF.
+    """
+
+    def __init__(
+            self,
+            collection_images: CollectionImages, *,
+            lib_img_to_pdf: LibImageToPdf = LibImageToPdf.IMAGE_TO_PDF_FITZ
+    ):
+        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:
+            self.convert: ABCConvertImageToPdf = ImplementImageToPdfPil(collection_images)
+        elif lib_img_to_pdf == LibImageToPdf.IMAGE_TO_PDF_FITZ:
+            self.convert: ABCConvertImageToPdf = ImplementImageToPdfFitz(collection_images)
+        else:
+            raise NotImplementedError()
+
+        self._count: int = 0
+
+    @property
+    def is_null(self) -> bool:
+        return self.convert.collection_images.is_empty
+
+    @property
+    def pbar(self) -> ProgressBarAdapter:
+        return self.convert.pbar
+
+    def set_pbar(self, p: ProgressBarAdapter):
+        self.convert.set_pbar(p)
+
+    def add_file(self, file: File) -> None:
+        self.convert.collection_images.add_file_image(file)
+
+    def add_files(self, files: list[File]) -> None:
+        self.convert.collection_images.add_files_image(files)
+
+    def add_image(self, image: ImageObject) -> None:
+        self.convert.collection_images.add_image(image)
+
+    def add_images(self, images: list[ImageObject]) -> None:
+        self.convert.collection_images.add_images(images)
+
+    def add_directory(self, src_dir: Directory, max_files: int = 4000) -> None:
+        self.convert.collection_images.add_directory_images(src_dir, max_files=max_files)
+
+    def to_document(self, land_scape: bool = True, *, a4: bool = False) -> DocumentPdf:
+        return self.convert.to_document(land_scape, a4=a4)
+
+    def to_file_pdf(self, output_file: File, *, land_scape: bool = True, a4: bool = False) -> None:
+        self.convert.to_file_pdf(output_file, land_scape=land_scape, a4=a4)
+
+    def set_gausian_blur(self, sigma: float = 0.8) -> None:
+        self.convert.collection_images.set_gausian_blur(sigma)
+
+    def set_land_scape(self):
+        self.convert.collection_images.set_land_scape()

convert_stream-2.5.1/convert_stream/convert/pdf_to_image.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+#
+"""
+    Módulo para trabalhar com imagens
+"""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+
+from sheet_stream.type_utils import MetaDataFile
+
+from convert_stream import CollectionImages
+from soup_files import Directory, ProgressBarAdapter, CreatePbar
+from convert_stream.mod_types.enums import LibPdfToImage
+from convert_stream.mod_types.modules import DEFAULT_LIB_PDF_TO_IMG, DEFAULT_LIB_IMAGE, LibPDF
+from convert_stream.image.img_object import ImageObject, LibImage
+from convert_stream.pdf.pdf_document import DocumentPdf
+
+
+try:
+    import fitz
+    MOD_FITZ = True
+except ImportError:
+    try:
+        import pymupdf as fitz
+        from pymupdf import Page, Pixmap
+        MOD_FITZ = True
+    except ImportError:
+        fitz = object
+        fitz.Page = object
+        fitz.TextPage = object
+        Page = object
+        Pixmap = object
+
+
+class ABCConvertPdf(ABC):
+
+    def __init__(self, document: DocumentPdf):
+        self.document: DocumentPdf = document
+        self.lib_pdf_to_image: LibPdfToImage = DEFAULT_LIB_PDF_TO_IMG
+        self.pbar: ProgressBarAdapter = CreatePbar().get()
+
+    def set_pbar(self, pbar: ProgressBarAdapter):
+        self.pbar = pbar
+
+    @abstractmethod
+    def to_images(
+                self, *,
+                dpi: int = 150,
+                lib_image: LibImage = DEFAULT_LIB_IMAGE,
+            ) -> list[ImageObject]:
+        """
+            Converte as páginas PDF do documento em lista de objetos imagem ImageObject
+
+        :param dpi: DPI do documento, resolução da renderização.
+        :param lib_image: Biblioteca para manipular imagens PIL/OpenCv
+        """
+        pass
+
+    @abstractmethod
+    def to_files_image(
+            self,
+            output_dir: Directory, *,
+            replace: bool = False,
+            gaussian_filter: bool = False,
+            dpi: int = 300,
+            lib_image: LibImage = DEFAULT_LIB_IMAGE,
+            ) -> None:
+        """
+            Converte todas as páginas do documento em objeto de imagem e salva no disco
+        em formato de imagem PNG.
+        """
+        pass
+
+
+class ImplementConvertPdfFitz(ABCConvertPdf):
+
+    def __init__(self, document: DocumentPdf):
+        super().__init__(document)
+        self.lib_pdf_to_image: LibPdfToImage = LibPdfToImage.PDF_TO_IMG_FITZ
+
+    def __get_pages(self) -> list[Page]:
+        pages = self.document.to_pages()
+        fitz_pages = []
+        for p in pages:
+            fitz_pages.append(p.implement_page_pdf.mod_page)
+        return fitz_pages
+
+    def to_images(
+                self, *,
+                dpi: int = 200,
+                lib_image: LibImage = LibImage.PIL
+            ) -> list[ImageObject]:
+        """
+            Converte um Documento em lista de objetos ImageObject.
+        """
+        images: list[ImageObject] = []
+        _metadata: MetaDataFile = self.document.metadata
+
+        pages_fitz: list[Page] = self.__get_pages()
+        _count = len(pages_fitz)
+        for n, pg in enumerate(pages_fitz):
+            self.pbar.update(
+                ((n+1)/_count) * 100,
+                f'[Documento para Imagens]: página {n+1}/{_count}'
+            )
+            pix: Pixmap = pg.get_pixmap(dpi=dpi)
+            img = ImageObject.create_from_bytes(
+                pix.tobytes('png', jpg_quality=100),
+                lib_image=LibImage.PIL,
+            )
+            img.metadata.name = _metadata.name
+            img.metadata.file_path = _metadata.file_path
+            images.append(img)
+        return images
+
+    def to_files_image(
+                self,
+                output_dir: Directory, *,
+                replace: bool = False,
+                gaussian_filter: bool = False,
+                dpi: int = 300,
+                lib_image: LibImage = LibImage.PIL
+            ) -> None:
+        pages_fitz: list[Page] = self.__get_pages()
+        _count = len(pages_fitz)
+        for n, pg in enumerate(pages_fitz):
+            self.pbar.update(
+                ((n + 1) / _count) * 100,
+                f'[Documento para arquivos de imagens]: {n + 1}/{_count}'
+            )
+            out_file = output_dir.join_file(f'pag-{n+1}.png')
+            if not replace:
+                if out_file.exists():
+                    self.pbar.update_text(f'Pulando: {out_file.basename()}')
+                    continue
+            pix: Pixmap = pg.get_pixmap(dpi=dpi)
+            img = ImageObject.create_from_bytes(
+                pix.tobytes('png', jpg_quality=100),
+                lib_image=LibImage.PIL,
+            )
+            img.to_file(out_file)
+        print()
+
+
+class ConvertPdfToImages(object):
+
+    def __init__(self, mod_conv_to_img: ABCConvertPdf | DocumentPdf):
+        if isinstance(mod_conv_to_img, ABCConvertPdf):
+            self.mod_convert_to_image: ABCConvertPdf = mod_conv_to_img
+        elif isinstance(mod_conv_to_img, ImplementConvertPdfFitz):
+            self.mod_convert_to_image: ABCConvertPdf = mod_conv_to_img
+        elif isinstance(mod_conv_to_img, DocumentPdf):
+            self.mod_convert_to_image = ImplementConvertPdfFitz(mod_conv_to_img)
+        else:
+            raise NotImplementedError()
+
+    def set_pbar(self, pbar: ProgressBarAdapter):
+        self.mod_convert_to_image.set_pbar(pbar)
+
+    def to_images(
+                self, *,
+                dpi: int = 300,
+                lib_image: LibImage = LibImage.PIL,
+            ) -> list[ImageObject]:
+        return self.mod_convert_to_image.to_images(dpi=dpi, lib_image=lib_image)
+
+    def to_files_image(
+                self,
+                output_dir: Directory, *,
+                replace: bool = False,
+                gaussian_filter: bool = False,
+                dpi: int = 300,
+                lib_image: LibImage = LibImage.PIL,
+            ) -> None:
+        self.mod_convert_to_image.to_files_image(
+            dpi=dpi,
+            lib_image=lib_image,
+            replace=replace,
+            output_dir=output_dir,
+            gaussian_filter=gaussian_filter
+        )
+
+    def inner_images(self) -> CollectionImages:
+        """
+            Extrair imagens embutidas nas páginas PDF.
+        """
+        # doc = Document(stream=page_bytes, filetype="pdf")
+        collection_imgs: CollectionImages = CollectionImages([])
+        tmp_doc: fitz.Document
+        if self.mod_convert_to_image.document.lib_pdf == LibPDF.FITZ:
+            tmp_doc: fitz.Document = self.mod_convert_to_image.document.get_real_document()
+        elif self.mod_convert_to_image.document.lib_pdf == LibPDF.PYPDF:
+            tmp_doc = fitz.Document(
+                stream=self.mod_convert_to_image.document.to_bytes().getvalue(), filetype="pdf"
+            )
+        else:
+            raise NotImplementedError()
+
+        page: fitz.Page
+        for num, page in enumerate(tmp_doc):
+            # Extrair imagens embutidas na página
+            images_list: list = page.get_images(full=True)
+            for img in images_list:
+                try:
+                    # Referência do objeto da imagem
+                    xref = img[0]
+                    # Extrair imagem
+                    base_image = tmp_doc.extract_image(xref)
+                    # Bytes da imagem
+                    image_bytes = base_image["image"]
+                    # Extensão (jpg, png, etc.)
+                    #image_ext = base_image["ext"]
+                except Exception as e:
+                    print(e)
+                else:
+                    img = ImageObject(image_bytes)
+                    collection_imgs.append(img)
+        return collection_imgs
+
+    @classmethod
+    def create(cls, doc: DocumentPdf) -> ConvertPdfToImages:
+        _mod = ImplementConvertPdfFitz(doc)
+        return cls(_mod)

{convert_stream-2.5 → convert_stream-2.5.1}/convert_stream.egg-info/PKG-INFO

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

{convert_stream-2.5 → convert_stream-2.5.1}/convert_stream.egg-info/SOURCES.txt

@@ -10,6 +10,9 @@ convert_stream.egg-info/SOURCES.txt
 convert_stream.egg-info/dependency_links.txt
 convert_stream.egg-info/requires.txt
 convert_stream.egg-info/top_level.txt
+convert_stream/convert/__init__.py
+convert_stream/convert/image_to_pdf.py
+convert_stream/convert/pdf_to_image.py
 convert_stream/image/__init__.py
 convert_stream/image/img_object.py
 convert_stream/mod_types/__init__.py

{convert_stream-2.5 → convert_stream-2.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "convert_stream"
-version = "2.5"
+version = "2.5.1"
 authors = [
   { name="Bruno Chaves"},
 ]
@@ -30,6 +30,7 @@ dependencies = [
 [tool.setuptools]
 packages = [
     "convert_stream",
+    "convert_stream.convert",
     "convert_stream.mod_types",
     "convert_stream.pdf",
     "convert_stream.image",