Function return value of wrong type if I use multiprocessing

world!
I have this code:

from numpy import array
from cv2 import imshow, cvtColor, imwrite, imread, destroyAllWindows, COLOR_BGR2RGB
from pyscreenshot import grab
import pytesseract


filename = 'image.png'
elements_for_replace = {'iL': '1L', 'Bi': 'B1', 'Bl': 'B1', 'Ci': 'C1', 'Cl': 'C1'}

pytesseract.pytesseract.tesseract_cmd = r'C:\Users\Administrator\AppData\Local\Tesseract-OCR\tesseract.exe'


def scanning(x1, y1, x2, y2):
    screen = array(grab(bbox=(x1, y1, x2, y2)))
    imwrite(filename, screen)
    img = imread(filename)
    text = pytesseract.image_to_string(img)
    history = text.split()
    return history


def first():
    return scanning(730, 740, 1335, 790)


def second():
    return scanning(730, 453, 1335, 500)


def third():
    return scanning(817, 45, 1522, 99)


def replace_elements(data, replace_data):
    for item in data:
        if item in replace_data:
            data[data.index(item)] = replace_data[item]
    return data


def get_data():
    x = replace_elements(first(), elements_for_replace)
    y = replace_elements(second(), elements_for_replace)
    z = replace_elements(third(), elements_for_replace)
    destroyAllWindows()
    return x, y, z

When the function get_data() is called, this code uses computer vision to translate an image into text at three different locations on the screen. Does it consistently. It then replaces the failed elements with the correct ones. At the output, we get a tuple of lists (x, y, z), which will be processed by another part of the program.

Converting images to text takes a lot of time. And the sequential execution of the program multiplies this time by 3. I came to the conclusion that I need to use the multiprocessing module (or rather concurrent.futures) to reduce the program execution time.

I rewrote the function get_data() like this:

import concurrent.futures


def get_data():
    with concurrent.futures.ProcessPoolExecutor() as executor:
        x = executor.submit(replace_elements, first(), elements_for_replace)
        y = executor.submit(replace_elements, second(), elements_for_replace)
        z = executor.submit(replace_elements, third(), elements_for_replace)
    destroyAllWindows()
    return x, y, z

Now the returned variables have data type <class 'concurrent.futures._base.Future'> instead of <class 'list'> and the program, trying to process this data, throws an error 'TypeError: 'Future' object is not subscriptable'.

How to start parallel execution of a function so that the return value of the function is the same as in the first version of the code, that is <class 'list'> ???

executor.submit() returns a Future object, not the value of the function called. In order to get the value returned by the function, you must call result() on the Future object. In your case you'll want to modify your code like so:

def get_data():
    with concurrent.futures.ProcessPoolExecutor() as executor:
        future_x = executor.submit(replace_elements, first(), elements_for_replace)
        future_y = executor.submit(replace_elements, second(), elements_for_replace)
        future_z = executor.submit(replace_elements, third(), elements_for_replace)
    destroyAllWindows()

    # Actually get the value of the function here
    x = future_x.result()
    y = future_y.result()
    z = future_z.result()

    return x, y, z

Additionally, as a suggestion you could also look into using the ProcessPoolExecutor.map() to clean up the code a bit. With it, you wouldn't have to define each result.