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

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

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

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

@@ -24,14 +24,17 @@ from convert_stream import (
 
 
 def test():
-    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'))
+    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():

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

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

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

@@ -81,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)
@@ -107,6 +109,17 @@ class PdfStream(ABCDocumentStream):
     def add_image(self, image: ImageObject):
         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():
@@ -196,22 +209,25 @@ class PdfStream(ABCDocumentStream):
 class ImageStream(object):
     def __init__(
                 self, *,
-                library_image = LibraryImage.OPENCV,
-                library_pdf = LibraryPDF.PILPDF,
+                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.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.convert_image_to_pdf: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.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_canvas(library_image)
         elif library_pdf == LibraryPDF.PILPDF:
             self.convert_image_to_pdf: ImageConvertPdf = ImageConvertPdf.create_from_pil(library_image)
+        else:
+            raise ValueError(f'PYPDF não pode converter imagens em PDF!!')
             
         # Objeto para converter PDF em imagem
         self.convert_pdf_to_images: ConvertPdfToImage = ConvertPdfToImage(
@@ -220,6 +236,10 @@ class ImageStream(object):
                 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]:
@@ -237,20 +257,33 @@ class ImageStream(object):
     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:
+        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:
+        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:
@@ -264,6 +297,7 @@ class ImageStream(object):
         
     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'
             self.progress_bar.update(
@@ -271,14 +305,22 @@ class ImageStream(object):
                 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:
+        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):

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

@@ -7,41 +7,48 @@ from PIL import Image, ImageOps, ImageFilter
 from cv2.typing import MatLike
 import cv2
 import numpy as np
-
 from soup_files import File
 from convert_stream.models.models_image import LibraryImage, ABCImageObject, ABCInvertColor
 
 #=============================================================================#
 # Inverter cores em imagens
 #=============================================================================#
+
+
 class ImplementInvertColorOpenCv(ABCInvertColor):
     """
         Escurecer texto em imagens.
     """
-    def __init__(self, image_bytes):
+    def __init__(self, image_bytes: bytes):
         super().__init__()
         if not isinstance(image_bytes, bytes):
             raise ValueError(f'{__class__.__name__}\nUse: bytes, não {type(image_bytes)}')
-        self.image_bytes:bytes = image_bytes
+        self.image_bytes: bytes = image_bytes
         
-    def _image_bytes_to_opencv(self, img_bytes:bytes) -> MatLike:
+    def _image_bytes_to_opencv(self, img_bytes: bytes) -> MatLike:
         """Converte os bytes de uma imagem em objeto opencv MatLike"""
         nparr = np.frombuffer(img_bytes, np.uint8)
         return cv2.imdecode(nparr, cv2.IMREAD_GRAYSCALE)
         
     def _image_opencv_tobytes(self, img:MatLike) -> bytes:
         """Convert um objeto opencv MatLike em bytes de imagem"""
-        _, buffer = cv2.imencode('.png', img)  # Codifica como PNG (ou use '.jpg' para JPEG)
-        return buffer.tobytes()  # Obtém os bytes da imagem
+        # Codifica como PNG (ou use '.jpg' para JPEG)
+        _, buffer = cv2.imencode('.png', img)
+        # Obtém os bytes da imagem
+        return buffer.tobytes()
         
     def set_gaussian_blur(self):
         # Aplica um filtro Gaussiano para reduzir o ruído
-        _blurred:MatLike = cv2.GaussianBlur(self._image_bytes_to_opencv(self.image_bytes), (3, 3), 0.5)
+        _blurred: MatLike = cv2.GaussianBlur(
+            self._image_bytes_to_opencv(self.image_bytes),
+            (3, 3),
+            0.5
+        )
         self.image_bytes = self._image_opencv_tobytes(_blurred)
 
-    def __set_black(self):
+    def __set_background_black(self):
         # Aplica binarização adaptativa (texto branco, fundo preto)
-        binary:MatLike = cv2.adaptiveThreshold(
+        binary: MatLike = cv2.adaptiveThreshold(
             self._image_bytes_to_opencv(self.image_bytes),
             150,
             cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
@@ -51,7 +58,7 @@ class ImplementInvertColorOpenCv(ABCInvertColor):
         )
         self.image_bytes = self._image_opencv_tobytes(binary)
         
-    def __set_gray(self):
+    def __set_background_gray(self):
         # Aplica binarização adaptativa (texto preto, fundo branco)
         _binary = cv2.adaptiveThreshold(
             self._image_bytes_to_opencv(self.image_bytes),
@@ -65,17 +72,17 @@ class ImplementInvertColorOpenCv(ABCInvertColor):
 
     def set_background_black(self):
         self.set_gaussian_blur()
-        self.__set_black()
-        _result:MatLike = cv2.bitwise_not(self._image_bytes_to_opencv(self.image_bytes))
+        self.__set_background_black()
+        _result: MatLike = cv2.bitwise_not(self._image_bytes_to_opencv(self.image_bytes))
         self.image_bytes = self._image_opencv_tobytes(_result)
         
     def set_background_gray(self):
         self.set_gaussian_blur()
-        self.__set_gray()
-        _result:MatLike = cv2.bitwise_not(self._image_bytes_to_opencv(self.image_bytes))
+        self.__set_background_gray()
+        _result: MatLike = cv2.bitwise_not(self._image_bytes_to_opencv(self.image_bytes))
         self.image_bytes = self._image_opencv_tobytes(_result)
 
-    def to_file(self, output_path:File):
+    def to_file(self, output_path: File):
         print(f'Salvando: {output_path.basename()}')
         cv2.imwrite(output_path.absolute(), self._image_bytes_to_opencv(self.image_bytes))
         
@@ -99,12 +106,12 @@ class ImplementInvertColorPIL(ABCInvertColor):
         super().__init__()
         if not isinstance(image_bytes, bytes):
             raise ValueError(f'{__class__.__name__}\nUse: bytes, não {type(image_bytes)}')
-        self.image_bytes:bytes = image_bytes
+        self.image_bytes: bytes = image_bytes
         
     def set_gaussian_blur(self):
         img_pil = Image.open(BytesIO(self.image_bytes))
         # Aplicar um desfoque semelhante ao cv2.GaussianBlur
-        blurred:Image.Image = img_pil.filter(ImageFilter.GaussianBlur(radius=1))
+        blurred: Image.Image = img_pil.filter(ImageFilter.GaussianBlur(radius=1))
         buff = BytesIO()
         blurred.save(buff, 'PNG')
         self.image_bytes = buff.getvalue()
@@ -139,7 +146,7 @@ class ImplementInvertColorPIL(ABCInvertColor):
         buff.close()
         
     def to_file(self, output_path: File):
-        img:Image.Image = Image.open(self.image_bytes)
+        img: Image.Image = Image.open(self.image_bytes)
         img.save(output_path.absolute(), 'PNG')
 
     def to_bytes(self) -> bytes:
@@ -157,7 +164,7 @@ class ImageInverColor(ABCInvertColor):
     """
         Escurecer texto em imagens.
     """
-    def __init__(self, invert_color:ABCInvertColor):
+    def __init__(self, invert_color: ABCInvertColor):
         if not isinstance(invert_color, ABCInvertColor):
             raise ValueError(f'{__class__.__name__}\nUse: ABCInvertColor(), não {type(invert_color)}')
         self.invert_color:ABCInvertColor = invert_color
@@ -178,12 +185,15 @@ class ImageInverColor(ABCInvertColor):
         return self.invert_color.to_bytes()
     
     @classmethod
-    def create_from_file(cls, f:File, *, library:LibraryImage=LibraryImage.OPENCV) -> 'ImageInverColor':
-        img:ImageObject = ImageObject.create_from_file(f, library=library)
+    def create_from_file(
+                    cls, f: File, *,
+                    library: LibraryImage = LibraryImage.OPENCV
+            ) -> ImageInverColor:
+        img: ImageObject = ImageObject.create_from_file(f, library=library)
         if library == LibraryImage.OPENCV:
-            inv:ABCInvertColor = ImplementInvertColorOpenCv(f.path.read_bytes())
+            inv: ABCInvertColor = ImplementInvertColorOpenCv(f.path.read_bytes())
         elif library == LibraryImage.PIL:
-            inv:ABCInvertColor = ImplementInvertColorPIL(f.path.read_bytes())
+            inv: ABCInvertColor = ImplementInvertColorPIL(f.path.read_bytes())
         else:
             raise NotImplementedError(
                 f'{__class__.__name__}\nUse: LibraryImage.OPENCV, ou LibraryImage.PIL, não {type(library)}'
@@ -191,49 +201,60 @@ class ImageInverColor(ABCInvertColor):
         return cls(inv)
     
     @classmethod
-    def create_from_bytes(cls, bt:bytes, *, library:LibraryImage=LibraryImage.OPENCV) -> 'ImageInverColor':
+    def create_from_bytes(
+                cls, bt: bytes, *,
+                library: LibraryImage = LibraryImage.OPENCV
+            ) -> ImageInverColor:
         if library == LibraryImage.OPENCV:
-            invert_color:ABCInvertColor = ImplementInvertColorOpenCv(bt)
+            invert_color: ABCInvertColor = ImplementInvertColorOpenCv(bt)
         elif library == LibraryImage.PIL:
-            invert_color:ABCInvertColor = ImplementInvertColorPIL(bt)
+            invert_color: ABCInvertColor = ImplementInvertColorPIL(bt)
         else:
             raise NotImplementedError(
                 f'{__class__.__name__}\nUse: LibraryImage.OPENCV, ou LibraryImage.PIL, não {type(library)}'
             )
         return cls(invert_color)
 
+
 #=============================================================================#
 # Manipulação de imagens
 #=============================================================================#
+
+
 class ImageObjectPIL(ABCImageObject):
     """
         Implementação de ImageObject usando PIL.
     """
-    def __init__(self, image_bytes:bytes):
+    def __init__(self, image_bytes: bytes):
         super().__init__()
         if not isinstance(image_bytes, bytes):
             raise ValueError(f'{__class__.__name__} Use: bytes, não {type(image_bytes)}')
         self.current_library = LibraryImage.PIL
         self.image_bytes = image_bytes
-        self.max_size:Tuple[int, int] = (1980, 720) # Dimensões máximas, altere se necessário.
+        self.max_size: Tuple[int, int] = (1980, 720) # Dimensões máximas, altere se necessário.
         
         try:
-            img = Image.open(BytesIO(image_bytes))
+            image_pil = Image.open(BytesIO(image_bytes))
         except Exception as e:
             raise ValueError(f"{__class__.__name__}\nPIL: Bytes de imagem inválidos")
         else:
-            self.dimensions = img.size
-    
-        # Redimensionar, se as dimensões forem maior que self.max_size.
-        if img.width > self.max_size[0] or img.height > self.max_size[1]:
-            #img.thumbnail(self.max_size, Image.LANCZOS)  # Mantém proporção
-            buff_image:BytesIO = BytesIO()
-            img.save(buff_image, format='PNG', optimize=True, quality=80)
+            self.dimensions = image_pil.size
+
+        # Redimensionar, se as dimensões estiverem maior que self.max_size.
+        if (image_pil.width > self.max_size[0]) or (image_pil.height > self.max_size[1]):
+            #print(f'{__class__.__name__} Redimensionando imagem [{self.dimensions}], aguarde...')
+            buff_image: BytesIO = BytesIO()
+            image_pil.save(buff_image, format='PNG', optimize=True, quality=80)
+            image_pil = Image.open(buff_image)
+            self.dimensions = image_pil.size
             self.image_bytes = buff_image.getvalue()
-            self.dimensions = img.size
             buff_image.seek(0)
             buff_image.close()
-        del img
+            del buff_image
+            #print(f'{__class__.__name__} Nova dimensão [{self.dimensions}]')
+        self.width = image_pil.width
+        self.height = image_pil.height
+        del image_pil
             
     def is_paisagem(self) -> bool:
         """
@@ -264,10 +285,10 @@ class ImageObjectPIL(ABCImageObject):
             img.save(new_bytes, format='PNG')
             self.image_bytes = new_bytes.getvalue()
             
-    def set_optimize(self):
+    def set_optimize(self, quality: int = 70):
         optimized_bytes = BytesIO()
         img = self.to_image_pil()
-        img.save(optimized_bytes, format='PNG', optimize=True, quality=70)
+        img.save(optimized_bytes, format='PNG', optimize=True, quality=quality)
         self.image_bytes = optimized_bytes.getvalue()
         
     def set_background_black(self):
@@ -306,6 +327,7 @@ class ImageObjectPIL(ABCImageObject):
         except Exception as e:
             raise Exception(f"Erro ao salvar imagem PIL: {e}")
 
+
 class ImageObjectOpenCV(ABCImageObject):
     """
         Implementação de ImageObject usando OpenCV.
@@ -316,11 +338,11 @@ class ImageObjectOpenCV(ABCImageObject):
             raise ValueError(f'{__class__.__name__} Use: bytes, não {type(image_bytes)}')
         self.current_library = LibraryImage.OPENCV
         self.image_bytes = image_bytes
-        self.max_size:Tuple[int, int] = (1980, 720)
+        self.max_size: Tuple[int, int] = (1980, 720)
         
         try:
             nparr = np.frombuffer(self.image_bytes, np.uint8)
-            image_opencv:MatLike = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            image_opencv: MatLike = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
         except Exception as e:
             print('-' * 80)
             raise ValueError(f"\nCV2: Bytes de imagem OpenCV inválidos")
@@ -328,16 +350,20 @@ class ImageObjectOpenCV(ABCImageObject):
             self.dimensions = (image_opencv.shape[1], image_opencv.shape[0])  # (largura, altura)
         
         # Redimensionar se necessário
-        if self.dimensions[0] > self.max_size[0] or self.dimensions[1] > self.max_size[1]:
+        if (self.dimensions[0] > self.max_size[0]) or (self.dimensions[1] > self.max_size[1]):
+            #print(f'{__class__.__name__} Redimensionando imagem [{self.dimensions}], aguarde...')
             h, w = image_opencv.shape[:2]
             scale = min(self.max_size[0] / w, self.max_size[1] / h)
             new_size = (int(w * scale), int(h * scale))
-            image_opencv = cv2.resize(image_opencv, new_size, interpolation=cv2.INTER_LANCZOS4)                  
+            image_opencv = cv2.resize(image_opencv, new_size, interpolation=cv2.INTER_LANCZOS4)
+            self.dimensions = (image_opencv.shape[1], image_opencv.shape[0])
+            #print(f'{__class__.__name__} Nova dimensão [{self.dimensions}]')
         # Converter a imagem de volta para bytes
         _, encoded_img = cv2.imencode('.png', image_opencv)
         self.image_bytes = encoded_img.tobytes()
-        # Atualizar dimensões após redimensionamento
-        self.dimensions = (image_opencv.shape[1], image_opencv.shape[0])  
+        # Atualizar dimensões após redução
+        self.height = self.dimensions[0]
+        self.width = self.dimensions[1]
         
     def is_paisagem(self) -> bool:
         """
@@ -372,12 +398,12 @@ class ImageObjectOpenCV(ABCImageObject):
             if success:
                 self.image_bytes = encoded_image.tobytes()
                 
-    def set_optimize(self):
+    def set_optimize(self, quality: int = 70):
         """
             Reduz o tamanho da imagem, e salva a imagen reduzida na propriedade bytes.
         """
-        imagem:MatLike = self.to_image_opencv()
-        _status, buffer = cv2.imencode(".png", imagem, [cv2.IMWRITE_JPEG_QUALITY, 80])
+        imagem: MatLike = self.to_image_opencv()
+        _status, buffer = cv2.imencode(".png", imagem, [cv2.IMWRITE_JPEG_QUALITY, quality])
         if _status:
             self.image_bytes = buffer.tobytes()
             
@@ -416,20 +442,29 @@ class ImageObjectOpenCV(ABCImageObject):
         except Exception as e:
             raise Exception(f"Erro ao salvar imagem OpenCV: {e}")
 
-class ImageObject(ABCImageObject):
+
+class ImageObject(object):
     """
         Facade para manipular imagens com PIL ou OPENCV
     """
-    def __init__(self, img_obj:ABCImageObject):
+    def __init__(self, img_obj: ABCImageObject):
         super().__init__()
-        self.img_obj:ABCImageObject = img_obj
-        self.current_library:LibraryImage = self.img_obj.current_library
-        
-    def set_optimize(self):
+        self.img_obj: ABCImageObject = img_obj
+        self.current_library: LibraryImage = self.img_obj.current_library
+
+    @property
+    def width(self) -> int:
+        return self.img_obj.width
+
+    @property
+    def height(self) -> int:
+        return self.img_obj.height
+
+    def set_optimize(self, quality: int = 70):
         """
             Reduz o tamanho da imagem, e salva a imagen reduzida na propriedade bytes.
         """
-        self.img_obj.set_optimize()
+        self.img_obj.set_optimize(quality)
         
     def set_rotation(self, rotation: LibraryImage = LibraryImage.ROTATION_180):
         self.img_obj.set_rotation(rotation)
@@ -452,7 +487,7 @@ class ImageObject(ABCImageObject):
     def to_image_opencv(self) -> cv2.typing.MatLike:
         return self.img_obj.to_image_opencv()
         
-    def to_file(self, f:File):
+    def to_file(self, f: File):
         self.img_obj.to_file(f.absolute())
     
     def is_paisagem(self) -> bool:
@@ -462,7 +497,10 @@ class ImageObject(ABCImageObject):
         return self.img_obj.to_bytes()
 
     @classmethod
-    def create_from_bytes(cls, image_bytes: bytes, *, library:LibraryImage=LibraryImage.OPENCV) -> 'ImageObject':
+    def create_from_bytes(
+                cls, image_bytes: bytes, *,
+                library: LibraryImage = LibraryImage.OPENCV
+            ) -> ImageObject:
         if library == LibraryImage.PIL:
             img = ImageObjectPIL(image_bytes)
         elif library == LibraryImage.OPENCV:
@@ -472,8 +510,10 @@ class ImageObject(ABCImageObject):
         return cls(img)
 
     @classmethod
-    def create_from_file(cls, filepath: File, *, library:LibraryImage=LibraryImage.OPENCV) -> 'ImageObject':
-        print(f'Obtendo imagem do arquivo: {filepath.basename()}')
+    def create_from_file(
+                cls, filepath: File, *,
+                library: LibraryImage = LibraryImage.OPENCV
+            ) -> ImageObject:
         try:
             if library == LibraryImage.PIL:
                 image = ImageObjectPIL(filepath.path.read_bytes())

{convert_stream-1.2.1 → convert_stream-1.2.3}/convert_stream/models/m_text.py

@@ -371,7 +371,7 @@ class DataString(object):
     
     
 class ArrayString(object):
-    def __init__(self, values:List[str]):
+    def __init__(self, values: List[str]):
         self.values = values
         self.length = len(self.values)
         
@@ -381,7 +381,7 @@ class ArrayString(object):
         self.values.append(item)
         self.length += 1
         
-    def add_all(self, items:List[str]):
+    def add_all(self, items: List[str]):
         for i in items:
             self.add(i)
 

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

@@ -47,6 +47,8 @@ class ABCImageObject(ABC):
     def __init__(self):
         super().__init__()
         self.current_library: LibraryImage = None
+        self.width: int = 0
+        self.height: int = 0
         
     @abstractmethod
     def is_paisagem(self) -> bool:
@@ -56,7 +58,7 @@ class ABCImageObject(ABC):
         pass
     
     @abstractmethod
-    def set_optimize(self):
+    def set_optimize(self, quality: int = 70):
         pass
     
     @abstractmethod