londonaicentre-mesa-utils 1.0.0__tar.gz

londonaicentre_mesa_utils-1.0.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: londonaicentre-mesa-utils
+Version: 1.0.0
+Summary: MESA utils
+Author-email: "Dr. Joe Zhang" <jzhang@nhs.net>, Sophie Ratkai <s.ratkai@nhs.net>, Martin Chapman <contact@martinchapman.co.uk>
+License-Expression: CC-BY-NC-ND-4.0
+Requires-Python: >=3.12
+Requires-Dist: boto3>=1.41.1
+Requires-Dist: bs4>=0.0.2
+Requires-Dist: litellm>=1.80.0
+Requires-Dist: markdown>=3.10
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: londonaicentre-mesa-types>=1.0.0

londonaicentre_mesa_utils-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "londonaicentre-mesa-utils"
+description = "MESA utils"
+authors = [
+    { name = "Dr. Joe Zhang", email = "jzhang@nhs.net" },
+    { name = "Sophie Ratkai", email = "s.ratkai@nhs.net" },
+    { name = "Martin Chapman", email = "contact@martinchapman.co.uk" },
+]
+version = "1.0.0"
+requires-python = ">=3.12"
+license = "CC-BY-NC-ND-4.0"
+dependencies = [
+    "boto3>=1.41.1",
+    "bs4>=0.0.2",
+    "litellm>=1.80.0",
+    "markdown>=3.10",
+    "pydantic>=2.12.5",
+    "londonaicentre-mesa-types>=1.0.0",
+]
+[build-system]
+requires = ["setuptools>=80.9.0"]
+build-backend = "setuptools.build_meta"
+[tool.uv.sources]
+londonaicentre-mesa-types = { path = "../types", editable = true }
+[tool.setuptools]
+package-data = {"utils" = ["py.typed"]}
+[dependency-groups]
+dev = [
+    "boto3-stubs>=1.41.4",
+    "mypy>=1.18.2",
+    "pytest>=9.0.2",
+    "ruff>=0.14.6",
+    "types-markdown>=3.10.0.20251106",
+]

londonaicentre_mesa_utils-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

londonaicentre_mesa_utils-1.0.0/src/londonaicentre_mesa_utils.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: londonaicentre-mesa-utils
+Version: 1.0.0
+Summary: MESA utils
+Author-email: "Dr. Joe Zhang" <jzhang@nhs.net>, Sophie Ratkai <s.ratkai@nhs.net>, Martin Chapman <contact@martinchapman.co.uk>
+License-Expression: CC-BY-NC-ND-4.0
+Requires-Python: >=3.12
+Requires-Dist: boto3>=1.41.1
+Requires-Dist: bs4>=0.0.2
+Requires-Dist: litellm>=1.80.0
+Requires-Dist: markdown>=3.10
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: londonaicentre-mesa-types>=1.0.0

londonaicentre_mesa_utils-1.0.0/src/londonaicentre_mesa_utils.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+pyproject.toml
+src/londonaicentre_mesa_utils.egg-info/PKG-INFO
+src/londonaicentre_mesa_utils.egg-info/SOURCES.txt
+src/londonaicentre_mesa_utils.egg-info/dependency_links.txt
+src/londonaicentre_mesa_utils.egg-info/requires.txt
+src/londonaicentre_mesa_utils.egg-info/top_level.txt
+src/utils/__init__.py
+src/utils/assets.py
+src/utils/aws.py
+src/utils/llm.py
+src/utils/prompt.py
+src/utils/py.typed
+tests/test_assets.py
+tests/test_aws.py
+tests/test_llm.py

londonaicentre_mesa_utils-1.0.0/src/londonaicentre_mesa_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

londonaicentre_mesa_utils-1.0.0/src/londonaicentre_mesa_utils.egg-info/requires.txt

@@ -0,0 +1,6 @@
+boto3>=1.41.1
+bs4>=0.0.2
+litellm>=1.80.0
+markdown>=3.10
+pydantic>=2.12.5
+londonaicentre-mesa-types>=1.0.0

londonaicentre_mesa_utils-1.0.0/src/londonaicentre_mesa_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+utils

londonaicentre_mesa_utils-1.0.0/src/utils/__init__.py

