crfm-helm 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

helm/benchmark/scenarios/vision_language/image2structure/image2structure_scenario.py

@@ -0,0 +1,214 @@
+import os.path
+from typing import List, Optional, Dict, Any
+from abc import abstractmethod
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from helm.benchmark.scenarios.scenario import (
+    CORRECT_TAG,
+    ASSET_NAME_TAG,
+    ASSET_PATH_TAG,
+    TEST_SPLIT,
+    VALID_SPLIT,
+    Instance,
+    Input,
+    Output,
+    Reference,
+    Scenario,
+)
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_directory_exists
+from helm.common.hierarchical_logger import hlog
+
+PROCESSED: str = "processed"
+
+
+class Image2StructureScenario(Scenario):
+    BASE_PROMPT: str
+    HUGGINGFACE_DATASET_NAME: str
+    SUBSETS: List[str]
+
+    name: str
+    description: str
+    tags = ["vision-language"]
+
+    helm_split_to_huggingface_split = {
+        TEST_SPLIT: "test",
+        VALID_SPLIT: "validation",
+    }
+
+    def __init__(self, subset: str, recompile_prompt: bool = True, split: str = VALID_SPLIT):
+        super().__init__()
+        assert subset in self.SUBSETS, f"Invalid subset: {subset}"
+        self._subset: str = subset
+        self._recompile_prompt: bool = recompile_prompt
+        self._split: str = split
+        self._output_path: Optional[str] = None
+
+    def preprocess_row(self, row: Dict[str, Any], assets_path: str) -> Dict[str, Any]:
+        # By default, there are no assets
+        del row["assets"]
+        row["assets_paths"] = []
+        row["assets_names"] = []
+        return row
+
+    def build_prompt(self, row: Dict[str, Any]) -> str:
+        return self.BASE_PROMPT
+
+    @abstractmethod
+    def compile_and_save(self, structure: str, assets_path: str, destination_path: str) -> str:
+        """Compile the prompt, should save the image and return the text extracted from the image"""
+        pass
+
+    def finalize(self, row: Dict[str, Any]) -> None:
+        """Perform cleanup operations after the instance has been generated."""
+        pass
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        """Get the instances for the scenario. This compile_and_save method should be implemented by the subclass.
+        Additionally, the subclass should implement the preprocess_row method if any preprocessing is needed.
+
+        For each instance, the following steps are performed:
+        1. Preprocess the row
+        2. Save the image locally
+            - 2.a. If we don't want to recompile the prompt, save the image directly
+            - 2.b. If we want to recompile the prompt, compile the structure and save the image
+        3. Create the prompt
+        4. Create the multimedia content
+        5. Create the reference
+        6. Finalize the Instance
+
+        Args:
+            output_path (str): The path where the instances will be saved
+
+        Returns:
+            List[Instance]: The list of instances
+        """
+        self._output_path = output_path
+        images_path: str = os.path.join(output_path, "data/images", self._subset)
+        assets_path: str = os.path.join(output_path, "data/assets", self._subset)
+        ensure_directory_exists(images_path)
+        ensure_directory_exists(assets_path)
+
+        instances: List[Instance] = []
+
+        # Process the desired set of instances
+        for row in tqdm(
+            load_dataset(
+                self.HUGGINGFACE_DATASET_NAME,
+                self._subset,
+                split=self.helm_split_to_huggingface_split[self._split],
+                cache_dir=output_path,
+            )
+        ):
+            question_uuid: str = str(row["uuid"]).replace('"', "")
+            if row["category"][1:-1] != self._subset:
+                hlog(
+                    f"Skipping instance {question_uuid} as it belong in category"
+                    f" {row['category']} and not {self._subset}"
+                )
+                continue
+
+            # Step 1: Preprocess the row
+            row = self.preprocess_row(row, assets_path)
+
+            # Step 2: Save the image locally
+            image_path: str = os.path.join(images_path, f"{question_uuid}.png")
+            if not os.path.exists(image_path):
+                if not self._recompile_prompt:  # 2.a
+                    row["image"].save(image_path)
+                else:  # 2.b
+                    if "structure" not in row:
+                        raise ValueError("Cannot recompile prompt without structure")
+                    structure: str = row["structure"]
+                    text: str = self.compile_and_save(structure, assets_path, image_path)
+                    row["text"] = text
+
+            # Step 3: Create the prompt
+            prompt: str = self.build_prompt(row)
+
+            # Step 4: Create the multimedia content
+            image_object = MediaObject(location=image_path, content_type="image/png")
+            content: List[MediaObject] = [
+                MediaObject(text=prompt, content_type="text/plain"),
+                image_object,
+            ]
+
+            # Step 5: Create the references
+            # 5.a Create the reference containing the structure and the associated image.
+            reference: Reference
+            if "structure" in row:
+                multimedia_object: MultimediaObject
+                if os.path.exists(row["structure"]):
+                    # 5.a.1 The structure is a path, therefore represent it as a multimedia object
+                    # containing the files used to compile the structure (such as a repository
+                    # containing the HTML, CSS, and JavaScript files used to generate a webpage)
+                    multimedia_object = MultimediaObject(
+                        [image_object, MediaObject(location=row["structure"], content_type="path/path")]
+                    )
+                elif row["structure"] == PROCESSED:
+                    # 5.a.2 The structure has been processed and is no longer present in the row
+                    # This can be the case if the structure is a base64 encoding of an archive that
+                    # has been extracted to a temporary path and processed but the path is no longer
+                    # existing (deleted after the processing is done)
+                    multimedia_object = MultimediaObject([image_object])
+                else:
+                    # 5.a.3 The structure is not a path, therefore it is directly a valid string
+                    # representing the structure (such as LaTeX code)
+                    multimedia_object = MultimediaObject([image_object])
+                reference = Reference(
+                    output=Output(text=row["text"], multimedia_content=multimedia_object),
+                    tags=[CORRECT_TAG],
+                )
+            else:
+                if "text" in row:
+                    reference = Reference(
+                        output=Output(text=row["text"], multimedia_content=MultimediaObject([image_object])),
+                        tags=[CORRECT_TAG],
+                    )
+                else:
+                    reference = Reference(
+                        output=Output(multimedia_content=MultimediaObject([image_object])), tags=[CORRECT_TAG]
+                    )
+            references: List[Reference] = [reference]
+
+            # 5.b Create the reference containing the assets
+            if len(row["assets_paths"]) > 0:
+                assets_paths_reference: Reference = Reference(
+                    output=Output(
+                        text=", ".join(
+                            row["assets_paths"]
+                        ),  # TODO: This is for debugging purposes (to show in the frontend)
+                        multimedia_content=MultimediaObject(
+                            [
+                                MediaObject(location=asset, content_type=f"image/{asset.split('.')[-1].lower()}")
+                                for asset in row["assets_paths"]
+                            ]
+                        ),
+                    ),
+                    tags=[ASSET_PATH_TAG],
+                )
+                references.append(assets_paths_reference)
+                assets_names_reference: Reference = Reference(
+                    output=Output(
+                        text=", ".join(
+                            row["assets_names"]
+                        ),  # TODO: This is for debugging purposes (to show in the frontend)
+                        multimedia_content=MultimediaObject(
+                            [MediaObject(text=asset, content_type="text/plain") for asset in row["assets_names"]]
+                        ),
+                    ),
+                    tags=[ASSET_NAME_TAG],
+                )
+                references.append(assets_names_reference)
+
+            # Step 6: Finalize the Instance
+            self.finalize(row)
+            instance = Instance(
+                input=Input(multimedia_content=MultimediaObject(content)), references=references, split=self._split
+            )
+            instances.append(instance)
+
+        assert len(instances) > 0, f"No instances found for subject {self._subset}"
+        return instances

