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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 2.2.5
+Version: 2.2.7
 Summary: Manipulação de documentos PDF e Imagens. Converter, Ler, rotacionar exportar etc.
 Author: Bruno Chaves
 Requires-Python: >=3.11
@@ -24,12 +24,12 @@ pip3 install -r requirements.txt
     >>> from file import File, Directory
     >>> from pdflib import PdfStream
     # instâncie o caminho do arquivo PDF e o diretório para exportar os dados.
-    f = File('path/to/file.pdf')
-    d = Directory('path/to/save')
+    file_pdf = File('path/to/file.pdf')
+    output_dir = Directory('path/to/save')
 
     pdf_stream = PdfStream()
-    pdf_stream.add_file_pdf(f)
-    pdf_stream.to_files_pdf(d) # isso irá converter cada página em um arquivo PDF
+    pdf_stream.add_file_pdf(file_pdf)
+    pdf_stream.to_files_pdf(output_dir) # isso irá converter cada página em um arquivo PDF
 
 # Uso para unir vários arquivos PDF.
     >>> from file import File, Directory

{convert_stream-2.2.5 → convert_stream-2.2.7}/README.md

@@ -6,12 +6,12 @@ pip3 install -r requirements.txt
     >>> from file import File, Directory
     >>> from pdflib import PdfStream
     # instâncie o caminho do arquivo PDF e o diretório para exportar os dados.
-    f = File('path/to/file.pdf')
-    d = Directory('path/to/save')
+    file_pdf = File('path/to/file.pdf')
+    output_dir = Directory('path/to/save')
 
     pdf_stream = PdfStream()
-    pdf_stream.add_file_pdf(f)
-    pdf_stream.to_files_pdf(d) # isso irá converter cada página em um arquivo PDF
+    pdf_stream.add_file_pdf(file_pdf)
+    pdf_stream.to_files_pdf(output_dir) # isso irá converter cada página em um arquivo PDF
 
 # Uso para unir vários arquivos PDF.
     >>> from file import File, Directory

convert_stream-2.2.7/convert_stream/__init__.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+from io import BytesIO
+from typing import Union
+from soup_files import File, Directory, LibraryDocs, InputFiles
+
+from ._version import (
+    __module_name__, __author__, __license__, __modify_date__, __version__
+)
+from convert_stream.enum_libs.enums import *
+from convert_stream.enum_libs.modules import (
+    LibPDF, LibDate, LibImage, LibPdfToImage, LibImageToPdf,
+    DEFAULT_LIB_PDF, DEFAULT_LIB_IMAGE, DEFAULT_LIB_PDF_TO_IMG,
+    DEFAULT_LIB_IMAGE_TO_PDF, ModPdfToImage, ModPagePdf, ModuleImage,
+    ModImageToPdf, MOD_FITZ, MOD_PYPDF, MOD_CANVAS, MOD_IMG_PIL, MOD_IMG_OPENCV,
+)
+from .text.terminal import print_title, print_line
+from .text.string import (
+    FindText, ArrayString, MapText
+)
+from .text.date import ConvertStringDate
+from convert_stream.image.img_object import (
+    ImageObject, Image, MatLike, get_hash_from_bytes, CollectionImages,
+)
+from convert_stream.pdf import (
+    PageDocumentPdf, DocumentPdf, ConvertImageToPdf, ConvertPdfToImages,
+    ModImageToPdf, ModDocPdf, CollectionPagePdf, DEFAULT_LIB_PDF,
+    DEFAULT_LIB_IMAGE_TO_PDF, DEFAULT_LIB_PDF_TO_IMG
+)
+from .doc_stream import PdfStream, SplitPdf
+from .sheets import save_data, ReadFileSheet
+from .table_files import (
+    get_void_df, create_df_from_file_pdf, create_map_from_values,
+    FileToTable, ColumnsTable, PdfFinder, SearchableTextPdf
+)
+
+
+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(image: Union[str, File, bytes, BytesIO]) -> PdfStream:
+    _pdf_stream = __create_stream()
+    if isinstance(image, str):
+        _pdf_stream.add_file_image(File(image))
+    elif isinstance(image, File):
+        _pdf_stream.add_image(ImageObject.create_from_file(image))
+    elif isinstance(image, bytes):
+        _pdf_stream.add_image(ImageObject.create_from_bytes(image))
+    elif isinstance(image, BytesIO):
+        image.seek(0)
+        _pdf_stream.add_image(ImageObject.create_from_bytes(image.getvalue()))
+    else:
+        raise ValueError()
+    return _pdf_stream
+
+

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/_version.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-__version__ = '2.2'
+__version__ = '2.2.7'
 __author__ = 'Bruno Chaves'
 __license__ = 'MIT'
 __module_name__ = 'convert_stream'
-__modify_date__ = '2025-08-23'
+__modify_date__ = '2025-09-08'
 

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/enum_libs/enums.py

@@ -67,4 +67,4 @@ class RotationAngle(Enum):
 
     ROTATION_90 = 90
     ROTATION_180 = 180
-    ROTATION_270 = 270
+    ROTATION_270 = 270

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

@@ -54,9 +54,9 @@ except ImportError:
         import pymupdf as fitz
         MOD_FITZ = True
     except ImportError:
-        fitz = None
-        fitz.Page = None
-        fitz.TextPage = None
+        fitz = object
+        fitz.Page = object
+        fitz.TextPage = object
 
 try:
     from pypdf import PdfWriter, PdfReader, PageObject
@@ -68,20 +68,20 @@ except ImportError:
 
 
 if MOD_FITZ and MOD_PYPDF:
-    ModulePagePdf: TypeAlias = Union[PageObject, fitz.Page]
-    ModuleDocPdf: TypeAlias = Union[fitz.Document, PdfWriter]
+    ModPagePdf = Union[PageObject, fitz.Page]
+    ModDocPdf = Union[fitz.Document, PdfWriter]
     DEFAULT_LIB_PDF = LibPDF.FITZ
 elif MOD_FITZ:
-    ModulePagePdf: TypeAlias = Union[fitz.Page]
-    ModuleDocPdf: TypeAlias = Union[fitz.Document]
+    ModPagePdf = Union[fitz.Page]
+    ModDocPdf = Union[fitz.Document]
     DEFAULT_LIB_PDF = LibPDF.FITZ
 elif MOD_PYPDF:
-    ModulePagePdf: TypeAlias = Union[PageObject]
-    ModuleDocPdf: TypeAlias = Union[PdfWriter]
+    ModPagePdf = Union[PageObject]
+    ModDocPdf = Union[PdfWriter]
     DEFAULT_LIB_PDF = LibPDF.PYPDF
 else:
-    ModulePagePdf = None  # fallback para runtime
-    ModuleDocPdf: TypeAlias = None
+    ModPagePdf = None  # fallback para runtime
+    ModDocPdf = None
     DEFAULT_LIB_PDF = LibPDF.NOT_IMPLEMENTED
 
 #=================================================================#

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

@@ -12,8 +12,8 @@ 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 (
-    MOD_IMG_OPENCV, MOD_IMG_PIL, ModuleImage, DEFAULT_LIB_IMAGE,
-    cv2, MatLike, Image, ImageOps, ImageFilter
+    MOD_IMG_PIL, ModuleImage, DEFAULT_LIB_IMAGE,
+    cv2, MatLike, Image, ImageFilter
 )
 
 
@@ -578,7 +578,3 @@ class CollectionImages(object):
     def set_pbar(self, p: ProgressBarAdapter) -> None:
         self.pbar = p
 
-
-
-
-

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/pdf/__init__.py

@@ -3,11 +3,12 @@
 from convert_stream.enum_libs.enums import LibPDF
 from convert_stream.enum_libs.modules import (
     DEFAULT_LIB_PDF, DEFAULT_LIB_PDF_TO_IMG, DEFAULT_LIB_IMAGE_TO_PDF,
-    ModulePagePdf, MOD_FITZ, MOD_PYPDF, ModPdfToImage, ModImageToPdf
+    ModPagePdf, MOD_FITZ, MOD_PYPDF, ModPdfToImage, ModImageToPdf,
+    PdfWriter, PdfReader
 )
-from .pdf_page import PageDocumentPdf, fitz, PdfReader, PdfWriter
+from .pdf_page import PageDocumentPdf, fitz
 from .pdf_document import (
-    DocumentPdf, DEFAULT_LIB_PDF, ModuleDocPdf, CollectionPagePdf
+    DocumentPdf, DEFAULT_LIB_PDF, ModDocPdf, CollectionPagePdf
 )
 from .pdf_to_image import ConvertPdfToImages
 from .image_to_pdf import ConvertImageToPdf

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/pdf/image_to_pdf.py

@@ -9,7 +9,7 @@ from soup_files import File, Directory, ProgressBarAdapter
 from abc import ABC, abstractmethod
 from convert_stream.enum_libs.enums import LibImageToPdf
 from convert_stream.enum_libs.modules import (
-    ModImageToPdf, MOD_CANVAS, DEFAULT_LIB_IMAGE_TO_PDF, canvas, Canvas, letter, ImageReader
+    MOD_CANVAS, DEFAULT_LIB_IMAGE_TO_PDF, canvas, letter, ImageReader
 )
 from convert_stream.pdf import DocumentPdf
 from convert_stream.pdf.pdf_page import fitz
@@ -91,7 +91,7 @@ class ImplementImageToPdfCanvas(ABCConvertImageToPdf):
             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):