@@ -0,0 +1,5 @@
+"""MESA utilities."""
+
+from utils.prompt import BasePromptBuilder
+
+__all__ = ["BasePromptBuilder"]

londonaicentre_mesa_utils-1.0.0/src/utils/assets.py

@@ -0,0 +1,13 @@
+from bs4 import BeautifulSoup, Tag
+import markdown
+
+
+class Assets:
+    @staticmethod
+    def markdown_to_text(source: str, remove_title: bool = True) -> str:
+        html: str = markdown.markdown(source, extensions=["fenced_code"])
+        soup: BeautifulSoup = BeautifulSoup(html, "html.parser")
+        h1: Tag | None = soup.find("h1")
+        if remove_title and h1:
+            h1.decompose()
+        return soup.get_text()

londonaicentre_mesa_utils-1.0.0/src/utils/aws.py

@@ -0,0 +1,314 @@
+import os
+from pathlib import Path
+import random
+import time
+from typing import Any
+
+import boto3
+from botocore.exceptions import ClientError
+from litellm import RateLimitError, ModelResponse
+from pydantic import BaseModel
+
+from utils.llm import LLM, Message, TextContent
+
+
+class ModelInput(BaseModel):
+    anthropic_version: str = "bedrock-2023-05-31"
+    system: str | None
+    max_tokens: int
+    messages: list[Message]
+
+
+class AnthropicBedrockBatchEntry(BaseModel):
+    recordId: str
+    modelInput: ModelInput
+
+
+class AWS:
+    @staticmethod
+    def upload_file(
+        region_name: str,
+        file_name: str,
+        bucket: str,
+        object_name: str | None = None,
+        path: str | None = None,
+    ) -> bool:
+        """Upload a file to S3
+
+        Args:
+            region_name (str): The region in which the bucket exists
+            file_name (str): The name of the local file to upload
+            bucket (str): The name of the target bucket
+            object_name (str, optional): the name of the uploaded object.
+                If absent, file_name is used.
+            path (str, optional): the path to the uploaded object. If absent,
+                file_name is used.
+
+        Returns:
+            bool: Whether the upload was successful
+
+        """
+        if object_name is None:
+            object_name = os.path.basename(file_name)
+        try:
+            boto3.client("s3", region_name=region_name).upload_file(
+                file_name, bucket, path + "/" + object_name if path else object_name
+            )
+        except ClientError as e:
+            print(e)
+            return False
+        return True
+
+    @staticmethod
+    def download_file(
+        region_name: str,
+        bucket: str,
+        file_name: str,
+        object_name: str | None = None,
+        path: str | None = None,
+    ) -> bool:
+        """Download a file from S3
+
+        Args:
+            region_name (str): The region in which the bucket exists
+            bucket (str): The name of the target bucket
+            file_name (str): The name to use for the downloaded file
+            object_name (str, optional): the name of the object to download.
+                If absent, file_name is used.
+            path (str, optional): the path to the target object. If absent,
+                file_name is used.
+
+        Returns:
+            bool: Whether the upload was successful
+
+        """
+        if object_name is None:
+            object_name = os.path.basename(file_name)
+        try:
+            boto3.client("s3", region_name=region_name).download_file(
+                bucket, path + "/" + object_name if path else object_name, file_name
+            )
+        except ClientError as e:
+            print(e)
+            return False
+        return True
+
+    @staticmethod
+    def download_file_with_wildcard(
+        region_name: str,
+        bucket: str,
+        file_name: str,
+        object_name: str,
+        path: str,
+    ) -> bool:
+        """Download a file from S3 with a path that contains a wildcard
+
+        Args:
+            region_name (str): The region in which the bucket exists
+            bucket (str): The name of the target bucket
+            file_name (str): The name to use for the downloaded file
+            object_name (str, optional): the name of the object to download.
+            path (str): the path to the target object. Can contain
+                a wildcard.
+
+        Returns:
+            bool: Whether the upload was successful
+
+        """
+        prefix: str
+        suffix: str
+        prefix, suffix = (path + "/" + object_name).split("*/", 1)
+        for page in (
+            boto3.client("s3", region_name=region_name)
+            .get_paginator("list_objects_v2")
+            .paginate(Bucket=bucket, Prefix=prefix)
+        ):
+            for object in page.get("Contents", []):
+                key: str = object["Key"]
+                if key.endswith(suffix):
+                    return AWS.download_file(
+                        region_name,
+                        bucket,
+                        file_name,
+                        object_name,
+                        str(Path(key).parent),
+                    )
+        return False
+
+    @staticmethod
+    def bedrock_completion(
+        model_name: str,
+        system_prompt: str | None,
+        user_prompt: str,
+        bedrock_api_key: str,
+        max_tokens: int = 8192,
+        temperature: float = 0.001,
+    ) -> ModelResponse | None:
+        """Use a Bedrock LLM for inference. Uses backoff and jitter on rate limit.
+
+        Args:
+            model_name (str): The name of the LLM
+            system_prompt (str): The system prompt to use
+            user_prompt (str): The user prompt to use
+            bedrock_api_key (str): API key to access AWS Bedrock
+            max_tokens (int): Maximum output tokens. Defaults to 8192.
+            temperature (float): Model randomness. Defaults to 0.001.
+
+        Returns:
+            ModelResponse: The model's prediction (LiteLLM wrapper object)
+
+        """
+        max_retries: int = 5
+        for attempt in range(max_retries + 1):
+            try:
+                return LLM.completion(
+                    model_name=model_name,
+                    system_prompt=system_prompt,
+                    user_prompt=user_prompt,
+                    api_key=bedrock_api_key,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    aws_region_name="eu-west-2",
+                )
+            except RateLimitError:
+                if attempt == max_retries:
+                    raise
+                # https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+                delay: float = random.uniform(0, min(60, 2**attempt))
+                print(
+                    "hit rate limit, waiting "
+                    + str(round(delay, 2))
+                    + " seconds (retry "
+                    + str(attempt + 1)
+                    + ")"
+                )
+                time.sleep(delay)
+        return None
+
+    @staticmethod
+    def create_anthropic_bedrock_batch_entry(
+        id: str, system_prompt: str | None, user_prompt: str, max_tokens: int = 8192
+    ) -> dict[str, Any]:
+        """Create an entry for a Bedrock batch execution file targeting
+            Anthropic models.
+
+        Args:
+            id (str): Unique id of the entry in the resulting file
+            system_prompt (str, optional): The system prompt to use
+                during batch inference
+            user_prompt (str): The user prompt to use during batch inference
+            max_tokens (int, optional): The maximum number of output tokens
+
+        Returns:
+            dict: The batch entry object as a dictionary
+
+        """
+        return AnthropicBedrockBatchEntry(
+            recordId=id,
+            modelInput=ModelInput(
+                max_tokens=max_tokens,
+                messages=[
+                    Message(
+                        role="user",
+                        content=[TextContent(type="text", text=user_prompt)],
+                    )
+                ],
+                system=system_prompt,
+            ),
+        ).model_dump(exclude_none=True)
+
+    @staticmethod
+    def create_model_invocation_job(
+        job_id: str,
+        model_id: str,
+        batch_file: str,
+        bucket: str,
+        bedrock_execution_role: str,
+        model_region: str,
+    ) -> bool:
+        """Create a model invocation job (batch inference run)
+            on AWS Bedrock
+
+        Args:
+            job_id (str): The id to give to the batch job
+            model_id (str): The Bedrock id of the model to use for
+                inference in the batch job
+            batch_file (str): The name of the local file
+                containing the batch specification
+            bucket (str): The name of the bucket in which the batch
+                specification exists
+            bedrock_execution_role (str): The ARN of an IAM role with
+                permissions to access S3 for batch specification and
+                access cross-region models
+            model_region (str): The region in which to run the job
+
+        Returns:
+            bool: Whether the batch inference run started successfully
+
+        """
+        try:
+            boto3.client(
+                "bedrock", region_name=model_region
+            ).create_model_invocation_job(
+                jobName="schemallama-" + job_id.replace("/", "-"),
+                modelId=model_id,
+                roleArn=bedrock_execution_role,
+                inputDataConfig={
+                    "s3InputDataConfig": {
+                        "s3Uri": "s3://"
+                        + bucket
+                        + "/"
+                        + job_id
+                        + "/input/"
+                        + batch_file
+                    }
+                },
+                outputDataConfig={
+                    "s3OutputDataConfig": {
+                        "s3Uri": "s3://" + bucket + "/" + job_id + "/output/"
+                    }
+                },
+            )
+        except ClientError as e:
+            print(e)
+            return False
+        return True
+
+    @staticmethod
+    def run_batch_inference(
+        job_id: str,
+        model_id: str,
+        batch_file: str,
+        bucket: str,
+        bedrock_execution_role: str,
+        model_region: str,
+    ) -> None:
+        """Generate samples via batch inference
+
+        Args:
+            job_id (str): The id to give to the batch job
+            model_id (str): The Bedrock id of the model to use for
+                inference in the batch job
+            batch_file (str): The name of the local file
+                containing the batch specification
+            bucket (str): The name of the bucket to which the batch
+                specification should be uploaded
+            bedrock_execution_role (str): The ARN of an IAM role with
+                permissions to access S3 for batch specification and
+                access cross-region models
+            model_region (str): The region in which to run the job
+
+        """
+        # Upload to S3 bucket
+        AWS.upload_file(
+            model_region,
+            batch_file,
+            bucket,
+            batch_file,
+            job_id + "/input",
+        )
+
+        # Generate samples in batch mode
+        AWS.create_model_invocation_job(
+            job_id, model_id, batch_file, bucket, bedrock_execution_role, model_region
+        )

