def test_text(image_file, lang='eng'):
    print image_file

    return tesseract.image_to_string(
            Image.open(image_file),
            lang=lang,
            builder=tesseract.DigitBuilder())

    def __test_txt(self, image_file, expected_box_file, lang='eng'):
        image_file = "tests/data/" + image_file
        expected_box_file = "tests/tesseract/" + expected_box_file

        with codecs.open(expected_box_file, 'r', encoding='utf-8') \
                as file_descriptor:
            expected_boxes = self.builder.read_file(file_descriptor)
        expected_boxes.sort()

        boxes = tesseract.image_to_string(Image.open(image_file), lang=lang,
                                             builder=self.builder)
        boxes.sort()

        self.assertTrue(len(boxes) > 0)
        self.assertEqual(len(boxes), len(expected_boxes))

        for i in range(0, min(len(boxes), len(expected_boxes))):
            try:
                # python 2.7
                self.assertEqual(type(expected_boxes[i].content), unicode)
                self.assertEqual(type(boxes[i].content), unicode)
            except NameError:
                # python 3
                self.assertEqual(type(expected_boxes[i].content), str)
                self.assertEqual(type(boxes[i].content), str)
            self.assertEqual(boxes[i], expected_boxes[i])

    def _read_from_img(self, image_path, lang=None):
        boxes = tesseract.image_to_string(
            Image.open(image_path),
            lang=lang,
            builder=self._builder
        )
        boxes.sort()

        return boxes

def find_secret_rects(image, secret_res, lang, tesseract_configs=None):
    """
    Find secret rects in an image.

    param: Image image
    param: list secret_res
    param: str lang
    param: str tesseract_configs
    return: list of rects
    rtype: list
    """

    # When using pyocr, an input image is converted to RGB (not RGBA).
    # During the conversion, transparent pixels are converted into BLACK.
    # Sometimes the black pixels get in the way of recognizing text.
    #
    # For example, macOS's screenshot image taken by Command+Shift+4+Space
    # has transparent pixels around an window. This results in a black and
    # thick border in the edge of image. The border worsen quality of OCR
    # of text near by the border. To avoid this, convert transparent pixels
    # into WHITE by pasting image into an white background.
    #
    # See: http://stackoverflow.com/questions/9166400/convert-rgba-png-to-rgb-with-pil
    if image.mode == 'RGBA':
        background = Image.new('RGB', image.size, (255, 255, 255))
        background.paste(image, mask=image.split()[3])  # Paste image masked by alpha channel [3]
        image = background

    # offset = (0, 150)
    # cropped_image = image.crop((offset[0], offset[1], image.size[0], 220))
    offset = (0, 0)
    cropped_image = image

    builder = ModifiedCharBoxBuilder(cropped_image.size[1])
    if tesseract_configs:
        builder.tesseract_configs = tesseract_configs

    boxes = image_to_string(cropped_image, lang=lang, builder=builder)

    if os.environ.get('DEBUG'):
        for box in boxes:
            print(box.content, box.position)

    content = ''.join(box.content for box in boxes)
    assert len(boxes) == len(content)

    secret_rects = []
    for secret_re in secret_res:
        for m in secret_re.finditer(content):
            matched_boxes = boxes[m.start():m.end()]
            matched_rects = [b.position for b in matched_boxes]
            for rect in bounding_boxes_by_line(matched_rects):
                rect = offset_rect(offset, padding_box(rect, 2))
                secret_rects.append(rect)

    return secret_rects

    def __test_txt(self, image_file, expected_output_file, lang="eng"):
        image_file = "tests/data/" + image_file
        expected_output_file = "tests/tesseract/" + expected_output_file

        expected_output = ""
        with codecs.open(expected_output_file, "r", encoding="utf-8") as file_descriptor:
            for line in file_descriptor:
                expected_output += line
        expected_output = expected_output.strip()

        output = tesseract.image_to_string(Image.open(image_file), lang=lang)

        self.assertEqual(output, expected_output)

    def __test_text(self, image_file, expected_output_file, lang='eng'):
        image_file = "tests/data/" + image_file
        expected_output_file = "tests/tesseract/" + expected_output_file

        expected_output = ""
        with codecs.open(expected_output_file, 'r', encoding='utf-8') \
                as file_descriptor:
            for line in file_descriptor:
                expected_output += line
        expected_output = expected_output.strip()

        output = tesseract.image_to_string(Image.open(image_file), lang=lang, builder=self.builder)

        self.assertEqual(output, expected_output)

    def __test_txt(self, image_file, expected_output_file, lang='eng'):
        image_file = os.path.join("tests", "input", "specific", image_file)
        expected_output_file = os.path.join(
            "tests", "output", "specific", "tesseract", expected_output_file
        )

        expected_output = ""
        with codecs.open(expected_output_file, 'r', encoding='utf-8') \
                as file_descriptor:
            for line in file_descriptor:
                expected_output += line
        expected_output = expected_output.strip()

        output = tesseract.image_to_string(Image.open(image_file), lang=lang)

        self.assertEqual(output, expected_output)

 def get_data(self, region, rerun=0,
              image_optimizer=None, data_optimizer=None, threshold=None):
     '''Gets data out of a single region
     :param rerun: incrementing integer for every rerun.
     :param image_optimizer: callback, takes PIL.Image and rerun as params.
     :param data_optimizer: callback, takes String and rerun as params.
     :param threshold: callback, takes String and should return False for a rerun.
     '''
     if image_optimizer:
         optiregion = image_optimizer(region, rerun)
     data = tesseract.image_to_string(optiregion)
     if data_optimizer:
         data = data_optimizer(data, rerun)
     if threshold and not threshold(data):
         return self.get_data(
             region, rerun + 1,
             image_optimizer, data_optimizer, threshold)
     else:
         return data

    def test_write_read(self):
        original_boxes = tesseract.image_to_string(Image.open("tests/data/test.png"), builder=self.builder)
        self.assertTrue(len(original_boxes) > 0)

        (file_descriptor, tmp_path) = tempfile.mkstemp()
        try:
            # we must open the file with codecs.open() for utf-8 support
            os.close(file_descriptor)

            with codecs.open(tmp_path, "w", encoding="utf-8") as fdescriptor:
                self.builder.write_file(fdescriptor, original_boxes)

            with codecs.open(tmp_path, "r", encoding="utf-8") as fdescriptor:
                new_boxes = self.builder.read_file(fdescriptor)

            self.assertEqual(len(new_boxes), len(original_boxes))
            for i in range(0, len(original_boxes)):
                self.assertEqual(new_boxes[i], original_boxes[i])
        finally:
            os.remove(tmp_path)

def getText(filename):
    img = Image.open(filename)
    text = tesseract.image_to_string(img)
    return text

from pyocr import tesseract
from PIL import Image
imagefile = Image.open('code.jpg')
val = tesseract.image_to_string(imagefile)
print(val)