ocr-stream 2.3.2__tar.gz → 2.4.1__tar.gz

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stream
-Version: 2.3.2
+Version: 2.4.1
 Summary: Extrair textos de documentos digitalizados e imagens.
 Author: Bruno Chaves
 Requires-Python: >=3.11
@@ -12,7 +12,7 @@ Requires-Dist: pandas
 Requires-Dist: requests>=2.32.4
 Requires-Dist: opencv-python
 Requires-Dist: pytesseract
-Requires-Dist: convert_stream>=2.3.2
+Requires-Dist: convert_stream>=2.4.1
 Requires-Dist: soup_files>=1.4
 
 # ocrlib

ocr_stream-2.4.1/ocr_stream/__init__.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+from io import BytesIO
+from ocr_stream.modules import *
+from ocr_stream.bin_tess import BinTesseract, get_path_tesseract_sys
+from ocr_stream.ocr import TesseractOcr, TextRecognized
+from ocr_stream.recognize import (
+    RecognizeImage, RecognizePdf, VoidPbar, ProgressVoid
+)
+import convert_stream as cs
+import pandas as pd
+import soup_files as sp
+
+__version__ = '2.4'
+
+
+def read_image(img: cs.ImageObject, rec: RecognizeImage = RecognizeImage()) -> TextRecognized:
+    _txt = rec.image_recognize(img)
+    _txt.metadata = img.metadata
+    return _txt
+
+
+def read_images(
+            images: list[cs.ImageObject], *,
+            rec: RecognizeImage = RecognizeImage(),
+            pbar: sp.ProgressBarAdapter = sp.CreatePbar().get()
+        ) -> cs.DocumentPdf:
+    pbar.start()
+    print()
+    max_num = len(images)
+    pages = []
+
+    for idx, image in enumerate(images):
+        pbar.update(
+            ((idx + 1) / max_num) * 100,
+            f'[OCR IMAGENS] {idx + 1} / {max_num}',
+        )
+        out = read_image(image, rec=rec).to_page_pdf()
+        pages.append(out)
+    tmp_doc = cs.DocumentPdf.create_from_pages(pages)
+    print()
+    pbar.stop()
+    return tmp_doc
+
+
+def read_document(
+            document: cs.DocumentPdf, *,
+            dpi: int = 300,
+            pbar: sp.ProgressBarAdapter = sp.CreatePbar().get()
+        ) -> cs.DocumentPdf:
+    pbar.start()
+    print()
+    _metadata: cs.MetaDataFile = document.metadata
+    recognized_items: list[TextRecognized] = []
+    pages_pdf: list[cs.PageDocumentPdf] = document.to_pages()
+    total = len(pages_pdf)
+    void_pbar = ProgressVoid()
+    for num, page in enumerate(pages_pdf):
+        pbar.update(
+            ((num + 1) / total) * 100,
+            f'[OCR PDF] {num + 1}/{total} {page.metadata.name}',
+        )
+        convert: cs.ConvertPdfToImages = cs.ConvertPdfToImages(cs.DocumentPdf.create_from_pages([page]))
+        convert.set_pbar(void_pbar)
+        images: list[cs.ImageObject] = convert.to_images(dpi=dpi)
+        for im in images:
+            recognized_items.append(read_image(im))
+    print()
+    final_pages: list[cs.PageDocumentPdf] = [x.to_page_pdf() for x in recognized_items]
+    final_doc: cs.DocumentPdf = cs.DocumentPdf.create_from_pages(final_pages)
+    final_doc.metadata = _metadata
+    return final_doc
+
+
+class SearchableTextImage(object):
+    """
+
+    return {
+            cs.ColumnsTable.KEY.value: cs.ColumnBody(cs.ColumnsTable.KEY.value, ListString([])),
+            cs.ColumnsTable.NUM_PAGE.value: cs.ColumnBody(cs.ColumnsTable.NUM_PAGE.value, ListString([])),
+            cs.ColumnsTable.NUM_LINE.value: cs.ColumnBody(cs.ColumnsTable.NUM_LINE.value, ListString([])),
+            cs.ColumnsTable.TEXT.value: cs.ColumnBody(cs.ColumnsTable.TEXT.value, ListString([])),
+            cs.ColumnsTable.FILE_NAME.value: cs.ColumnBody(cs.ColumnsTable.FILE_NAME.value, ListString([])),
+            cs.ColumnsTable.FILETYPE.value: cs.ColumnBody(cs.ColumnsTable.FILETYPE.value, ListString([])),
+            cs.ColumnsTable.FILE_PATH.value: cs.ColumnBody(cs.ColumnsTable.FILE_PATH.value, ListString([])),
+            cs.ColumnsTable.DIR.value: cs.ColumnBody(cs.ColumnsTable.DIR.value, ListString([])),
+        }
+    """
+    def __init__(self, silent: bool = False):
+        self.silent = silent
+        self.elements: cs.DictTextTable = cs.DictTextTable.create_void_dict()
+
+    def __repr__(self):
+        return f'SearchableTextPdf: {self.elements}'
+
+    @property
+    def length(self) -> int:
+        return len(self.elements[cs.ColumnsTable.TEXT.value])
+
+    def is_empty(self) -> bool:
+        return len(self.elements[cs.ColumnsTable.TEXT.value]) == 0
+
+    @property
+    def columns(self) -> cs.HeadValues:
+        return cs.HeadValues([cs.HeadCell(x) for x in list(self.elements.keys())])
+
+    @property
+    def first(self) -> dict[str, str]:
+        if self.is_empty():
+            return {}
+        cols = self.columns
+        _first = {}
+        for c in cols:
+            _first[c] = self.elements[c][0]
+        return _first
+
+    @property
+    def last(self) -> dict[str, str]:
+        if self.is_empty():
+            return {}
+        if self.is_empty():
+            return {}
+        cols = self.columns
+        _last = {}
+        for c in cols:
+            _last[c] = self.elements[c][-1]
+        return _last
+
+    def get_item(self, idx: int) -> dict[str, str]:
+        _current_item = {}
+        cols = self.columns
+        try:
+            for col in cols:
+                _current_item[col] = self.elements[col][idx]
+        except Exception as err:
+            if not self.silent:
+                print(err)
+            return _current_item
+        else:
+            return _current_item
+
+    def add_line(self, line: dict[str, str]) -> None:
+        cols: cs.HeadValues = self.columns
+        cols_line: cs.HeadValues = cs.HeadValues([cs.HeadCell(y) for y in list(line.keys())])
+        for col in cols:
+            if cols_line.contains(col, case=True, iqual=True):
+                self.elements[col].append(line[col])
+
+    def clear(self) -> None:
+        for _k in self.elements.keys():
+            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[cs.ColumnsTable.TEXT.value])
+        except Exception as e:
+            print(e)
+            return 'nas'
+
+    def to_data_frame(self) -> pd.DataFrame:
+        return pd.DataFrame.from_dict(self.elements)
+
+    def to_file_json(self, file: sp.File):
+        """Exporta os dados da busca para um arquivo JSON"""
+        dt = sp.JsonConvert.from_dict(self.elements).to_json_data()
+        dt.to_file(file)
+
+    def to_file_excel(self, file: sp.File):
+        """Exporta os dados da busca para um arquivo .XLSX"""
+        self.to_data_frame().to_excel(file.absolute(), index=False)
+
+
+class ImageFinder(object):
+    """
+        Classe para Filtrar texto em Imagens
+    """
+
+    def __init__(self):
+        self.docs_collection: dict[str, cs.ImageObject] = {}
+        self.recognize: RecognizeImage = RecognizeImage()
+        self.pbar: sp.ProgressBarAdapter = sp.ProgressBarAdapter()
+
+    def is_empty(self) -> bool:
+        return len(self.docs_collection) == 0
+
+    def clear(self) -> None:
+        self.docs_collection.clear()
+
+    def add_image(self, img: sp.File | bytes | BytesIO | str | cs.ImageObject) -> None:
+        if isinstance(img, sp.File):
+            img = cs.ImageObject(img)
+        elif isinstance(img, cs.ImageObject):
+            pass
+        elif isinstance(img, bytes):
+            img = cs.ImageObject(img)
+        elif isinstance(img, str):
+            img = cs.ImageObject(img)
+        elif isinstance(img, BytesIO):
+            img = cs.ImageObject(img)
+
+        if not img.metadata.file_path.is_empty:
+            self.docs_collection[img.metadata.file_path] = img
+        else:
+            self.docs_collection[img.metadata.name] = img
+
+    def add_images(self, images: list[sp.File] | list[cs.ImageObject] | list[bytes] | list[BytesIO]) -> None:
+        for f in images:
+            self.add_image(f)
+
+    def add_directory_images(self, dir_pdf: sp.Directory) -> None:
+        files = sp.InputFiles(dir_pdf).get_files(file_type=sp.LibraryDocs.IMAGE)
+        if len(files) > 0:
+            self.add_images(files)
+
+    def find(
+            self, text: str,
+            separator: str = '\n',
+            iqual: bool = False,
+            case: bool = False,
+            silent: bool = False,
+            ) -> SearchableTextImage:
+        """
+            Filtrar texto retornando a primeira ocorrência do Documento PDF.
+        """
+        _searchable = SearchableTextImage(silent)
+        if self.is_empty():
+            return _searchable
+
+        total_num: int = len(self.docs_collection.keys())
+        for n, file_key in enumerate(self.docs_collection.keys()):
+            self.pbar.update(
+                ((n + 1) / total_num) * 100,
+                f'[PESQUISANDO]: {n+1}/{total_num}',
+            )
+
+            current_img: cs.ImageObject = self.docs_collection[file_key]
+            txt_in_img = self.recognize.image_to_string(current_img)
+            if (txt_in_img == '') or (txt_in_img is None):
+                self.pbar.update_text(f'ERRO: {n+1} {current_img.metadata.name}')
+                continue
+            try:
+                fd = cs.text.FindText(txt_in_img, separator=separator)
+                idx = fd.find_index(text, iqual=iqual, case=case)
+                if idx is None:
+                    continue
+                math_text: str | None = fd.get_index(idx)
+            except Exception as err:
+                print(f'{__class__.__name__} {err}')
+            else:
+                new_line: dict[str, str] = {
+                    cs.ColumnsTable.KEY.value: f'{idx}',
+                    cs.ColumnsTable.NUM_PAGE.value: 'nan',
+                    cs.ColumnsTable.NUM_LINE.value: f'{idx + 1}',
+                    cs.ColumnsTable.TEXT.value: math_text,
+                    cs.ColumnsTable.FILE_NAME.value: current_img.metadata.file_path,
+                    cs.ColumnsTable.FILETYPE.value: current_img.metadata.extension,
+                    cs.ColumnsTable.FILE_PATH.value: current_img.metadata.dir_path,
+                    cs.ColumnsTable.DIR.value: current_img.metadata.dir_path,
+                }
+                _searchable.add_line(new_line)
+                return _searchable
+        return _searchable
+
+    def find_all(
+                self, text: str,
+                separator: str = '\n',
+                iqual: bool = False,
+                case: bool = False,
+                silent: bool = False,
+            ) -> SearchableTextImage:
+        """
+            Filtrar texto em documento PDF e retorna todas as ocorrências do texto
+        encontradas no documento, incluindo o número da linha, página e nome do arquivo
+        em cada ocorrência.
+        """
+        _searchable = SearchableTextImage(silent)
+        if self.is_empty():
+            return _searchable
+
+        total_num: int = len(self.docs_collection.keys())
+        for n, file_key in enumerate(self.docs_collection.keys()):
+            self.pbar.update(
+                ((n + 1) / total_num) * 100,
+                f'[PESQUISANDO]: {n + 1}/{total_num}',
+            )
+
+            current_img: cs.ImageObject = self.docs_collection[file_key]
+            txt_in_img = self.recognize.image_to_string(current_img)
+            if (txt_in_img == '') or (txt_in_img is None):
+                self.pbar.update_text(f'ERRO: {n + 1} {current_img.metadata.name}')
+                continue
+            try:
+                fd = cs.text.FindText(txt_in_img, separator=separator)
+                idx = fd.find_index(text, iqual=iqual, case=case)
+                if idx is None:
+                    continue
+                math_text: str | None = fd.get_index(idx)
+            except Exception as err:
+                print(f'{__class__.__name__} {err}')
+            else:
+                new_line: dict[str, str] = {
+                    cs.ColumnsTable.KEY.value: f'{idx}',
+                    cs.ColumnsTable.NUM_PAGE.value: 'nan',
+                    cs.ColumnsTable.NUM_LINE.value: f'{idx + 1}',
+                    cs.ColumnsTable.TEXT.value: math_text,
+                    cs.ColumnsTable.FILE_NAME.value: current_img.metadata.file_path,
+                    cs.ColumnsTable.FILETYPE.value: current_img.metadata.extension,
+                    cs.ColumnsTable.FILE_PATH.value: current_img.metadata.dir_path,
+                    cs.ColumnsTable.DIR.value: current_img.metadata.dir_path,
+                }
+                _searchable.add_line(new_line)
+        return _searchable
+
+
+__all__ = [
+    'ImageFinder', 'SearchableTextImage', 'read_images',
+    'read_document', 'RecognizeImage', 'RecognizePdf', 'VoidPbar', 'ProgressVoid'
+]

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/ocr_stream/bin_tess/__init__.py