+        for num, img_obj in enumerate(self.collection_images.images[1:], 1):
 
             self.pbar.update(
                 ((num + 1) / max_num) * 100,
@@ -174,7 +174,7 @@ class ImplementImageToPdfPil(ABCConvertImageToPdf):
 
                 # Redimensiona a imagem
                 resized_image = original_pil_image.resize(
-                (scaled_width, scaled_height), Image.Resampling.LANCZOS
+                    (scaled_width, scaled_height), Image.Resampling.LANCZOS
                 )
 
                 # Cria uma nova imagem de fundo branca com o tamanho A4
@@ -237,8 +237,8 @@ class ImplementImageToPdfFitz(ABCConvertImageToPdf):
 
         for num, img_obj in enumerate(self.collection_images.images):
             self.pbar.update(
-                ((num+1)/max_num) * 100,
-                f'Convertendo: [{num+1} de {max_num}]'
+                ((num + 1) / max_num) * 100,
+                f'Convertendo: [{num + 1} de {max_num}]'
             )
             if land_scape:
                 img_obj.set_landscape()
@@ -294,11 +294,11 @@ class ConvertImageToPdf(object):
     """
 
     def __init__(
-                self,
-                collection_images: CollectionImages = CollectionImages(),
-                *,
-                lib_img_to_pdf: LibImageToPdf = DEFAULT_LIB_IMAGE_TO_PDF
-            ):
+            self,
+            collection_images: CollectionImages = CollectionImages(),
+            *,
+            lib_img_to_pdf: LibImageToPdf = DEFAULT_LIB_IMAGE_TO_PDF
+    ):
         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:
@@ -347,4 +347,3 @@ class ConvertImageToPdf(object):
 
     def set_land_scape(self):
         self.convert.collection_images.set_land_scape()
-

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

@@ -6,16 +6,16 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
 from io import BytesIO
-
+from typing import Union
 import pandas as pd
 from soup_files import File, Directory, LibraryDocs, InputFiles, ProgressBarAdapter, JsonConvert
 from convert_stream.enum_libs.enums import LibPDF, ColumnsTable
 from convert_stream.enum_libs.modules import (
-    DEFAULT_LIB_PDF, ModuleDocPdf, ModulePagePdf, PdfWriter, PdfReader, PageObject, fitz,
+    DEFAULT_LIB_PDF, ModDocPdf, PdfWriter, PdfReader, PageObject, fitz,
 )
 from convert_stream.image.img_object import get_hash_from_bytes
 from convert_stream.pdf.pdf_page import PageDocumentPdf
-from convert_stream.text import show_error, show_info, show_warning, MapText, FindText
+from convert_stream.text import print_line, show_warning, MapText, FindText
 from convert_stream.sheets.save import save_data
 
 
@@ -23,7 +23,7 @@ class SearchableTextPdf(object):
     """
         Esta classe serve para armazenar textos filtrados em documentos PDF
     guardando o texto buscado e outros elementos como a página em que o texto foi
-    encontrado, linha e o nome do arquivo.
+    encontrado, linha e o nome do respectivo arquivo.
     """
     def __init__(self, silent: bool = False):
         self.silent = silent
@@ -81,6 +81,7 @@ class SearchableTextPdf(object):
 
     def add_line(self, text, *, num_page: str, num_line: str, file: str) -> None:
         if not self.silent:
+            print_line()
             print(f'{file} => {text}')
         self.elements[ColumnsTable.NUM_PAGE.value].append(num_page)
         self.elements[ColumnsTable.NUM_LINHA.value].append(num_line)
@@ -92,6 +93,10 @@ class SearchableTextPdf(object):
             self.elements[_k].clear()
 
     def to_string(self) -> str:
+        """
+            Retorna o texto da coluna TEXT em formato de string
+        ou 'nas' em caso de erro nas = Not a String
+        """
         try:
             return ' '.join(self.elements[ColumnsTable.TEXT.value])
         except Exception as e:
@@ -102,34 +107,36 @@ class SearchableTextPdf(object):
         return pd.DataFrame.from_dict(self.elements)
 
     def to_file_json(self, file: File):
+        """Exporta os dados da busca para um arquivo .JSON"""
         dt = JsonConvert.from_dict(self.elements).to_json_data()
         dt.to_file(file)
 
     def to_file_excel(self, file: File):
+        """Exporta os dados da busca para um arquivo .XLSX"""
         save_data(self.to_data_frame(), file=file)
 
 
 class ABCDocument(ABC):
 
-    def __init__(self, mod_doc_pdf: ModuleDocPdf, name: str):
-        self.mod_doc_pdf: ModuleDocPdf = mod_doc_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
         self.name: str = name
 
     @abstractmethod
-    def get_first_page(self) -> PageDocumentPdf:
+    def lenght(self) -> int:
         pass
 
     @abstractmethod
-    def get_last_page(self) -> PageDocumentPdf:
+    def get_first_page(self) -> PageDocumentPdf:
         pass
 
     @abstractmethod
-    def get_page(self, idx: int) -> PageDocumentPdf | None:
+    def get_last_page(self) -> PageDocumentPdf:
         pass
 
     @abstractmethod
-    def get_number_pages(self) -> int:
+    def get_page(self, idx: int) -> PageDocumentPdf | None:
         pass
 
     @abstractmethod
@@ -163,11 +170,14 @@ class ABCDocument(ABC):
 
 class ImplementDocumentFitz(ABCDocument):
 
-    def __init__(self, mod_doc_pdf: ModuleDocPdf, name: str):
+    def __init__(self, mod_doc_pdf: ModDocPdf, name: str):
         super().__init__(mod_doc_pdf, name)
-        self.mod_doc_pdf: ModuleDocPdf = mod_doc_pdf
+        self.mod_doc_pdf: ModDocPdf = mod_doc_pdf
         self.lib_pdf: LibPDF = LibPDF.FITZ
 
+    def lenght(self) -> int:
+        return self.mod_doc_pdf.page_count
+
     def get_first_page(self) -> PageDocumentPdf:
         return self.get_page(0)
 
@@ -178,14 +188,11 @@ class ImplementDocumentFitz(ABCDocument):
     def get_page(self, idx: int) -> PageDocumentPdf | None:
         _page_pdf = None
         if 0 <= idx < self.mod_doc_pdf.page_count:
-            pg = self.mod_doc_pdf.load_page(idx)  # retorna fitz.Page
+            pg: fitz.Page = self.mod_doc_pdf.load_page(idx)  # retorna fitz.Page
             if pg is not None:
-                _page_pdf = PageDocumentPdf.create_from_page_fitz(pg)
+                _page_pdf = PageDocumentPdf.create_from_page_fitz(pg, pg.number + 1)
         return _page_pdf
 
-    def get_number_pages(self) -> int:
-        return self.mod_doc_pdf.page_count
-
     def add_page(self, page: PageDocumentPdf):
         # Assume que page.mod_page é fitz.Page
         self.mod_doc_pdf.insert_pdf(
@@ -212,15 +219,15 @@ class ImplementDocumentFitz(ABCDocument):
 
     def to_pages(self) -> list[PageDocumentPdf]:
         pages = []
-        for pg in self.mod_doc_pdf:
-            page_pdf = PageDocumentPdf.create_from_page_fitz(pg)
+        for num, pg in enumerate(self.mod_doc_pdf):
+            page_pdf = PageDocumentPdf.create_from_page_fitz(pg, num + 1)
             pages.append(page_pdf)
         return pages
 
     @classmethod
     def create_from_bytes(cls, bt: BytesIO) -> ImplementDocumentFitz:
         # Cria documento a partir de BytesIO
-        doc: ModuleDocPdf = fitz.open(stream=bt.getvalue(), filetype="pdf")
+        doc: ModDocPdf = fitz.open(stream=bt.getvalue(), filetype="pdf")
         name = get_hash_from_bytes(bt)
         return cls(doc, name)
 
@@ -254,6 +261,9 @@ class ImplementDocumentPyPdf(ABCDocument):
         self.mod_doc_pdf: PdfWriter = mod_doc_pdf  # ou PdfReader
         self.lib_pdf: LibPDF = LibPDF.PYPDF
 
+    def lenght(self) -> int:
+        return len(self.mod_doc_pdf.pages)
+
     def get_first_page(self) -> PageDocumentPdf:
         """
         Retorna a primeira página do documento.
@@ -281,9 +291,6 @@ class ImplementDocumentPyPdf(ABCDocument):
             return PageDocumentPdf.create_from_page_pypdf(pg, idx + 1)
         return None
 
-    def get_number_pages(self) -> int:
-        return len(self.mod_doc_pdf.pages)
-
     def add_page(self, page: PageDocumentPdf):
         self.mod_doc_pdf.add_page(page.implement_page_pdf.mod_page)
 
@@ -304,7 +311,7 @@ class ImplementDocumentPyPdf(ABCDocument):
     def to_pages(self) -> list[PageDocumentPdf]:
         pages_pdf: list[PageDocumentPdf] = []
         for num, page in enumerate(self.mod_doc_pdf.pages):
-            pg = PageDocumentPdf.create_from_page_pypdf(page)
+            pg = PageDocumentPdf.create_from_page_pypdf(page, num + 1)
             pages_pdf.append(pg)
         return pages_pdf
 
@@ -339,7 +346,6 @@ class ImplementDocumentPyPdf(ABCDocument):
         for page_obj in pages:
             # Obtém o objeto de página da implementação da lib
             pdf_writer.add_page(page_obj.implement_page_pdf.mod_page)
-
         output_bytes = BytesIO()
         pdf_writer.write(output_bytes)
         pdf_bytes = output_bytes
@@ -347,12 +353,62 @@ class ImplementDocumentPyPdf(ABCDocument):
 
 
 class DocumentPdf(object):
-    def __init__(self, doc_pdf: ABCDocument):
-        self.doc_pdf: ABCDocument = doc_pdf
-        self.lib_pdf: LibPDF = doc_pdf.lib_pdf
-        self.name: str = doc_pdf.name
+    def __init__(
+                self,
+                document: Union[str, File, PdfWriter, fitz.Document, BytesIO],
+                *,
+                lib_pdf: LibPDF = LibPDF.FITZ
+            ):
+        self.doc_pdf = None
+        self.lib_pdf: LibPDF = lib_pdf
+        if isinstance(document, str):
+            if lib_pdf == LibPDF.PYPDF:
+                self.doc_pdf = ImplementDocumentPyPdf.create_from_file(File(document))
+            elif lib_pdf == LibPDF.FITZ:
+                self.doc_pdf = ImplementDocumentFitz.create_from_file(File(document))
+        elif isinstance(document, File):
+            if lib_pdf == LibPDF.PYPDF:
+                self.doc_pdf = ImplementDocumentPyPdf.create_from_file(document)
+            elif lib_pdf == LibPDF.FITZ:
+                self.doc_pdf = ImplementDocumentFitz.create_from_file(document)
+        elif isinstance(document, PdfWriter):
+            _tmp_bytes = BytesIO()
+            document.write(_tmp_bytes)
+            _tmp_bytes.seek(0)
+            if lib_pdf == LibPDF.PYPDF:
+                name = get_hash_from_bytes(_tmp_bytes)
+                self.doc_pdf = ImplementDocumentPyPdf(document, name)
+                del _tmp_bytes
+            elif lib_pdf == LibPDF.FITZ:
+                self.doc_pdf = ImplementDocumentFitz.create_from_bytes(_tmp_bytes)
+        elif isinstance(document, fitz.Document):
+            _tmp_bytes = BytesIO(document.tobytes())
+            _tmp_bytes.seek(0)
+            if lib_pdf == LibPDF.PYPDF:
+                self.doc_pdf = ImplementDocumentPyPdf.create_from_bytes(_tmp_bytes)
+            elif lib_pdf == LibPDF.FITZ:
+                name = get_hash_from_bytes(_tmp_bytes)
+                self.doc_pdf = ImplementDocumentFitz(document, name)
+                del _tmp_bytes
+        elif isinstance(document, BytesIO):
+            if lib_pdf == LibPDF.PYPDF:
+                self.doc_pdf = ImplementDocumentPyPdf.create_from_bytes(document)
+            elif lib_pdf == LibPDF.FITZ:
+                self.doc_pdf = ImplementDocumentFitz.create_from_bytes(document)
+        elif isinstance(document, ImplementDocumentFitz):
+            self.doc_pdf = document
+        elif isinstance(document, ImplementDocumentPyPdf):
+            self.doc_pdf = document
+
+        if self.doc_pdf is None:
+            raise ValueError(f'documento inválido, use: str, File, PdfWriter, fitz.Document ou BytesIO não => {type(document)}')
+        self.name: str = self.doc_pdf.name
 
-    def get_real_document(self) -> ModuleDocPdf:
+    @property
+    def lenght(self) -> int:
+        return self.doc_pdf.lenght()
+
+    def get_real_document(self) -> fitz.Document | PdfWriter:
         return self.doc_pdf.mod_doc_pdf
 
     def get_first_page(self) -> PageDocumentPdf:
@@ -375,9 +431,6 @@ class DocumentPdf(object):
         """
         return self.doc_pdf.get_page(idx)
 
-    def get_number_pages(self) -> int:
-        return self.doc_pdf.get_number_pages()
-
     def add_page(self, page: PageDocumentPdf):
         self.doc_pdf.add_page(page)
 
@@ -521,25 +574,11 @@ class DocumentPdf(object):
 
     @classmethod
     def create_from_bytes(cls, bt: BytesIO, *, lib_pdf: LibPDF = LibPDF.FITZ) -> DocumentPdf:
-        if lib_pdf == LibPDF.FITZ:
-            mod_pdf = ImplementDocumentFitz.create_from_bytes(bt)
-            return cls(mod_pdf)
-        elif lib_pdf == LibPDF.PYPDF:
-            mod_pdf = ImplementDocumentPyPdf.create_from_bytes(bt)
-            return cls(mod_pdf)
-        else:
-            raise NotImplementedError(f'Módulo PDF não implementado: {lib_pdf}')
+        return cls(bt, lib_pdf=lib_pdf)
 
     @classmethod
     def create_from_file(cls, file: File, *, lib_pdf: LibPDF = DEFAULT_LIB_PDF) -> DocumentPdf:
-        if lib_pdf == LibPDF.FITZ:
-            mod_pdf = ImplementDocumentFitz.create_from_file(file)
-            return cls(mod_pdf)
-        elif lib_pdf == LibPDF.PYPDF:
-            mod_pdf = ImplementDocumentPyPdf.create_from_file(file)
-            return cls(mod_pdf)
-        else:
-            raise NotImplementedError(f'Módulo PDF não implementado: {lib_pdf}')
+        return cls(file, lib_pdf=lib_pdf)
 
     @classmethod
     def create_from_pages(
@@ -549,10 +588,10 @@ class DocumentPdf(object):
             ) -> DocumentPdf:
         if lib_pdf == LibPDF.FITZ:
             mod_pdf = ImplementDocumentFitz.create_from_pages(pages)
-            return cls(mod_pdf)
+            return cls(mod_pdf, lib_pdf=lib_pdf)
         elif lib_pdf == LibPDF.PYPDF:
             mod_pdf = ImplementDocumentPyPdf.create_from_pages(pages)
-            return cls(mod_pdf)
+            return cls(mod_pdf, lib_pdf=lib_pdf)
         else:
             raise NotImplementedError(f'Módulo PDF não implementado: {lib_pdf}')
 
@@ -561,8 +600,6 @@ class CollectionPagePdf(object):
 
     def __init__(self, pages: list[PageDocumentPdf] = list()) -> None:
         self.pages: list[PageDocumentPdf] = pages
-        self.__count: int = 0
-        self.__max_num_pages: int = len(self.pages)
         self.pbar: ProgressBarAdapter = ProgressBarAdapter()
 
     @property
@@ -581,28 +618,25 @@ class CollectionPagePdf(object):
 
     def clear(self):
         self.pages.clear()
-        self.__count = 0
-        self.__max_num_pages = 0
 
     def set_pbar(self, p: ProgressBarAdapter):
         self.pbar = p
 
     def add_page(self, page: PageDocumentPdf) -> None:
-        self.__count += 1
-        self.pbar.update_text(f'Adicionando página PDF {self.__count}')
-        self.__max_num_pages += 1
-        page.number_page = self.__max_num_pages
+        page.number_page = len(self.pages) + 1
+        self.pbar.update_text(f'Adicionando página PDF {page.number_page}')
         self.pages.append(page)
 
     def add_pages(self, pages: list[PageDocumentPdf]) -> None:
+        _counter = len(pages)
         for n, pg in enumerate(pages):
-            self.__max_num_pages += 1
-            pg.number_page = self.__max_num_pages
+            _counter += 1
+            pg.number_page = _counter
             self.pages.append(pg)
 
     def add_file_pdf(self, file: File, *, lib_pdf: LibPDF = DEFAULT_LIB_PDF) -> None:
         self.pbar.update_text(f'Adicionando arquivo PDF {file.basename()}')
-        doc_pdf = DocumentPdf.create_from_file(file, lib_pdf=lib_pdf)
+        doc_pdf = DocumentPdf(file, lib_pdf=lib_pdf)
         self.add_pages(doc_pdf.to_pages())
 
     def add_files_pdf(self, files: list[File], lib_pdf: LibPDF = DEFAULT_LIB_PDF) -> None:
@@ -612,14 +646,9 @@ class CollectionPagePdf(object):
                 ((num + 1) / max_num) * 100,
                 f'Adicionando arquivo: [{num+1} de {max_num}] {f.basename()}'
             )
-            _doc_pdf = DocumentPdf.create_from_file(f, lib_pdf=lib_pdf)
-            _pages_pdf = _doc_pdf.to_pages()
-            for _page in _pages_pdf:
-                self.__max_num_pages += 1
-                _page.number_page = self.__max_num_pages
-                self.pages.append(_page)
+            _doc_pdf = DocumentPdf(f, lib_pdf=lib_pdf)
+            self.add_pages(_doc_pdf.to_pages())
             del _doc_pdf
-            del _pages_pdf
 
     def add_document(self, doc: DocumentPdf) -> None:
         self.add_pages(doc.to_pages())
@@ -631,6 +660,18 @@ class CollectionPagePdf(object):
     def set_land_scape(self):
         for p in self.pages:
             p.set_land_scape()
+            
+    def to_document(self, lib_pdf: LibPDF = DEFAULT_LIB_PDF) -> DocumentPdf:
+        return DocumentPdf.create_from_pages(self.pages, lib_pdf=lib_pdf)
+
+    def to_file_pdf(self, file: File, *, replace: bool = False) -> None:
+        if not replace:
+            if file.exists():
+                print(f'[PULANDO]: o arquivo já existe {file.absolute()}')
+                return
+        _doc = DocumentPdf.create_from_pages(self.pages)
+        _doc.to_file(file)
+        del _doc
 
     def to_files_pdf(
                 self,

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

@@ -7,18 +7,18 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from convert_stream.enum_libs.enums import LibPDF, ColumnsTable
 from convert_stream.enum_libs.modules import (
-    ModulePagePdf, PageObject, PdfWriter, PdfReader, fitz
+    ModPagePdf, PageObject, fitz
 )
 from convert_stream.text.string import FindText, ArrayString, MapText
 
 
 class ABCPagePdf(ABC):
 
-    def __init__(self, mod_page: ModulePagePdf, page_number: int):
+    def __init__(self, mod_page: ModPagePdf, page_number: int):
         if page_number < 1:
             raise ValueError('page_number must be >= 1')
-        self.mod_page: ModulePagePdf = mod_page
-        self.lib_pdf: LibPDF = LibPDF.FITZ
+        self.mod_page: ModPagePdf = mod_page
+        self.lib_pdf: LibPDF = LibPDF.NOT_IMPLEMENTED
         self.number_page: int = page_number
 
     @abstractmethod
@@ -72,21 +72,21 @@ class ABCPagePdf(ABC):
         pass
 
     @classmethod
-    def create_from_pypdf(cls, page: PageObject) -> ABCPagePdf:
+    def create_from_pypdf(cls, page: PageObject, number: int) -> ABCPagePdf:
         pass
 
     @classmethod
-    def create_from_fitz(cls, page: fitz.Page) -> ABCPagePdf:
+    def create_from_fitz(cls, page: fitz.Page, number: int) -> ABCPagePdf:
         pass
 
 
 class ImplementPypdf(ABCPagePdf):
 
-    def __init__(self, mod_page: ModulePagePdf, page_number: int):
+    def __init__(self, mod_page: ModPagePdf, page_number: int):
         super().__init__(mod_page, page_number)
         self.lib_pdf: LibPDF = LibPDF.PYPDF
         self.number_page: int = page_number
-        self.mod_page: ModulePagePdf = mod_page
+        self.mod_page: ModPagePdf = mod_page
 
     def set_rotation(self, num: int):
         try:
@@ -163,7 +163,6 @@ class ImplementPypdf(ABCPagePdf):
         text_page = self.to_string()
         if (text_page is None) or (text_page == '') or (text_page == 'nas'):
             return None
-
         fd = FindText(text_page, separator)
         return fd.find(text, iqual=iqual, case=case)
 
@@ -175,14 +174,13 @@ class ImplementPypdf(ABCPagePdf):
         return fd.find_all(text, iqual=iqual, case=case)
 
     @classmethod
-    def create_from_pypdf(cls, page: ModulePagePdf) -> ImplementPypdf:
-        mod_page: ModulePagePdf = page
-        return ImplementPypdf(mod_page, mod_page.page_number + 1)
+    def create_from_pypdf(cls, page: PageObject, number: int) -> ImplementPypdf:
+        return cls(page, number)
 
 
 class ImplementFitz(ABCPagePdf):
 
-    def __init__(self, mod_page: ModulePagePdf, page_number: int):
+    def __init__(self, mod_page: ModPagePdf, page_number: int):
         super().__init__(mod_page, page_number)
         self.lib_pdf: LibPDF = LibPDF.FITZ
         self.number_page: int = page_number
@@ -276,8 +274,8 @@ class ImplementFitz(ABCPagePdf):
         return fd.find_all(text, iqual=iqual, case=case)
 
     @classmethod
-    def create_from_fitz(cls, page: fitz.Page) -> ABCPagePdf:
-        return cls(page, page.number + 1)
+    def create_from_fitz(cls, page: fitz.Page, number: int) -> ABCPagePdf:
+        return cls(page, number)
 
 
 class PageDocumentPdf(object):
@@ -343,15 +341,13 @@ class PageDocumentPdf(object):
         self.implement_page_pdf.set_rotation(num)
 
     @classmethod
-    def create_from_page_pypdf(cls, page: ModulePagePdf) -> PageDocumentPdf:
-        p = ImplementPypdf.create_from_pypdf(page)
-        return cls(p)
+    def create_from_page_pypdf(cls, page: PageObject, number: int) -> PageDocumentPdf:
+        return cls(ImplementPypdf(page, number))
 
     @classmethod
-    def create_from_page_fitz(cls, page: ModulePagePdf) -> PageDocumentPdf:
+    def create_from_page_fitz(cls, page: fitz.Page, number: int) -> PageDocumentPdf:
         if page is None:
             raise ValueError(f'fitz.Page não pode ser None')
-        p = ImplementFitz.create_from_fitz(page)
-        return cls(p)
+        return cls(ImplementFitz(page, number))
 
 

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/pdf/pdf_to_image.py

@@ -5,13 +5,26 @@
 """
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from soup_files import File, Directory, ProgressBarAdapter, CreatePbar
+from soup_files import Directory, ProgressBarAdapter, CreatePbar
 from convert_stream.enum_libs.enums import LibPdfToImage
 from convert_stream.enum_libs.modules import DEFAULT_LIB_PDF_TO_IMG, DEFAULT_LIB_IMAGE
 from convert_stream.image.img_object import ImageObject, LibImage, CollectionImages
-from convert_stream.pdf.pdf_page import PageDocumentPdf, fitz
+from convert_stream.pdf.pdf_page import PageDocumentPdf
 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
+
 
 class ABCConvertPdf(ABC):
 
@@ -57,48 +70,36 @@ class ImplementConvertPdfFitz(ABCConvertPdf):
 
     def __init__(self, document: DocumentPdf):
         super().__init__(document)
-        self.lib_pdf_to_image: LibPdfToImage = LibPdfToImage.PDF_TO_IMG_FITZ
-        self.__collection_imgs: CollectionImages = CollectionImages()
-        self.__collection_imgs.set_pbar(self.pbar)
 
-    def __extract_images(
-                self, *,
-                dpi: int = 300,
-                lib_image: LibImage = DEFAULT_LIB_IMAGE,
-            ) -> None:
-        """
-            Extrair as imagens do documento e salvar na propriedade CollectionImages()
-        """
-        if not self.__collection_imgs.is_empty:
-            return
+    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
 
-        self.pbar.start()
+    def to_images(
+                self, *,
+                dpi: int = 200,
+                lib_image: LibImage = DEFAULT_LIB_IMAGE
+            ) -> list[ImageObject]:
+        images: list[ImageObject] = []
+        pages_fitz: list[Page] = self.__get_pages()
+        _count = len(pages_fitz)
         print()
-        zoom = dpi / 72  # fator de escala para o fitz.Matrix
-        matrix = fitz.Matrix(zoom, zoom)
-        pages_pdf: list[PageDocumentPdf] = self.document.to_pages()
-        max_num: int = len(pages_pdf)
-        for num, current_page in enumerate(pages_pdf):
+        for n, pg in enumerate(pages_fitz):
             self.pbar.update(
-                ((num + 1) / max_num) * 100,
-                f'Convertendo imagem: {num + 1} de {max_num}',
+                ((n+1)/_count) * 100,
+                f'Convetendo: {n+1} de {_count}'
+            )
+            pix: Pixmap = pg.get_pixmap(dpi=dpi)
+            img = ImageObject.create_from_bytes(
+                pix.tobytes('png', jpg_quality=100),
+                lib_image=LibImage.PIL,
             )
-            page: fitz.Page = current_page.implement_page_pdf.mod_page
-            pix: fitz.Pixmap = page.get_pixmap(matrix=matrix, alpha=False)  # sem canal alpha
-            img_bytes = pix.tobytes("png")
-            img_obj = ImageObject.create_from_bytes(img_bytes, lib_image=lib_image)
-            #img_obj = ImageObject.create_from_pil(pix.pil_image())
-            self.__collection_imgs.add_image(img_obj)
+            images.append(img)
         print()
-        self.pbar.stop()
-
-    def to_images(
-                self, *,
-                dpi: int = 300,
-                lib_image: LibImage = DEFAULT_LIB_IMAGE,
-            ) -> list[ImageObject]:
-        self.__extract_images(dpi=dpi, lib_image=lib_image)
-        return self.__collection_imgs.images
+        return images
 
     def to_files_image(
                 self,
@@ -106,19 +107,28 @@ class ImplementConvertPdfFitz(ABCConvertPdf):
                 replace: bool = False,
                 gaussian_filter: bool = False,
                 dpi: int = 300,
-                lib_image: LibImage = DEFAULT_LIB_IMAGE,
+                lib_image: LibImage = DEFAULT_LIB_IMAGE
             ) -> None:
-        """
-            Renderiza as páginas e salva como PNG.
-        """
-        self.__extract_images(dpi=dpi, lib_image=lib_image)
-        if self.__collection_imgs.is_empty:
-            return
-        self.__collection_imgs.to_files_image(
-            output_dir=output_dir,
-            replace=replace,
-            gaussian_filter=gaussian_filter,
-        )
+        pages_fitz: list[Page] = self.__get_pages()
+        _count = len(pages_fitz)
+        print()
+        for n, pg in enumerate(pages_fitz):
+            self.pbar.update(
+                ((n + 1) / _count) * 100,
+                f'Exportando: {n + 1} de {_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):

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/sheets/load.py

@@ -1,26 +1,23 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 from __future__ import annotations
-import sys
 from abc import ABC, abstractmethod
-from typing import Optional, List
 from openpyxl import Workbook, load_workbook
 from openpyxl.worksheet._read_only import ReadOnlyWorksheet
 from pandas.io.parsers import TextFileReader
 import pandas as pd
 import csv
-from soup_files import File, Directory, ProgressBarAdapter, CreatePbar
-from soup_files.files import ExtensionFiles
+from soup_files import File, ProgressBarAdapter, CreatePbar
 
 
 class ABCSheetReader(ABC):
     """Classe abstrata para leitura de planilhas CSV e EXCEL"""
 
     def __init__(
-                self,
-                file: File, *,
-                pbar: ProgressBarAdapter = CreatePbar().get()
-            ):
+            self,
+            file: File, *,
+            pbar: ProgressBarAdapter = CreatePbar().get()
+    ):
         self.pbar: ProgressBarAdapter = pbar
         self.file: File = file
         self.df = None
@@ -117,8 +114,8 @@ class ReaderCsv(ABCSheetReader):
         total_lines = self.get_total_rows()
         chunks_text: list[TextFileReader] = []
         for num, chunk in enumerate(
-                    pd.read_csv(self.file.absolute(), chunksize=1000, sep=self.separator),
-                ):
+                pd.read_csv(self.file.absolute(), chunksize=1000, sep=self.separator),
+        ):
             percent: float = (((num + 1) * 1000) / total_lines) * 100
             self.pbar.update(percent, f"Lendo CSV [{self.file.basename()}]")
             chunks_text.append(chunk)
