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

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

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

convert_stream-2.3.3/convert_stream/__init__.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+from io import BytesIO
+from typing import Union
+from soup_files import File
+
+from ._version import (
+    __module_name__, __author__, __license__, __modify_date__, __version__
+)
+from .image import ImageObject, CollectionImages
+from .pdf import DocumentPdf, PageDocumentPdf, CollectionPagePdf
+from .doc_stream import PdfStream
+
+
+def __create_stream() -> PdfStream:
+    st = PdfStream()
+    st.clear()
+    return st
+
+
+def read_pdf(file: Union[str, File, bytes, BytesIO]) -> PdfStream:
+    _pdf_stream = __create_stream()
+
+    if isinstance(file, File):
+        _pdf_stream.add_file_pdf(file)
+    elif isinstance(file, str):
+        _pdf_stream.add_file_pdf(File(file))
+    elif isinstance(file, bytes):
+        _pdf_stream.add_document(DocumentPdf(BytesIO(file)))
+    elif isinstance(file, BytesIO):
+        _pdf_stream.add_document(DocumentPdf(file))
+    else:
+        raise ValueError()
+    return _pdf_stream
+
+
+def read_files_pdf(files: Union[list[str], list[File]]) -> PdfStream:
+    _pdf_stream = __create_stream()
+    if len(files) == 0:
+        return _pdf_stream
+
+    if isinstance(files[0], str):
+        for f in files:
+            _pdf_stream.add_file_pdf(File(f))
+    elif isinstance(files[0], File):
+        _pdf_stream.add_files_pdf(files)
+    else:
+        raise ValueError()
+    return _pdf_stream
+
+
+def read_image(img: Union[str, File, bytes, BytesIO]) -> PdfStream:
+    _pdf_stream = __create_stream()
+    if isinstance(img, str):
+        _pdf_stream.add_file_image(File(img))
+    elif isinstance(img, File):
+        _pdf_stream.add_image(ImageObject.create_from_file(img))
+    elif isinstance(img, bytes):
+        _pdf_stream.add_image(ImageObject.create_from_bytes(img))
+    elif isinstance(img, BytesIO):
+        img.seek(0)
+        _pdf_stream.add_image(ImageObject.create_from_bytes(img.getvalue()))
+    else:
+        raise ValueError()
+    return _pdf_stream
+
+
+__all__ = [
+    '__modify_date__', '__author__', '__license__', '__module_name__', '__version__',
+    'PdfStream', 'DocumentPdf', 'PageDocumentPdf', 'CollectionPagePdf', 'CollectionImages',
+    'read_pdf', 'read_files_pdf', 'read_image',
+]
+

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