helm/benchmark/scenarios/vision_language/image2structure/latex_scenario.py

@@ -0,0 +1,25 @@
+from helm.benchmark.scenarios.scenario import VALID_SPLIT
+from helm.benchmark.scenarios.vision_language.image2structure.utils_latex import (
+    latex_to_image,
+    strip_unnecessary_latex_parts,
+)
+from helm.benchmark.scenarios.vision_language.image2structure.image2structure_scenario import Image2StructureScenario
+
+
+class LatexScenario(Image2StructureScenario):
+    BASE_PROMPT = "Please provide the LaTeX code used to generate this image. Only generate the code relevant to what you see. Your code will be surrounded by all the imports necessary as well as the begin and end document delimiters."  # noqa: E501
+    HUGGINGFACE_DATASET_NAME = "stanford-crfm/i2s-latex"
+    SUBSETS = ["equation", "table", "plot", "algorithm"]
+
+    name = "image2latex"
+    description = "Evaluate multimodal models on Latex generation to recreate a provided image"
+
+    def __init__(self, subset: str, recompile_prompt: bool = True, split: str = VALID_SPLIT):
+        super().__init__(subset, recompile_prompt, split)
+
+    def compile_and_save(self, structure: str, assets_path: str, destination_path: str) -> str:
+        image, infos = latex_to_image(structure, assets_path=assets_path, crop=True)
+        image.save(destination_path)
+        assert "latex_code" in infos
+        text: str = strip_unnecessary_latex_parts(infos["latex_code"])
+        return text