londonaicentre_mesa_utils-1.0.0/src/utils/llm.py

@@ -0,0 +1,110 @@
+from re import Match, DOTALL, search
+from typing import Any, Literal
+
+from litellm import Usage, completion, ModelResponse
+from pydantic import BaseModel
+
+
+class TextContent(BaseModel):
+    type: Literal["text"]
+    text: str
+
+
+class Message(BaseModel):
+    role: Literal["user", "assistant"]
+    content: list[TextContent]
+
+
+class ModelInput(BaseModel):
+    anthropic_version: str
+    max_tokens: int
+    messages: list[Message]
+
+
+class ModelOutput(BaseModel):
+    model: str
+    id: str
+    type: str
+    role: str
+    content: list[TextContent]
+    stop_reason: str
+    stop_sequence: str | None = None
+    usage: Usage
+
+
+class BatchOutput(BaseModel):
+    modelInput: ModelInput
+    modelOutput: ModelOutput
+    recordId: str
+
+
+class BatchOutputs(BaseModel):
+    outputs: list[BatchOutput]
+
+
+class LLM:
+    @staticmethod
+    def completion(
+        model_name: str,
+        system_prompt: str | None,
+        user_prompt: str,
+        api_key: str,
+        max_tokens: int = 8192,
+        temperature: float = 0.001,
+        **kwargs: Any,
+    ) -> ModelResponse | None:
+        """Use an LLM for inference.
+
+        Args:
+            model_name (str): The name of the LLM
+            system_prompt (str): The system prompt to use
+            user_prompt (str): The user prompt to use
+            api_key (str): API key to access the remote API
+            max_tokens (int): Maximum output tokens. Defaults to 8192.
+            temperature (float): Model randomness. Defaults to 0.001.
+
+        Returns:
+            ModelResponse: The model's prediction (LiteLLM wrapper object)
+
+        """
+        messages: list[dict[str, str]] = []
+        if system_prompt is not None:
+            messages.append({"content": system_prompt, "role": "system"})
+        messages.append({"content": user_prompt, "role": "user"})
+        return completion(
+            model=model_name,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            messages=messages,
+            api_key=api_key,
+            stream=False,
+            **kwargs,
+        )
+
+    @staticmethod
+    def extract_output_content(response_text: str) -> tuple[bool, str, str]:
+        """Extract the json portion of an LLM schema standardisation response.
+
+        Args:
+            response_text (str): The full response text
+
+        Returns:
+            tuple: Whether the extraction was successful, a status message,
+                and the extracted (or full) content
+
+        """
+        pattern: str = r"<OUTPUT>(.*?)</OUTPUT>"
+        match: Match[str] | None = search(pattern, response_text, DOTALL)
+        if match:
+            content: str = match.group(1).strip()
+            return (
+                True,
+                f"Successfully extracted content from <OUTPUT> tags (length={len(content)} chars)",
+                content,
+            )
+        else:
+            return (
+                False,
+                "No <OUTPUT> tags found in response, using full response text",
+                response_text.strip(),
+            )

