convert-stream 2.2.7__tar.gz → 2.3.1__tar.gz

{convert_stream-2.2.7 → convert_stream-2.3.1}/PKG-INFO

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

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream/__init__.py

@@ -88,3 +88,13 @@ def read_image(image: Union[str, File, bytes, BytesIO]) -> PdfStream:
     return _pdf_stream
 
 
+def merge(stream: list[PdfStream]) -> PdfStream:
+    if len(stream) == 0:
+        raise ValueError()
+    if len(stream) == 1:
+        return stream[0]
+    else:
+        s = stream[0]
+        for pdf_stream in stream[1:]:
+            s.add_pages(pdf_stream.to_document().to_pages())
+        return s

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream/doc_stream.py

@@ -8,7 +8,6 @@ from convert_stream.enum_libs.modules import (
     DEFAULT_LIB_PDF, DEFAULT_LIB_IMAGE, DEFAULT_LIB_PDF_TO_IMG, DEFAULT_LIB_IMAGE_TO_PDF,
 )
 from convert_stream.enum_libs.enums import LibPDF, LibImage, LibImageToPdf, LibPdfToImage
-from convert_stream.text.string import FindText
 from convert_stream.pdf.pdf_page import PageDocumentPdf
 from convert_stream.image.img_object import ImageObject, CollectionImages
 from convert_stream.pdf.pdf_document import DocumentPdf, CollectionPagePdf
@@ -108,22 +107,43 @@ class PdfStream(object):
     def add_directory_image(self, src_dir: Directory, max_files: int = 4000) -> None:
         self.collection_images.add_directory_images(src_dir, max_files=max_files)
 
-    def to_document(self) -> DocumentPdf:
+    def to_document(self, *, land_scape: bool = False, a4: bool = False) -> DocumentPdf:
+        """
+
+            Converte os documentos adicionados em PdfStream (imagens/pdfs) em
+        objeto do tipo DocumentPdf().
+        """
         if self.collection_pages.is_null and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
+
         _doc = None
-        if not self.collection_pages.is_null:
-            _doc = DocumentPdf.create_from_pages(self.collection_pages.pages)
         if not self.collection_images.is_empty:
-            _convert_img_to_pdf = ConvertImageToPdf(self.collection_images)
-            _pages = _convert_img_to_pdf.to_document().to_pages()
-            self.collection_images.clear()
+            _convert = ConvertImageToPdf(self.collection_images, lib_img_to_pdf=self.lib_img_to_pdf)
+            _doc: DocumentPdf = _convert.to_document(land_scape, a4=a4)
+        if not self.collection_pages.is_null:
             if _doc is None:
-                _doc = DocumentPdf.create_from_pages(_pages)
+                _doc: DocumentPdf = self.collection_pages.to_document(self.lib_pdf)
             else:
-                _doc.add_pages(_pages)
+                _doc.add_pages(self.collection_pages.pages)
         return _doc
 