@@ -138,9 +135,9 @@ class ReaderCsv(ABCSheetReader):
 class ReaderExcel(ABCSheetReader):
 
     def __init__(
-                self, file: File, *,
-                pbar: ProgressBarAdapter = CreatePbar().get()
-            ):
+            self, file: File, *,
+            pbar: ProgressBarAdapter = CreatePbar().get()
+    ):
         super().__init__(file, pbar=pbar)
         self.df = pd.DataFrame()
 
@@ -315,10 +312,10 @@ class ReaderOds(ABCSheetReader):
 class ReadFileSheet(object):
 
     def __init__(
-                self, file: File, *,
-                separator: str = '\t',
-                pbar: ProgressBarAdapter = CreatePbar().get()
-            ):
+            self, file: File, *,
+            separator: str = '\t',
+            pbar: ProgressBarAdapter = CreatePbar().get()
+    ):
         if file.is_csv():
             self.sheet_reader: ABCSheetReader = ReaderCsv(file, pbar=pbar, separator=separator)
         elif file.is_excel():
@@ -345,5 +342,3 @@ class ReadFileSheet(object):
 
     def get_dataframe(self, sheet_name: str = None, *, progress: bool = True) -> pd.DataFrame:
         return self.sheet_reader.get_dataframe(sheet_name, progress=progress)