@@ -4,38 +4,26 @@
     Módulo para trabalhar com pdfs e imagens
 """
 from __future__ import annotations
-from convert_stream.enum_libs.modules import (
+from convert_stream.mod_types.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.mod_types.enums import LibPDF, LibImage, LibPdfToImage
 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
 from convert_stream.pdf.image_to_pdf import LibImageToPdf, ConvertImageToPdf
 from convert_stream.pdf.pdf_to_image import ConvertPdfToImages
-from soup_files import File, Directory, ProgressBarAdapter, ABCProgressBar
-
-
-class VoidProgressBar(ABCProgressBar):
-
-    def __init__(self):
-        super().__init__()
-
-    def set_percent(self, percent: float):
-        pass
-
-    def set_text(self, text: str):
-        pass
+from soup_files import File, Directory, ProgressBarAdapter
 
 
 class ImageStream(CollectionImages):
 
-    def __init__(self, images: list[ImageObject] = []) -> None:
+    def __init__(self, images: list[ImageObject]) -> None:
         super().__init__(images)
 
     def add_image_bytes(self, bt: bytes) -> None:
         im = ImageObject.create_from_bytes(bt)
-        self.images.append(im)
+        self.append(im)
 
 
 class PdfStream(object):
@@ -49,8 +37,8 @@ class PdfStream(object):
                 lib_pdf_to_img: LibPdfToImage = DEFAULT_LIB_PDF_TO_IMG,
             ) -> None:
         self.progress: ProgressBarAdapter = pbar
-        self.collection_pages: CollectionPagePdf = CollectionPagePdf()
-        self.collection_images: CollectionImages = CollectionImages()
+        self.collection_pages: CollectionPagePdf = CollectionPagePdf([])
+        self.collection_images: CollectionImages = CollectionImages([])
         self.collection_images.set_pbar(pbar)
         self.collection_pages.set_pbar(pbar)
         self.lib_pdf: LibPDF = lib_pdf
@@ -61,7 +49,7 @@ class PdfStream(object):
 
     @property
     def is_empty(self) -> bool:
-        return self.collection_pages.is_null
+        return self.collection_pages.is_empty
 
     def set_land_scape(self):
         self.collection_pages.set_land_scape()
@@ -109,28 +97,28 @@ class PdfStream(object):
 
     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:
+        if self.collection_pages.is_empty and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
 
-        _doc = None
+        _doc: DocumentPdf = None
         if not self.collection_images.is_empty:
             _convert = ConvertImageToPdf(self.collection_images, lib_img_to_pdf=self.lib_img_to_pdf)
+            _convert.set_pbar(self.progress)
             _doc: DocumentPdf = _convert.to_document(land_scape, a4=a4)
-        if not self.collection_pages.is_null:
+        if not self.collection_pages.is_empty:
             if _doc is None:
                 _doc: DocumentPdf = self.collection_pages.to_document(self.lib_pdf)
             else:
-                _doc.add_pages(self.collection_pages.pages)
+                _doc.add_pages(self.collection_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)
+        images: list[ImageObject] = self.collection_images
+        if not self.collection_pages.is_empty:
+            tmp_doc = DocumentPdf.create_from_pages(self.collection_pages)
             conv_pdf_to_img = ConvertPdfToImages.create(tmp_doc)
             images.extend(conv_pdf_to_img.to_images(dpi=dpi))
             del tmp_doc
@@ -151,17 +139,17 @@ class PdfStream(object):
                 land_scape: bool = False,
                 dpi: int = 300,
             ) -> None:
-        if self.collection_pages.is_null and self.collection_images.is_empty:
+        if self.collection_pages.is_empty and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
         self.progress.start()
 
-        image_stream = ImageStream()
+        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:
+            image_stream.add_images(self.collection_images)
+        if not self.collection_pages.is_empty:
             self.progress.update_text('Processando Imagens')
             # Criar um documento a partir das páginas
-            doc_pdf = DocumentPdf.create_from_pages(self.collection_pages.pages)
+            doc_pdf = DocumentPdf.create_from_pages(self.collection_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.
             _pdf_to_images: list[ImageObject] = convert_pdf_to_img.to_images(dpi=dpi)
@@ -178,11 +166,11 @@ class PdfStream(object):
                 a4: bool = False,
                 prefix: str = None,
             ) -> None:
-        if self.collection_pages.is_null and self.collection_images.is_empty:
+        if self.collection_pages.is_empty and self.collection_images.is_empty:
             raise ValueError('Adicione imagens e/ou documentos para prosseguir!')
         pages_document = []
-        if not self.collection_pages.is_null:
-            pages_document.extend(self.collection_pages.pages)
+        if not self.collection_pages.is_empty:
+            pages_document.extend(self.collection_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)
@@ -201,7 +189,7 @@ class SplitPdf(object):
         self.__collection_pages.set_pbar(self.pbar)
 
     def is_empty(self) -> bool:
-        return self.__collection_pages.is_null
+        return self.__collection_pages.is_empty
 
     def add_pages_pdf(self, pages: list[PageDocumentPdf]) -> None:
         self.__collection_pages.add_pages(pages)
@@ -212,6 +200,3 @@ class SplitPdf(object):
             return
         self.__collection_pages.to_files_pdf(output_dir, replace=replace, prefix=prefix)
         self.__collection_pages.clear()
-
-
-

convert_stream-2.3.3/convert_stream/image/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+from .img_object import ImageObject, CollectionImages
+__all__ = ['ImageObject', 'CollectionImages']
+
+
+

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

@@ -6,29 +6,31 @@
 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
 from io import BytesIO
 import numpy as np
 from scipy.ndimage import uniform_filter
-from convert_stream.enum_libs.enums import LibImage, RotationAngle
-from convert_stream.enum_libs.modules import (
+from convert_stream.mod_types import get_void_metadata, get_hash_from_bytes
+from convert_stream.mod_types.enums import LibImage, RotationAngle
+from convert_stream.mod_types.table_types import ListItems
+from convert_stream.mod_types.modules import (
     MOD_IMG_PIL, ModuleImage, DEFAULT_LIB_IMAGE,
     cv2, MatLike, Image, ImageFilter
 )
 
 
-def get_hash_from_bytes(bt: BytesIO) -> str:
-    return md5_hash(bt.getvalue()).hexdigest().upper()
-
-
 class ABCImageObject(ABC):
 
-    def __init__(self, module_image: ModuleImage, name: str) -> None:
-        self.max_size: tuple[int, int] = (1980, 720) # Dimensões máximas, altere se necessário.
+    def __init__(self, module_image: ModuleImage) -> None:
+        # Dimensões máximas, altere se necessário.
+        self.max_size: tuple[int, int] = (1980, 720)
         self.module_image: ModuleImage = module_image
         self.lib_image: LibImage = LibImage.OPENCV
-        self.name: str = name
+        self.metadata: dict[str, str | None] = get_void_metadata()
+
+    @property
+    def name(self) -> str | None:
+        return self.metadata['name']
 
     @abstractmethod
     def get_dimensions(self) -> tuple[int, int]:
@@ -89,8 +91,8 @@ class ABCImageObject(ABC):
 
 
 class ImplementOpenCv(ABCImageObject):
-    def __init__(self, module_image: ModuleImage, name: str) -> None:
-        super().__init__(module_image, name)
+    def __init__(self, module_image: ModuleImage) -> None:
+        super().__init__(module_image)
         self.lib_image = LibImage.OPENCV
 
         # Redimensionar se necessário
@@ -202,7 +204,13 @@ class ImplementOpenCv(ABCImageObject):
         img = cv2.imread(f.absolute())
         if img is None:
             raise ValueError(f"Não foi possível abrir a imagem: {f.absolute()}")
-        return cls(img, f.name())
+        im_obj = cls(img)
+        im_obj.metadata['file_path'] = f.absolute()
+        im_obj.metadata['md5'] = f.md5()
+        im_obj.metadata['name'] = f.absolute()
+        im_obj.metadata['size'] = f.size()
+        im_obj.metadata['extension'] = f.extension()
+        return im_obj
 
     @classmethod
     def create_from_bytes(cls, bt: bytes) -> ABCImageObject:
@@ -211,14 +219,17 @@ class ImplementOpenCv(ABCImageObject):
         if img is None:
             raise ValueError("Não foi possível criar a imagem a partir dos bytes fornecidos.")
         bytes_io = BytesIO(bt)
-        name = get_hash_from_bytes(bytes_io)
+        name: str = get_hash_from_bytes(bytes_io)
         bytes_io.close()
-        return cls(img, name)
+        _obj = cls(img)
+        _obj.metadata['md5'] = name
+        _obj.metadata['name'] = name
+        return _obj
 
 
 class ImplementPIL(ABCImageObject):
-    def __init__(self, module_image: ModuleImage, name: str):
-        super().__init__(module_image, name)
+    def __init__(self, module_image: ModuleImage):
+        super().__init__(module_image)
         self.lib_image = LibImage.PIL
 
         # Redimensionar, se as dimensões estiverem maior que self.max_size.
@@ -342,7 +353,13 @@ class ImplementPIL(ABCImageObject):
     @classmethod
     def create_from_file(cls, f: File) -> ABCImageObject:
         img = Image.open(f.path)
-        return cls(img, f.name())
+        im_obj = cls(img)
+        im_obj.metadata['file_path'] = f.absolute()
+        im_obj.metadata['md5'] = f.md5()
+        im_obj.metadata['name'] = f.absolute()
+        im_obj.metadata['size'] = f.size()
+        im_obj.metadata['extension'] = f.extension()
+        return im_obj
 
     @classmethod
     def create_from_bytes(cls, bt: bytes) -> ABCImageObject:
@@ -350,7 +367,10 @@ class ImplementPIL(ABCImageObject):
         bytes_io = BytesIO(bt)
         name = get_hash_from_bytes(bytes_io)
         bytes_io.close()
-        return cls(img, name)
+        _obj = cls(img)
+        _obj.metadata['md5'] = name
+        _obj.metadata['name'] = name
+        return _obj
 
 
 class ImageObject(object):
@@ -398,6 +418,10 @@ class ImageObject(object):
     def name(self) -> str:
         return self.img_adapter.name
 
+    @property
+    def metadata(self) -> dict[str, str | None]:
+        return self.img_adapter.metadata
+
     def to_pil(self) -> Image.Image:
         """
         Converte o ImageObject para um objeto PIL.Image.
