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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: convert_stream
-Version: 2.3.3
+Version: 2.3.5
 Summary: Manipulação de documentos PDF e Imagens. Converter, Ler, rotacionar exportar etc.
 Author: Bruno Chaves
 Requires-Python: >=3.11
@@ -21,8 +21,9 @@ pip3 install -r requirements.txt
 
 
 # Uso dividir páginas de um arquivo PDF:
-    >>> from file import File, Directory
+    >>> from soup_files import File, Directory
     >>> from pdflib import PdfStream
+
     # instâncie o caminho do arquivo PDF e o diretório para exportar os dados.
     file_pdf = File('path/to/file.pdf')
     output_dir = Directory('path/to/save')
@@ -32,8 +33,9 @@ pip3 install -r requirements.txt
     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
+    >>> from soup_files import File, Directory
     >>> from pdflib import PdfStream
+
     # instâncie o caminho dos arquivos PDF que deseja unir.
     f = File('path/to/file.pdf')
     f2 = File('path/to/file2.pdf)

{convert_stream-2.3.3 → convert_stream-2.3.5}/README.md

@@ -3,8 +3,9 @@ pip3 install -r requirements.txt
 
 
 # Uso dividir páginas de um arquivo PDF:
-    >>> from file import File, Directory
+    >>> from soup_files import File, Directory
     >>> from pdflib import PdfStream
+
     # instâncie o caminho do arquivo PDF e o diretório para exportar os dados.
     file_pdf = File('path/to/file.pdf')
     output_dir = Directory('path/to/save')
@@ -14,8 +15,9 @@ pip3 install -r requirements.txt
     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
+    >>> from soup_files import File, Directory
     >>> from pdflib import PdfStream
+
     # instâncie o caminho dos arquivos PDF que deseja unir.
     f = File('path/to/file.pdf')
     f2 = File('path/to/file2.pdf)

{convert_stream-2.3.3 → convert_stream-2.3.5}/convert_stream/__init__.py

@@ -2,14 +2,21 @@
 from __future__ import annotations
 from io import BytesIO
 from typing import Union
-from soup_files import File
+from soup_files import File, Directory, LibraryDocs, InputFiles
 
 from ._version import (
     __module_name__, __author__, __license__, __modify_date__, __version__
 )
+from .mod_types import (
+    MetaDataFile, MetaDataItem, create_metadata, ColumnsTable, ListString, ArrayString,
+    HeadCell, HeadValues, ColumnBody, TextTable, LibDate, LibPDF, LibImage, LibPdfToImage,
+    LibImageToPdf, create_dict_map_from_file, create_void_dict_map, RotationAngle
+)
 from .image import ImageObject, CollectionImages
 from .pdf import DocumentPdf, PageDocumentPdf, CollectionPagePdf
-from .doc_stream import PdfStream
+from .pdf.pdf_document import SearchableTextPdf
+from .doc_stream import PdfStream, SplitPdf
+from .table_files import PdfFinder
 
 
 def __create_stream() -> PdfStream:
@@ -68,6 +75,10 @@ def read_image(img: Union[str, File, bytes, BytesIO]) -> PdfStream:
 __all__ = [
     '__modify_date__', '__author__', '__license__', '__module_name__', '__version__',
     'PdfStream', 'DocumentPdf', 'PageDocumentPdf', 'CollectionPagePdf', 'CollectionImages',
-    'read_pdf', 'read_files_pdf', 'read_image',
+    'ImageObject', 'File', 'Directory', 'LibraryDocs', 'InputFiles', 'SearchableTextPdf',
+    'PdfFinder', 'SplitPdf', 'read_pdf', 'read_files_pdf', 'read_image',
+    'MetaDataFile', 'MetaDataItem', 'create_metadata', 'ColumnsTable', 'ListString', 'ArrayString',
+    'HeadCell', 'HeadValues', 'ColumnBody', 'TextTable', 'LibDate', 'LibPDF', 'LibImage', 'LibPdfToImage',
+    'LibImageToPdf', 'create_dict_map_from_file', 'create_void_dict_map', 'RotationAngle'
 ]
 

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

@@ -183,7 +183,7 @@ class PdfStream(object):
 
 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)

convert_stream-2.3.5/convert_stream/image/__init__.py

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

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

@@ -10,12 +10,12 @@ from soup_files import File, Directory, InputFiles, LibraryDocs, ProgressBarAdap
 from io import BytesIO
 import numpy as np
 from scipy.ndimage import uniform_filter
-from convert_stream.mod_types import get_void_metadata, get_hash_from_bytes
+from convert_stream.mod_types import get_hash_from_bytes, MetaDataFile, MetaDataItem, create_metadata
 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
+    cv2, MatLike, Image, ImageFilter, LibImage
 )
 
 