helm/benchmark/scenarios/vision_language/image2structure/musicsheet_scenario.py

@@ -0,0 +1,20 @@
+from helm.benchmark.scenarios.scenario import VALID_SPLIT
+from helm.benchmark.scenarios.vision_language.image2structure.image2structure_scenario import Image2StructureScenario
+
+
+class MusicSheetScenario(Image2StructureScenario):
+    BASE_PROMPT = (
+        "Please generate the Lilypond code to generate a music sheet that looks like this image as much as feasible possible.\n"  # noqa: E501
+        "This music sheet was created by me, and I would like to recreate it using Lilypond."
+    )
+    HUGGINGFACE_DATASET_NAME = "stanford-crfm/i2s-musicsheet"
+    SUBSETS = ["music"]
+
+    name = "image2musicsheet"
+    description = "Evaluate multimodal models on Lilypond generation to recreate a provided image"
+
+    def __init__(self, subset: str, recompile_prompt: bool = True, split: str = VALID_SPLIT):
+        super().__init__(subset, recompile_prompt, split)
+
+    def compile_and_save(self, structure: str, assets_path: str, destination_path: str) -> str:
+        raise Exception("Music sheets have no ground truth, compilation is not possible")

helm/benchmark/scenarios/vision_language/image2structure/utils_latex.py

