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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stream
-Version: 2.4.1
+Version: 2.4.2
 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.4.1
+Requires-Dist: convert_stream>=2.4.3
 Requires-Dist: soup_files>=1.4
 
 # ocrlib

{ocr_stream-2.4.1 → ocr_stream-2.4.2}/ocr_stream/__init__.py

@@ -4,27 +4,31 @@ 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
+from ocr_stream.recognize import RecognizeImage, RecognizePdf
+from convert_stream import DocumentPdf
+from convert_stream.image import ImageObject
+from sheet_stream.type_utils import HeadValues, HeadCell
+from sheet_stream import TableRow, TableDocuments, TableTextKeyWord, VoidAdapter, ColumnsTable
+from convert_stream.mod_types import DictTextTable
+from convert_stream.text import FindText, FindStrings
 import pandas as pd
-import soup_files as sp
-
-__version__ = '2.4'
+from soup_files import (
+    JsonConvert, ProgressBarAdapter, ABCProgressBar, CreatePbar,
+    Directory, File, InputFiles, LibraryDocs
+)
 
 
-def read_image(img: cs.ImageObject, rec: RecognizeImage = RecognizeImage()) -> TextRecognized:
+def read_image(img: ImageObject, rec: RecognizeImage = RecognizeImage()) -> TextRecognized:
     _txt = rec.image_recognize(img)
     _txt.metadata = img.metadata
     return _txt
 
 
 def read_images(
-            images: list[cs.ImageObject], *,
+            images: list[ImageObject], *,
             rec: RecognizeImage = RecognizeImage(),
-            pbar: sp.ProgressBarAdapter = sp.CreatePbar().get()
-        ) -> cs.DocumentPdf:
+            pbar: ProgressBarAdapter = CreatePbar().get()
+        ) -> DocumentPdf:
     pbar.start()
     print()
     max_num = len(images)
@@ -33,76 +37,55 @@ def read_images(
     for idx, image in enumerate(images):
         pbar.update(
             ((idx + 1) / max_num) * 100,
-            f'[OCR IMAGENS] {idx + 1} / {max_num}',
+            f'[OCR Imagem] {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()
+    tmp_doc = DocumentPdf.create_from_pages(pages)
     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
+            document: DocumentPdf, *,
+            dpi: int = 200,
+            rec: RecognizePdf = RecognizePdf(),
+        ) -> DocumentPdf:
+    rec.pbar.start()
+    return rec.recognize_document(document, dpi=dpi)
 
 
 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([])),
+            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: cs.DictTextTable = cs.DictTextTable.create_void_dict()
+        self.elements: DictTextTable = 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])
+        return len(self.elements[ColumnsTable.TEXT.value])
 
     def is_empty(self) -> bool:
-        return len(self.elements[cs.ColumnsTable.TEXT.value]) == 0
+        return len(self.elements[ColumnsTable.TEXT.value]) == 0
 
     @property
-    def columns(self) -> cs.HeadValues:
-        return cs.HeadValues([cs.HeadCell(x) for x in list(self.elements.keys())])
+    def columns(self) -> HeadValues:
+        return HeadValues([HeadCell(x) for x in list(self.elements.keys())])
 
     @property
     def first(self) -> dict[str, str]:
@@ -140,8 +123,8 @@ class SearchableTextImage(object):
             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())])
+        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])
@@ -156,7 +139,7 @@ class SearchableTextImage(object):
         ou 'nas' em caso de erro nas = Not a String
         """
         try:
-            return ' '.join(self.elements[cs.ColumnsTable.TEXT.value])
+            return ' '.join(self.elements[ColumnsTable.TEXT.value])
         except Exception as e:
             print(e)
             return 'nas'
@@ -164,12 +147,12 @@ class SearchableTextImage(object):
     def to_data_frame(self) -> pd.DataFrame:
         return pd.DataFrame.from_dict(self.elements)
 
-    def to_file_json(self, file: sp.File):
+    def to_file_json(self, file: File):
         """Exporta os dados da busca para um arquivo JSON"""
-        dt = sp.JsonConvert.from_dict(self.elements).to_json_data()
+        dt = JsonConvert.from_dict(self.elements).to_json_data()
         dt.to_file(file)
 
-    def to_file_excel(self, file: sp.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)
 
@@ -180,9 +163,9 @@ class ImageFinder(object):
     """
 
     def __init__(self):