+    def thresold(self, *, land_scape: bool = False, a4: bool = False, dpi=300) -> DocumentPdf:
+        images: list[ImageObject] = self.collection_images.images
+        if not self.collection_pages.is_null:
+            tmp_doc = DocumentPdf.create_from_pages(self.collection_pages.pages)
+            conv_pdf_to_img = ConvertPdfToImages.create(tmp_doc)
+            images.extend(conv_pdf_to_img.to_images(dpi=dpi))
+            del tmp_doc
+        if len(images) == 0:
+            raise ValueError('Adicione imagens para prosseguir!')
+        if land_scape:
+            for img in images:
+                img.set_landscape()
+        for i in images:
+            i.set_threshold_gray()
+        conv_img_to_pdf = ConvertImageToPdf(CollectionImages(images), lib_img_to_pdf=self.lib_img_to_pdf)
+        return conv_img_to_pdf.to_document(a4=a4)
+
     def to_files_images(
                 self,
                 output_dir: Directory, *,
@@ -134,16 +154,20 @@ class PdfStream(object):
         if self.collection_pages.is_null and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
         self.progress.start()
+
+        image_stream = ImageStream()
+        if not self.collection_images.is_empty:
+            image_stream.add_images(self.collection_images.images)
         if not self.collection_pages.is_null:
             self.progress.update_text('Processando Imagens')
             # Criar um documento a partir das páginas
             doc_pdf = DocumentPdf.create_from_pages(self.collection_pages.pages)
             convert_pdf_to_img = ConvertPdfToImages.create(doc_pdf)
             # Converter as páginas PDF em imagens e adicionar a coleção já existe de imagens.
-            self.collection_images.add_images(convert_pdf_to_img.to_images(dpi=dpi))
-            self.collection_pages.clear()
+            _pdf_to_images: list[ImageObject] = convert_pdf_to_img.to_images(dpi=dpi)
+            image_stream.add_images(_pdf_to_images)
         # Exportar para arquivos.
-        self.collection_images.to_files_image(output_dir, replace=replace, land_scape=land_scape)
+        image_stream.to_files_image(output_dir, replace=replace, land_scape=land_scape)
         self.progress.stop()
 
     def to_files_pdf(
@@ -151,21 +175,27 @@ class PdfStream(object):
                 output_dir: Directory, *,
                 replace: bool = False,
                 land_scape: bool = False,
+                a4: bool = False,
+                prefix: str = None,
             ) -> None:
         if self.collection_pages.is_null and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
+        pages_document = []
         if not self.collection_pages.is_null:
-            convert_img_to_pdf = ConvertImageToPdf(self.collection_images)
-            self.collection_pages.add_pages(convert_img_to_pdf.to_document().to_pages())
-            self.collection_images.clear()
+            pages_document.extend(self.collection_pages.pages)
+        if not self.collection_images.is_empty:
+            img_to_pdf = ConvertImageToPdf(self.collection_images, lib_img_to_pdf=self.lib_img_to_pdf)
+            tmp_document = img_to_pdf.to_document(land_scape, a4=a4)
+            pages_document.extend(tmp_document.to_pages())
+        final_collection = CollectionPagePdf(pages_document)
         if land_scape:
-            self.collection_pages.set_land_scape()
-        self.collection_pages.to_files_pdf(output_dir, replace=replace)
+            final_collection.set_land_scape()
+        final_collection.to_files_pdf(output_dir, replace=replace, prefix=prefix)
 
 
 class SplitPdf(object):
 
-    def __init__(self, pages: list[PageDocumentPdf], pbar: ProgressBarAdapter = ProgressBarAdapter()):
+    def __init__(self, pages: list[PageDocumentPdf] = [], pbar: ProgressBarAdapter = ProgressBarAdapter()):
         self.pbar: ProgressBarAdapter = pbar
         self.__collection_pages: CollectionPagePdf = CollectionPagePdf(pages)
         self.__collection_pages.set_pbar(self.pbar)
@@ -173,6 +203,9 @@ class SplitPdf(object):
     def is_empty(self) -> bool:
         return self.__collection_pages.is_null
 
+    def add_pages_pdf(self, pages: list[PageDocumentPdf]) -> None:
+        self.__collection_pages.add_pages(pages)
+
     def export(self, output_dir: Directory, *, replace: bool = False, prefix: str = 'pag') -> None:
         if self.is_empty():
             self.pbar.update_text(f'O Documento está vazio!')

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream/enum_libs/modules.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 from __future__ import annotations
-from typing import Union, TypeAlias
+from typing import Union, TypeAlias #, Any
 from convert_stream.enum_libs.enums import *
 
 MOD_IMG_PIL: bool = False
@@ -10,6 +10,17 @@ MOD_PYPDF: bool = False
 MOD_FITZ: bool = False
 MOD_CANVAS: bool = False
 
+
+class FakeType(object):
+    Image = object
+    MatLike = object
+    TextPage = object
+    Page = object
+    
+    def __init__(self):
+        pass
+
+
 #=================================================================#
 # Módulos de Imagen, PIL e opencv
 #=================================================================#
@@ -18,16 +29,16 @@ try:
     from cv2.typing import MatLike
     MOD_IMG_OPENCV = True
 except ImportError:
-    cv2.typing.MatLike = object
-    MatLike = None
+    #cv2.typing.MatLike = FakeType
+    MatLike = FakeType
 
 try:
     from PIL import Image
     from PIL import ImageOps, ImageFilter
     MOD_IMG_PIL = True
 except ImportError:
-    Image = None
-    Image.Image = None
+    Image = FakeType
+    Image.Image = FakeType
 
 if MOD_IMG_OPENCV and MOD_IMG_PIL:
     ModuleImage: TypeAlias = Union[MatLike, Image.Image]
@@ -40,7 +51,7 @@ elif MOD_IMG_PIL:
     DEFAULT_LIB_IMAGE = LibImage.PIL
 else:
     DEFAULT_LIB_IMAGE = LibImage.NOT_IMPLEMENTED
-    ModuleImage = None  # fallback para runtime
+    ModuleImage = FakeType  # fallback para runtime
 
 #=================================================================#
 # Módulos para PDF fitz e pypdf
@@ -54,17 +65,17 @@ except ImportError:
         import pymupdf as fitz
         MOD_FITZ = True
     except ImportError:
-        fitz = object
-        fitz.Page = object
-        fitz.TextPage = object
+        fitz = FakeType
+        fitz.Page = FakeType
+        fitz.TextPage = FakeType
 
 try:
     from pypdf import PdfWriter, PdfReader, PageObject
     MOD_PYPDF = True
 except ImportError:
-    PageObject = None
-    PdfReader = None
-    PdfWriter = None
+    PageObject = FakeType
+    PdfReader = FakeType
+    PdfWriter = FakeType
 
 
 if MOD_FITZ and MOD_PYPDF:
@@ -80,8 +91,8 @@ elif MOD_PYPDF:
     ModDocPdf = Union[PdfWriter]
     DEFAULT_LIB_PDF = LibPDF.PYPDF
 else:
-    ModPagePdf = None  # fallback para runtime
-    ModDocPdf = None
+    ModPagePdf = FakeType  # fallback para runtime
+    ModDocPdf = FakeType
     DEFAULT_LIB_PDF = LibPDF.NOT_IMPLEMENTED
 
 #=================================================================#
@@ -95,10 +106,10 @@ try:
     from reportlab.lib.utils import ImageReader
     MOD_CANVAS = True
 except ImportError:
-    canvas = None
-    Canvas = None
+    canvas = FakeType
+    Canvas = FakeType
     letter = (612, 792)
-    ImageReader = None
+    ImageReader = FakeType
 
 if MOD_CANVAS and MOD_FITZ and MOD_IMG_PIL:
     ModImageToPdf: TypeAlias = Union[canvas, fitz.Page, Image]
@@ -113,7 +124,7 @@ elif MOD_IMG_PIL:
     ModImageToPdf: TypeAlias = Union[Image]
     DEFAULT_LIB_IMAGE_TO_PDF = LibImageToPdf.IMAGE_TO_PDF_PIL
 else:
-    ModImageToPdf = None
+    ModImageToPdf = FakeType
     DEFAULT_LIB_IMAGE_TO_PDF = LibImageToPdf.NOT_IMPLEMENTED
 
 #=================================================================#
@@ -125,4 +136,4 @@ if MOD_FITZ:
     ModPdfToImage: TypeAlias = Union[fitz]
 else:
     DEFAULT_LIB_PDF_TO_IMG = LibPdfToImage.NOT_IMPLEMENTED
-    ModPdfToImage = None
+    ModPdfToImage = FakeType

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream/image/img_object.py

@@ -4,6 +4,7 @@
     Módulo para trabalhar com imagens
 """
 from __future__ import annotations
+from typing import Union
 from abc import ABC, abstractmethod
 from hashlib import md5 as md5_hash
 from soup_files import File, Directory, InputFiles, LibraryDocs, ProgressBarAdapter
@@ -63,11 +64,11 @@ class ABCImageObject(ABC):
         pass
 
     @abstractmethod
-    def set_background_black(self):
+    def set_threshold_black(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
         pass
 
     @abstractmethod
-    def set_background_gray(self):
+    def set_threshold_gray(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
         pass
 
     @abstractmethod
@@ -114,7 +115,8 @@ class ImplementOpenCv(ABCImageObject):
 
     def set_landscape(self):
         if self.is_vertical():
-            self.set_rotation(RotationAngle.ROTATION_90)
+            #self.set_rotation(RotationAngle.ROTATION_90)
+            self.module_image = cv2.rotate(self.module_image, cv2.ROTATE_90_COUNTERCLOCKWISE)
 
     def set_vertical(self):
         if self.is_landscape():
@@ -128,36 +130,10 @@ class ImplementOpenCv(ABCImageObject):
         elif angle == RotationAngle.ROTATION_270:
             self.module_image = cv2.rotate(self.module_image, cv2.ROTATE_90_COUNTERCLOCKWISE)
 
-    def set_gausian_blur(self, sigma: float = 0.7):
-        # 1. Converte para escala de cinza
-        gray = cv2.cvtColor(self.module_image, cv2.COLOR_BGR2GRAY)
-
-        # 2. Detecta o texto com threshold adaptativo
-        #    Texto ficará branco (255) e fundo preto (0)
-        text_mask = cv2.adaptiveThreshold(
-            gray, 160,
-            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-            cv2.THRESH_BINARY_INV,
-            25, 15
-        )
-
-        # 3. Inverte máscara (fundo branco, texto preto)
-        background_mask = cv2.bitwise_not(text_mask)
-
-        # 4. Borra apenas o fundo
-        blurred_background = cv2.GaussianBlur(gray, (0, 0), sigma)
-
-        # 5. Combina: fundo borrado + texto nítido
-        text_part = cv2.bitwise_and(gray, gray, mask=text_mask)
-        background_part = cv2.bitwise_and(blurred_background, blurred_background, mask=background_mask)
-        combined = cv2.add(text_part, background_part)
-
-        # 6. Realça contraste (texto mais escuro, fundo mais claro)
-        combined = cv2.normalize(combined, None, 0, 255, cv2.NORM_MINMAX)
-        combined = cv2.convertScaleAbs(combined, alpha=1.5, beta=20)
-
-        # 7. Salva de volta em BGR
-        self.module_image = cv2.cvtColor(combined, cv2.COLOR_GRAY2BGR)
+    def set_gausian_blur(self, sigma: float = 0.5):
+        # Aplica um filtro Gaussiano para reduzir o ruído
+        _blurred: MatLike = cv2.GaussianBlur(self.module_image, (3, 3), sigma)
+        self.module_image = _blurred
 
     def set_background_blur(self, sigma: float):
         # 1. Converter para escala de cinza
@@ -175,42 +151,39 @@ class ImplementOpenCv(ABCImageObject):
         # 5. Converter de volta para BGR
         self.module_image = cv2.cvtColor(norm, cv2.COLOR_GRAY2BGR)
 
-    def set_background_black(self):
-        mask = cv2.cvtColor(self.module_image, cv2.COLOR_BGR2GRAY)
-        _, mask = cv2.threshold(mask, 200, 255, cv2.THRESH_BINARY)
-        mask_inv = cv2.bitwise_not(mask)
-        self.module_image = cv2.bitwise_and(self.module_image, self.module_image, mask=mask_inv)
-
-    def set_background_gray(self):
-        # 1. Converte para escala de cinza
-        gray = cv2.cvtColor(self.module_image, cv2.COLOR_BGR2GRAY)
-
-        # 2. Detecta o texto (texto=branco, fundo=preto)
-        text_mask = cv2.adaptiveThreshold(
-            gray, 200,
+    def set_threshold_black(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
+        nparr = np.frombuffer(self.to_bytes().getvalue(), np.uint8)
+        img_opencv: cv2.typing.MatLike = cv2.imdecode(nparr, cv2.IMREAD_GRAYSCALE)
+        # Aplica um filtro Gaussiano para reduzir o ruído
+        _blurred: cv2.typing.MatLike = cv2.GaussianBlur(img_opencv, (3, 3), sigma)
+        # Aplica binarização adaptativa (texto branco, fundo preto)
+        binary: cv2.typing.MatLike = cv2.adaptiveThreshold(
+            _blurred,
+            max_value,
             cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-            cv2.THRESH_BINARY_INV,
-            25, 15
+            cv2.THRESH_BINARY,
+            11,
+            2
         )
+        self.module_image = cv2.bitwise_not(binary)
 
-        # 3. Inverte máscara para pegar fundo
-        background_mask = cv2.bitwise_not(text_mask)
+    def set_threshold_gray(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
+        nparr = np.frombuffer(self.to_bytes().getvalue(), np.uint8)
+        img_opencv: cv2.typing.MatLike = cv2.imdecode(nparr, cv2.IMREAD_GRAYSCALE)
 
-        # 4. Cria fundo uniforme cinza claro
-        gray_bg_value = 200  # tom claro de cinza (0=preto, 255=branco)
-        background = np.full_like(gray, gray_bg_value, dtype=np.uint8)
+        # Aplica um filtro Gaussiano para reduzir o ruído
+        _blurred: cv2.typing.MatLike = cv2.GaussianBlur(img_opencv, (3, 3), sigma)
 
-        # 5. Deixa texto bem escuro
-        text_dark_value = 30
-        text_layer = np.full_like(gray, text_dark_value, dtype=np.uint8)
-
-        # 6. Combina texto escuro com fundo cinza
-        text_part = cv2.bitwise_and(text_layer, text_layer, mask=text_mask)
-        background_part = cv2.bitwise_and(background, background, mask=background_mask)
-        combined = cv2.add(text_part, background_part)
-
-        # 7. Salva em BGR
-        self.module_image = cv2.cvtColor(combined, cv2.COLOR_GRAY2BGR)
+        # Aplica binarização adaptativa (texto preto, fundo branco)
+        binary = cv2.adaptiveThreshold(
+            _blurred,
+            max_value,
+            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY_INV,  # Inverte o texto para ser branco inicialmente
+            11,
+            2
+        )
+        self.module_image = cv2.bitwise_not(binary)
 
     def to_file(self, file: File):
         #print(f'Exportando arquivo: {file.basename()}')
@@ -317,19 +290,18 @@ class ImplementPIL(ABCImageObject):
         img.paste(blurred, mask=mask)
         self.module_image = img
 
-    def set_background_black(self):
+    def set_threshold_black(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
         img = self.module_image.convert("RGBA")
         gray = img.convert("L")
         mask = gray.point(lambda p: 255 if p > 200 else 0).convert("1")
-        black_bg = Image.new("RGBA", img.size, (0, 0, 0, 255))
+        black_bg = Image.new("RGBA", img.size, (0, 0, 0, max_value))
         img.paste(black_bg, mask=mask)
         self.module_image = img
 
-    def set_background_gray(self):
+    def set_threshold_gray(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
         if not MOD_IMG_PIL:
             raise RuntimeError("PIL não está disponível.")
-
-            # 1. Converte para escala de cinza
+        # 1. Converte para escala de cinza
         gray_img = self.module_image.convert("L")
 
         # 2. Detecta o texto usando um threshold adaptativo (via NumPy)
@@ -343,11 +315,8 @@ class ImplementPIL(ABCImageObject):
 
         # 3. Máscara do fundo (inverso)
         mask_background = 255 - mask_text
-
         # 4. Cria fundo cinza claro
-        gray_bg_value = 200
-        background_np = np.full_like(img_np, gray_bg_value, dtype=np.uint8)
-
+        background_np = np.full_like(img_np, max_value, dtype=np.uint8)
         # 5. Texto escuro
         text_dark_value = 30
         text_np = np.full_like(img_np, text_dark_value, dtype=np.uint8)
@@ -355,7 +324,6 @@ class ImplementPIL(ABCImageObject):
         # 6. Combina texto escuro com fundo cinza
         combined_np = ((text_np * (mask_text // 255)) +
                        (background_np * (mask_background // 255))).astype(np.uint8)
-
         # 7. Converte de volta para PIL (BGR → RGB não é necessário, pois estamos em L)
         self.module_image = Image.fromarray(combined_np).convert("RGB")
 
@@ -387,9 +355,48 @@ class ImplementPIL(ABCImageObject):
 
 class ImageObject(object):
 
-    def __init__(self, img_adapter: ABCImageObject) -> None:
-        self.img_adapter: ABCImageObject = img_adapter
-        self.name: str = img_adapter.name
+    def __init__(
+                self, img: Union[ABCImageObject, bytes, BytesIO, str, File],
+                *, lib_image: LibImage = DEFAULT_LIB_IMAGE,
+            ) -> None:
+        #
+        if isinstance(img, ABCImageObject):
+            self.img_adapter: ABCImageObject = img
+        elif isinstance(img, bytes):
+            if lib_image == LibImage.OPENCV:
+                self.img_adapter = ImplementOpenCv.create_from_bytes(img)
+            elif lib_image == LibImage.PIL:
+                self.img_adapter = ImplementPIL.create_from_bytes(img)
+            else:
+                raise ValueError('Use: PIL ou OPENCV')
+        elif isinstance(img, BytesIO):
+            img.seek(0)
+            if lib_image == LibImage.OPENCV:
+                self.img_adapter = ImplementOpenCv.create_from_bytes(img.getvalue())
+            elif lib_image == LibImage.PIL:
+                self.img_adapter = ImplementPIL.create_from_bytes(img.getvalue())
+            else:
+                raise ValueError('Use: PIL ou OPENCV')
+        elif isinstance(img, File):
+            if lib_image == LibImage.OPENCV:
+                self.img_adapter = ImplementOpenCv.create_from_file(img)
+            elif lib_image == LibImage.PIL:
+                self.img_adapter = ImplementPIL.create_from_file(img)
+            else:
+                raise ValueError('Use: PIL ou OPENCV')
+        elif isinstance(img, str):
+            if lib_image == LibImage.OPENCV:
+                self.img_adapter = ImplementOpenCv.create_from_file(File(img))
+            elif lib_image == LibImage.PIL:
+                self.img_adapter = ImplementPIL.create_from_file(File(img))
+            else:
+                raise ValueError('Use: PIL ou OPENCV')
+        else:
+            raise ValueError('Use: str, bytes, BytesIO, File, OPENCV or PIL')
+
+    @property
+    def name(self) -> str:
+        return self.img_adapter.name
 
     def to_pil(self) -> Image.Image:
         """
@@ -425,17 +432,17 @@ class ImageObject(object):
     def set_rotation(self, angle: RotationAngle = RotationAngle.ROTATION_90) -> None:
         self.img_adapter.set_rotation(angle)
 
-    def set_gausian_blur(self, sigma: float = 0.7):
+    def set_gausian_blur(self, sigma: float = 0.5):
         self.img_adapter.set_gausian_blur(sigma)
 
     def set_background_blur(self, sigma: float):
         self.img_adapter.set_background_blur(sigma)
 
-    def set_background_black(self):
-        self.img_adapter.set_background_black()
+    def set_threshold_black(self, *, max_value: float = 150, sigma: float = 0.5) -> None:
+        self.img_adapter.set_threshold_black(max_value=max_value, sigma=sigma)
 
-    def set_background_gray(self):
-        self.img_adapter.set_background_gray()
+    def set_threshold_gray(self, *, max_value: float = 150, sigma: float = 0.5):
+        self.img_adapter.set_threshold_gray(max_value=max_value, sigma=sigma)
 
     def to_file(self, file: File):
         self.img_adapter.to_file(file)
@@ -474,7 +481,7 @@ class CollectionImages(object):
     
     def __init__(self, images: list[ImageObject] = []) -> None:
         """
-
+            Gerir uma lista de Imagens
         :type images: list[ImageObject]
         """
         self.images: list[ImageObject] = images
@@ -550,7 +557,7 @@ class CollectionImages(object):
                 img.set_landscape()
             if gaussian_filter:
                 img.set_gausian_blur()
-                img.set_background_gray()
+                img.set_threshold_gray()
             try:
                 img.to_file(file_path)
             except Exception as e:
@@ -571,7 +578,7 @@ class CollectionImages(object):
                 f'Aplicando GausianBlur: [{_num + 1} de {max_num}]'
             )
             im.set_gausian_blur(sigma)