@@ -473,44 +497,35 @@ class ImageObject(object):
 
     @classmethod
     def create_from_pil(cls, pil: ModuleImage) -> ImageObject:
-        name = get_hash_from_bytes(BytesIO(pil.tobytes()))
-        return cls(ImplementPIL(pil, name))
+        return cls(ImplementPIL(pil))
 
 
-class CollectionImages(object):
+class CollectionImages(ListItems):
     
-    def __init__(self, images: list[ImageObject] = []) -> None:
+    def __init__(self, images: list[ImageObject]) -> None:
         """
             Gerir uma lista de Imagens
         :type images: list[ImageObject]
         """
-        self.images: list[ImageObject] = images
+        super().__init__(images)
         self.pbar: ProgressBarAdapter = ProgressBarAdapter()
         self.__count: int = 0
 
-    @property
-    def length(self) -> int:
-        return len(self.images)
-
-    @property
-    def is_empty(self) -> bool:
-        return len(self.images) == 0
-
     def clear(self) -> None:
-        self.images.clear()
+        self.clear()
         self.__count = 0
 
     def add_image(self, image: ImageObject) -> None:
         self.__count += 1
         self.pbar.update_text(f'Adicionando imagem {self.__count}')
-        self.images.append(image)
+        self.append(image)
 
     def add_file_image(self, file: File) -> None:
         self.pbar.start()
         self.__count += 1
         self.pbar.update_text(f'Adicionando imagem {self.__count} {file.basename()}')
         im = ImageObject.create_from_file(file)