-        self.docs_collection: dict[str, cs.ImageObject] = {}
+        self.docs_collection: dict[str, ImageObject] = {}
         self.recognize: RecognizeImage = RecognizeImage()
-        self.pbar: sp.ProgressBarAdapter = sp.ProgressBarAdapter()
+        self.pbar: ProgressBarAdapter = ProgressBarAdapter()
 
     def is_empty(self) -> bool:
         return len(self.docs_collection) == 0
@@ -190,29 +173,29 @@ class ImageFinder(object):
     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):
+    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 = cs.ImageObject(img)
+            img = ImageObject(img)
         elif isinstance(img, str):
-            img = cs.ImageObject(img)
+            img = ImageObject(img)
         elif isinstance(img, BytesIO):
-            img = cs.ImageObject(img)
+            img = 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:
+    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: sp.Directory) -> None:
-        files = sp.InputFiles(dir_pdf).get_files(file_type=sp.LibraryDocs.IMAGE)
+    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)
 
@@ -237,13 +220,13 @@ class ImageFinder(object):
                 f'[PESQUISANDO]: {n+1}/{total_num}',
             )
 
-            current_img: cs.ImageObject = self.docs_collection[file_key]
+            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 = cs.text.FindText(txt_in_img, separator=separator)
+                fd = FindText(txt_in_img, separator=separator)
                 idx = fd.find_index(text, iqual=iqual, case=case)
                 if idx is None:
                     continue
@@ -252,14 +235,14 @@ class ImageFinder(object):
                 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,
+                    ColumnsTable.KEY: f'{idx}',
+                    ColumnsTable.NUM_PAGE: 'nan',
+                    ColumnsTable.NUM_LINE: f'{idx + 1}',
+                    ColumnsTable.TEXT: math_text,
+                    ColumnsTable.FILE_NAME: current_img.metadata.file_path,
+                    ColumnsTable.FILETYPE: current_img.metadata.extension,
+                    ColumnsTable.FILE_PATH: current_img.metadata.dir_path,
+                    ColumnsTable.DIR: current_img.metadata.dir_path,
                 }
                 _searchable.add_line(new_line)
                 return _searchable
@@ -288,13 +271,13 @@ class ImageFinder(object):
                 f'[PESQUISANDO]: {n + 1}/{total_num}',
             )
 
-            current_img: cs.ImageObject = self.docs_collection[file_key]
+            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 = cs.text.FindText(txt_in_img, separator=separator)
+                fd = FindText(txt_in_img, separator=separator)
                 idx = fd.find_index(text, iqual=iqual, case=case)
                 if idx is None:
                     continue
@@ -303,14 +286,14 @@ class ImageFinder(object):
                 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,
+                    ColumnsTable.KEY: f'{idx}',
+                    ColumnsTable.NUM_PAGE: 'nan',
+                    ColumnsTable.NUM_LINE: f'{idx + 1}',
+                    ColumnsTable.TEXT: math_text,
+                    ColumnsTable.FILE_NAME: current_img.metadata.file_path,
+                    ColumnsTable.FILETYPE: current_img.metadata.extension,
+                    ColumnsTable.FILE_PATH: current_img.metadata.dir_path,
+                    ColumnsTable.DIR: current_img.metadata.dir_path,
                 }
                 _searchable.add_line(new_line)
         return _searchable
@@ -318,5 +301,5 @@ class ImageFinder(object):
 
 __all__ = [
     'ImageFinder', 'SearchableTextImage', 'read_images',
-    'read_document', 'RecognizeImage', 'RecognizePdf', 'VoidPbar', 'ProgressVoid'
+    'read_document', 'RecognizeImage', 'RecognizePdf', 'LibOcr',
 ]

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

@@ -8,11 +8,13 @@ class LibOcr(Enum):
 
     PYTESSERACT = "pytesseract"
     PYOCR = "pyocr"
+    EASYOCR = "easyocr"
     NOT_IMPLEMENTED = "not_implemented"
 
 
 MOD_PYTESSERACT: bool = False
 MOD_PYOCR: bool = False
+MOD_EASYOCR: bool = False
 
 try:
     from pytesseract import pytesseract, Output
@@ -27,16 +29,24 @@ try:
     import pyocr.tesseract
     MOD_PYOCR = True
 except Exception as err:
-    print(err)
+    #print(err)
     pyocr = object
 
 
-if MOD_PYTESSERACT and MOD_PYOCR:
-    ModuleOcr: TypeAlias = Union[pyocr, pytesseract]
+try:
+    import easyocr
+    MOD_EASYOCR = True
+except Exception as err:
+    easyocr = object
+
+if MOD_PYTESSERACT and MOD_PYOCR and MOD_EASYOCR:
+    ModuleOcr: TypeAlias = Union[esasyocr, pytesseract, pyocr]
     DEFAULT_LIB_OCR = LibOcr.PYTESSERACT
 elif MOD_PYTESSERACT:
     ModuleOcr: TypeAlias = Union[pytesseract]
     DEFAULT_LIB_OCR = LibOcr.PYTESSERACT
+elif MOD_EASYOCR:
+    ModuleOcr: TypeAlias = Union[easyocr]
 elif MOD_PYOCR:
     ModuleOcr: TypeAlias = Union[pyocr]
     DEFAULT_LIB_OCR = LibOcr.PYOCR
@@ -44,5 +54,3 @@ else:
     ModuleOcr: TypeAlias = None
     DEFAULT_LIB_OCR = LibOcr.NOT_IMPLEMENTED
 
-
-__all__ = ['LibOcr', 'DEFAULT_LIB_OCR']

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

@@ -4,24 +4,23 @@ from __future__ import annotations
 import os.path
 from abc import abstractmethod, ABC
 from typing import Union
-from io import BytesIO
 from pandas import DataFrame
 from soup_files import File
-from convert_stream import DocumentPdf, PageDocumentPdf
+from convert_stream import DocumentPdf, PageDocumentPdf, DictTextTable
 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 sheet_stream.type_utils import MetaDataFile
 from ocr_stream.modules import (
-    LibOcr, DEFAULT_LIB_OCR, pytesseract, Output, pyocr,
+    LibOcr, DEFAULT_LIB_OCR, pytesseract, pyocr, easyocr
 )
 from ocr_stream.bin_tess import BinTesseract
 
-try:
-    import pyocr.tesseract
-except Exception as err:
-    print(err)
-    pyocr = None
+import cv2
+from PIL import Image
+from io import BytesIO
+from reportlab.pdfgen import canvas
+#from reportlab.lib.pagesizes import A4
+from reportlab.lib.utils import ImageReader
 
 
 class TextRecognized(object):
@@ -33,6 +32,7 @@ class TextRecognized(object):
     def __init__(self, bytes_recognized: bytes):
         self.metadata: MetaDataFile = MetaDataFile()
         self.bytes_recognized: bytes = bytes_recognized
+        self.__text_document: str | None = None
 
         self.list_bad_char: list[str] = [
             ':', ',', ';', '$', '=',
@@ -44,8 +44,28 @@ class TextRecognized(object):
             '%', '~', '¥', '♀',
         ]
 
+    @property
+    def is_empty(self) -> bool:
+        txt = self.to_string()
+        if (txt is None) or (txt == '') or (txt == 'nas'):
+            return True
+        return False
+
     def to_string(self) -> str | None:
-        return self.to_page_pdf().to_string()
+        if self.__text_document is None:
+            _pages: list[PageDocumentPdf] = self.to_document().to_pages()
+            content: str = ''
+            txt_page: str
+            for page in _pages:
+                txt_page = page.to_string()
+                if (txt_page is None) or (txt_page == '') or (txt_page == 'nas'):
+                    continue
+                if content == '':
+                    content = txt_page
+                    continue
+                content = f'{content}\n{txt_page}'
+            self.__text_document = content
+        return self.__text_document
 
     def to_page_pdf(self) -> PageDocumentPdf:
         doc = self.to_document()
@@ -57,7 +77,7 @@ class TextRecognized(object):
         tmp_doc.metadata.dir_path = self.metadata.dir_path
         return tmp_doc
 
-    def to_dict(self, separator: str = '\n') -> dict[str, ColumnBody]:
+    def to_dict(self, separator: str = '\n') -> DictTextTable:
         return self.to_page_pdf().to_dict(separator=separator)
 
     def to_dataframe(self, separator='\n') -> DataFrame:
@@ -142,6 +162,71 @@ class IPytesseract(ABCOcrTesseract):
         return TextRecognized(bt)
 
 