londonaicentre_mesa_utils-1.0.0/src/utils/prompt.py

@@ -0,0 +1,86 @@
+"""Base prompt builder for schemas"""
+
+import inspect
+from abc import ABC
+from importlib.resources import files
+from importlib.resources.abc import Traversable
+
+from pydantic import BaseModel
+
+
+class BasePromptBuilder(ABC):
+    """Base class for schema prompt builders
+
+    (adapted from SchemaLlamaAssets wrapper)
+    """
+
+    def __init__(self, base_dir: str, schema: type[BaseModel]) -> None:
+        """Initialize prompt builder.
+
+        Args:
+            base_dir: Package name (e.g. 'oncoschema', 'genoschema')
+            schema: Pydantic model class for this schema
+        """
+        self._base_dir: Traversable = files(base_dir)
+        self._schema: type[BaseModel] = schema
+
+    def _load(self, folder: str, file: str) -> str:
+        """Load a resource file from the package.
+
+        Args:
+            folder: Subdirectory name (e.g. 'examples')
+            file: Filename (e.g. 'example.json')
+
+        Returns:
+            File contents as string
+        """
+        return self._base_dir.joinpath(f"{folder}/{file}").read_text()
+
+    def _load_root(self, file: str) -> str:
+        """Load a file from package root.
+
+        Args:
+            file: Filename (e.g. 'prompt_datagen.txt')
+
+        Returns:
+            File contents as string
+        """
+        return self._base_dir.joinpath(file).read_text()
+
+    def build_datagen_prompt(self) -> str:
+        """Build data generation prompt with schema and example.
+
+        Returns:
+            Complete prompt with {SCHEMA} and {EXAMPLE} replaced
+        """
+        prompt = self._load_root("prompt_datagen.txt")
+
+        # inserts full schema
+        schema_module = inspect.getmodule(self._schema)
+        if(schema_module is not None):
+            schema_source = inspect.getsource(schema_module)
+        else:
+            raise ValueError('module not found')
+
+        example_json = self._load("examples", "example.json")
+
+        prompt = prompt.replace("{SCHEMA}", schema_source)
+        prompt = prompt.replace("{EXAMPLE}", example_json)
+        return prompt
+
+    def build_main_prompt(self) -> str:
+        """Build main/inference prompt with schema only.
+
+        Returns:
+            Complete prompt with {SCHEMA} replaced
+        """
+        prompt = self._load_root("prompt_main.txt")
+
+        schema_module = inspect.getmodule(self._schema)
+        if(schema_module is not None):
+            schema_source = inspect.getsource(schema_module)
+        else:
+            raise ValueError('module not found')
+
+        prompt = prompt.replace("{SCHEMA}", schema_source)
+        return prompt