@@ -26,11 +26,11 @@ class ABCImageObject(ABC):
         self.max_size: tuple[int, int] = (1980, 720)
         self.module_image: ModuleImage = module_image
         self.lib_image: LibImage = LibImage.OPENCV
-        self.metadata: dict[str, str | None] = get_void_metadata()
+        self.metadata: MetaDataFile = MetaDataFile()
 
     @property
     def name(self) -> str | None:
-        return self.metadata['name']
+        return self.metadata.name if not self.metadata.name.is_empty else None
 
     @abstractmethod
     def get_dimensions(self) -> tuple[int, int]:
@@ -205,11 +205,7 @@ class ImplementOpenCv(ABCImageObject):
         if img is None:
             raise ValueError(f"Não foi possível abrir a imagem: {f.absolute()}")
         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()
+        im_obj.metadata = create_metadata(f)
         return im_obj
 
     @classmethod
@@ -221,10 +217,10 @@ class ImplementOpenCv(ABCImageObject):
         bytes_io = BytesIO(bt)
         name: str = get_hash_from_bytes(bytes_io)
         bytes_io.close()
-        _obj = cls(img)
-        _obj.metadata['md5'] = name
-        _obj.metadata['name'] = name
-        return _obj
+        im_obj = cls(img)
+        im_obj.metadata.name = MetaDataItem(name)
+        im_obj.metadata.md5 = MetaDataItem(name)
+        return im_obj
 
 
 class ImplementPIL(ABCImageObject):
@@ -352,13 +348,9 @@ class ImplementPIL(ABCImageObject):
 
     @classmethod
     def create_from_file(cls, f: File) -> ABCImageObject:
-        img = Image.open(f.path)
+        img = Image.open(f.absolute())
         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()
+        im_obj.metadata = create_metadata(f)
         return im_obj
 
     @classmethod
@@ -368,8 +360,8 @@ class ImplementPIL(ABCImageObject):
         name = get_hash_from_bytes(bytes_io)
         bytes_io.close()
         _obj = cls(img)
-        _obj.metadata['md5'] = name
-        _obj.metadata['name'] = name
+        _obj.metadata.name = MetaDataItem(name)
+        _obj.metadata.md5 = MetaDataItem(name)
         return _obj
 
 
@@ -419,9 +411,13 @@ class ImageObject(object):
         return self.img_adapter.name
 
     @property
-    def metadata(self) -> dict[str, str | None]:
+    def metadata(self) -> MetaDataFile:
         return self.img_adapter.metadata
 