-        self.images.append(im)
+        self.append(im)
         self.pbar.stop()
 
     def add_images(self, images: list[ImageObject]) -> None:
@@ -525,7 +540,7 @@ class CollectionImages(object):
                 ((num+1) / max_num) * 100,
                 f'Adicionando imagem: [{num+1} de {max_num}]'
             )
-            self.images.append(ImageObject.create_from_file(f))
+            self.append(ImageObject.create_from_file(f))
         self.pbar.stop()
 
     def add_directory_images(self, d: Directory, max_files: int = 4000) -> None:
@@ -542,8 +557,8 @@ class CollectionImages(object):
         self.pbar.start()
         print()
         output_dir.mkdir()
-        max_num = len(self.images)
-        for n, img in enumerate(self.images):
+        max_num = self.length
+        for n, img in enumerate(self):
             filename = f'{img.name}.png'
             file_path = output_dir.join_file(filename)
             if (not replace) and (file_path.exists()):
@@ -566,13 +581,13 @@ class CollectionImages(object):
         self.pbar.stop()
 
     def set_land_scape(self):
-        for im in self.images:
+        for im in self:
             im.set_landscape()
 
     def set_gausian_blur(self, sigma: float = 0.8) -> None:
         self.pbar.start()
         max_num: int = self.length