-
-

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream/table_files.py

@@ -9,7 +9,7 @@ from soup_files import (
 from convert_stream.enum_libs.enums import ColumnsTable
 from convert_stream.text.string import FindText, ArrayString, MapText
 from convert_stream.pdf.pdf_document import SearchableTextPdf, DocumentPdf
-from convert_stream.stream import PdfStream, CollectionPagePdf
+from convert_stream.doc_stream import PdfStream, CollectionPagePdf
 import pandas as pd
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 2.2.5
+Version: 2.2.7
 Summary: Manipulação de documentos PDF e Imagens. Converter, Ler, rotacionar exportar etc.
 Author: Bruno Chaves
 Requires-Python: >=3.11
@@ -24,12 +24,12 @@ pip3 install -r requirements.txt
     >>> from file import File, Directory
     >>> from pdflib import PdfStream
     # instâncie o caminho do arquivo PDF e o diretório para exportar os dados.
-    f = File('path/to/file.pdf')
-    d = Directory('path/to/save')
+    file_pdf = File('path/to/file.pdf')
+    output_dir = Directory('path/to/save')
 
     pdf_stream = PdfStream()
-    pdf_stream.add_file_pdf(f)
-    pdf_stream.to_files_pdf(d) # isso irá converter cada página em um arquivo PDF
+    pdf_stream.add_file_pdf(file_pdf)
+    pdf_stream.to_files_pdf(output_dir) # isso irá converter cada página em um arquivo PDF
 
 # Uso para unir vários arquivos PDF.
     >>> from file import File, Directory

{convert_stream-2.2.5 → convert_stream-2.2.7}/convert_stream.egg-info/SOURCES.txt

@@ -3,13 +3,14 @@ pyproject.toml
 convert_stream/__init__.py
 convert_stream/__main__.py
 convert_stream/_version.py
-convert_stream/stream.py
+convert_stream/doc_stream.py
 convert_stream/table_files.py
 convert_stream.egg-info/PKG-INFO
 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/enum_libs/__init__.py
 convert_stream/enum_libs/enums.py
 convert_stream/enum_libs/modules.py
 convert_stream/image/__init__.py

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

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

convert_stream-2.2.5/convert_stream/__init__.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-
-from ._version import (
-    __module_name__, __author__, __license__, __modify_date__, __version__
-)
-
-from convert_stream.enum_libs.enums import *
-from convert_stream.enum_libs.modules import (
-    LibPDF, LibDate, LibImage, LibPdfToImage, LibImageToPdf,
-    DEFAULT_LIB_PDF, DEFAULT_LIB_IMAGE, DEFAULT_LIB_PDF_TO_IMG,
-    DEFAULT_LIB_IMAGE_TO_PDF, ModPdfToImage, ModulePagePdf, ModuleImage,
-    ModImageToPdf, MOD_FITZ, MOD_PYPDF, MOD_CANVAS, MOD_IMG_PIL, MOD_IMG_OPENCV,
-)
-from .text.string import (
-    FindText, ArrayString,  print_line, print_title, MapText
-)
-from .text.date import ConvertStringDate
-from convert_stream.image.img_object import (
-    ImageObject, Image, MatLike, get_hash_from_bytes, CollectionImages,
-)
-from convert_stream.pdf import (
-    PageDocumentPdf, DocumentPdf, ConvertImageToPdf, ConvertPdfToImages,
-    ModImageToPdf, ModuleDocPdf, CollectionPagePdf, DEFAULT_LIB_PDF,
-    DEFAULT_LIB_IMAGE_TO_PDF, DEFAULT_LIB_PDF_TO_IMG
-)
-from .stream import PdfStream, SplitPdf
-from .sheets import save_data, ReadFileSheet
-from .table_files import (
-    get_void_df, create_df_from_file_pdf, create_map_from_values,
-    FileToTable, ColumnsTable, PdfFinder, SearchableTextPdf
-)