+    @metadata.setter
+    def metadata(self, metadata: MetaDataFile) -> None:
+        self.img_adapter.metadata = metadata
+
     def to_pil(self) -> Image.Image:
         """
         Converte o ImageObject para um objeto PIL.Image.
@@ -600,3 +596,72 @@ class CollectionImages(ListItems):
     def set_pbar(self, p: ProgressBarAdapter) -> None:
         self.pbar = p
 
+
+class ProcessImageScanner(object):
+
+    def __init__(self, image: ImageObject):
+        self.image: ImageObject = image
+
+    def select_doc(self) -> ImageObject | None:
+        """
+        Detecta e recorta automaticamente a área do documento principal
+        (texto ou folha digitalizada) em uma imagem.
+        Retorna um novo ImageObject contendo apenas o recorte detectado.
+        """
+        # Converte para matriz OpenCV
+        img_cv: np.ndarray = cv2.imdecode(self.image.to_numpy(), cv2.IMREAD_COLOR)
+        if img_cv is None:
+            print(f'[NDARRAY] Falha na imagem: {self.image.metadata.name}')
+            return None
+
+        # Etapa 1: converter para tons de cinza
+        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+
+        # Etapa 2: aplicar blur para suavizar ruídos
+        gray_blur = cv2.GaussianBlur(gray, (5, 5), 0)
+
+        # Etapa 3: detecção de bordas
+        edges = cv2.Canny(gray_blur, 50, 150)
+
+        # Etapa 4: encontrar contornos
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            print(f'[CONTOURS] Falha na imagem: {self.image.metadata.name}')
+            return None
+
+        # Etapa 5: selecionar o maior contorno plausível (maior área retangular)
+        contours = sorted(contours, key=cv2.contourArea, reverse=True)
+        doc_contour = None
+
+        for c in contours:
+            perimeter = cv2.arcLength(c, True)
+            approx = cv2.approxPolyDP(c, 0.02 * perimeter, True)
+            if len(approx) == 4:
+                doc_contour = approx
+                break
+
+        if doc_contour is None:
+            # Caso não encontre um quadrilátero, usa o maior contorno
+            doc_contour = contours[0]
+
+        # Etapa 6: criar bounding box e recortar
+        x, y, w, h = cv2.boundingRect(doc_contour)
+        cropped = img_cv[y:y + h, x:x + w]
+
+        # Evitar recortes muito pequenos (ruído)
+        if w < 50 or h < 50:
+            return None
+
+        # Etapa 7: converter o recorte em ImageObject
+        success, buffer = cv2.imencode(".png", cropped)
+        if not success:
+            print(f'Falha na imagem: {self.image.metadata.name}')
+            return None
+
+        bytes_io = BytesIO(buffer.tobytes())
+        new_image = ImageObject(bytes_io, lib_image=LibImage.OPENCV)
+        # Herdar metadados originais
+        new_image.metadata = self.image.metadata
+        new_image.metadata.name = MetaDataItem(f"{self.image.metadata.name}_crop")
+        return new_image
+

convert_stream-2.3.5/convert_stream/mod_types/__init__.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+#
+from __future__ import annotations
+from hashlib import md5 as md5_hash
+from io import BytesIO
+from soup_files import File
+from .enums import (
+    RotationAngle, ColumnsTable, LibImage, LibPdfToImage, LibPDF, LibImageToPdf, LibDate
+)
+
+from .table_types import (
+    TextTable, ListString, ArrayString, HeadCell, HeadValues,
+    ColumnBody, create_void_dict_map, create_dict_map_values, create_void_df_map,
+    create_dict_map_from_file, 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)}")
+
+
+class MetaDataItem(str):
+
+    def __init__(self, text: str = 'nan'):
+        super().__init__()
+        self.text: str = text
+
+    @property
+    def is_empty(self) -> bool:
+        return self.text == 'nan'
+
+
+class MetaDataFile(object):
+
+    def __init__(
+                self, *,
+                file_path: MetaDataItem = MetaDataItem(),
+                dir_path: MetaDataItem = MetaDataItem(),
+                name: MetaDataItem = MetaDataItem(),
+                md5: MetaDataItem = MetaDataItem(),
+                size: MetaDataItem = MetaDataItem(),
+                extension: MetaDataItem = MetaDataItem(),
+                origin_src: MetaDataItem = MetaDataItem(),
+            ):
+        self.file_path: MetaDataItem = file_path
+        self.dir_path: MetaDataItem = dir_path
+        self.name: MetaDataItem = name
+        self.md5: MetaDataItem = md5
+        self.size: MetaDataItem = size
+        self.extension: MetaDataItem = extension
+        self.origin_src: MetaDataItem = origin_src
+
+    def to_dict(self) -> dict[str, str | None]:
+        return {
+            'file_path': self.file_path if not self.file_path.is_empty else None,
+            'dir_path': self.dir_path if not self.dir_path.is_empty else None,
+            'name': self.name if not self.name.is_empty else None,
+            'md5': self.md5 if not self.md5.is_empty else None,
+            'size': self.size if not self.size.is_empty else None,
+            'extension': self.extension if not self.extension.is_empty else None,
+            'origin_src': self.origin_src if not self.origin_src.is_empty else None,
+        }
+
+
+def get_void_metadata() -> dict[str, str | None]:
+    """
+        Salvar os metadados básico de documentos/imagens lidas em disco.
+    """
+    return MetaDataFile().to_dict()
+
+
+def create_metadata(file: str | File) -> MetaDataFile:
+    if isinstance(file, str):
+        file = File(file)
+    mt = MetaDataFile(
+        file_path=MetaDataItem(file.absolute()),
+        dir_path=MetaDataItem(file.dirname()),
+        extension=MetaDataItem(file.extension()),
+        origin_src=MetaDataItem('file'),
+        name=MetaDataItem(file.name()),
+    )
+    if file.exists():
+        mt.size = MetaDataItem(file.size())
+        mt.md5 = MetaDataItem(file.md5())
+    return mt
+
+
+__all__ = [
+    'get_hash_from_bytes', 'get_void_metadata', 'get_void_metadata', 'contains',
+    'concat_maps', 'create_dict_map_from_file', 'create_dict_map_values',
+    'create_void_df_map', 'create_void_dict_map', 'ColumnBody', 'ColumnsTable',
+    'ListString', 'HeadCell', 'HeadValues', 'TextTable', 'RotationAngle', 'LibPDF',
+    'LibImageToPdf', 'LibPdfToImage', 'LibImage', 'LibDate', 'ArrayString',
+    'MetaDataFile', 'MetaDataItem', 'create_metadata',
+]

{convert_stream-2.3.3 → convert_stream-2.3.5}/convert_stream/mod_types/table_types.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
-#
+
 from __future__ import annotations
 from convert_stream.mod_types.enums import ColumnsTable
 import os.path
 import pandas as pd
-from soup_files import File, ProgressBarAdapter, CreatePbar
+from soup_files import File
 
 
 def contains(text: str, values: list[str], *, case: bool = True, iqual: bool = False) -> bool:
@@ -32,6 +32,61 @@ def contains(text: str, values: list[str], *, case: bool = True, iqual: bool = F
     return False
 
 
+def find_index(text: str, values: list[str], *, case: bool = True, iqual: bool = False) -> int | None:
+    """
+        Verificar se um texto existe em lista de ‘strings’ se existir, retorna o índice da posição
+    do texto na lista.
+    """
+    _idx: int | None = None
+    if case:
+        if iqual:
+            for num, x in enumerate(values):
+                if text == x:
+                    _idx = num
+                    break
+        else:
+            for num, x in enumerate(values):
+                if text in x:
+                    _idx = num
+                    break
+    else:
+        if iqual:
+            for num, x in enumerate(values):
+                if text.upper() == x.upper():
+                    _idx = num
+                    break
+        else:
+            for num, x in enumerate(values):
+                if text.upper() in x.upper():
+                    _idx = num
+                    break
+    return _idx
+
+
+def find_all_index(text: str, values: list[str], *, case: bool = True, iqual: bool = False) -> list[int]:
+    """
+
+    """
+    items: list[int] = ListItems([])
+    if iqual:
+        for num, i in enumerate(values):
+            if case:
+                if i == text:
+                    items.append(num)
+            else:
+                if text.lower() == i.lower():
+                    items.append(num)
+    else:
+        for num, i in enumerate(values):
+            if case:
+                if text in i:
+                    items.append(num)
+            else:
+                if text.lower() in i.lower():
+                    items.append(num)
+    return items
+
+
 class ListItems(list):
 
     def __init__(self, items: list):
@@ -57,6 +112,9 @@ class ListString(ListItems):
     def contains(self, item: str, *, case: bool = True, iqual: bool = False) -> bool:
         return contains(item, self, case=case, iqual=iqual)
 
+    def find_index(self, item: str, *, case: bool = True, iqual: bool = False) -> int | None:
+        return find_index(item, self, case=case, iqual=iqual)
+
     def get(self, idx: int) -> str:
         return self[idx]
 
@@ -77,35 +135,23 @@ class ArrayString(ListString):
     def __init__(self, items: list[str]):
         super().__init__(items)
 
-    def get_next(self, text: str, *, iqual: bool = False, case: bool = False) -> str | None:
+    def get_next_string(self, text: str, *, iqual: bool = False, case: bool = False) -> str | None:
         """
         Ao encontrar o texto 'text' na lista retorna a próxima string se existir, se não retorna None.
         """
-        _idx: int | None = self.get_back_index(text, iqual=iqual, case=case)
-        if _idx is None:
-            return None
-        if _idx < 0:
-            return None
-        if _idx >= self.length - 1:
-            return None
-        return self[_idx+1]
+        next_idx: int | None = self.get_next_index(text, iqual=iqual, case=case)
+        return None if next_idx is None else self[next_idx]
 
     def get_next_all(self, text: str, iqual: bool = False, case: bool = False) -> ListString:
-        _idx: int | None = self.get_back_index(text, iqual=iqual, case=case)
-        if _idx is None:
-            return ListString([])
-        if _idx < 0:
-            return ListString([])
-        if _idx >= self.length - 1:
-            return ListString([])
-        return ListString(self[(_idx + 1):])
+        next_idx: int | None = self.get_next_index(text, iqual=iqual, case=case)
+        return ListString([]) if next_idx is None else ListString(self[next_idx:])
 
     def get_next_index(self, text: str, *, iqual: bool = False, case: bool = False) -> int | None:
         """
             Ao encontrar o texto 'text' na lista retorna o índice da string anterior
         se existir, se não retorna None.
         """
-        _idx: int | None = self.get_back_index(text, iqual=iqual, case=case)
+        _idx: int | None = self.find_index(text, iqual=iqual, case=case)
         if _idx is None:
             return None
         if _idx < 0:
@@ -126,7 +172,7 @@ class ArrayString(ListString):
             return None
         return _final_idx - 1
 
-    def get_back(self, text: str, iqual: bool = False, case: bool = False) -> str | None:
+    def get_back_string(self, text: str, iqual: bool = False, case: bool = False) -> str | None:
         """
         Ao encontrar o texto 'text' na lista retorna a string anterior se existir, se não retorna None.
         """
@@ -137,79 +183,24 @@ class ArrayString(ListString):
         _idx = self.get_back_index(text, iqual=iqual, case=case)
         return ListString([]) if _idx is None else ListString(self[:_idx])
 
-    def find_index(self, text: str, *, iqual: bool = False, case: bool = True) -> int | None:
-        num_idx = None
-        if iqual:
-            for idx, i in enumerate(self):
-                if case:
-                    if i == text:
-                        num_idx = idx
-                        break
-                else:
-                    if text.lower() == i.lower():
-                        num_idx = idx
-                        break
-        else:
-            for idx, i in enumerate(self):
-                if case:
-                    if text in i:
-                        num_idx = idx
-                        break
-                else:
-                    if text.lower() in i.lower():
-                        num_idx = idx
-                        break
-        return num_idx
-
     def get(self, idx: int) -> str:
         return self[idx]
 
-    def find(self, text: str, *, iqual: bool = False, case: bool = False) -> str | None:
-        if text is None:
+    def find_text(self, text: str, *, iqual: bool = False, case: bool = False) -> str | None:
+        if (text is None) or (text == ""):
             raise ValueError(f'{__class__.__name__}: text is None')
+        idx_item = self.find_index(text, iqual=iqual, case=case)
+        return None if idx_item is None else self[idx_item]
 
-        element = None
-        if iqual:
-            for i in self:
-                if case:
-                    if text == i:
-                        element = i
-                        break
-                else:
-                    if text.lower() == i.lower():
-                        element = i
-                        break
-        else:
-            for i in self:
-                if case:
-                    if text in i:
-                        element = i
-                        break
-                else:
-                    if text.lower() in i.lower():
-                        element = i
-                        break
-        return element
+    def find_all(self, text: str, *, iqual: bool = False, case: bool = True) -> ListString:
+        list_idx: list[int] = find_all_index(text, self, case=case, iqual=iqual)
+        if len(list_idx) == 0:
+            return ListString([])
 
-    def find_all(self, text: str, *, iqual: bool = False, case: bool = True) -> list[str]:
-        items = []
-        if iqual:
-            for i in self:
-                if case:
-                    if i == text:
-                        items.append(i)
-                else:
-                    if text.lower() == i.lower():
-                        items.append(i)
-        else:
-            for i in self:
-                if case:
-                    if text in i:
-                        items.append(i)
-                else:
-                    if text.lower() in i.lower():
-                        items.append(i)
-        return items
+        new_values = ListString([])
+        for idx in list_idx:
+            new_values.append(self[idx])
+        return new_values
 
     def count(self, text: str, *, iqual: bool = False, case: bool = True) -> int:
         count: int = 0
@@ -257,7 +248,7 @@ class HeadValues(ListString):
             self.append(i)
 
 
-class ColumnBody(ListString):
+class ColumnBody(ArrayString):
     """
         Lista de strings nomeada para representar os dados da coluna de uma tabela.
     """
@@ -301,7 +292,7 @@ class TextTable(dict):
         self[col.col_name] = col
 
 
-def create_void_map() -> dict[str, ColumnBody]:
+def create_void_dict_map() -> dict[str, ColumnBody]:
 
     return {
             ColumnsTable.KEY.value: ColumnBody(ColumnsTable.KEY.value, ListString([])),
@@ -315,16 +306,16 @@ def create_void_map() -> dict[str, ColumnBody]:
         }
 
 
-def create_void_table() -> pd.DataFrame:
+def create_void_df_map() -> pd.DataFrame:
     """
         Retorna um DataFrame() vazio, apenas com as colunas formatadas
     para tabela de arquivos.
     @rtype: pd.DataFrame
     """
-    return pd.DataFrame.from_dict(create_void_map())
+    return pd.DataFrame.from_dict(create_void_dict_map())
 
 
-def create_map_from_values(
+def create_dict_map_values(
             values: list[str], *,
             page_num: str = 'nan',
             file_path: str = 'nan',
@@ -343,9 +334,9 @@ def create_map_from_values(
     """
     max_num = len(values)
     if max_num < 1:
