forecasting-tools 0.1.0__tar.gz

forecasting_tools-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CodexVeritas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

forecasting_tools-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: forecasting-tools
+Version: 0.1.0
+Summary: AI forecasting and research tools to help humans reason about and forecast the future
+License: MIT
+Author: Benjamin Wilson
+Author-email: mokoresearch@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiofiles (>=23.2.1,<24.0.0)
+Requires-Dist: aiohttp (>=3.9.3,<4.0.0)
+Requires-Dist: aiolimiter (>=1.1.0,<2.0.0)
+Requires-Dist: asyncio (>=3.4.3,<4.0.0)
+Requires-Dist: bs4 (>=0.0.1,<0.0.2)
+Requires-Dist: langchain-anthropic (>=0.2.4,<0.3.0)
+Requires-Dist: langchain-community (>=0.3.4,<0.4.0)
+Requires-Dist: langchain-core (>=0.3.15,<0.4.0)
+Requires-Dist: langchain-openai (>=0.2.5,<0.3.0)
+Requires-Dist: nest-asyncio (>=1.5.8,<2.0.0)
+Requires-Dist: numpy (>=1.26.0,<2.0.0)
+Requires-Dist: openai (>=1.51.0,<2.0.0)
+Requires-Dist: pillow (>=10.4.0,<11.0.0)
+Requires-Dist: pipreqs (>=0.4.13,<0.5.0)
+Requires-Dist: pre-commit (>=4.0.1,<5.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: regex (>=2023.8.8,<2024.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: scikit-learn (>=1.5.2,<2.0.0)
+Requires-Dist: streamlit (>=1.36.0,<2.0.0)
+Requires-Dist: tenacity (>=8.5.0,<9.0.0)
+Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
+Requires-Dist: transformers (>=4.44.1,<5.0.0)
+Requires-Dist: typeguard (>=4.3.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+Last Update: Oct 25 2024
+
+# Overview
+This repository contains forecasting and research tools built with Python and Streamlit. The project aims to assist users in making predictions, conducting research, and analyzing data related to hard to answer questions (especially those from Metaculus). Find the demo website here: https://mokoresearch.streamlit.app/
+
+Here are the key components and features of the project:
+- General Forecaster that integrates with the Metaculus AI benchmarking competition
+- Historical Base Rate Researcher
+- Niche List Researcher
+- Fermi Estimator
+- Key Factors Analysis
+
+# Getting Set Up
+
+## Environment Variables
+The environment variables from ```.env.template``` are needed to run. Copy this template as ```.env``` and fill it in. Talk to the project owner to get the correct values for some of the more project specific variables.
+
+## Docker Dev Container
+To get your development environment up and running, you need to have Docker Engine installed and running. Once you do, you can use the VSCode dev container pop-up to automatically set up everything for you
+
+### Install Docker
+For Windows and Mac, you will download Docker Desktop. For Linux, you will download Docker Engine. (NOTE: These instructions might be outdated).
+
+First download and setup Docker Engine using the instructions at the link below for your OS:
+ * Windows: [windows-install](https://docs.docker.com/desktop/install/windows-install/)
+ * Mac: [mac-install](mac-install)
+ * Linux: [install](https://docs.docker.com/engine/install/)
+    * Note: DO NOT install Docker Desktop for Linux, rather, select your Linux distribution on the left sidebar and follow the distribution specific instructions for Docker engine. Docker Desktop runs with a different environment in Linux. (TODO: Check if this restriction still applies)
+    * Remember to follow the post-installation steps for Linux: [linux-postinstall](https://docs.docker.com/engine/install/linux-postinstall/)
+
+
+### Starting the container
+Once Docker is installed, when you open up the project folder in VSCode, you will see a pop up noting that you have a setup for dev containers, and asking if you would like to open the folder in a container. You will want to click "open in container". This will automatically set up everything you need and bring you into the container. If the docker process times out in the middle of installing python packages you can run the postinstall.sh manually. You also may need to have the VSCode Docker extension and/or devcontainer extension downloaded
+
+You may need to reinstall some vscode extensions in the dev environment if you are opening it for the first time, but this should only be for the first time running it.
+
+Some extensions are installed automatically (e.g. linting). You may need to reload the window after all of these extensions are installed.
+
+### Managing Docker
+There are many ways to manager Docker containers, but generally if you download the vscode docker extension, you will be able to stop/start/remove all containers and images.
+
+
+### Alternatives to Docker
+If you choose not to run docker, use a python virtual environment so these packages don't conflict with local packages. To set this up run
+
+```
+python -m venv .venv
+```
+
+If you use a virtual environment, install python packages and their dependencies to the virtual environment via the command
+
+```
+pip install --require-virtualenv -r requirements.txt
+```
+
+## Running the Front End
+You can run any front end folder in the front_end directory by executing `streamlit run front_end/[site_file_name]/Home.py`. This will start a development server for you that you can run.
+
+
+# Testing
+This repository uses pytest and pytest-xdist. xdist spreads out all the tests between multiple threads that are each run on a separate CPU. Currently its setup to create a thread per CPU. Configuration for this is in `pytest.ini`. The tests are gathered afresh from each thread, so any initialization done in imports, globals, or class variables are done for each thread. Additionally, global state is not reset between tests on the same thread. When making tests, assume unknown values for globals and especially class variables (though try to avoid using these at all).
+

forecasting_tools-0.1.0/README.md

@@ -0,0 +1,61 @@
+Last Update: Oct 25 2024
+
+# Overview
+This repository contains forecasting and research tools built with Python and Streamlit. The project aims to assist users in making predictions, conducting research, and analyzing data related to hard to answer questions (especially those from Metaculus). Find the demo website here: https://mokoresearch.streamlit.app/
+
+Here are the key components and features of the project:
+- General Forecaster that integrates with the Metaculus AI benchmarking competition
+- Historical Base Rate Researcher
+- Niche List Researcher
+- Fermi Estimator
+- Key Factors Analysis
+
+# Getting Set Up
+
+## Environment Variables
+The environment variables from ```.env.template``` are needed to run. Copy this template as ```.env``` and fill it in. Talk to the project owner to get the correct values for some of the more project specific variables.
+
+## Docker Dev Container
+To get your development environment up and running, you need to have Docker Engine installed and running. Once you do, you can use the VSCode dev container pop-up to automatically set up everything for you
+
+### Install Docker
+For Windows and Mac, you will download Docker Desktop. For Linux, you will download Docker Engine. (NOTE: These instructions might be outdated).
+
+First download and setup Docker Engine using the instructions at the link below for your OS:
+ * Windows: [windows-install](https://docs.docker.com/desktop/install/windows-install/)
+ * Mac: [mac-install](mac-install)
+ * Linux: [install](https://docs.docker.com/engine/install/)
+    * Note: DO NOT install Docker Desktop for Linux, rather, select your Linux distribution on the left sidebar and follow the distribution specific instructions for Docker engine. Docker Desktop runs with a different environment in Linux. (TODO: Check if this restriction still applies)
+    * Remember to follow the post-installation steps for Linux: [linux-postinstall](https://docs.docker.com/engine/install/linux-postinstall/)
+
+
+### Starting the container
+Once Docker is installed, when you open up the project folder in VSCode, you will see a pop up noting that you have a setup for dev containers, and asking if you would like to open the folder in a container. You will want to click "open in container". This will automatically set up everything you need and bring you into the container. If the docker process times out in the middle of installing python packages you can run the postinstall.sh manually. You also may need to have the VSCode Docker extension and/or devcontainer extension downloaded
+
+You may need to reinstall some vscode extensions in the dev environment if you are opening it for the first time, but this should only be for the first time running it.
+
+Some extensions are installed automatically (e.g. linting). You may need to reload the window after all of these extensions are installed.
+
+### Managing Docker
+There are many ways to manager Docker containers, but generally if you download the vscode docker extension, you will be able to stop/start/remove all containers and images.
+
+
+### Alternatives to Docker
+If you choose not to run docker, use a python virtual environment so these packages don't conflict with local packages. To set this up run
+
+```
+python -m venv .venv
+```
+
+If you use a virtual environment, install python packages and their dependencies to the virtual environment via the command
+
+```
+pip install --require-virtualenv -r requirements.txt
+```
+
+## Running the Front End
+You can run any front end folder in the front_end directory by executing `streamlit run front_end/[site_file_name]/Home.py`. This will start a development server for you that you can run.
+
+
+# Testing
+This repository uses pytest and pytest-xdist. xdist spreads out all the tests between multiple threads that are each run on a separate CPU. Currently its setup to create a thread per CPU. Configuration for this is in `pytest.ini`. The tests are gathered afresh from each thread, so any initialization done in imports, globals, or class variables are done for each thread. Additionally, global state is not reset between tests on the same thread. When making tests, assume unknown values for globals and especially class variables (though try to avoid using these at all).

forecasting_tools-0.1.0/forecasting_tools/__init__.py

@@ -0,0 +1,31 @@
+from forecasting_tools.ai_models.resource_managers.monetary_cost_manager import (
+    MonetaryCostManager as MonetaryCostManager,
+)
+from forecasting_tools.forecasting.forecast_team.forecast_team import (
+    ForecastTeam as ForecastTeam,
+)
+from forecasting_tools.forecasting.llms.smart_searcher import (
+    SmartSearcher as SmartSearcher,
+)
+from forecasting_tools.forecasting.metaculus_api import (
+    MetaculusApi as MetaculusApi,
+)
+from forecasting_tools.forecasting.sub_question_responders.base_rate_responder import (
+    BaseRateResponder as BaseRateResponder,
+)
+from forecasting_tools.forecasting.sub_question_responders.estimator import (
+    Estimator as Estimator,
+)
+from forecasting_tools.forecasting.sub_question_responders.general_search_responder import (
+    GeneralSearchResponder as GeneralSearchResponder,
+)
+from forecasting_tools.forecasting.sub_question_responders.key_factors_searcher import (
+    KeyFactorsSearcher as KeyFactorsSearcher,
+)
+from forecasting_tools.forecasting.sub_question_responders.niche_list_researcher import (
+    NicheListResearcher as NicheListResearcher,
+)
+from forecasting_tools.forecasting.team_manager import (
+    TeamManager as TeamManager,
+)
+from forecasting_tools.front_end.Home import HomePage as HomePage

forecasting_tools-0.1.0/forecasting_tools/ai_models/ai_utils/ai_misc.py

@@ -0,0 +1,130 @@
+import asyncio
+import logging
+from typing import (
+    Any,
+    Callable,
+    TypeGuard,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+)
+
+T = TypeVar("T")
+
+logger = logging.getLogger(__name__)
+
+
+async def try_function_till_tries_run_out(
+    tries: int, function: Callable, *args, **kwargs
+) -> Any:
+    tries_left = tries
+    while tries_left > 0:
+        try:
+            response = await function(*args, **kwargs)
+            return response
+        except Exception as e:
+            tries_left -= 1
+            if tries_left == 0:
+                raise e
+            logger.warning(
+                f"Retrying function {function.__name__} due to error: {e}"
+            )
+            await asyncio.sleep(1)
+
+
+def retry_async_function(tries: int) -> Callable:
+    def decorator(function: Callable) -> Callable:
+        async def wrapper(*args, **kwargs) -> Any:
+            return await try_function_till_tries_run_out(
+                tries, function, *args, **kwargs
+            )
+
+        return wrapper
+
+    return decorator
+
+
+def validate_complex_type(value: T, expected_type: type[T]) -> TypeGuard[T]:
+    # NOTE: Consider using typeguard.check_type instead of this function
+    origin = get_origin(expected_type)
+    args = get_args(expected_type)
+
+    if origin is None:
+        # Base case: expected_type is not a generic alias (like int, str, etc.)
+        return isinstance(value, expected_type)
+
+    if origin is Union:
+        # Special handling for Union types (e.g., Union[int, str])
+        return any(validate_complex_type(value, arg) for arg in args)
+
+    if origin is tuple:
+        # Special handling for tuple types
+        if not isinstance(value, tuple) or len(value) != len(args):
+            return False
+        return all(validate_complex_type(v, t) for v, t in zip(value, args))
+
+    if origin is list:
+        # Special handling for list types
+        if not isinstance(value, list):
+            return False
+        return all(validate_complex_type(v, args[0]) for v in value)
+
+    if origin is dict:
+        # Special handling for dict types
+        if not isinstance(value, dict):
+            return False
+        key_type, value_type = args
+        return all(
+            validate_complex_type(k, key_type)
+            and validate_complex_type(v, value_type)
+            for k, v in value.items()
+        )
+
+    # Fallback for other types
+    return isinstance(value, expected_type)
+
+
+def clean_indents(text: str) -> str:
+    """
+    Cleans indents from the text, optimized for prompts
+    Note, this is not the same as textwrap.dedent (see the test for this function for examples)
+    """
+    lines = text.split("\n")
+    try:
+        indent_level_of_first_line = find_indent_level_of_string(lines[0])
+        indent_level_of_second_line = find_indent_level_of_string(lines[1])
+        greatest_indent_level_of_first_two_lines = max(
+            indent_level_of_first_line, indent_level_of_second_line
+        )
+    except IndexError:
+        greatest_indent_level_of_first_two_lines = find_indent_level_of_string(
+            lines[0]
+        )
+
+    new_lines = []
+    for line in lines:
+        indent_level_of_line = find_indent_level_of_string(line)
+        if indent_level_of_line >= greatest_indent_level_of_first_two_lines:
+            new_line = line[greatest_indent_level_of_first_two_lines:]
+        else:
+            new_line = line.lstrip()
+        new_lines.append(new_line)
+
+    combined_new_lines = "\n".join(new_lines)
+    return combined_new_lines
+
+
+def find_indent_level_of_string(string: str) -> int:
+    return len(string) - len(string.lstrip())
+
+
+def strip_code_block_markdown(string: str) -> str:
+    string = string.strip()
+    if string.startswith("```json") and string.endswith("```"):
+        string = string[7:-3].strip()
+    elif string.startswith("```python") and string.endswith("```"):
+        string = string[9:-3].strip()
+    elif string.startswith("```") and string.endswith("```"):
+        string = string[3:-3].strip()
+    return string

forecasting_tools-0.1.0/forecasting_tools/ai_models/ai_utils/openai_utils.py

@@ -0,0 +1,260 @@
+import logging
+
+logger = logging.getLogger(__name__)
+import base64
+import math
+import re
+from io import BytesIO
+from typing import Literal
+from urllib import request
+
+import tiktoken
+from openai.types.chat import (
+    ChatCompletionContentPartImageParam,
+    ChatCompletionContentPartTextParam,
+    ChatCompletionMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionUserMessageParam,
+)
+from openai.types.chat.chat_completion_content_part_image_param import ImageURL
+from PIL import Image
+from pydantic import BaseModel
+from tiktoken import Encoding
+
+
+class VisionMessageData(BaseModel):
+    prompt: str
+    b64_image: str
+    image_resolution: Literal["auto", "low", "high"]
+
+    def __str__(self) -> str:
+        return f"Prompt: {self.prompt}, Resolution: {self.image_resolution}, Image: {self.b64_image[:10]}..."
+
+
+class OpenAiUtils:
+
+    @staticmethod
+    def text_to_tokens_direct(text_to_tokenize: str, model: str) -> int:
+        encoding = OpenAiUtils.__get_encoding_for_model(model)
+        token_num = len(encoding.encode(text_to_tokenize))
+        return token_num
+
+    @staticmethod
+    def __get_encoding_for_model(model: str) -> Encoding:
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+        except KeyError:
+            logger.warning(
+                "Warning: model not found. Using o200k_base encoding."
+            )
+            encoding = tiktoken.get_encoding("o200k_base")
+        return encoding
+
+    @staticmethod
+    def messages_to_tokens(
+        messages: list[ChatCompletionMessageParam], model: str
+    ) -> int:
+        """
+        This functions takes in a list of messages and returns the number of tokens in the messages for gpt-3.5-turbo
+        Here is an OpenAI guide with the example code: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+        See here for other types of tokenization: https://github.com/shobrook/openlimit/blob/master/openlimit/utilities/token_counters.py
+        See here for gpt-vision code. This is an unpublished push to the examples: https://github.com/openai/openai-cookbook/pull/881/commits/555f5bb8b6d09d83fcc7a892562f97d7d1f085c7
+        """
+        encoding = OpenAiUtils.__get_encoding_for_model(model)
+
+        num_tokens = 0
+        for message in messages:
+            num_tokens += OpenAiUtils.__message_to_tokens(
+                message, model, encoding
+            )
+        num_tokens += (
+            3  # every reply is primed with <|start|>assistant<|message|>
+        )
+        return num_tokens
+
+    @staticmethod
+    def __message_to_tokens(
+        message: ChatCompletionMessageParam, model: str, encoding: Encoding
+    ) -> int:
+        if OpenAiUtils.__determine_if_message_is_an_image_message(message):
+            return OpenAiUtils.__turn_image_message_into_tokens(
+                message, model, encoding
+            )
+        else:
+            return OpenAiUtils.__turn_regular_message_into_tokens(
+                message, encoding
+            )
+
+    @staticmethod
+    def __determine_if_message_is_an_image_message(
+        message: ChatCompletionMessageParam,
+    ) -> bool:
+        try:
+            content = message["content"]  # type: ignore
+            content_types = [part["type"] for part in content]  # type: ignore
+            assert "image_url" in content_types
+            return True
+        except Exception:
+            return False
+
+    @classmethod
+    def __turn_regular_message_into_tokens(
+        cls, message: ChatCompletionMessageParam, encoding: Encoding
+    ) -> int:
+        # NOTE: The hardcoded values might change for future models, but applies to all models past gpt3.5 as of Oct 15 2024
+        tokens_per_message = 3
+        tokens_per_name = 1
+        num_tokens = tokens_per_message
+        for key, value in message.items():
+            content = value
+            assert isinstance(content, str)
+            if isinstance(value, list):
+                # for gpt-4v
+                for item in value:
+                    if isinstance(item, dict) and item.get("type") in ["text"]:
+                        content = item.get("text", "")
+            num_tokens += len(encoding.encode(content))
+            if key == "name":
+                num_tokens += tokens_per_name
+        return num_tokens
+
+    @staticmethod
+    def __turn_image_message_into_tokens(
+        message: ChatCompletionMessageParam, model: str, encoding: Encoding
+    ) -> int:
+        if model not in ["gpt-4-vision-preview", "gpt-4o"]:
+            raise NotImplementedError(
+                f"num_tokens_from_messages() is not implemented for model {model}"
+            )
+
+        num_tokens: int = 0
+        for key, value in message.items():
+            if isinstance(value, list):
+                for item in value:
+                    item: dict
+                    num_tokens += len(encoding.encode(item["type"]))
+                    if item["type"] == "text":
+                        num_tokens += len(encoding.encode(item["text"]))
+                    elif item["type"] == "image_url":
+                        num_tokens += OpenAiUtils.__calculate_tokens_of_image(item["image_url"]["url"], item["image_url"]["detail"])  # type: ignore
+            elif isinstance(value, str):
+                num_tokens += len(encoding.encode(value))
+
+        return num_tokens
+
+    @staticmethod
+    def __get_image_dimensions(image_url_or_b64: str) -> tuple[int, int]:
+        # regex to check if image is a URL or base64 string
+        url_regex = r"https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)"  # NOSONAR
+        base_64_regex = r"data:image\/\w+;base64,"
+        if re.match(url_regex, image_url_or_b64):
+            response = request.urlopen(image_url_or_b64)
+            image = Image.open(response)
+            return image.size
+        elif re.match(base_64_regex, image_url_or_b64):
+            image_url_or_b64 = re.sub(
+                r"data:image\/\w+;base64,", "", image_url_or_b64
+            )
+            image = Image.open(BytesIO(base64.b64decode(image_url_or_b64)))
+            return image.size
+        else:
+            raise ValueError("Image must be a URL or base64 string.")
+
+    @staticmethod
+    def __calculate_tokens_of_image(image_url_or_b64: str, detail: str) -> int:
+        # Constants
+        LOW_DETAIL_COST = 85
+        HIGH_DETAIL_COST_PER_TILE = 170
+        ADDITIONAL_COST = 85
+
+        if detail == "low":
+            # Low detail images have a fixed cost
+            return LOW_DETAIL_COST
+        elif detail == "high":
+            # Calculate token cost for high detail images
+            width, height = OpenAiUtils.__get_image_dimensions(
+                image_url_or_b64
+            )
+            # Check if resizing is needed to fit within a 2048 x 2048 square
+            if max(width, height) > 2048:
+                # Resize the image to fit within a 2048 x 2048 square
+                ratio = 2048 / max(width, height)
+                width = int(width * ratio)
+                height = int(height * ratio)
+
+            # Further scale down to 768px on the shortest side
+            if min(width, height) > 768:
+                ratio = 768 / min(width, height)
+                width = int(width * ratio)
+                height = int(height * ratio)
+
+            # Calculate the number of 512px squares
+            num_squares = math.ceil(width / 512) * math.ceil(height / 512)
+            total_cost = (
+                num_squares * HIGH_DETAIL_COST_PER_TILE + ADDITIONAL_COST
+            )
+            return total_cost
+        else:
+            # Invalid detail_option
+            raise ValueError("Invalid detail_option. Use 'low' or 'high'.")
+
+    @staticmethod
+    def put_single_user_message_in_list_using_prompt(
+        user_prompt: str,
+    ) -> list[ChatCompletionMessageParam]:
+        return [
+            ChatCompletionUserMessageParam(role="user", content=user_prompt)
+        ]
+
+    @staticmethod
+    def put_single_image_message_in_list_using_gpt_vision_input(
+        vision_data: VisionMessageData,
+    ) -> list[ChatCompletionMessageParam]:
+        prompt: str = vision_data.prompt
+        base64_image: str = vision_data.b64_image
+        resolution: str = vision_data.image_resolution
+        return [
+            ChatCompletionUserMessageParam(
+                role="user",
+                content=[
+                    ChatCompletionContentPartTextParam(
+                        type="text", text=prompt
+                    ),
+                    ChatCompletionContentPartImageParam(
+                        type="image_url",
+                        image_url=ImageURL(
+                            url=f"data:image/png;base64,{base64_image}",
+                            detail=resolution,
+                        ),
+                    ),
+                ],
+            )
+        ]
+
+    @staticmethod
+    def create_system_and_user_message_from_prompt(
+        user_prompt: str, system_prompt: str
+    ) -> list[ChatCompletionMessageParam]:
+        return [
+            ChatCompletionSystemMessageParam(
+                role="system", content=system_prompt
+            ),
+            ChatCompletionUserMessageParam(role="user", content=user_prompt),
+        ]
+
+    @classmethod
+    def create_system_and_image_message_from_prompt(
+        cls, vision_message_data: VisionMessageData, system_prompt: str
+    ) -> list[ChatCompletionMessageParam]:
+        image_message_as_list = (
+            cls.put_single_image_message_in_list_using_gpt_vision_input(
+                vision_message_data
+            )
+        )
+        image_message = image_message_as_list[0]
+        return [
+            ChatCompletionSystemMessageParam(
+                role="system", content=system_prompt
+            ),
+            image_message,
+        ]

forecasting_tools-0.1.0/forecasting_tools/ai_models/ai_utils/response_types.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class ModelResponse(BaseModel):
+    data: Any
+
+
+class TextTokenResponse(ModelResponse):
+    data: str
+    prompt_tokens_used: int
+    completion_tokens_used: int
+    total_tokens_used: int
+    model: str
+
+
+class TextTokenCostResponse(TextTokenResponse):
+    cost: float