ocr-stream 1.1__py3-none-any.whl

ocr_stream/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+from .models.m_modules_ocr import (
+    LibraryOCR,
+)
+
+from .modules_ocr import TextRecognized
+from .extractors import RecognizeImage, RecognizePdf
+from ._version import __version__, __modify_data__
+

ocr_stream/__main__.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+------------------------------------------------------------
+    Configuração instalação:
+------------------------------------------------------------
+ $ pip3 install -r requirements.txt
+ $ pip3 install https://gitlab.com/bschaves/pdflib/-/archive/V1.0/pdflib-V1.0.zip
+
+------------------------------------------------------------
+    Referências:
+------------------------------------------------------------
+
+https://gist.github.com/endolith/334196bac1cac45a4893
+
+Tesseract OCR
+https://github.com/tesseract-ocr/tesseract
+
+pytesseract
+https://github.com/h/pytesseract
+
+pyocr
+https://gitlab.gnome.org/World/OpenPaperwork/pyocr
+"""
+import sys, os
+this_file = os.path.abspath(os.path.relpath(__file__))
+dir_of_project = os.path.dirname(this_file)
+sys.path.insert(0, dir_of_project)
+
+from convert_stream import print_title
+from ocr_stream import __version__, __modify_data__
+
+def test():
+    # /usr/bin/tesseract
+    # /usr/share/tesseract-ocr/5/tessdata
+    pass
+    
+def main():
+    print_title(f' ocrlib Versão: {__version__} | Atualização: {__modify_data__} ')
+    test()
+
+if __name__ == '__main__':
+    main()

ocr_stream/_version.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+#
+
+__version__ = '1.1'
+__modify_data__ = '2025-04-22'

ocr_stream/extractors.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from ocr_stream.utils import (
+    File, 
+    Directory, 
+    ImageObject, 
+    DataFrame, 
+    PageDocumentPdf, 
+    DocumentPdf, 
+    PdfStream, 
+    LibraryPDF,    
+)
+
+from ocr_stream.models import ( 
+    ABCRecognizeImage,
+    LibraryOCR,
+)
+
+from ocr_stream.modules_ocr import ModuleOcr, TextRecognized
+
+class RecognizeImage(ABCRecognizeImage):
+    def __init__(self, module_ocr):
+        super().__init__(module_ocr)
+
+    def image_content_data(self, img: ImageObject | File) -> DataFrame:
+        if isinstance(img, File):
+            return self.module_ocr.image_content_data(ImageObject.create_from_file(img))
+        elif isinstance(img, ImageObject):
+            return self.module_ocr.image_content_data(img)
+        else:
+            raise ValueError(f'{__class__.__name__}\nUse: ImageObject() ou File(), não {type(img)}')
+    
+    def image_recognize(self, img: ImageObject | File) -> TextRecognized:
+        if isinstance(img, File):
+            return self.module_ocr.image_recognize(ImageObject.create_from_file(img))
+        elif isinstance(img, ImageObject):
+            return self.module_ocr.image_recognize(img)
+        else:
+            raise ValueError(f'{__class__.__name__}\nUse: ImageObject() ou File(), não {type(img)}')
+    
+    def image_to_string(self, img: ImageObject | File) -> str:
+        if isinstance(img, File):
+            return self.module_ocr.imag_to_string(ImageObject.create_from_file(img))
+        elif isinstance(img, ImageObject):
+            return self.module_ocr.imag_to_string(img)
+        else:
+            raise ValueError(f'{__class__.__name__}\nUse: ImageObject() ou File(), não {type(img)}')
+    
+    @classmethod
+    def create(cls, library_ocr=LibraryOCR.PYTESSERACT, *, path_tesseract, lang=None, tess_data_dir=None) -> RecognizeImage:
+        module_ocr:ModuleOcr = ModuleOcr.create(
+            library_ocr,
+            path_tesseract=path_tesseract,
+            lang=lang,
+            tess_data_dir=tess_data_dir
+        )
+        return cls(module_ocr)
+  
+  
+class RecognizePdf(object):
+    def __init__(self, recognize_image:RecognizeImage):
+        self.recognize_image:RecognizeImage = recognize_image
+
+    def recognize_page_pdf(self, page:PageDocumentPdf) -> PageDocumentPdf:
+        """
+            Converte a página em Imagem, reconhece o texto com OCR e
+        retorna uma nova página com o texto reconhecido.
+        """
+        pdf_stream = PdfStream(library_pdf=LibraryPDF.FITZ)
+        pdf_stream.add_page(page)
+        img:ImageObject = pdf_stream.to_images()[0]
+        text_recognized:TextRecognized = self.recognize_image.image_recognize(img)
+        return text_recognized.to_page_pdf()
+    
+    def recognize_document(self, doc:DocumentPdf) -> DocumentPdf:
+        new:DocumentPdf = DocumentPdf()
+        for page in doc.pages:
+            recognized_page:PageDocumentPdf = self.recognize_page_pdf(page)
+            new.add_page(recognized_page)
+        return new
+
+    @classmethod
+    def create(
+                cls, 
+                library_ocr=LibraryOCR.PYTESSERACT, 
+                *,
+                path_tesseract:File, 
+                lang:str=None,
+                tess_data_dir:Directory=None,
+            ) -> RecognizePdf:
+        ##
+        recognize_image = RecognizeImage.create(
+                    library_ocr, 
+                    path_tesseract=path_tesseract, 
+                    lang=lang, 
+                    tess_data_dir=tess_data_dir
+                )
+        return cls(recognize_image)
+   
+
+            
+        
+        
+        
+        
+        
+

ocr_stream/models/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+from .m_modules_ocr import LibraryOCR, ABCTextRecognized, ABCModuleOcr
+from .m_extractors import ABCRecognizeImage

ocr_stream/models/m_extractors.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+#
+from __future__ import annotations
+from abc import ABC, abstractmethod
+
+from pandas import DataFrame
+from soup_files import File, Directory
+from convert_stream import ImageObject
+from ocr_stream.models.m_modules_ocr import ABCModuleOcr, ABCTextRecognized, LibraryOCR
+
+class ABCRecognizeImage(ABC):
+    def __init__(self, module_ocr:ABCModuleOcr):
+        super().__init__()
+        self.module_ocr:ABCModuleOcr = module_ocr
+        
+    @abstractmethod
+    def image_to_string(self, img:ImageObject | File) -> str:
+        pass
+    
+    @abstractmethod
+    def image_recognize(self, img:ImageObject | File) -> ABCTextRecognized:
+        pass
+        
+    @abstractmethod
+    def image_content_data(self, img:ImageObject | File) -> DataFrame:
+        pass
+        
+    @classmethod
+    def create(
+                cls, 
+                library_ocr:LibraryOCR = LibraryOCR.PYTESSERACT,
+                *,
+                path_tesseract:File, 
+                lang:str=None, 
+                tess_data_dir:Directory=None
+            ) -> ABCRecognizeImage:
+        pass
+
+    

ocr_stream/models/m_modules_ocr.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+#
+from __future__ import annotations
+from typing import Dict, List
+from abc import ABC, abstractmethod
+from enum import Enum
+from pandas import DataFrame
+from soup_files import File, Directory
+from convert_stream import ImageObject, DocumentPdf, PageDocumentPdf, LibraryImage
+
+class LibraryOCR(Enum):
+    PYTESSERACT = 'pytesseract'
+    PYOCR = 'pyocr'
+    
+    
+class ABCTextRecognized(ABC):
+    def __init__(self, bytes_recognized:bytes):
+        super().__init__()
+        self.bytes_recognized:bytes = bytes_recognized
+        
+    @abstractmethod
+    def to_string(self) -> str:
+        pass
+    
+    @abstractmethod
+    def to_page_pdf(self) -> PageDocumentPdf:
+        pass
+    
+    @abstractmethod
+    def to_document(self) -> DocumentPdf:
+        pass
+    
+    @abstractmethod
+    def to_dataframe(self, column:str='TEXT') -> DataFrame:
+        pass
+    
+    @abstractmethod
+    def to_dict(self) -> Dict[str, List[str]]:
+        pass
+  
+#======================================================================#
+# Abstração para o módulo que extrai o texto das imagens (OCR)
+# pode ser implementado com pytesseract ou outros.
+#======================================================================#
+class ABCModuleOcr(ABC):
+    def __init__(self, *, cmd_executable:File, lang:str=None, tess_data_dir:Directory=None):
+        self.cmd_executable:File = cmd_executable
+        self.lang:str = lang
+        self.tess_data_dir:Directory = tess_data_dir
+        self.current_library_ocr:LibraryOCR = None
+    
+    @abstractmethod
+    def image_recognize(self, img:ImageObject) -> ABCTextRecognized:
+        pass
+    
+    @abstractmethod
+    def image_content_data(self, img: ImageObject) -> DataFrame:
+        pass
+    
+    @abstractmethod
+    def imag_to_string(self, img:ImageObject) -> str:
+        pass
+    
+    @classmethod
+    def create(
+                cls, 
+                library_ocr:LibraryOCR=LibraryOCR.PYTESSERACT,
+                *,
+                path_tesseract:File,
+                lang:str=None,
+                tess_data_dir:Directory=None,
+            ) -> ABCModuleOcr:
+        pass
+    
+    
+  
+
+    

ocr_stream/modules_ocr.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+from types import ModuleType
+from typing import List, Dict
+from pathlib import Path
+import re
+import os
+
+from ocr_stream.models import ( 
+    ABCModuleOcr,
+    ABCTextRecognized,
+    LibraryOCR,
+)
+from pandas import DataFrame
+from ocr_stream.utils import (
+    PageDocumentPdf, DocumentPdf, LibraryImage, ImageObject, ArrayString, DataString,
+    File, Directory
+)
+
+from pytesseract import pytesseract, Output
+
+def get_temp_dir(prefix=Path().home()) -> str:
+    prefix = Path().home()
+    sys_temp_dir = os.environ.get('TMP', os.path.join(prefix, 'var', 'temp'))
+    if not sys_temp_dir:
+        sys_temp_dir = os.path.join(prefix, 'var', 'temp')
+    if not os.path.exists(sys_temp_dir):
+        try:
+            os.makedirs(sys_temp_dir)
+        except Exception as e:
+            print(e)
+    os.environ["TEMP"] = sys_temp_dir
+    print('-' * 30)
+    print(f'Diretório temporário: {sys_temp_dir}')
+    print('-' * 30)
+    return sys_temp_dir
+
+  
+class TextRecognizedToi(object):
+    """
+        Extração/Filtro de texto em documentos do tipo carta TOI.
+    """
+    def __init__(self, value:str=None, *, separator:str='\n', column_text='TEXT', file:File):
+        # Todas as linhas que foram reconhecidas em uma imagem/página PDF.
+        if not isinstance(value, str):
+            raise ValueError(f'{__class__.__name__}Use: str, não {type(value)}')
+        self.text_document:str = DataString(value).to_upper().value if value is not None else None
+        self.separator:str = separator
+        self.file:File = file
+        self.column_text:str = column_text
+        
+        self.pattern_line_uc_toi = r'UC:\s*\d+\s*TOI:\s*\d+'
+        self.pattern_uc = r'\b(?:UC:?|UC):?\s*(\d+)'
+        self.pattern_toi = r'\b(?:TOI?|TO):?\s*(\d+)'
+        self.pattern_localidade = r'LOCALIDADE:\s*(.*)'
+        
+        self.words_toi = (
+            'TO]!', 'TO]', 'TOl', 'TOI', 'TOI:'
+        )
+        
+        self.words_uc = (
+            'UE', 'UE:' 'UC', 'UC:', 'JC;'
+        )
+        
+    def __replace_chars(self, text, char, new_char) -> str:
+        return re.sub(r'{}'.format(char), new_char, text)
+    
+    def __get_match_groups(self, pattern, text:str) -> object | None:
+        i = re.search(pattern, text)
+        if i is None:
+            return None
+        return i.groups()
+        
+    def __get_match_group(self, pattern, text:str) -> object | None:
+        i = re.search(pattern, text)
+        if i is None:
+            return None
+        return i.group()
+    
+    def is_null(self) -> bool:
+        if self.text_document is None:
+            return True
+        if self.text_document == '':
+            return True
+        return False
+        
+    def to_string(self) -> str | None:
+        return DataString(self.text_document).to_upper().value if not self.is_null() else None
+    
+    def to_list(self) -> List[str]:
+        return self.text_document.split(self.separator)
+    
+    def to_array_string(self) -> ArrayString:
+        values:List[str] = self.to_list()
+    
+    def to_upper(self) -> TextRecognizedToi:
+        self.text_document = self.text_document.upper()
+        return self
+    
+    def to_dataframe(self) -> DataFrame:
+        uc = self.uc()
+        toi = self.toi()
+        if uc is None:
+            uc = 'nan'
+        else:
+            uc = DataString(uc).replace_bad_chars().replace_all('- ', ' ').replace_all('_', ' ').value.strip()
+        #
+        if toi is None:
+            toi = 'nan'
+        else:
+            toi = DataString(toi).replace_bad_chars()
+            toi = toi.replace_all('- ', '-').replace_all('_', ' ').replace_all('-', ' ').replace_all('TOI', '').value.strip()
+        
+        df = DataFrame()
+        df[self.column_text] = self.to_list()
+        num = len(df)
+        df['UC'] = [uc] * num
+        df['TOI'] = [toi] * num
+        df['LOCALIDADE'] = [self.localidade()] * num
+        df['ARQUIVO'] = [self.file.absolute()] * num
+        df['MD5'] = [self.file.md5()] * num
+        return df
+    
+    def remove_bad_chars(self) -> TextRecognizedToi:
+        values = []
+        for item in self.to_list():
+            values.append(
+                DataString(item).replace_bad_chars(new_char='_').replace_all('/', '-').value
+            )
+        self.listText = values
+        return self
+    
+    def uc(self) -> str:
+        """
+            Extrair o número da UC em forma de string, se a operação falhar, será retornado (nan)
+        """
+        line_uc_toi = self.line_uc_and_toi()
+        uc_value:str = None
+        if line_uc_toi is not None:
+            uc_value = self.__get_match_group(self.pattern_uc, line_uc_toi)
+        if uc_value is not None:
+            return uc_value.replace('UC', '')
+        
+        arr = ArrayString(self.text_document.split(' '))
+        for w in self.words_uc:
+            out = arr.get_next(w).value
+            try:
+                int(out)
+            except:
+                pass
+            else:
+                return out
+        return None
+    
+    def toi(self) -> str:
+        line_uc_toi = self.line_uc_and_toi()
+        toi_value:str = None
+        if line_uc_toi is not None:
+            toi_value = self.__get_match_group(self.pattern_toi, line_uc_toi)
+        if toi_value is not None:
+            return toi_value.replace('TOI', '')
+        arr = ArrayString(self.text_document.split(' '))
+        
+        for w in self.words_toi:
+            out = arr.get_next(w).value
+            try:
+                int(out)
+            except:
+                pass
+            else:
+                return out
+        return None
+        
+    def roteiro(self) -> str:
+        self.remove_bad_chars()
+        pass
+
+    def localidade(self) -> str:
+        lines = self.to_list()
+        loc = 'nan'
+        for line in lines:
+            out = re.search(self.pattern_localidade, line)
+            if out:
+                loc = out.group(1)
+                break
+        loc = DataString(loc).replace_all(' ').value
+        # Remover "_" do final
+        return re.sub(r"_$", "", loc)
+    
+    def line_postagem(self) -> str:
+        pass
+        
+    def line_uc_and_toi(self) -> DataString | None:
+        line_toi = None
+        lines = self.to_list()
+        for item in lines:
+            out = self.__get_match_group(self.pattern_line_uc_toi, item)
+            if out is None:
+                continue
+            line_toi = out
+            break
+        return line_toi
+    
+    def line_roteiro(self) -> DataString:
+        return DataString(None) 
+
+#======================================================================#
+# Texto reconhecido de uma imagem.
+#======================================================================#
+class TextRecognized(ABCTextRecognized):
+    """
+        Recebe os bytes de uma página PDF reconhecida de imagem
+    e exporta para vários tipos de dados.
+    -> DataFrame()
+    -> str
+    -> PageDocumentPdf()
+    """
+    def __init__(self, bytes_recognized):
+        super().__init__(bytes_recognized)
+        
+        self.list_bad_char:List[str] = [
+                            ':', ',', ';', '$', '=', 
+                            '!', '}', '{', '(', ')', 
+                            '|', '\\', '‘', '*'
+                            '¢', '“', '\'', '¢', '"', 
+                            '#', '.', '<', '?', '>', 
+                            '»', '@', '+', '[', ']',
+                            '%', '~', '¥', '♀',
+        ]
+    
+    def to_string(self) -> str | None:
+        return self.to_page_pdf().to_string()
+    
+    def to_page_pdf(self) -> PageDocumentPdf:
+        return PageDocumentPdf.create_from_page_bytes(self.bytes_recognized)
+    
+    def to_document(self) -> DocumentPdf:
+        doc: DocumentPdf = DocumentPdf()
+        doc.add_page(self.to_page_pdf())
+        return doc
+    
+    def to_dict(self, separator:str='\n') -> Dict[str, List[str]]:
+        image_dict:Dict[str, List[str]] = {
+            'TEXT': [],
+            'NUM_LINHA': [],
+        }
+        image_text:str = self.to_string()
+        if (image_text is None) or (image_text == ''):
+            return {
+                    'TEXT': ['nan'],
+                    'NUM_LINHA': ['nan'],
+                }
+        
+        image_lines:List[str] = image_text.split(separator)
+        for num, line in enumerate(image_lines):
+            image_dict['TEXT'].append(line)
+            image_dict['NUM_LINHA'].append(num+1)
+        return image_dict    
+    
+    def to_dataframe(self, column = 'TEXT', separator:str='\n') -> DataFrame:
+        return DataFrame(self.to_dict(separator))
+    
+#======================================================================#
+# Modulo OCR pytesseract
+#======================================================================#
+
+class IModulePytesseract(ABCModuleOcr):
+    def __init__(self, *, cmd_executable, lang = None, tess_data_dir = None):
+        super().__init__(cmd_executable=cmd_executable, lang=lang, tess_data_dir=tess_data_dir)
+        self.current_library:LibraryOCR = LibraryOCR.PYTESSERACT
+        self._pyTesseract:pytesseract = pytesseract
+        self._pyTesseract.tesseract_cmd = self.cmd_executable.absolute()
+        
+    def __get_tess_dir_config(self) -> str | None:
+        """
+        https://github.com/h/pytesseract
+        
+        Example config: r'--tessdata-dir "C:\Program Files (x86)\Tesseract-OCR\tessdata"'
+        tessdata_dir_config = r'--tessdata-dir <replace_with_your_tessdata_dir_path>'
+        It's important to add double quotes around the dir path.
+        """
+        #
+        # Caminho para os dados de idioma, por, eng etc...
+        # os.environ["TESSDATA_PREFIX"] = self.tess_data_dir.absolute()
+        if self.tess_data_dir is None:
+            return ''
+        if not self.tess_data_dir.path.exists():
+            return ''
+        return r'--tessdata-dir "{}"'.format(self.tess_data_dir.absolute())
+        
+    def imag_to_string(self, img) -> str:
+        if img.current_library == LibraryImage.OPENCV:
+            text_img:str = self._pyTesseract.image_to_string(
+                img.to_image_opencv(),
+                lang=self.lang,
+                config=self.__get_tess_dir_config()
+            )
+        else:
+            text_img:str = self._pyTesseract.image_to_string(
+                    img.to_image_pil(),
+                    lang=self.lang,
+                    config=self.__get_tess_dir_config()
+                )
+        return text_img
+        
+    def image_recognize(self, img) -> TextRecognized:
+        if img.current_library == LibraryImage.OPENCV:
+            pdf_bytes:bytes = self._pyTesseract.image_to_pdf_or_hocr(
+                img.to_image_opencv(),
+                lang=self.lang,
+                config=self.__get_tess_dir_config()
+            )
+        else:
+            pdf_bytes:bytes = self._pyTesseract.image_to_pdf_or_hocr(
+                    img.to_image_pil(),
+                    lang=self.lang,
+                    config=self.__get_tess_dir_config()
+                )
+        return TextRecognized(pdf_bytes)
+        
+    def image_content_data(self, img) -> DataFrame:
+        if img.current_library == LibraryImage.OPENCV:
+            text_data:DataFrame = self._pyTesseract.image_to_data(
+                img.to_image_opencv(),
+                lang=self.lang,
+                config=self.__get_tess_dir_config(),
+                output_type=Output.DATAFRAME,
+            )
+        else:
+            text_data:DataFrame = self._pyTesseract.image_to_data(
+                img.to_image_pil(),
+                lang=self.lang,
+                config=self.__get_tess_dir_config(),
+                output_type=Output.DATAFRAME,
+            )
+        return text_data
+    
+   
+#======================================================================#
+# Modulo OCR pyocr
+#======================================================================#
+
+class IModulePyOcr(ABCModuleOcr):
+    def __init__(self, *, cmd_executable, lang = None, tess_data_dir = None):
+        super().__init__(cmd_executable=cmd_executable, lang=lang, tess_data_dir=tess_data_dir)
+        self.current_library:LibraryOCR = LibraryOCR.PYOCR
+        self.cmd_executable:File = cmd_executable
+        self.tess_data_dir:Directory = tess_data_dir
+        try:
+            import pyocr
+            import pyocr.tesseract
+        except Exception as e:
+            raise (e)
+        
+        pyocr_modules:List[ModuleType] = pyocr.get_available_tools()
+        if len(pyocr_modules) == 0:
+            raise ValueError(f"{__class__.__name__} No OCR tool found")
+        # The tools are returned in the recommended order of usage
+        self._pyOcr:pyocr.tesseract = pyocr_modules[0]
+        langs:List[str] = self._pyOcr.get_available_languages()
+        if lang in lang:
+            self.lang = lang
+        else:
+            self.lang = langs[0]
+        
+        # Ex: Will use tool 'libtesseract'
+        print(f"Will use tool {self._pyOcr.get_name()}")
+        
+    def imag_to_string(self, img) -> str:
+        return self._pyOcr.image_to_string(
+            img.to_image_pil(),
+            lang=self.lang,
+            builder=pyocr.builders.TextBuilder()
+        )
+        
+    def image_recognize(self, img) -> TextRecognized:
+        raise NotImplementedError(f'{__class__.__name__} método não implementado')
+        
+    def image_content_data(self, img) -> DataFrame:
+        raise NotImplementedError(f'{__class__.__name__} método não implementado')
+    
+
+class ModuleOcr(ABCModuleOcr):
+    def __init__(self, module_ocr:ABCModuleOcr):
+        super().__init__(
+                cmd_executable=module_ocr.cmd_executable, 
+                lang=module_ocr.lang, 
+                tess_data_dir=module_ocr.tess_data_dir
+            )
+        self.module_ocr:ABCModuleOcr = module_ocr
+        
+    def image_content_data(self, img:ImageObject) -> DataFrame:
+        return self.module_ocr.image_content_data(img)
+    
+    def image_recognize(self, img:ImageObject) -> TextRecognized:
+        return self.module_ocr.image_recognize(img)
+    
+    def imag_to_string(self, img) -> str:
+        return self.module_ocr.imag_to_string(img)
+    
+    @classmethod
+    def create(
+                cls, 
+                library_ocr = LibraryOCR.PYTESSERACT, 
+                *, 
+                path_tesseract, 
+                lang = None, 
+                tess_data_dir = None
+            ) -> ModuleOcr:
+        #
+        if library_ocr == LibraryOCR.PYTESSERACT:
+            _module_ocr = IModulePytesseract(cmd_executable=path_tesseract, lang=lang, tess_data_dir=tess_data_dir)
+        elif library_ocr == LibraryOCR.PYOCR:
+            _module_ocr = IModulePyOcr(cmd_executable=path_tesseract, lang=lang, tess_data_dir=tess_data_dir)
+        else:
+            raise NotImplementedError(f'{__class__.__name__}\nLibraryOcr não implementada: {library_ocr}')
+        return cls(_module_ocr)
+        
+        
+      
+   
+
+            
+        
+        
+        
+        
+        
+

ocr_stream/utils/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+#
+from pandas import DataFrame
+from soup_files import (
+    File, Directory, UserAppDir, UserFileSystem, InputFiles,
+    JsonConvert, JsonData
+)
+
+from convert_stream import (
+    LibraryDates, LibraryImage, LibraryPDF, ImageObject,
+    PdfStream, ImageStream,PageDocumentPdf, DocumentPdf, 
+    ArrayString, DataString, ConvertDate, print_line, print_title
+)

ocr_stream-1.1.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: ocr_stream
+Version: 1.1
+Summary: Extrair textos de documentos digitalizados e imagens.
+Author: Bruno Chaves
+Requires: PyPDF2
+Requires: PyMuPDF
+Requires: reportlab
+Requires: openpyxl
+Requires: openpyxl
+Requires: pandas
+Requires: Pillow
+Requires: opencv_python
+Requires: requests
+Requires: pytesseract
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: soup_files==1.0.1
+Requires-Dist: PyPDF2==3.0.1
+Requires-Dist: PyMuPDF==1.25.5
+Requires-Dist: reportlab==4.3.1
+Requires-Dist: openpyxl==3.1.5
+Requires-Dist: pandas==2.2.3
+Requires-Dist: Pillow==11.2.1
+Requires-Dist: opencv-python==4.11.0.86
+Requires-Dist: convert_stream==1.1.1
+Dynamic: requires
+
+# ocrlib
+
+# Uso simples
+
+from ocrlib.utils import File, DocumentPdf
+from ocrlib import RecognizeImage
+
+# passo 1 instânciar o objeto para reconhecer texto, ultilzaremos o caminho do tesseract
+# Substitua pelo tesseract do seu sistema
+
+tess = File('/usr/bin/tesseract')
+ocr = RecognizeImage.create(path_tesseract=tess)
+
+# passo 2 instânciar um arquivo de imagem para extrair o texto.
+image = File('path/to/file.png')
+
+# passo 3 extrair o texto
+text = ocr.image_to_string(image)
+print(text)
+
+# passo 4 opcional - você pode salvar um arquivo PDF com o texto extraido
+output_file = File('path/to/save.pdf')
+recognized = ocr.image_recognize(image)
+recognized.to_document().to_file_pdf(output_file)
+
+# passo 5 opcional - você pode salvar uma planilha com o texto da imagem
+output_excel = File('path/to/file.xlsx')
+recognized = ocr.image_recognize(image)
+recognized.to_document().to_excel(output_excel)

ocr_stream-1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+ocr_stream/__init__.py,sha256=cukkDxwmn2Kw-0apnpklR6nfbxZ4Sss8advGz2RpTGQ,224
+ocr_stream/__main__.py,sha256=vXjP4QOLSP_jCCl2ymGXcFSZKUVtr96T4soM61oLRmU,1169
+ocr_stream/_version.py,sha256=qRXc4Bg1d7fbAfm5NPtX06BqagIXnMYagMnA48keoU4,77
+ocr_stream/extractors.py,sha256=JQTcrLwo5vSvw3FoXCCbv3kN7eR2nDs48eAo3xNJJUM,3629
+ocr_stream/modules_ocr.py,sha256=PHPvRV6Onhj_zTHWZ724voKgXCv6F3HHWmRMZkqom-o,14996
+ocr_stream/models/__init__.py,sha256=ehyOznjUt72rBZ__xREJpf2VKwpuq0Vf1z2MYDBHgj0,137
+ocr_stream/models/m_extractors.py,sha256=cbasB5S8K25fHfNPxGWhpYA6lBfAl-PqYXaMZRf4AcY,1098
+ocr_stream/models/m_modules_ocr.py,sha256=F5042F3lQAk3Aeyac_fxWPiZaWjZya6W6_7dOZ5PyEo,2155
+ocr_stream/utils/__init__.py,sha256=ywM497Hyz_mg0yVjM5BWRJYjAo9I_e8n-areu0iRjG4,381
+ocr_stream-1.1.dist-info/METADATA,sha256=F2vkDKub96Ta1zga2SkfnmWdKv_OKPb_Onh-Q-lhqRU,1603
+ocr_stream-1.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+ocr_stream-1.1.dist-info/top_level.txt,sha256=P8kJ6573XVRx0Sr3lDXhEgKVOCBbGAxc5cqMSRq9Udg,11
+ocr_stream-1.1.dist-info/RECORD,,

ocr_stream-1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ocr_stream-1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ocr_stream