-            im.set_background_gray()
+            im.set_threshold_gray()
         print()
         self.pbar.stop()
 

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream/pdf/pdf_document.py

@@ -27,6 +27,9 @@ class SearchableTextPdf(object):
     """
     def __init__(self, silent: bool = False):
         self.silent = silent
+        # Cada elemento encontrado na busca de texto, será guardado nesse objeto para
+        # posterior consulta (self.elements), cada chave aqui deve ter uma lista de
+        # tamanho igual.
         self.elements: dict[str, list[str]] = {
             ColumnsTable.NUM_PAGE.value: [],
             ColumnsTable.NUM_LINHA.value: [],
@@ -117,7 +120,12 @@ class SearchableTextPdf(object):
 
 
 class ABCDocument(ABC):
-
+    """
+        Classe molde para gerir os documentos, para operações como:
+    - leitura e escrita de arquivos pdf
+    - exportar páginas ou arquivos pdf
+    - permitir a leitura de arquivos ou bytes de pdf.
+    """
     def __init__(self, mod_doc_pdf: ModDocPdf, name: str):
         self.mod_doc_pdf: ModDocPdf = mod_doc_pdf
         self.lib_pdf: LibPDF = DEFAULT_LIB_PDF
@@ -169,7 +177,9 @@ class ABCDocument(ABC):
 
 
 class ImplementDocumentFitz(ABCDocument):
-
+    """
+        Implementação usando a biblioteca fitz.
+    """
     def __init__(self, mod_doc_pdf: ModDocPdf, name: str):
         super().__init__(mod_doc_pdf, name)
         self.mod_doc_pdf: ModDocPdf = mod_doc_pdf
@@ -255,6 +265,9 @@ class ImplementDocumentFitz(ABCDocument):
 
 
 class ImplementDocumentPyPdf(ABCDocument):
+    """
+        Implementação usando a biblioteca pypdf
+    """
 
     def __init__(self, mod_doc_pdf: PdfWriter, name: str):
         super().__init__(mod_doc_pdf, name)
@@ -353,13 +366,20 @@ class ImplementDocumentPyPdf(ABCDocument):
 
 
 class DocumentPdf(object):
+    """
+        Gerir um documento PDF com uma implementação de fitz ou pypdf.
+    As operações são feitas pela classe encapsulada aqui.
+    """
     def __init__(
                 self,
-                document: Union[str, File, PdfWriter, fitz.Document, BytesIO],
+                document: Union[
+                    str, File, PdfWriter, fitz.Document, BytesIO,
+                    ImplementDocumentFitz, ImplementDocumentPyPdf,
+                ],
                 *,
                 lib_pdf: LibPDF = LibPDF.FITZ
             ):
-        self.doc_pdf = None
+        self.doc_pdf: ABCDocument = None
         self.lib_pdf: LibPDF = lib_pdf
         if isinstance(document, str):
             if lib_pdf == LibPDF.PYPDF:
@@ -415,7 +435,6 @@ class DocumentPdf(object):
         """
         Retorna a primeira página do documento.
         """
-        # O índice da primeira página em PyPDF2 é 0.
         return self.doc_pdf.get_first_page()
 
     def get_last_page(self) -> PageDocumentPdf:
@@ -597,7 +616,9 @@ class DocumentPdf(object):
 
 
 class CollectionPagePdf(object):
-
+    """
+        Gerir uma coleção de páginas PDF.
+    """
     def __init__(self, pages: list[PageDocumentPdf] = list()) -> None:
         self.pages: list[PageDocumentPdf] = pages
         self.pbar: ProgressBarAdapter = ProgressBarAdapter()
@@ -622,6 +643,14 @@ class CollectionPagePdf(object):
     def set_pbar(self, p: ProgressBarAdapter):
         self.pbar = p
 
+    def set_land_scape(self):
+        for page in self.pages:
+            page.set_land_scape()
+
+    def set_rotation(self, rotation: int) -> None:
+        for page in self.pages:
+            page.set_rotation(rotation)
+
     def add_page(self, page: PageDocumentPdf) -> None:
         page.number_page = len(self.pages) + 1
         self.pbar.update_text(f'Adicionando página PDF {page.number_page}')

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream/pdf/pdf_page.py

@@ -210,7 +210,7 @@ class ImplementFitz(ABCPagePdf):
             return
         try:
             # Rotaciona para 90 graus
-            self.mod_page.set_rotation(90)
+            self.mod_page.set_rotation(-90)
         except Exception:
             pass
 

{convert_stream-2.2.7 → convert_stream-2.3.1}/convert_stream.egg-info/PKG-INFO

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

{convert_stream-2.2.7 → convert_stream-2.3.1}/pyproject.toml

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