@@ -0,0 +1,347 @@
+from typing import Optional, Tuple, List, Dict, Any
+
+import io
+import os
+import re
+
+from helm.common.optional_dependencies import handle_module_not_found_error, OptionalDependencyNotInstalled
+
+try:
+    from latex import build_pdf
+    from pdf2image import convert_from_bytes
+    from PIL import ImageOps
+    from PIL.Image import Image
+except ModuleNotFoundError as e:
+    handle_module_not_found_error(e, suggestions=["image2structure"])
+
+# LaTeX preamble
+# Make sure to install "latex-full".
+TEX_INCLUDES = r"""
+\usepackage{amsmath,amssymb,amsfonts}
+\usepackage{graphicx}
+\usepackage{graphicx}
+\usepackage{amsmath}
+\usepackage{xcolor}
+\usepackage{algorithm}
+\usepackage{algorithmicx}
+\usepackage{algpseudocode}
+\usepackage{listings}
+\usepackage{stfloats}
+\usepackage{epstopdf}
+\usepackage{pgfplots}
+\usepackage{tikz}
+\usepackage{tikz-cd}
+\usepackage{tikz-qtree}
+\usepackage{tikz-dependency}
+\usepackage{tikz-3dplot}
+\usepackage{tikz-network}
+\usepackage[flushleft]{threeparttable}
+\usepackage{adjustbox}
+"""
+
+# LaTeX delimiters
+TEX_BEGIN_FILE = r"""\documentclass{article}"""
+TEX_BEGIN_DOCUMENT = r"""\begin{document}"""
+TEX_END_DOCUMENT = r"""\end{document}"""
+
+# Number of times to try to fix the LaTeX code
+MAX_NUM_TRIES: int = 3
+
+TEX_BEGIN_DOCUMENT = r"""\begin{document}"""
+TEX_END_DOCUMENT = r"""\end{document}"""
+
+TEX_REPLACE_NUMBERING: List[Tuple[str, str]] = [
+    ("{equation}", "{equation*}"),
+    ("{align}", "{align*}"),
+    ("{alignat}", "{alignat*}"),
+    ("{gather}", "{gather*}"),
+    ("{flalign}", "{flalign*}"),
+    ("{multline}", "{multline*}"),
+    ("{eqnarray}", "{eqnarray*}"),
+    ("{subeqnarray}", "{subeqnarray*}"),
+    ("{multline}", "{multline*}"),
+    ("{aligneq}", "{aligneq*}"),
+]
+
+
+def latex_to_pdf(latex_code: str, assets_path: str) -> io.BytesIO:
+    # Compiling LaTeX code to PDF
+    path = os.path.join(os.path.abspath(os.path.dirname(__file__)), assets_path)
+    pdf = build_pdf(latex_code, texinputs=[path, ""])
+    return io.BytesIO(pdf.data)  # Convert PDF to a byte stream
+
+
+def pdf_to_image(
+    pdf_stream: io.BytesIO,
+    crop: bool = False,
+    resize_to: Optional[Tuple[int, int]] = None,
+) -> Image:
+    # Convert the first page of the PDF stream to an image
+    images = convert_from_bytes(pdf_stream.read(), first_page=1, last_page=1)
+    if images:
+        image = images[0]
+
+        # Removes the white border around the image
+        if crop:
+            (w, h) = image.size
+            image = image.crop((0, 0, w, h - int(h * 0.2)))  # Remove pagination
+            image = image.crop(ImageOps.invert(image).getbbox())  # Remove white border
+
+        # Resize the image
+        if resize_to:
+            image = image.resize(resize_to)
+
+        return image
+    else:
+        raise Exception("PDF to Image conversion failed")
+
+
+def strip_unnecessary_latex_parts(latex_code: str) -> str:
+    """Strip unnecessary parts of the LaTeX code."""
+
+    # Remove comments
+    minimal_latex_code = re.sub(r"%.*?\n", "\n", latex_code)
+
+    # Remove \documentclass and any \usepackage lines
+    minimal_latex_code = re.sub(r"\\documentclass\{.*?\}\n", "", latex_code)
+    minimal_latex_code = re.sub(r"\\usepackage(\[.*?\])?\{.*?\}\n", "", minimal_latex_code)
+
+    # Remove everything before \begin{document} and including it, and everything after \end{document}
+    minimal_latex_code = re.sub(r"\\begin\{document\}\n*", "", minimal_latex_code, flags=re.DOTALL)
+    minimal_latex_code = re.sub(r"\\end\{document\}.*", "", minimal_latex_code, flags=re.DOTALL)
+
+    # Ensure \begin{...} is followed by a \n
+    minimal_latex_code = re.sub(r"(\\begin\{.*?\}(\[.*?\])?)(?!\n)", r"\1\n", minimal_latex_code)
+    # Ensure \end{...} has a \n before it
+    minimal_latex_code = re.sub(r"(\\end\{.*?\})(?!\n)", r"\1\n", minimal_latex_code)
+
+    # Normalize space sequences to a single space globally
+    minimal_latex_code = re.sub(r" +", " ", minimal_latex_code)
+    # Replace tabs with a single space
+    minimal_latex_code = re.sub(r"\t", " ", minimal_latex_code)
+    # Remove leading and trailing spaces on each line
+    minimal_latex_code = re.sub(r"^[ \t]+|[ \t]+$", "", minimal_latex_code, flags=re.MULTILINE)
+    # Remove unnecessary whitespace - multiple empty lines and tabulations
+    minimal_latex_code = re.sub(r"\n\s*\n", "\n", minimal_latex_code)
+
+    return minimal_latex_code.strip()
+
+
+def handle_latex_error(
+    e: Exception,
+    original_latex_code: str,
+    assets_path: str,
+    crop: bool,
+    resize_to: Optional[Tuple[int, int]],
+    num_try_remaining: int,
+) -> Tuple[Image, Dict[str, Any]]:
+    # Check for error that are caused by the original LaTeX code itself
+    # and should not be fixed by trying again with a different code
+    # TODO #2346: Make this list more exhaustive
+    str_e: str = str(e).replace("\n", "")
+    # Source of the descriptions:
+    # - https://www.overleaf.com/learn/latex/Errors
+    # - https://tex.stackexchange.com/
+    for error_message in [
+        # This error occurs when LaTeX encounters an undefined control sequence
+        # Example: \blabla
+        r"""Undefined control sequence""",
+        # This error appears when you have forgotten to include an \item command.
+        # It can also appear from trying to use lists inside a table incorrectly.
+        # Example:
+        #     \begin{itemize}
+        #     First item without the \item command
+        #     \end{itemize}
+        r"""LaTeX Error: Lonely \item--perhaps a missing list environment.""",
+        # This error occurs when a { or } is missing.
+        # Example: \sum_{i=1 ^n
+        r"""Missing } inserted""",
+        r"""Missing { inserted""",
+        # This error occurs when LaTeX encounters a double subscript.
+        # Example: a_b_c
+        r"""Double subscript.""",
+        # This error occurs when an environment or $ is added around something that cannot be typeset
+        # in the given mode.
+        # Example:
+        #      $
+        #      \begin{table}
+        #      ...
+        #      \end{table}
+        #      $
+        r"""LaTeX Error: Not in outer par mode.""",
+        # This error occurs when LaTeX is typesetting a table and detects
+        # an alignment character ( & ) where it did not expect to find one
+        r"""Extra alignment tab has been changed to \cr.""",
+        # Missing control sequence othen than $ (which is handled elsewhere).
+        # Example: \left( without
+        "Missing \\",
+        # LaTeX Error: \begin{<env>} on input line <line> ended by \end{<diff_env>}
+        # This error occurs when LaTeX encounters an environment that is not properly closed.
+        # Example:
+        #     \begin{table}
+        #     ...
+        #     \end{document}
+        r"""LaTeX Error: \begin{""",
+        # This error occurs when LaTeX encounters a \noalign command in the wrong place.
+        # Example:
+        #     \begin{tabular}
+        #     \noalign{\hrule}
+        #     ...
+        #     \end{tabular}
+        r"""Misplaced \noalign""",
+        # LaTeX Error: Command <command> already defined.
+        # This errors occurs when two packages define the same command.
+        # We cannot fix this as we would have to try to find the conflicting packages.
+        # Example:
+        #     \usepackage{algorithmic}
+        #     \usepackage{algorithmicx}
+        r""" already defined.""",
+    ]:
+        if error_message in str_e:
+            raise RuntimeError(str(e)) from e
+
+    if num_try_remaining > 0:
+        # Check if the error is easily fixable
+        fixed_code: str = original_latex_code
+
+        # Equation not in math mode
+        # We correct this error as the prompt might not be obvious if the output should be:
+        # <EQUATION_CODE> or $<EQUATION_CODE>$.
+        # We only handle this cas and that is why we add the $ at the beginning and end of the equation.
+        # The missing $ might come from elsewhere but then, it is a problem of the generated code,
+        # and not some unclear instructions, so we do not handle it.
+        # Error format: "Missing $ inserted" or "<command> allowed only in math mode"
+        if "Missing $ inserted" in str(e) or " allowed only in math mode" in str_e:
+            # Only wrap the content after \begin{document} and before \end{document}
+            fixed_code = re.sub(
+                r"(?<=\\begin{document})(.*?)(?=\\end{document})",
+                r"$$\1$$",
+                fixed_code,
+                flags=re.DOTALL,
+            )  # Use \begin{equation} instead of $ to avoid inline mode
+
+        # Missing include
+        # Missing includes are tolerated as the prompt suggests that it is not necessary to include them,
+        # and our TEX_INCLUDES might lack some packages.
+        # Error format: "LaTeX Error: Environment <env> undefined."
+        undefined_search = re.search(r"LaTeX Error: Environment (.*) undefined", str_e)
+        if undefined_search:
+            # If a package is missing and this is our first retry, then simply include TEX_INCLUDES
+            if num_try_remaining == MAX_NUM_TRIES:
+                fixed_code = fixed_code.replace(TEX_BEGIN_FILE, TEX_BEGIN_FILE + "\n" + TEX_INCLUDES + "\n")
+            if num_try_remaining < MAX_NUM_TRIES or fixed_code == original_latex_code:
+                # Here we try to manually solve the missing environment.
+                # This is either executed on the second rety or the first if no changements
+                # were made in the first retry.
+                assert TEX_INCLUDES in fixed_code, "TEX_INCLUDES should be present in the code"
+                # TEX_INCLUDES is already present, so we add the missing package
+                # Since we cannot know the name of the package that contains the missing environment,
+                # we simply hope that they are named the same way.
+                env_undefined: str = undefined_search.group(1)
+
+                if f"\\usepackage{{{env_undefined}}}" in fixed_code:
+                    # We already tried to include the missing package, but it probably
+                    # does not exist, so we raise an error
+                    raise RuntimeError(str(e)) from e
+
+                fixed_code = fixed_code.replace(TEX_BEGIN_FILE, TEX_BEGIN_FILE + f"\n\\usepackage{{{env_undefined}}}\n")
+
+        # Try again with the fixed code (if the fixed code is different from the original code)
+        if fixed_code != original_latex_code:
+            return latex_to_image(
+                fixed_code,
+                assets_path=assets_path,
+                crop=crop,
+                resize_to=resize_to,
+                num_try_remaining=num_try_remaining - 1,
+            )
+
+    # TODO #2346: Ideally we should never reach this point
+    # All errors should be either detected as:
+    # - generation error: should not be fixed and raised
+    # - easily fixable: should be fixed and tried again
+    # If we reach this point, it means that none of the above cases were detected.
+    raise RuntimeError(str(e)) from e
+
+
+def latex_to_image(
+    original_latex_code: str,
+    assets_path: str,
+    crop: bool = False,
+    resize_to: Optional[Tuple[int, int]] = None,
+    num_try_remaining: int = MAX_NUM_TRIES,
+) -> Tuple[Image, Dict[str, Any]]:
+    """Convert a LaTeX code to an image.
+
+    Args:
+        original_latex_code (str): The LaTeX code to convert to an image.
+        assets_path (str): The path to the assets.
+        crop (bool, optional): Whether to crop the image. Defaults to False.
+        resize_to (Optional[Tuple[int, int]], optional): The size to resize the image to. Defaults to None.
+        num_try_remaining (int, optional): The number of tries remaining. Defaults to MAX_NUM_TRIES.
+
+    Returns:
+        image (Image): The image of the LaTeX code.
+        infos (Dict[str, Any]): a dictionnary containing:
+            size (Tuple[int, int]): The size of the image.
+            latex_code (str): The modified LaTeX code that was successfully compiled.
+
+    Raises:
+        OptionalDependencyNotInstalled: If LaTeX is not installed.
+        RuntimeError: If the LaTeX code cannot be converted to an image.
+    """
+    # Basic LaTeX processing
+    # This changes cannot break the original LaTeX code
+    # Other processing will be done in the handle_latex_error function
+    # but these might break the original LaTeX code so they are only applied
+    # if the original LaTeX code does not compile.
+
+    # 0. Remove all environments that might cause numbering
+    # This is important because the numbering of the equations might change
+    # the bounding box of the image.
+    for replace in TEX_REPLACE_NUMBERING:
+        original_latex_code = original_latex_code.replace(replace[0], replace[1])
+    # Also removes all \label commands
+    # If it is followed by a \n, it should be removed as well
+    original_latex_code = re.sub(r"\\label\{.*?\}[\t ]*(\n)?", "", original_latex_code)
+
+    # 1. Add begin/end document if not present
+    if TEX_BEGIN_DOCUMENT not in original_latex_code and TEX_BEGIN_FILE not in original_latex_code:
+        original_latex_code = TEX_BEGIN_DOCUMENT + original_latex_code
+    if TEX_END_DOCUMENT not in original_latex_code:
+        original_latex_code = original_latex_code + TEX_END_DOCUMENT
+
+    # 2. Add preamble
+    # 2.1. Remove \documentclass if present to make sure we use our own
+    documentclass_search = re.search(r"\\documentclass\{(.*)\}", original_latex_code)
+    if documentclass_search:
+        documentclass: str = documentclass_search.group(1)
+        original_latex_code = original_latex_code.replace(f"\\documentclass{{{documentclass}}}", TEX_BEGIN_FILE)
+    else:
+        # If there is no \documentclass, we add our own
+        original_latex_code = TEX_BEGIN_FILE + "\n\n" + original_latex_code
+
+    # 2.2. Add includes. In this first step, we only add includes if none are present.
+    # We do this because if some are present, we might define them twice which can cause errors
+    # and this section should not make the original LaTeX code fail if it was compilable.
+    # If there are missing packages, in handle_latex_error, we will add TEX_INCLUDES after the begin document,
+    # which might define some packages twice, but often solves the problem.
+    if not re.search(r"\\usepackage\{.*\}", original_latex_code):
+        original_latex_code = original_latex_code.replace(TEX_BEGIN_FILE, TEX_BEGIN_FILE + "\n" + TEX_INCLUDES + "\n")
+
+    latex_code: str = original_latex_code
+    try:
+        pdf_stream = latex_to_pdf(latex_code, assets_path=assets_path)
+        image = pdf_to_image(pdf_stream, crop=crop, resize_to=resize_to)
+        return image, {"image_size": image.size, "latex_code": latex_code}
+    except RuntimeError as e:
+        if str(e) == "No available builder could be instantiated. Please make sure LaTeX is installed.":
+            raise OptionalDependencyNotInstalled(
+                "Optional dependency LaTeX is not installed. "
+                "Please install LaTeX and make sure it is available in your PATH."
+                "You can install LaTeX on Ubuntu with `sudo apt-get install texlive-full`."
+            ) from e
+        else:
+            return handle_latex_error(e, original_latex_code, assets_path, crop, resize_to, num_try_remaining)
+    except Exception as e:
+        return handle_latex_error(e, original_latex_code, assets_path, crop, resize_to, num_try_remaining)