-        return create_void_map()
+        return create_void_dict_map()
 
-    _map: dict[str, ColumnBody] = create_void_map()
+    _map: dict[str, ColumnBody] = create_void_dict_map()
     _map[ColumnsTable.KEY.value].extend([f'{x}' for x in range(0, max_num)])
     _map[ColumnsTable.NUM_PAGE.value].extend([page_num] * max_num)
     _map[ColumnsTable.NUM_LINE.value].extend([f'{x+1}' for x in range(0, max_num)])
@@ -357,8 +348,9 @@ def create_map_from_values(
     return _map
 
 
-def create_map_from_file_values(
-            file: File, values: list[str], *,
+def create_dict_map_from_file(
+            file: File,
+            values: list[str], *,
             page_num: str = 'nan'
         ) -> dict[str, ColumnBody]:
     """
@@ -370,16 +362,19 @@ def create_map_from_file_values(
     """
     max_num = len(values)
     if max_num < 1:
-        return create_void_map()
-    return create_map_from_values(
+        return create_void_dict_map()
+    return create_dict_map_values(
         values, page_num=page_num, file_path=file.absolute(), dir_path=file.dirname(), file_type=file.extension()
     )
 
 
-def get_text_from_file(file: str) -> ListString:
+def get_text_from_file(file: str | File) -> ListString:
     """
         Retorna o texto de um arquivo .txt em formato de lista
     """
+    if isinstance(file, File):
+        file = file.absolute()
+
     try:
         with open(file, 'rt') as f:
             lines = ListString(f.readlines())