+# ======================================================================#
+# Modulo easyocr
+# ======================================================================#
+class IEasyOcr(ABCOcrTesseract):
+
+    def __init__(self, bin_tess: BinTesseract, *, lang: str = 'pt', tess_data_dir: str = None):
+        super().__init__(bin_tess, lang=lang, tess_data_dir=tess_data_dir)
+        self.reader: easyocr.Reader = easyocr.Reader([self.lang], gpu=True)
+
+    def to_string(self, img: Union[File, ImageObject]) -> str:
+        if isinstance(img, File):
+            img = ImageObject(img)
+        result = self.reader.readtext(img.to_opencv())
+        text = '\n'.join([res[1] for res in result])
+        return text
+
+    def to_reconize(self, img: Union[File, ImageObject]) -> TextRecognized:
+
+        # 1️⃣ Converter o objeto de entrada para imagem OpenCV
+        if isinstance(img, File):
+            img = ImageObject(img)
+        img_cv = img.to_opencv()
+        img_h, img_w = img_cv.shape[:2]
+
+        # 2️⃣ Reconhecer o texto com EasyOCR
+        results: list = self.reader.readtext(img_cv)
+
+        # 3️⃣ Converter a imagem para PDF (imagem de fundo)
+        buffer = BytesIO()
+        pdf = canvas.Canvas(buffer, pagesize=(img_w, img_h))
+
+        # Desenha a imagem original como fundo
+        img_pil = Image.fromarray(cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB))
+        pdf.drawImage(ImageReader(img_pil), 0, 0, width=img_w, height=img_h)
+
+        # 4️⃣ Adiciona o texto OCR como camada "invisível" sobre a imagem
+        pdf.setFont("Helvetica", 8)
+        pdf.setFillColorRGB(1, 1, 1, alpha=0)  # texto invisível
+
+        for (bbox, text, conf) in results:
+            if not text.strip():
+                continue
+            # Coordenadas do bounding box (EasyOCR retorna 4 pontos)
+            (x1, y1), (x2, y2), (x3, y3), (x4, y4) = bbox
+
+            # Média da posição vertical
+            avg_y = (y1 + y2 + y3 + y4) / 4
+
+            # Posição invertida (PDF tem origem no canto inferior esquerdo)
+            y_pdf = img_h - avg_y
+
+            # Largura estimada
+            text_width = abs(x2 - x1)
+            pdf.drawString(x1, y_pdf, text)
+
+        pdf.showPage()
+        pdf.save()
+        buffer.seek(0)
+
+        # 5️⃣ Retorna como TextRecognized (bytes do PDF com texto embutido)
+        text_rec = TextRecognized(buffer.read())
+        text_rec.metadata = img.metadata if hasattr(img, "metadata") else MetaDataFile()
+        return text_rec
+
+
 # ======================================================================#
 # Modulo OCR pyocr
 # ======================================================================#
@@ -206,6 +291,10 @@ class TesseractOcr(object):
             md = IPytesseract(bin_tess, lang=lang, tess_data_dir=tess_data_dir)
         elif lib_ocr == LibOcr.PYOCR:
             md = IPyOcr(bin_tess, lang=lang, tess_data_dir=tess_data_dir)
+        elif lib_ocr == LibOcr.EASYOCR:
+            if lang is None:
+                lang = 'pt'
+            md = IEasyOcr(bin_tess, lang=lang, tess_data_dir=tess_data_dir)
         else:
             raise ValueError(f'{lib_ocr} is not supported')
         return cls(md)

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

@@ -1,40 +1,11 @@
 #!/usr/bin/env python3
 from __future__ import annotations
-from convert_stream import DocumentPdf, PageDocumentPdf
-from convert_stream.pdf import ConvertPdfToImages
-from convert_stream.image import ImageObject
+import convert_stream as cs
 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
-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
+from soup_files import File, ProgressBarAdapter, CreatePbar
 
 
 class RecognizeImage(object):
@@ -59,7 +30,7 @@ class RecognizeImage(object):
     def bin_tesseract(self) -> BinTesseract:
         return self.module_ocr.mod_ocr.bin_tess
 