londonaicentre_mesa_utils-1.0.0/tests/test_assets.py

@@ -0,0 +1,9 @@
+from utils.assets import Assets
+
+
+def test_markdown_to_text() -> None:
+    source: str = '# foo\n**bar**\n```json\n{"baz":\n{"qux":"quux"}}\n```'
+    assert (
+        Assets.markdown_to_text(source, False) == 'foo\nbar\n{"baz":\n{"qux":"quux"}}\n'
+    )
+    Assets.markdown_to_text(source) == 'bar\n{"baz":\n{"qux":"quux"}}\n'

londonaicentre_mesa_utils-1.0.0/tests/test_aws.py

@@ -0,0 +1,90 @@
+from unittest.mock import MagicMock, patch
+
+from litellm import RateLimitError
+import pytest
+
+from utils.aws import AWS
+
+
+@patch("utils.aws.boto3.client")
+def test_upload_file_valid_input_succeeds(mock_client: MagicMock) -> None:
+    mock_s3_client = MagicMock()
+    mock_client.return_value = mock_s3_client
+    AWS.upload_file("foo", "bar", "baz", "qux", "quux")
+    mock_s3_client.upload_file.assert_called_once_with("bar", "baz", "quux/qux")
+
+
+@patch("utils.aws.boto3.client")
+def test_download_file_valid_input_succeeds(mock_client: MagicMock) -> None:
+    mock_s3_client = MagicMock()
+    mock_client.return_value = mock_s3_client
+    AWS.download_file("foo", "bar", "baz", "qux", "quux")
+    mock_s3_client.download_file.assert_called_once_with("bar", "quux/qux", "baz")
+
+
+@patch("utils.aws.boto3.client")
+def test_download_file_with_wildcard_invalid_input_fails(
+    mock_client: MagicMock,
+) -> None:
+    mock_object = {"Key": "foo"}
+    mock_page = {"Contents": [mock_object]}
+    mock_paginator = MagicMock()
+    mock_paginator.paginate.return_value = [mock_page]
+    mock_s3_client = MagicMock()
+    mock_s3_client.get_paginator.return_value = mock_paginator
+    mock_client.return_value = mock_s3_client
+    assert not AWS.download_file_with_wildcard("foo", "bar", "baz", "qux", "quux/*")
+
+
+@patch("utils.llm.completion")
+def test_completion_content_returned(
+    mock_completion: MagicMock, model_response: MagicMock
+) -> None:
+    mock_completion.return_value = model_response
+    AWS.bedrock_completion(
+        "foo", "bar", "baz", "quux"
+    ) == "The quick brown fox jumped over the lazy dog"
+    AWS.bedrock_completion("foo", "bar", "baz", "quux") is not None
+
+
+@patch("utils.llm.completion", side_effect=RateLimitError("", "", ""))
+def test_completion_limit_raises_exception(
+    mock_completion: MagicMock, model_response: MagicMock
+) -> None:
+    mock_completion.return_value = model_response
+    with pytest.raises(RateLimitError):
+        AWS.bedrock_completion("foo", "bar", "baz", "quux")
+
+
+def test_create_anthropic_bedrock_batch_entry_valid_fields_are_present() -> None:
+    assert (
+        AWS.create_anthropic_bedrock_batch_entry("", None, "")["modelInput"][
+            "anthropic_version"
+        ]
+        == "bedrock-2023-05-31"
+    )
+    assert (
+        AWS.create_anthropic_bedrock_batch_entry("foo", None, "")["recordId"] == "foo"
+    )
+    assert (
+        AWS.create_anthropic_bedrock_batch_entry("", None, "bar")["modelInput"][
+            "messages"
+        ][0]["content"][0]["text"]
+        == "bar"
+    )
+    assert (
+        "system"
+        not in AWS.create_anthropic_bedrock_batch_entry("", None, "bar")[
+            "modelInput"
+        ].keys()
+    )
+
+
+@patch("utils.aws.boto3.client")
+def test_create_model_invocation_job_valid_input_succeeds(
+    mock_client: MagicMock,
+) -> None:
+    mock_bedrock_client = MagicMock()
+    mock_client.return_value = mock_bedrock_client
+    AWS.create_model_invocation_job("foo", "bar", "baz", "qux", "quux", "foobar")
+    mock_bedrock_client.create_model_invocation_job.assert_called_once()

londonaicentre_mesa_utils-1.0.0/tests/test_llm.py

@@ -0,0 +1,26 @@
+from unittest.mock import MagicMock, patch
+
+from utils.llm import LLM
+
+
+@patch("utils.llm.completion")
+def test_completion_content_returned(
+    mock_completion: MagicMock, model_response: MagicMock
+) -> None:
+    mock_completion.return_value = model_response
+    LLM.completion(
+        "foo", "bar", "baz", "quux"
+    ) == "The quick brown fox jumped over the lazy dog"
+    LLM.completion("foo", "bar", "baz", "quux") is not None
+
+
+def test_extract_output_content_nested_data_returned() -> None:
+    input: str = "<OUTPUT>foo</OUTPUT>"
+    result: bool
+    content: str
+    result, _, content = LLM.extract_output_content(input)
+    assert result and content == "foo"
+    assert result and content != "bar"
+    result, _, content = LLM.extract_output_content("bar")
+    assert not result and content == "bar"
+    assert not result and content != "foo"