Add application file

easyocr.py

@@ -0,0 +1,579 @@
+# -*- coding: utf-8 -*-
+
+from .recognition import get_recognizer, get_text
+from .utils import group_text_box, get_image_list, calculate_md5, get_paragraph,\
+                   download_and_unzip, printProgressBar, diff, reformat_input,\
+                   make_rotated_img_list, set_result_with_confidence,\
+                   reformat_input_batched, merge_to_free
+from .config import *
+from bidi import get_display
+import numpy as np
+import cv2
+import torch
+import os
+import sys
+from PIL import Image
+from logging import getLogger
+import yaml
+import json
+
+if sys.version_info[0] == 2:
+    from io import open
+    from six.moves.urllib.request import urlretrieve
+    from pathlib2 import Path
+else:
+    from urllib.request import urlretrieve
+    from pathlib import Path
+
+LOGGER = getLogger(__name__)
+
+class Reader(object):
+
+    def __init__(self, lang_list, gpu=True, model_storage_directory=None,
+                 user_network_directory=None, detect_network="craft", 
+                 recog_network='standard', download_enabled=True, 
+                 detector=True, recognizer=True, verbose=True, 
+                 quantize=True, cudnn_benchmark=False):
+        """Create an EasyOCR Reader
+
+        Parameters:
+            lang_list (list): Language codes (ISO 639) for languages to be recognized during analysis.
+
+            gpu (bool): Enable GPU support (default)
+
+            model_storage_directory (string): Path to directory for model data. If not specified,
+            models will be read from a directory as defined by the environment variable
+            EASYOCR_MODULE_PATH (preferred), MODULE_PATH (if defined), or ~/.EasyOCR/.
+
+            user_network_directory (string): Path to directory for custom network architecture.
+            If not specified, it is as defined by the environment variable
+            EASYOCR_MODULE_PATH (preferred), MODULE_PATH (if defined), or ~/.EasyOCR/.
+
+            download_enabled (bool): Enabled downloading of model data via HTTP (default).
+        """
+        self.verbose = verbose
+        self.download_enabled = download_enabled
+
+        self.model_storage_directory = MODULE_PATH + '/model'
+        if model_storage_directory:
+            self.model_storage_directory = model_storage_directory
+        Path(self.model_storage_directory).mkdir(parents=True, exist_ok=True)
+
+        self.user_network_directory = MODULE_PATH + '/user_network'
+        if user_network_directory:
+            self.user_network_directory = user_network_directory
+        Path(self.user_network_directory).mkdir(parents=True, exist_ok=True)
+        sys.path.append(self.user_network_directory)
+
+        if gpu is False:
+            self.device = 'cpu'
+            if verbose:
+                LOGGER.warning('Using CPU. Note: This module is much faster with a GPU.')
+        elif gpu is True:
+            if torch.cuda.is_available():
+                self.device = 'cuda'
+            elif torch.backends.mps.is_available():
+                self.device = 'mps'
+            else:
+                self.device = 'cpu'
+                if verbose:
+                    LOGGER.warning('Neither CUDA nor MPS are available - defaulting to CPU. Note: This module is much faster with a GPU.')
+        else:
+            self.device = gpu
+
+        self.detection_models = detection_models
+        self.recognition_models = recognition_models
+
+        # check and download detection model
+        self.support_detection_network = ['craft', 'dbnet18']
+        self.quantize=quantize, 
+        self.cudnn_benchmark=cudnn_benchmark
+        if detector:
+            detector_path = self.getDetectorPath(detect_network)
+        
+        # recognition model
+        separator_list = {}
+
+        if recog_network in ['standard'] + [model for model in recognition_models['gen1']] + [model for model in recognition_models['gen2']]:
+            if recog_network in [model for model in recognition_models['gen1']]:
+                model = recognition_models['gen1'][recog_network]
+                recog_network = 'generation1'
+                self.model_lang = model['model_script']
+            elif recog_network in [model for model in recognition_models['gen2']]:
+                model = recognition_models['gen2'][recog_network]
+                recog_network = 'generation2'
+                self.model_lang = model['model_script']
+            else: # auto-detect
+                unknown_lang = set(lang_list) - set(all_lang_list)
+                if unknown_lang != set():
+                    raise ValueError(unknown_lang, 'is not supported')
+                # choose recognition model
+                if lang_list == ['en']:
+                    self.setModelLanguage('english', lang_list, ['en'], '["en"]')
+                    model = recognition_models['gen2']['english_g2']
+                    recog_network = 'generation2'
+                elif 'th' in lang_list:
+                    self.setModelLanguage('thai', lang_list, ['th','en'], '["th","en"]')
+                    model = recognition_models['gen1']['thai_g1']
+                    recog_network = 'generation1'
+                elif 'ch_tra' in lang_list:
+                    self.setModelLanguage('chinese_tra', lang_list, ['ch_tra','en'], '["ch_tra","en"]')
+                    model = recognition_models['gen1']['zh_tra_g1']
+                    recog_network = 'generation1'
+                elif 'ch_sim' in lang_list:
+                    self.setModelLanguage('chinese_sim', lang_list, ['ch_sim','en'], '["ch_sim","en"]')
+                    model = recognition_models['gen2']['zh_sim_g2']
+                    recog_network = 'generation2'
+                elif 'ja' in lang_list:
+                    self.setModelLanguage('japanese', lang_list, ['ja','en'], '["ja","en"]')
+                    model = recognition_models['gen2']['japanese_g2']
+                    recog_network = 'generation2'
+                elif 'ko' in lang_list:
+                    self.setModelLanguage('korean', lang_list, ['ko','en'], '["ko","en"]')
+                    model = recognition_models['gen2']['korean_g2']
+                    recog_network = 'generation2'
+                elif 'ta' in lang_list:
+                    self.setModelLanguage('tamil', lang_list, ['ta','en'], '["ta","en"]')
+                    model = recognition_models['gen1']['tamil_g1']
+                    recog_network = 'generation1'
+                elif 'te' in lang_list:
+                    self.setModelLanguage('telugu', lang_list, ['te','en'], '["te","en"]')
+                    model = recognition_models['gen2']['telugu_g2']
+                    recog_network = 'generation2'
+                elif 'kn' in lang_list:
+                    self.setModelLanguage('kannada', lang_list, ['kn','en'], '["kn","en"]')
+                    model = recognition_models['gen2']['kannada_g2']
+                    recog_network = 'generation2'
+                elif set(lang_list) & set(bengali_lang_list):
+                    self.setModelLanguage('bengali', lang_list, bengali_lang_list+['en'], '["bn","as","en"]')
+                    model = recognition_models['gen1']['bengali_g1']
+                    recog_network = 'generation1'
+                elif set(lang_list) & set(arabic_lang_list):
+                    self.setModelLanguage('arabic', lang_list, arabic_lang_list+['en'], '["ar","fa","ur","ug","en"]')
+                    model = recognition_models['gen1']['arabic_g1']
+                    recog_network = 'generation1'
+                elif set(lang_list) & set(devanagari_lang_list):
+                    self.setModelLanguage('devanagari', lang_list, devanagari_lang_list+['en'], '["hi","mr","ne","en"]')
+                    model = recognition_models['gen1']['devanagari_g1']
+                    recog_network = 'generation1'
+                elif set(lang_list) & set(cyrillic_lang_list):
+                    self.setModelLanguage('cyrillic', lang_list, cyrillic_lang_list+['en'],
+                                          '["ru","rs_cyrillic","be","bg","uk","mn","en"]')
+                    model = recognition_models['gen2']['cyrillic_g2']
+                    recog_network = 'generation2'
+                else:
+                    self.model_lang = 'latin'
+                    model = recognition_models['gen2']['latin_g2']
+                    recog_network = 'generation2'
+            self.character = model['characters']
+
+            model_path = os.path.join(self.model_storage_directory, model['filename'])
+            # check recognition model file
+            if recognizer:
+                if os.path.isfile(model_path) == False:
+                    if not self.download_enabled:
+                        raise FileNotFoundError("Missing %s and downloads disabled" % model_path)
+                    LOGGER.warning('Downloading recognition model, please wait. '
+                                   'This may take several minutes depending upon your network connection.')
+                    download_and_unzip(model['url'], model['filename'], self.model_storage_directory, verbose)
+                    assert calculate_md5(model_path) == model['md5sum'], corrupt_msg
+                    LOGGER.info('Download complete.')
+                elif calculate_md5(model_path) != model['md5sum']:
+                    if not self.download_enabled:
+                        raise FileNotFoundError("MD5 mismatch for %s and downloads disabled" % model_path)
+                    LOGGER.warning(corrupt_msg)
+                    os.remove(model_path)
+                    LOGGER.warning('Re-downloading the recognition model, please wait. '
+                                   'This may take several minutes depending upon your network connection.')
+                    download_and_unzip(model['url'], model['filename'], self.model_storage_directory, verbose)
+                    assert calculate_md5(model_path) == model['md5sum'], corrupt_msg
+                    LOGGER.info('Download complete')
+            self.setLanguageList(lang_list, model)
+
+        else: # user-defined model
+            with open(os.path.join(self.user_network_directory, recog_network+ '.yaml'), encoding='utf8') as file:
+                recog_config = yaml.load(file, Loader=yaml.FullLoader)
+            
+            global imgH # if custom model, save this variable. (from *.yaml)
+            if recog_config['imgH']:
+                imgH = recog_config['imgH']
+                
+            available_lang = recog_config['lang_list']
+            self.setModelLanguage(recog_network, lang_list, available_lang, str(available_lang))
+            #char_file = os.path.join(self.user_network_directory, recog_network+ '.txt')
+            self.character = recog_config['character_list']
+            model_file = recog_network+ '.pth'
+            model_path = os.path.join(self.model_storage_directory, model_file)
+            self.setLanguageList(lang_list, recog_config)
+
+        dict_list = {}
+        for lang in lang_list:
+            dict_list[lang] = os.path.join(BASE_PATH, 'dict', lang + ".txt")
+
+        if detector:
+            self.detector = self.initDetector(detector_path)
+            
+        if recognizer:
+            if recog_network == 'generation1':
+                network_params = {
+                    'input_channel': 1,
+                    'output_channel': 512,
+                    'hidden_size': 512
+                    }
+            elif recog_network == 'generation2':
+                network_params = {
+                    'input_channel': 1,
+                    'output_channel': 256,
+                    'hidden_size': 256
+                    }
+            else:
+                network_params = recog_config['network_params']
+            self.recognizer, self.converter = get_recognizer(recog_network, network_params,\
+                                                         self.character, separator_list,\
+                                                         dict_list, model_path, device = self.device, quantize=quantize)
+
+    def getDetectorPath(self, detect_network):
+        if detect_network in self.support_detection_network:
+            self.detect_network = detect_network
+            if self.detect_network == 'craft':
+                from .detection import get_detector, get_textbox
+            elif self.detect_network in ['dbnet18']:
+                from .detection_db import get_detector, get_textbox
+            else:
+                raise RuntimeError("Unsupport detector network. Support networks are craft and dbnet18.")
+            self.get_textbox = get_textbox
+            self.get_detector = get_detector
+            corrupt_msg = 'MD5 hash mismatch, possible file corruption'
+            detector_path = os.path.join(self.model_storage_directory, self.detection_models[self.detect_network]['filename'])
+            if os.path.isfile(detector_path) == False:
+                if not self.download_enabled:
+                    raise FileNotFoundError("Missing %s and downloads disabled" % detector_path)
+                LOGGER.warning('Downloading detection model, please wait. '
+                               'This may take several minutes depending upon your network connection.')
+                download_and_unzip(self.detection_models[self.detect_network]['url'], self.detection_models[self.detect_network]['filename'], self.model_storage_directory, self.verbose)
+                assert calculate_md5(detector_path) == self.detection_models[self.detect_network]['md5sum'], corrupt_msg
+                LOGGER.info('Download complete')
+            elif calculate_md5(detector_path) != self.detection_models[self.detect_network]['md5sum']:
+                if not self.download_enabled:
+                    raise FileNotFoundError("MD5 mismatch for %s and downloads disabled" % detector_path)
+                LOGGER.warning(corrupt_msg)
+                os.remove(detector_path)
+                LOGGER.warning('Re-downloading the detection model, please wait. '
+                               'This may take several minutes depending upon your network connection.')
+                download_and_unzip(self.detection_models[self.detect_network]['url'], self.detection_models[self.detect_network]['filename'], self.model_storage_directory, self.verbose)
+                assert calculate_md5(detector_path) == self.detection_models[self.detect_network]['md5sum'], corrupt_msg
+        else:
+            raise RuntimeError("Unsupport detector network. Support networks are {}.".format(', '.join(self.support_detection_network)))
+        
+        return detector_path
+
+    def initDetector(self, detector_path):
+        return self.get_detector(detector_path, 
+                                 device = self.device, 
+                                 quantize = self.quantize, 
+                                 cudnn_benchmark = self.cudnn_benchmark
+                                 )
+    
+    def setDetector(self, detect_network):
+        detector_path = self.getDetectorPath(detect_network)
+        self.detector = self.initDetector(detector_path)
+    
+    def setModelLanguage(self, language, lang_list, list_lang, list_lang_string):
+        self.model_lang = language
+        if set(lang_list) - set(list_lang) != set():
+            if language == 'ch_tra' or language == 'ch_sim':
+                language = 'chinese'
+            raise ValueError(language.capitalize() + ' is only compatible with English, try lang_list=' + list_lang_string)
+
+    def getChar(self, fileName):
+        char_file = os.path.join(BASE_PATH, 'character', fileName)
+        with open(char_file, "r", encoding="utf-8-sig") as input_file:
+            list = input_file.read().splitlines()
+            char = ''.join(list)
+        return char
+
+    def setLanguageList(self, lang_list, model):
+        self.lang_char = []
+        for lang in lang_list:
+            char_file = os.path.join(BASE_PATH, 'character', lang + "_char.txt")
+            with open(char_file, "r", encoding = "utf-8-sig") as input_file:
+                char_list =  input_file.read().splitlines()
+            self.lang_char += char_list
+        if model.get('symbols'):
+            symbol = model['symbols']
+        elif model.get('character_list'):
+            symbol = model['character_list']
+        else:
+            symbol = '0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ '
+        self.lang_char = set(self.lang_char).union(set(symbol))
+        self.lang_char = ''.join(self.lang_char)
+
+    def detect(self, img, min_size = 20, text_threshold = 0.7, low_text = 0.4,\
+               link_threshold = 0.4,canvas_size = 2560, mag_ratio = 1.,\
+               slope_ths = 0.1, ycenter_ths = 0.5, height_ths = 0.5,\
+               width_ths = 0.5, add_margin = 0.1, reformat=True, optimal_num_chars=None,
+               threshold = 0.2, bbox_min_score = 0.2, bbox_min_size = 3, max_candidates = 0,
+               ):
+
+        if reformat:
+            img, img_cv_grey = reformat_input(img)
+
+        text_box_list = self.get_textbox(self.detector, 
+                                    img, 
+                                    canvas_size = canvas_size, 
+                                    mag_ratio = mag_ratio,
+                                    text_threshold = text_threshold, 
+                                    link_threshold = link_threshold, 
+                                    low_text = low_text,
+                                    poly = False, 
+                                    device = self.device, 
+                                    optimal_num_chars = optimal_num_chars,
+                                    threshold = threshold, 
+                                    bbox_min_score = bbox_min_score, 
+                                    bbox_min_size = bbox_min_size, 
+                                    max_candidates = max_candidates,
+                                    )
+
+        horizontal_list_agg, free_list_agg = [], []
+        for text_box in text_box_list:
+            horizontal_list, free_list = group_text_box(text_box, slope_ths,
+                                                        ycenter_ths, height_ths,
+                                                        width_ths, add_margin,
+                                                        (optimal_num_chars is None))
+            if min_size:
+                horizontal_list = [i for i in horizontal_list if max(
+                    i[1] - i[0], i[3] - i[2]) > min_size]
+                free_list = [i for i in free_list if max(
+                    diff([c[0] for c in i]), diff([c[1] for c in i])) > min_size]
+            horizontal_list_agg.append(horizontal_list)
+            free_list_agg.append(free_list)
+
+        return horizontal_list_agg, free_list_agg
+
+    def recognize(self, img_cv_grey, horizontal_list=None, free_list=None,\
+                  decoder = 'greedy', beamWidth= 5, batch_size = 1,\
+                  workers = 0, allowlist = None, blocklist = None, detail = 1,\
+                  rotation_info = None,paragraph = False,\
+                  contrast_ths = 0.1,adjust_contrast = 0.5, filter_ths = 0.003,\
+                  y_ths = 0.5, x_ths = 1.0, reformat=True, output_format='standard'):
+
+        if reformat:
+            img, img_cv_grey = reformat_input(img_cv_grey)
+
+        if allowlist:
+            ignore_char = ''.join(set(self.character)-set(allowlist))
+        elif blocklist:
+            ignore_char = ''.join(set(blocklist))
+        else:
+            ignore_char = ''.join(set(self.character)-set(self.lang_char))
+
+        if self.model_lang in ['chinese_tra','chinese_sim']: decoder = 'greedy'
+
+        if (horizontal_list==None) and (free_list==None):
+            y_max, x_max = img_cv_grey.shape
+            horizontal_list = [[0, x_max, 0, y_max]]
+            free_list = []
+
+        # without gpu/parallelization, it is faster to process image one by one
+        if ((batch_size == 1) or (self.device == 'cpu')) and not rotation_info:
+            result = []
+            for bbox in horizontal_list:
+                h_list = [bbox]
+                f_list = []
+                image_list, max_width = get_image_list(h_list, f_list, img_cv_grey, model_height = imgH)
+                result0 = get_text(self.character, imgH, int(max_width), self.recognizer, self.converter, image_list,\
+                              ignore_char, decoder, beamWidth, batch_size, contrast_ths, adjust_contrast, filter_ths,\
+                              workers, self.device)
+                result += result0
+            for bbox in free_list:
+                h_list = []
+                f_list = [bbox]
+                image_list, max_width = get_image_list(h_list, f_list, img_cv_grey, model_height = imgH)
+                result0 = get_text(self.character, imgH, int(max_width), self.recognizer, self.converter, image_list,\
+                              ignore_char, decoder, beamWidth, batch_size, contrast_ths, adjust_contrast, filter_ths,\
+                              workers, self.device)
+                result += result0
+        # default mode will try to process multiple boxes at the same time
+        else:
+            image_list, max_width = get_image_list(horizontal_list, free_list, img_cv_grey, model_height = imgH)
+            image_len = len(image_list)
+            if rotation_info and image_list:
+                image_list = make_rotated_img_list(rotation_info, image_list)
+                max_width = max(max_width, imgH)
+
+            result = get_text(self.character, imgH, int(max_width), self.recognizer, self.converter, image_list,\
+                          ignore_char, decoder, beamWidth, batch_size, contrast_ths, adjust_contrast, filter_ths,\
+                          workers, self.device)
+
+            if rotation_info and (horizontal_list+free_list):
+                # Reshape result to be a list of lists, each row being for 
+                # one of the rotations (first row being no rotation)
+                result = set_result_with_confidence(
+                    [result[image_len*i:image_len*(i+1)] for i in range(len(rotation_info) + 1)])
+
+        if self.model_lang == 'arabic':
+            direction_mode = 'rtl'
+            result = [list(item) for item in result]
+            for item in result:
+                item[1] = get_display(item[1])
+        else:
+            direction_mode = 'ltr'
+
+        if paragraph:
+            result = get_paragraph(result, x_ths=x_ths, y_ths=y_ths, mode = direction_mode)
+
+        if detail == 0:
+            return [item[1] for item in result]
+        elif output_format == 'dict':
+            if paragraph:
+                return [ {'boxes':item[0],'text':item[1]} for item in result]    
+            return [ {'boxes':item[0],'text':item[1],'confident':item[2]} for item in result]
+        elif output_format == 'json':
+            if paragraph:
+                return [json.dumps({'boxes':[list(map(int, lst)) for lst in item[0]],'text':item[1]}, ensure_ascii=False) for item in result]
+            return [json.dumps({'boxes':[list(map(int, lst)) for lst in item[0]],'text':item[1],'confident':item[2]}, ensure_ascii=False) for item in result]
+        elif output_format == 'free_merge':
+            return merge_to_free(result, free_list)
+        else:
+            return result
+
+    def readtext(self, image, decoder = 'greedy', beamWidth= 5, batch_size = 1,\
+                 workers = 0, allowlist = None, blocklist = None, detail = 1,\
+                 rotation_info = None, paragraph = False, min_size = 20,\
+                 contrast_ths = 0.1,adjust_contrast = 0.5, filter_ths = 0.003,\
+                 text_threshold = 0.7, low_text = 0.4, link_threshold = 0.4,\
+                 canvas_size = 2560, mag_ratio = 1.,\
+                 slope_ths = 0.1, ycenter_ths = 0.5, height_ths = 0.5,\
+                 width_ths = 0.5, y_ths = 0.5, x_ths = 1.0, add_margin = 0.1, 
+                 threshold = 0.2, bbox_min_score = 0.2, bbox_min_size = 3, max_candidates = 0,
+                 output_format='standard'):
+        '''
+        Parameters:
+        image: file path or numpy-array or a byte stream object
+        '''
+        img, img_cv_grey = reformat_input(image)
+
+        horizontal_list, free_list = self.detect(img, 
+                                                 min_size = min_size, text_threshold = text_threshold,\
+                                                 low_text = low_text, link_threshold = link_threshold,\
+                                                 canvas_size = canvas_size, mag_ratio = mag_ratio,\
+                                                 slope_ths = slope_ths, ycenter_ths = ycenter_ths,\
+                                                 height_ths = height_ths, width_ths= width_ths,\
+                                                 add_margin = add_margin, reformat = False,\
+                                                 threshold = threshold, bbox_min_score = bbox_min_score,\
+                                                 bbox_min_size = bbox_min_size, max_candidates = max_candidates
+                                                 )
+        # get the 1st result from hor & free list as self.detect returns a list of depth 3
+        horizontal_list, free_list = horizontal_list[0], free_list[0]
+        result = self.recognize(img_cv_grey, horizontal_list, free_list,\
+                                decoder, beamWidth, batch_size,\
+                                workers, allowlist, blocklist, detail, rotation_info,\
+                                paragraph, contrast_ths, adjust_contrast,\
+                                filter_ths, y_ths, x_ths, False, output_format)
+
+        return result
+    
+    def readtextlang(self, image, decoder = 'greedy', beamWidth= 5, batch_size = 1,\
+                 workers = 0, allowlist = None, blocklist = None, detail = 1,\
+                 rotation_info = None, paragraph = False, min_size = 20,\
+                 contrast_ths = 0.1,adjust_contrast = 0.5, filter_ths = 0.003,\
+                 text_threshold = 0.7, low_text = 0.4, link_threshold = 0.4,\
+                 canvas_size = 2560, mag_ratio = 1.,\
+                 slope_ths = 0.1, ycenter_ths = 0.5, height_ths = 0.5,\
+                 width_ths = 0.5, y_ths = 0.5, x_ths = 1.0, add_margin = 0.1, 
+                 threshold = 0.2, bbox_min_score = 0.2, bbox_min_size = 3, max_candidates = 0,
+                 output_format='standard'):
+        '''
+        Parameters:
+        image: file path or numpy-array or a byte stream object
+        '''
+        img, img_cv_grey = reformat_input(image)
+
+        horizontal_list, free_list = self.detect(img, 
+                                                 min_size = min_size, text_threshold = text_threshold,\
+                                                 low_text = low_text, link_threshold = link_threshold,\
+                                                 canvas_size = canvas_size, mag_ratio = mag_ratio,\
+                                                 slope_ths = slope_ths, ycenter_ths = ycenter_ths,\
+                                                 height_ths = height_ths, width_ths= width_ths,\
+                                                 add_margin = add_margin, reformat = False,\
+                                                 threshold = threshold, bbox_min_score = bbox_min_score,\
+                                                 bbox_min_size = bbox_min_size, max_candidates = max_candidates
+                                                 )
+        # get the 1st result from hor & free list as self.detect returns a list of depth 3
+        horizontal_list, free_list = horizontal_list[0], free_list[0]
+        result = self.recognize(img_cv_grey, horizontal_list, free_list,\
+                                decoder, beamWidth, batch_size,\
+                                workers, allowlist, blocklist, detail, rotation_info,\
+                                paragraph, contrast_ths, adjust_contrast,\
+                                filter_ths, y_ths, x_ths, False, output_format)
+       
+        char = []
+        directory = 'characters/'
+        for i in range(len(result)):
+            char.append(result[i][1])
+        
+        def search(arr,x):
+            g = False
+            for i in range(len(arr)):
+                if arr[i]==x:
+                    g = True
+                    return 1
+            if g == False:
+                return -1
+        def tupleadd(i):
+            a = result[i]
+            b = a + (filename[0:2],)
+            return b
+        
+        for filename in os.listdir(directory):
+            if filename.endswith(".txt"):
+                with open ('characters/'+ filename,'rt',encoding="utf8") as myfile:  
+                    chartrs = str(myfile.read().splitlines()).replace('\n','') 
+                    for i in range(len(char)):
+                        res = search(chartrs,char[i])
+                        if res != -1:
+                            if filename[0:2]=="en" or filename[0:2]=="ch":
+                                print(tupleadd(i))
+
+    def readtext_batched(self, image, n_width=None, n_height=None,\
+                         decoder = 'greedy', beamWidth= 5, batch_size = 1,\
+                         workers = 0, allowlist = None, blocklist = None, detail = 1,\
+                         rotation_info = None, paragraph = False, min_size = 20,\
+                         contrast_ths = 0.1,adjust_contrast = 0.5, filter_ths = 0.003,\
+                         text_threshold = 0.7, low_text = 0.4, link_threshold = 0.4,\
+                         canvas_size = 2560, mag_ratio = 1.,\
+                         slope_ths = 0.1, ycenter_ths = 0.5, height_ths = 0.5,\
+                         width_ths = 0.5, y_ths = 0.5, x_ths = 1.0, add_margin = 0.1, 
+                         threshold = 0.2, bbox_min_score = 0.2, bbox_min_size = 3, max_candidates = 0,
+                         output_format='standard'):
+        '''
+        Parameters:
+        image: file path or numpy-array or a byte stream object
+        When sending a list of images, they all must of the same size,
+        the following parameters will automatically resize if they are not None
+        n_width: int, new width
+        n_height: int, new height
+        '''
+        img, img_cv_grey = reformat_input_batched(image, n_width, n_height)
+
+        horizontal_list_agg, free_list_agg = self.detect(img, 
+                                                 min_size = min_size, text_threshold = text_threshold,\
+                                                 low_text = low_text, link_threshold = link_threshold,\
+                                                 canvas_size = canvas_size, mag_ratio = mag_ratio,\
+                                                 slope_ths = slope_ths, ycenter_ths = ycenter_ths,\
+                                                 height_ths = height_ths, width_ths= width_ths,\
+                                                 add_margin = add_margin, reformat = False,\
+                                                 threshold = threshold, bbox_min_score = bbox_min_score,\
+                                                 bbox_min_size = bbox_min_size, max_candidates = max_candidates
+                                                 )
+        result_agg = []
+        # put img_cv_grey in a list if its a single img
+        img_cv_grey = [img_cv_grey] if len(img_cv_grey.shape) == 2 else img_cv_grey
+        for grey_img, horizontal_list, free_list in zip(img_cv_grey, horizontal_list_agg, free_list_agg):
+            result_agg.append(self.recognize(grey_img, horizontal_list, free_list,\
+                                            decoder, beamWidth, batch_size,\
+                                            workers, allowlist, blocklist, detail, rotation_info,\
+                                            paragraph, contrast_ths, adjust_contrast,\
+                                            filter_ths, y_ths, x_ths, False, output_format))
+
+        return result_agg

model.py

@@ -0,0 +1,24 @@
+import easyocr
+from typing import List
+
+class EasyOCRModel:
+    def __init__(self):
+        self.reader = easyocr.Reader(['en'])  # Initialize with English; add languages if needed.
+
+    def predict(self, image_path: str) -> List[str]:
+        """
+        Perform OCR on the given image.
+
+        Args:
+            image_path (str): Path to the input image.
+
+        Returns:
+            List[str]: Extracted text from the image.
+        """
+        return self.reader.readtext(image_path, detail=0)
+
+# Test the model locally
+if __name__ == "__main__":
+    model = EasyOCRModel()
+    result = model.predict("sample_image.jpg")
+    print(result)