ocr-stream 2.3__tar.gz → 2.3.3__tar.gz

{ocr_stream-2.3 → ocr_stream-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stream
-Version: 2.3
+Version: 2.3.3
 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
+Requires-Dist: convert_stream>=2.3.3
 Requires-Dist: soup_files>=1.4
 
 # ocrlib

ocr_stream-2.3.3/ocr_stream/__init__.py

@@ -0,0 +1,316 @@
+#!/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
+from convert_stream import DocumentPdf
+from convert_stream.image import ImageObject
+from convert_stream.mod_types import (
+    ColumnsTable, ColumnBody, HeadCell, HeadValues, create_void_table, create_void_map
+)
+from convert_stream.text import FindText
+from convert_stream.pdf import ConvertPdfToImages
+import pandas as pd
+from soup_files import (
+    JsonConvert, ProgressBarAdapter, CreatePbar, Directory, File, InputFiles, LibraryDocs
+)
+
+
+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):
+    """
+
+    create_void_map() -> dict[str, ColumnBody]:
+
+    return {
+            ColumnsTable.KEY.value: ColumnBody(ColumnsTable.KEY.value, ListString([])),
+            ColumnsTable.NUM_PAGE.value: ColumnBody(ColumnsTable.NUM_PAGE.value, ListString([])),
+            ColumnsTable.NUM_LINE.value: ColumnBody(ColumnsTable.NUM_LINE.value, ListString([])),
+            ColumnsTable.TEXT.value: ColumnBody(ColumnsTable.TEXT.value, ListString([])),
+            ColumnsTable.FILE_NAME.value: ColumnBody(ColumnsTable.FILE_NAME.value, ListString([])),
+            ColumnsTable.FILETYPE.value: ColumnBody(ColumnsTable.FILETYPE.value, ListString([])),
+            ColumnsTable.FILE_PATH.value: ColumnBody(ColumnsTable.FILE_PATH.value, ListString([])),
+            ColumnsTable.DIR.value: ColumnBody(ColumnsTable.DIR.value, ListString([])),
+        }
+    """
+    def __init__(self, silent: bool = False):
+        self.silent = silent
+        self.elements: dict[str, ColumnBody] = create_void_map()
+
+    def __repr__(self):
+        return f'SearchableTextPdf: {self.elements}'
+
+    @property
+    def length(self) -> int:
+        return len(self.elements[ColumnsTable.TEXT.value])
+
+    def is_empty(self) -> bool:
+        return len(self.elements[ColumnsTable.TEXT.value]) == 0
+
+    @property
+    def columns(self) -> HeadValues:
+        return HeadValues([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: HeadValues = self.columns
+        cols_line: HeadValues = HeadValues([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[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: 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"""
+        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, ImageObject] = {}
+        self.recognize: RecognizeImage = RecognizeImage()
+        self.pbar: ProgressBarAdapter = 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: File | bytes | BytesIO | str | ImageObject) -> None:
+        if isinstance(img, File):
+            img = ImageObject(img)
+        elif isinstance(img, ImageObject):
+            pass
+        elif isinstance(img, bytes):
+            img = ImageObject(img)
+        elif isinstance(img, str):
+            img = ImageObject(img)
+        elif isinstance(img, BytesIO):
+            img = ImageObject(img)
+
+        if img.metadata['file_path'] is not None:
+            self.docs_collection[img.metadata['file_path']] = img
+        else:
+            self.docs_collection[img.metadata['name']] = img
+
+    def add_images(self, images: list[File] | list[ImageObject] | list[bytes] | list[BytesIO]) -> None:
+        for f in images:
+            self.add_image(f)
+
+    def add_directory_images(self, dir_pdf: Directory) -> None:
+        files = InputFiles(dir_pdf).get_files(file_type=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: 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 = 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:
+                file_path = current_img.metadata["file_path"]
+                file_name = current_img.metadata["name"]
+                dir_path = current_img.metadata["dir_path"]
+                file_type = current_img.metadata["extension"]
+
+                new_line: dict[str, str] = {
+                    ColumnsTable.KEY.value: f'{idx}',
+                    ColumnsTable.NUM_PAGE.value: 'nan',
+                    ColumnsTable.NUM_LINE.value: f'{idx + 1}',
+                    ColumnsTable.TEXT.value: math_text,
+                    ColumnsTable.FILE_NAME.value: file_name if file_path is not None else 'nan',
+                    ColumnsTable.FILETYPE.value: file_type if file_path is not None else 'nan',
+                    ColumnsTable.FILE_PATH.value: file_path if file_path is not None else 'nan',
+                    ColumnsTable.DIR.value: dir_path if file_path is not None else 'nan',
+                }
+                _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: 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 = 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:
+                file_path = current_img.metadata["file_path"]
+                file_name = current_img.metadata["name"]
+                dir_path = current_img.metadata["dir_path"]
+                file_type = current_img.metadata["extension"]
+
+                new_line: dict[str, str] = {
+                    ColumnsTable.KEY.value: f'{idx}',
+                    ColumnsTable.NUM_PAGE.value: 'nan',
+                    ColumnsTable.NUM_LINE.value: f'{idx + 1}',
+                    ColumnsTable.TEXT.value: math_text,
+                    ColumnsTable.FILE_NAME.value: file_name if file_path is not None else 'nan',
+                    ColumnsTable.FILETYPE.value: file_type if file_path is not None else 'nan',
+                    ColumnsTable.FILE_PATH.value: file_path if file_path is not None else 'nan',
+                    ColumnsTable.DIR.value: dir_path if file_path is not None else 'nan',
+                }
+                _searchable.add_line(new_line)
+        return _searchable
+
+
+__all__ = [
+    'ImageFinder', 'SearchableTextImage', 'read_images',
+    'read_document', 'RecognizeImage', 'RecognizePdf'
+]

{ocr_stream-2.3 → ocr_stream-2.3.3}/ocr_stream/bin_tess/__init__.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 import os
 from shutil import which
-from soup_files import File, Directory, KERNEL_TYPE
+from soup_files import File, KERNEL_TYPE
 
 
 def __get_path_tesseract_unix() -> File | None:
@@ -95,3 +95,4 @@ class BinTesseract(object):
         return self.__path_tesseract.exists()
 
 
+__all__ = ['BinTesseract', 'get_path_tesseract_sys']

{ocr_stream-2.3 → ocr_stream-2.3.3}/ocr_stream/modules/__init__.py

@@ -17,7 +17,8 @@ MOD_PYOCR: bool = False
 try:
     from pytesseract import pytesseract, Output
     MOD_PYTESSERACT = True
-except:
+except Exception as err:
+    print(err)
     pytesseract = None
     Output = None
 
@@ -25,7 +26,8 @@ try:
     import pyocr
     import pyocr.tesseract
     MOD_PYOCR = True
-except:
+except Exception as err:
+    print(err)
     pyocr = object
     #pyocr.tesseract = object
 
@@ -41,3 +43,7 @@ elif MOD_PYOCR:
 else:
     ModuleOcr: TypeAlias = None
     DEFAULT_LIB_OCR = LibOcr.NOT_IMPLEMENTED
+
+
+__all__ = ['LibOcr', 'DEFAULT_LIB_OCR']
+

{ocr_stream-2.3 → ocr_stream-2.3.3}/ocr_stream/ocr/__init__.py

@@ -6,20 +6,21 @@ from abc import abstractmethod, ABC
 from typing import Union
 from io import BytesIO
 from pandas import DataFrame
-from soup_files import File, Directory
-from convert_stream import (
-    ImageObject, DocumentPdf, PageDocumentPdf, MapText, ColumnsTable,
-    get_hash_from_bytes, DEFAULT_LIB_IMAGE, LibImage
-)
+from soup_files import File
+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 get_void_metadata
+from convert_stream.mod_types.table_types import ColumnBody
 from ocr_stream.modules import (
-    LibOcr, ModuleOcr, DEFAULT_LIB_OCR, MOD_PYOCR, MOD_PYTESSERACT,
-    pytesseract, Output, pyocr,
+    LibOcr, DEFAULT_LIB_OCR, pytesseract, Output, pyocr,
 )
 from ocr_stream.bin_tess import BinTesseract
 
 try:
     import pyocr.tesseract
-except:
+except Exception as err:
+    print(err)
     pyocr = None
 
 
@@ -30,6 +31,7 @@ class TextRecognized(object):
     """
 
     def __init__(self, bytes_recognized: bytes):
+        self.metadata: dict[str, str | None] = get_void_metadata()
         self.bytes_recognized: bytes = bytes_recognized
         self.list_bad_char: list[str] = [
             ':', ',', ';', '$', '=',
@@ -51,21 +53,11 @@ class TextRecognized(object):
     def to_document(self) -> DocumentPdf:
         return DocumentPdf(BytesIO(self.bytes_recognized))
 
-    def to_map(self, separator: str = '\n') -> MapText:
-        text = self.to_string()
-        if (text is None) or (text == '') or (text == 'nas'):
-            return MapText([])
-        try:
-            return MapText(text.split(separator))
-        except Exception as err:
-            print(err)
-            return MapText([])
-
-    def to_dict(self, separator: str = '\n') -> dict[str, list[str]]:
-        return self.to_map(separator).map_elements
+    def to_dict(self, separator: str = '\n') -> dict[str, ColumnBody]:
+        return self.to_page_pdf().to_dict(separator=separator)
 
     def to_dataframe(self, separator='\n') -> DataFrame:
-        return self.to_map(separator).to_data()
+        return DataFrame.from_dict(self.to_dict(separator=separator))
 
 
 class ABCOcrTesseract(ABC):
@@ -166,8 +158,6 @@ class IPyOcr(ABCOcrTesseract):
             self.lang = lang
         else:
             self.lang = langs[0]
-
-        # Ex: Will use tool 'libtesseract'
         print(f"Will use tool {self._pyOcr.get_name()}")
 
     def to_string(self, img: Union[File, ImageObject]) -> str:
@@ -215,3 +205,6 @@ class TesseractOcr(object):
         else:
             raise ValueError(f'{lib_ocr} is not supported')
         return cls(md)
+
+
+__all__ = ['TesseractOcr', 'TextRecognized']

{ocr_stream-2.3 → ocr_stream-2.3.3}/ocr_stream/recognize.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python3
 from __future__ import annotations
-from convert_stream import ImageObject, LibImage, DocumentPdf, PageDocumentPdf, ConvertPdfToImages, PdfStream
+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, ModuleOcr
+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

{ocr_stream-2.3 → ocr_stream-2.3.3}/ocr_stream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stream
-Version: 2.3
+Version: 2.3.3
 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
+Requires-Dist: convert_stream>=2.3.3
 Requires-Dist: soup_files>=1.4
 
 # ocrlib

{ocr_stream-2.3 → ocr_stream-2.3.3}/ocr_stream.egg-info/requires.txt

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

{ocr_stream-2.3 → ocr_stream-2.3.3}/pyproject.toml

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

ocr_stream-2.3/ocr_stream/__init__.py

@@ -1,51 +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, Directory, InputFiles, LibraryDocs, CreatePbar, ProgressBarAdapter
-from convert_stream import ImageObject, PdfStream, DocumentPdf, ConvertPdfToImages
-
-
-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)
-
-
-
-
-
-
-