@@ -93,3 +93,6 @@ class BinTesseract(object):
         if self.__path_tesseract is None:
             return False
         return self.__path_tesseract.exists()
+
+
+__all__ = ['BinTesseract', 'get_path_tesseract_sys']

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/ocr_stream/modules/__init__.py

@@ -29,7 +29,7 @@ try:
 except Exception as err:
     print(err)
     pyocr = object
-    #pyocr.tesseract = object
+
 
 if MOD_PYTESSERACT and MOD_PYOCR:
     ModuleOcr: TypeAlias = Union[pyocr, pytesseract]
@@ -43,3 +43,6 @@ elif MOD_PYOCR:
 else:
     ModuleOcr: TypeAlias = None
     DEFAULT_LIB_OCR = LibOcr.NOT_IMPLEMENTED
+
+
+__all__ = ['LibOcr', 'DEFAULT_LIB_OCR']

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/ocr_stream/ocr/__init__.py

@@ -7,10 +7,10 @@ from typing import Union
 from io import BytesIO
 from pandas import DataFrame
 from soup_files import File
-from convert_stream import (
-    ImageObject, DocumentPdf, PageDocumentPdf, DEFAULT_LIB_IMAGE, LibImage
-)
-from convert_stream.mod_types import get_void_metadata
+from convert_stream import DocumentPdf, PageDocumentPdf
+from convert_stream.mod_types.modules import DEFAULT_LIB_IMAGE, LibImage
+from convert_stream.image import ImageObject
+from convert_stream.mod_types import MetaDataItem, MetaDataFile
 from convert_stream.mod_types.table_types import ColumnBody
 from ocr_stream.modules import (
     LibOcr, DEFAULT_LIB_OCR, pytesseract, Output, pyocr,
@@ -31,8 +31,9 @@ class TextRecognized(object):
     """
 
     def __init__(self, bytes_recognized: bytes):
-        self.metadata: dict[str, str | None] = get_void_metadata()
+        self.metadata: MetaDataFile = MetaDataFile()
         self.bytes_recognized: bytes = bytes_recognized
+
         self.list_bad_char: list[str] = [
             ':', ',', ';', '$', '=',
             '!', '}', '{', '(', ')',
@@ -51,7 +52,10 @@ class TextRecognized(object):
         return doc.to_pages()[0]
 
     def to_document(self) -> DocumentPdf:
-        return DocumentPdf(BytesIO(self.bytes_recognized))
+        tmp_doc = DocumentPdf(BytesIO(self.bytes_recognized))
+        tmp_doc.metadata.file_path = self.metadata.file_path
+        tmp_doc.metadata.dir_path = self.metadata.dir_path
+        return tmp_doc
 
     def to_dict(self, separator: str = '\n') -> dict[str, ColumnBody]:
         return self.to_page_pdf().to_dict(separator=separator)
@@ -205,3 +209,6 @@ class TesseractOcr(object):
         else:
             raise ValueError(f'{lib_ocr} is not supported')
         return cls(md)
+
+
+__all__ = ['TesseractOcr', 'TextRecognized']

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/ocr_stream/recognize.py

@@ -1,11 +1,40 @@
 #!/usr/bin/env python3
 from __future__ import annotations
-from convert_stream import ImageObject, DocumentPdf, PageDocumentPdf, ConvertPdfToImages
+from convert_stream import DocumentPdf, PageDocumentPdf
+from convert_stream.pdf import ConvertPdfToImages
+from convert_stream.image import ImageObject
 from ocr_stream.bin_tess import BinTesseract
 from ocr_stream.modules import LibOcr, DEFAULT_LIB_OCR
 from ocr_stream.ocr import TesseractOcr, TextRecognized
 from pandas import DataFrame
-from soup_files import File, ProgressBarAdapter, CreatePbar
+import soup_files as sp
+
+
+class VoidPbar(sp.ABCProgressBar):
+
+    def __init__(self):
+        super().__init__()
+
+    def set_percent(self, percent: float):
+        pass
+
+    def set_text(self, text: str):
+        pass
+
+
+class ProgressVoid(sp.ProgressBarAdapter):
+
+    def __init__(self, progress_bar: sp.ABCProgressBar = VoidPbar()):
+        super().__init__(progress_bar)
+
+    def update(self, percent: float, status: str = "-"):
+        pass
+
+    def update_percent(self, percent: float = 0):
+        pass
+
+    def update_text(self, text: str = "-"):
+        pass
 
 
 class RecognizeImage(object):
@@ -30,7 +59,7 @@ class RecognizeImage(object):
     def bin_tesseract(self) -> BinTesseract:
         return self.module_ocr.mod_ocr.bin_tess
 
-    def image_content_data(self, img: ImageObject | File) -> DataFrame:
+    def image_content_data(self, img: ImageObject | sp.File) -> DataFrame:
         """
         Retorna uma tabela estruturada com os dados reconhecidos da imagem.
 
@@ -39,35 +68,35 @@ class RecognizeImage(object):
         nível do OCR e confiabilidade, entre outras.
 
         Parâmetros:
-        img (ImageObject | File): A imagem a ser processada, podendo ser um objeto
-        `ImageObject` ou um arquivo `File`.
+        img (ImageObject | sp.File): A imagem a ser processada, podendo ser um objeto
+        `ImageObject` ou um arquivo `sp.File`.
 
         Retorna:
         DataFrame: Uma tabela contendo os dados reconhecidos na imagem.
 
         Lança:
-        ValueError: Se o tipo do parâmetro `img` não for `ImageObject` ou `File`.
+        ValueError: Se o tipo do parâmetro `img` não for `ImageObject` ou `sp.File`.
 
         @param img: Imagem a ser processada, podendo ser uma instância de `ImageObject`
-            ou um arquivo `File`.
-        @type img: ImageObject | File
+            ou um arquivo `sp.File`.
+        @type img: ImageObject | sp.File
 
         @rtype: pandas.DataFrame
         @return: Um DataFrame com os dados reconhecidos na imagem.
 
-        @raise ValueError: Caso o tipo de `img` não seja `ImageObject` nem `File`.
+        @raise ValueError: Caso o tipo de `img` não seja `ImageObject` nem `sp.File`.
         """
         return self.image_recognize(img).to_dataframe()
 
-    def image_recognize(self, img: ImageObject | File, *, land_scape: bool = False) -> TextRecognized:
-        if isinstance(img, File):
+    def image_recognize(self, img: ImageObject | sp.File, *, land_scape: bool = False) -> TextRecognized:
+        if isinstance(img, sp.File):
             img = ImageObject(img)
         if land_scape:
             img.set_landscape()
         rec: TextRecognized = self.module_ocr.to_reconize(img)
         return rec
 
-    def image_to_string(self, img: ImageObject | File) -> str:
+    def image_to_string(self, img: ImageObject | sp.File) -> str:
         return self.module_ocr.to_string(img)
 
 
@@ -79,9 +108,9 @@ class RecognizePdf(object):
                 lib_ocr: LibOcr = DEFAULT_LIB_OCR,
             ):
         self.recognize_image: RecognizeImage = RecognizeImage(bin_tess, lib_ocr=lib_ocr)
-        self.pbar: ProgressBarAdapter = CreatePbar().get()
+        self.pbar: sp.ProgressBarAdapter = sp.CreatePbar().get()
 
-    def set_pbar(self, p: ProgressBarAdapter):
+    def set_pbar(self, p: sp.ProgressBarAdapter):
         self.pbar = p
 
     def recognize_page_pdf(self, page: PageDocumentPdf, *, dpi: int = 300) -> DocumentPdf:
@@ -91,34 +120,38 @@ class RecognizePdf(object):
         """
         _doc = DocumentPdf.create_from_pages([page])
         _conv = ConvertPdfToImages.create(_doc)
+        _conv.set_pbar(self.pbar)
         img: ImageObject = _conv.to_images(dpi=dpi)[0]
         text_recognized: TextRecognized = self.recognize_image.image_recognize(img)
         del _doc
         del _conv
         del img
+        text_recognized.metadata.file_path = page.metadata.file_path
+        text_recognized.metadata.dir_path = page.metadata.dir_path
         return text_recognized.to_document()
 
     def recognize_document(self, doc: DocumentPdf, *, dpi: int = 300) -> DocumentPdf:
         _pages: list[PageDocumentPdf] = []
         _pages.clear()
         _conv = ConvertPdfToImages.create(doc)
+        _conv.set_pbar(self.pbar)
         images: list[ImageObject] = _conv.to_images(dpi=dpi)
         max_num: int = len(images)
         for num, img in enumerate(images):
             self.pbar.update(
                 ((num + 1) / max_num) * 100,
-                f'Aplicando OCR [{num+1} de {max_num}]'
+                f'OCR Documento [{num+1} de {max_num}]'
             )
             text_recognized = self.recognize_image.image_recognize(img)
             _pages.append(text_recognized.to_page_pdf())
         print()
         self.pbar.stop()
         new_doc = DocumentPdf.create_from_pages(_pages)
+        new_doc.metadata = doc.metadata
         return new_doc
 
-    def recognize_file_pdf(self, file: File, *, dpi: int = 300) -> DocumentPdf:
+    def recognize_file_pdf(self, file: sp.File, *, dpi: int = 300) -> DocumentPdf:
         file_doc = DocumentPdf.create_from_file(file)
         recognized_doc = self.recognize_document(file_doc, dpi=dpi)
         del file_doc
         return recognized_doc
-

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/ocr_stream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stream
-Version: 2.3.2
+Version: 2.4.1
 Summary: Extrair textos de documentos digitalizados e imagens.
 Author: Bruno Chaves
 Requires-Python: >=3.11
@@ -12,7 +12,7 @@ Requires-Dist: pandas
 Requires-Dist: requests>=2.32.4
 Requires-Dist: opencv-python
 Requires-Dist: pytesseract
-Requires-Dist: convert_stream>=2.3.2
+Requires-Dist: convert_stream>=2.4.1
 Requires-Dist: soup_files>=1.4
 
 # ocrlib

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/ocr_stream.egg-info/requires.txt

@@ -5,5 +5,5 @@ pandas
 requests>=2.32.4
 opencv-python
 pytesseract
-convert_stream>=2.3.2
+convert_stream>=2.4.1
 soup_files>=1.4

{ocr_stream-2.3.2 → ocr_stream-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ocr_stream"
-version = "2.3.2"
+version = "2.4.1"
 authors = [
   { name="Bruno Chaves"},
 ]
@@ -21,7 +21,7 @@ dependencies = [
     "requests>=2.32.4",
     "opencv-python",
     "pytesseract",
-    "convert_stream>=2.3.2",
+    "convert_stream>=2.4.1",
     "soup_files>=1.4",
 ]
 

ocr_stream-2.3.2/ocr_stream/__init__.py

@@ -1,269 +0,0 @@
-#!/usr/bin/env python3
-
-from ocr_stream.modules import *
-from ocr_stream.bin_tess import BinTesseract, get_path_tesseract_sys
-from ocr_stream.ocr import TesseractOcr, TextRecognized, DEFAULT_LIB_OCR
-from ocr_stream.recognize import RecognizeImage, RecognizePdf
-from soup_files import File
-from convert_stream import (
-    ImageObject, DocumentPdf, ConvertPdfToImages, ColumnsTable, CollectionImages, FindText
-)
-from pandas import DataFrame
-from soup_files import JsonConvert, ProgressBarAdapter, CreatePbar
-
-
-def read_images(
-            images: list[ImageObject], *,
-            pbar: ProgressBarAdapter = CreatePbar().get()
-        ) -> DocumentPdf:
-    pbar.start()
-    print()
-    max_num = len(images)
-    pages = []
-    rec = RecognizeImage()
-    for idx, image in enumerate(images):
-        pbar.update(
-            ((idx + 1) / max_num) * 100,
-            f'[OCR] {idx + 1} / {max_num}',
-        )
-        out = rec.image_recognize(image).to_page_pdf()
-        pages.append(out)
-    tmp_doc = DocumentPdf.create_from_pages(pages)
-    print()
-    pbar.stop()
-    return tmp_doc
-
-
-def read_document(
-            document: DocumentPdf, *,
-            dpi: int = 300,
-            pbar: ProgressBarAdapter = CreatePbar().get()
-        ) -> DocumentPdf:
-    pbar.start()
-    print()
-    convert = ConvertPdfToImages.create(document)
-    convert.set_pbar(pbar)
-    images = convert.to_images(dpi=dpi)
-    print()
-    return read_images(images, pbar=pbar)
-
-
-class SearchableTextImage(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 respetivo arquivo.
-    """
-    def __init__(self, silent: bool = False):
-        self.silent = silent
-        self.elements: dict[str, list[str]] = {
-            ColumnsTable.NUM_LINE.value: [],
-            ColumnsTable.TEXT.value: [],
-            ColumnsTable.FILE_PATH.value: [],
-        }
-
-    def __repr__(self):
-        return f'{__class__.__name__}: {self.elements}'
-
-    def is_empty(self) -> bool:
-        return len(self.elements[ColumnsTable.TEXT.value]) == 0
-
-    @property
-    def first(self) -> dict[str, str]:
-        if self.is_empty():
-            return {}
-        return {
-            ColumnsTable.NUM_LINE.value: self.elements[ColumnsTable.NUM_LINE.value][0],
-            ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][0],
-            ColumnsTable.FILE_PATH.value: self.elements[ColumnsTable.FILE_PATH.value][0],
-        }
-
-    @property
-    def last(self) -> dict[str, str]:
-        if self.is_empty():
-            return {}
-        return {
-            ColumnsTable.NUM_LINE.value: self.elements[ColumnsTable.NUM_LINE.value][-1],
-            ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][-1],
-            ColumnsTable.FILE_PATH.value: self.elements[ColumnsTable.FILE_PATH.value][-1],
-        }
-
-    @property
-    def length(self) -> int:
-        return len(self.elements[ColumnsTable.TEXT.value])
-
-    @property
-    def files(self) -> list[str]:
-        if self.is_empty():
-            return []
-        return self.elements[ColumnsTable.FILE_PATH.value]
-
-    def get_item(self, idx: int) -> dict[str, str]:
-        try:
-            return {
-                ColumnsTable.NUM_LINE.value: self.elements[ColumnsTable.NUM_LINE.value][idx],
-                ColumnsTable.TEXT.value: self.elements[ColumnsTable.TEXT.value][idx],
-                ColumnsTable.FILE_PATH.value: self.elements[ColumnsTable.FILE_PATH.value][idx],
-            }
-        except Exception as err:
-            if not self.silent:
-                print(err)
-            return {}
-
-    def add_line(self, text, *, num_line: str, file: str) -> None:
-        if not self.silent:
-            print('----------------------')
-            print(f'{file} => {text}')
-        self.elements[ColumnsTable.NUM_LINE.value].append(num_line)
-        self.elements[ColumnsTable.TEXT.value].append(text)
-        self.elements[ColumnsTable.FILE_PATH.value].append(file)
-
-    def clear(self) -> None:
-        for _k in self.elements.keys():
-            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:
-            print(e)
-            return 'nas'
-
-    def to_data_frame(self) -> DataFrame:
-        return DataFrame.from_dict(self.elements)
-
-    def to_file_json(self, file: File):
-        """Exporta os dados da busca para 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"""
-        try:
-            self.to_data_frame().to_excel(file.absolute())
-        except Exception as e:
-            print(e)
-
-
-class FindTextImages(object):
-
-    def __init__(
-                self, collection_images: CollectionImages,
-                *,
-                rec_img: RecognizeImage = RecognizeImage(),
-                pbar: ProgressBarAdapter = CreatePbar().get(),
-            ):
-        self.collection_images: CollectionImages = collection_images
-        self._rec_img: RecognizeImage = rec_img
-        self.pbar: ProgressBarAdapter = pbar
-
-    def find(
-            self, text: str,
-            separator: str = '\n',
-            iqual: bool = False,
-            case: bool = False,
-            silent: bool = False,
-    ) -> SearchableTextImage:
-        """
-            Filtrar texto retornando a primeira ocorrência do Documento PDF.
-        """
-        print()
-        self.pbar.start()
-        _searchable = SearchableTextImage(silent)
-
-        max_num: int = self.collection_images.length
-        for idx, image in enumerate(self.collection_images):
-            self.pbar.update(
-                ((idx + 1) / max_num) * 100,
-                f'[Pesquisando]: {idx + 1} / {max_num} Aguarde...',
-            )
-            text_str_in_page: str = self._rec_img.image_to_string(image)
-
-            if (text_str_in_page == 'nas') or (text_str_in_page is None):
-                continue
-            try:
-                fd = FindText(text_str_in_page, separator=separator)
-                idx = fd.find_index(text, iqual=iqual, case=case)
-                if idx is None:
-                    continue
-                math_text = fd.get_index(idx)
-            except Exception as err:
-                print(f'{__class__.__name__} {err}')
-            else:
-                _searchable.add_line(
-                    math_text,
-                    num_line=str(idx + 1),
-                    file=image.name,
-                )
-                return _searchable
-        self.pbar.stop()
-        print()
-        return _searchable
-
-    def find_all(
-            self, text: str,
-            separator: str = '\n',
-            iqual: bool = False,
-            case: bool = False,
-            silent: bool = False,
-    ) -> SearchableTextImage:
-        """
-            Filtrar texto em documento PDF e retorna todas as ocorrências do texto
-        encontradas no documento, incluindo o número da linha, página e nome do arquivo
-        em cada ocorrência.
-        """
-        print()
-        self.pbar.start()
-        _searchable = SearchableTextImage(silent)
-        max_num: int = self.collection_images.length
-        for idx, image in enumerate(self.collection_images):
-            self.pbar.update(
-                ((idx + 1) / max_num) * 100,
-                f'[Pesquisando]: {idx + 1} / {max_num} Aguarde...',
-            )
-
-            text_str_in_page = self._rec_img.image_to_string(image)
-            if (text_str_in_page == 'nas') or (text_str_in_page is None):
-                continue
-            try:
-                _values = text_str_in_page.split(separator)
-                for num, item in enumerate(_values):
-                    if case:
-                        if iqual:
-                            if text == item:
-                                _searchable.add_line(
-                                    item,
-                                    num_line=str(num + 1),
-                                    file=image.name,
-                                )
-                        else:
-                            if text in item:
-                                _searchable.add_line(
-                                    item,
-                                    num_line=str(num + 1),
-                                    file=image.name,
-                                )
-                    else:
-                        if iqual:
-                            if text.lower() == item.lower():
-                                _searchable.add_line(
-                                    item,
-                                    num_line=str(num + 1),
-                                    file=image.name,
-                                )
-                        else:
-                            if text.lower() in item.lower():
-                                _searchable.add_line(
-                                    item,
-                                    num_line=str(num + 1),
-                                    file=image.name,
-                                )
-            except Exception as e:
-                print(f'{__class__.__name__} {e}')
-        self.pbar.stop()
-        print()
-        return _searchable