-        for _num, im in enumerate(self.images):
+        for _num, im in enumerate(self):
             self.pbar.update(
                 ((_num + 1) / max_num) * 100,
                 f'Aplicando GausianBlur: [{_num + 1} de {max_num}]'

convert_stream-2.3.3/convert_stream/mod_types/__init__.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+#
+from __future__ import annotations
+from hashlib import md5 as md5_hash
+from io import BytesIO
+from .table_types import (
+    TextTable, ColumnsTable, ListString, ArrayString, HeadCell, HeadValues,
+    ColumnBody, create_void_map, create_map_from_values, create_void_table,
+    create_map_from_file_values, concat_maps, contains, get_text_from_file
+)
+
+
+def get_hash_from_bytes(bt: BytesIO | bytes) -> str:
+    if isinstance(bt, BytesIO):
+        return md5_hash(bt.getvalue()).hexdigest().upper()
+    elif isinstance(bt, bytes):
+        return md5_hash(bt).hexdigest().upper()
+    else:
+        raise TypeError(f"Unsupported type {type(bt)}")
+
+
+def get_void_metadata() -> dict[str, str | None]:
+    """
+        Salvar os metadados básico de documentos/imagens lidas em disco.
+    """
+    return {
+        'file_path': None,
+        'dir_path': None,
+        'name': None,
+        'md5': None,
+        'size': None,
+        'extension': None,
+        'origin_src': None,
+    }
+
+
+__all__ = [
+    'get_hash_from_bytes', 'get_void_metadata', 'get_void_metadata', 'contains',
+    'concat_maps', 'create_map_from_file_values', 'create_map_from_values',
+    'create_void_table', 'create_void_map', 'ColumnBody', 'ColumnsTable',
+    'ListString', 'HeadCell', 'HeadValues', 'TextTable',
+]

{convert_stream-2.3.1/convert_stream/enum_libs → convert_stream-2.3.3/convert_stream/mod_types}/enums.py

@@ -1,33 +1,37 @@
 #!/usr/bin/env python3
-
 from enum import Enum
 
 
 class ColumnsTable(Enum):
+    """
+        Classe enum para padronizar os nomes das tabelas geradas por este módulo.
+    """
 
-    NUM_LINHA = 'NUM_LINHA'
-    NUM_PAGE = 'NUM_PÁGINA'
+    NUM_LINE = 'LINHA'
+    NUM_PAGE = 'PÁGINA'
     TEXT = 'TEXTO'
-    FILE = 'ARQUIVO'
-    FILENAME = 'NOME_ARQUIVO'
+    FILE_PATH = 'ARQUIVO'
+    FILE_NAME = 'NOME_ARQUIVO'
     DIR = 'PASTA'
     FILETYPE = 'TIPO_ARQUIVO'
+    KEY = 'KEY'
 
     @classmethod
     def to_list(cls) -> list[str]:
         return [
-            cls.NUM_LINHA.value,
+            cls.NUM_LINE.value,
             cls.NUM_PAGE.value,
             cls.TEXT.value,
-            cls.FILE.value,
-            cls.FILENAME.value,
+            cls.FILE_PATH.value,
+            cls.FILE_NAME.value,
             cls.FILETYPE.value,
             cls.DIR.value,
+            cls.KEY.value,
         ]
 
 
 class LibPdfToImage(Enum):
-
+    """Enumerar as bibliotecas externas que convertem PDF em imagem"""
     PDF_TO_IMG_FITZ = 'fitz'
     NOT_IMPLEMENTED = 'null'
 

{convert_stream-2.3.1/convert_stream/enum_libs → convert_stream-2.3.3/convert_stream/mod_types}/modules.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 from __future__ import annotations
-from typing import Union, TypeAlias #, Any
-from convert_stream.enum_libs.enums import *
+from typing import Union, TypeAlias
+from convert_stream.mod_types.enums import *
 
 MOD_IMG_PIL: bool = False
 MOD_IMG_OPENCV: bool = False
@@ -29,7 +29,6 @@ try:
     from cv2.typing import MatLike
     MOD_IMG_OPENCV = True
 except ImportError:
-    #cv2.typing.MatLike = FakeType
     MatLike = FakeType
 
 try:
@@ -51,7 +50,7 @@ elif MOD_IMG_PIL:
     DEFAULT_LIB_IMAGE = LibImage.PIL
 else:
     DEFAULT_LIB_IMAGE = LibImage.NOT_IMPLEMENTED
-    ModuleImage = FakeType  # fallback para runtime
+    ModuleImage = FakeType
 
 #=================================================================#
 # Módulos para PDF fitz e pypdf