-    def image_content_data(self, img: ImageObject | sp.File) -> DataFrame:
+    def image_content_data(self, img: cs.ImageObject | File) -> DataFrame:
         """
         Retorna uma tabela estruturada com os dados reconhecidos da imagem.
 
@@ -68,35 +39,35 @@ class RecognizeImage(object):
         nível do OCR e confiabilidade, entre outras.
 
         Parâmetros:
-        img (ImageObject | sp.File): A imagem a ser processada, podendo ser um objeto
-        `ImageObject` ou um arquivo `sp.File`.
+        img (cs.ImageObject | File): A imagem a ser processada, podendo ser um objeto
+        `cs.ImageObject` ou um arquivo `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 `sp.File`.
+        ValueError: Se o tipo do parâmetro `img` não for `cs.ImageObject` ou `File`.
 
-        @param img: Imagem a ser processada, podendo ser uma instância de `ImageObject`
-            ou um arquivo `sp.File`.
-        @type img: ImageObject | sp.File
+        @param img: Imagem a ser processada, podendo ser uma instância de `cs.ImageObject`
+            ou um arquivo `File`.
+        @type img: cs.ImageObject | 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 `sp.File`.
+        @raise ValueError: Caso o tipo de `img` não seja `cs.ImageObject` nem `File`.
         """
         return self.image_recognize(img).to_dataframe()
 
-    def image_recognize(self, img: ImageObject | sp.File, *, land_scape: bool = False) -> TextRecognized:
-        if isinstance(img, sp.File):
-            img = ImageObject(img)
+    def image_recognize(self, img: cs.ImageObject | File, *, land_scape: bool = False) -> TextRecognized:
+        if isinstance(img, File):
+            img = cs.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 | sp.File) -> str:
+    def image_to_string(self, img: cs.ImageObject | File) -> str:
         return self.module_ocr.to_string(img)
 
 
@@ -108,50 +79,45 @@ class RecognizePdf(object):
                 lib_ocr: LibOcr = DEFAULT_LIB_OCR,
             ):
         self.recognize_image: RecognizeImage = RecognizeImage(bin_tess, lib_ocr=lib_ocr)
-        self.pbar: sp.ProgressBarAdapter = sp.CreatePbar().get()
+        self.pbar: ProgressBarAdapter = CreatePbar().get()
 
-    def set_pbar(self, p: sp.ProgressBarAdapter):
+    def set_pbar(self, p: ProgressBarAdapter):
         self.pbar = p
 
-    def recognize_page_pdf(self, page: PageDocumentPdf, *, dpi: int = 300) -> DocumentPdf:
+    def recognize_page_pdf(self, page: cs.PageDocumentPdf, *, dpi: int = 200) -> cs.DocumentPdf:
         """
             Converte a página em Imagem, reconhece o texto com OCR e
         retorna uma nova página com o texto reconhecido.
         """
-        _doc = DocumentPdf.create_from_pages([page])
-        _conv = ConvertPdfToImages.create(_doc)
-        _conv.set_pbar(self.pbar)
-        img: ImageObject = _conv.to_images(dpi=dpi)[0]
+        _stream = cs.PdfStream(pbar=self.pbar, dpi=dpi)
+        _stream.add_page(page)
+        img: cs.ImageObject = _stream.convert_pdf_to_images.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)
+    def recognize_document(self, doc: cs.DocumentPdf, *, dpi: int = 200) -> cs.DocumentPdf:
+        _pages: list[cs.PageDocumentPdf] = []
+        _stream = cs.PdfStream(pbar=self.pbar, dpi=dpi)
+        _stream.add_document(doc)
+        _conv = _stream.convert_pdf_to_images
+        images: list[cs.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'OCR Documento [{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 = cs.DocumentPdf.create_from_pages(_pages)
         new_doc.metadata = doc.metadata
         return new_doc
 
-    def recognize_file_pdf(self, file: sp.File, *, dpi: int = 300) -> DocumentPdf:
-        file_doc = DocumentPdf.create_from_file(file)
+    def recognize_file_pdf(self, file: File, *, dpi: int = 300) -> cs.DocumentPdf:
+        file_doc = cs.DocumentPdf.create_from_file(file)
         recognized_doc = self.recognize_document(file_doc, dpi=dpi)
         del file_doc
         return recognized_doc

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stream
-Version: 2.4.1
+Version: 2.4.2
 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.4.1
+Requires-Dist: convert_stream>=2.4.3
 Requires-Dist: soup_files>=1.4
 
 # ocrlib

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

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

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

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