Skip to content

openai_utils

convert_dict_to_input 

convert_dict_to_input(content_dict: dict, media_folder: str) -> dict

Convert dictionary to an input that can be used by the OpenAI API. The output is a dictionary with keys “role” and “contents”.

Parameters:

Name Type Description Default
content_dict dict

Content dictionary with keys “role” and “content” where the values are strings.

 required
media_folder str

Folder where media files are stored ({data_folder}/media).

 required

Returns:

Type Description
dict

dict with keys “role” and “contents” where the value of role is either “user” or “model” and the value of contents is a list of inputs to make up an input (which can include text or image/video inputs).
Source code in src/prompto/apis/openai/openai_utils.py 
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
def convert_dict_to_input(content_dict: dict, media_folder: str) -> dict:
    """
    Convert dictionary to an input that can be used by the OpenAI API.
    The output is a dictionary with keys "role" and "contents".

    Parameters
    ----------
    content_dict : dict
        Content dictionary with keys "role" and "content" where
        the values are strings.
    media_folder : str
        Folder where media files are stored ({data_folder}/media).

    Returns
    -------
    dict
        dict with keys "role" and "contents"  where the value of
        role is either "user" or "model" and the value of
        contents is a list of inputs to make up an input (which can include
        text or image/video inputs).
    """
    if "role" not in content_dict:
        raise KeyError("role key is missing in content dictionary")
    if "content" not in content_dict:
        raise KeyError("content key is missing in content dictionary")

    return {
        "role": content_dict["role"],
        "content": parse_content(
            content_dict["content"],
            media_folder=media_folder,
        ),
    }

parse_content 

parse_content(
    contents: list[dict | str] | dict | str, media_folder: str
) -> list[dict]

Parse contents data and create a list of multimedia data objects. If contents is a single dictionary, a list with a single multimedia data object is returned.

Parameters:

Name Type Description Default
contents list[dict | str] | dict | str

Contents data to parse and create Part object(s). Can be a list of dictionaries and strings, or a single dictionary or string.

 required
media_folder str

Folder where media files are stored ({data_folder}/media).

 required

Returns:

Type Description
list[dict]

List of dictionaries each defining a text or image_url object
Source code in src/prompto/apis/openai/openai_utils.py 
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
def parse_content(
    contents: list[dict | str] | dict | str, media_folder: str
) -> list[dict]:
    """
    Parse contents data and create a list of multimedia data objects.
    If contents is a single dictionary, a list with a single multimedia data object is returned.

    Parameters
    ----------
    contents : list[dict | str] | dict | str
        Contents data to parse and create Part object(s).
        Can be a list of dictionaries and strings, or a single dictionary or string.
    media_folder : str
        Folder where media files are stored ({data_folder}/media).

    Returns
    -------
    list[dict]
        List of dictionaries each defining a text or image_url object
    """
    # convert to list[dict | str]
    if isinstance(contents, dict) or isinstance(contents, str):
        contents = [contents]

    return [parse_content_value(p, media_folder=media_folder) for p in contents]

parse_content_value 

parse_content_value(content: dict | str, media_folder: str) -> dict

Parse content dictionary and create a dictionary input for OpenAI API. If content is a string, a dictionary to represent a text object is returned. If content is a dictionary, expected keys are: - type: str, multimedia type, one of [“text”, “image_url”]

If type is “text”, expect a key “text” with the text content. If type is “image_url”, expect a key “image_url” which is a dictionary with keys: - url: str, URL of the image (can be a local path or a URL starting with “https://”) - detail: str, optional detail parameter (default is “auto)

Parameters:

Name Type Description Default
content dict | str

Either a dictionary or a string which defines a multimodal object.

 required
media_folder str

Folder where media files are stored ({data_folder}/media).

 required

Returns:

Type Description
dict

Dictionary which defines a text or image_url object
Source code in src/prompto/apis/openai/openai_utils.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
def parse_content_value(content: dict | str, media_folder: str) -> dict:
    """
    Parse content dictionary and create a dictionary input for OpenAI API.
    If content is a string, a dictionary to represent a text object is returned.
    If content is a dictionary, expected keys are:
    - type: str, multimedia type, one of ["text", "image_url"]

    If type is "text", expect a key "text" with the text content.
    If type is "image_url", expect a key "image_url" which is a dictionary with keys:
    - url: str, URL of the image (can be a local path or a URL starting with "https://")
    - detail: str, optional detail parameter (default is "auto)

    Parameters
    ----------
    content : dict | str
        Either a dictionary or a string which defines a multimodal object.
    media_folder : str
        Folder where media files are stored ({data_folder}/media).

    Returns
    -------
    dict
        Dictionary which defines a text or image_url object
    """
    if isinstance(content, str):
        return {"type": "text", "text": content}

    # read multimedia type
    type = content.get("type")
    if type is None:
        raise ValueError("Multimedia type is not specified")

    # create dictionary based on multimedia type
    if type == "text":
        # read file location
        text = content.get("text")
        if text is None:
            raise ValueError(
                "Got type == 'text', but 'text' is not a key in the content dictionary"
            )

        return {"type": "text", "text": text}
    else:
        if type == "image_url":
            # read file location
            image_url = content.get("image_url")
            if image_url is None:
                raise ValueError(
                    "Got type == 'image_url', but 'image_url' is not a key in the content dictionary"
                )

            if isinstance(image_url, str):
                image_url = {"url": image_url}

            # get url (can be either a local path or a URL starting with "https://")
            url = image_url.get("url")
            if url is None:
                raise ValueError(
                    "Got type == 'image_url', but 'url' is not a key in the content['image_url'] dictionary"
                )

            # get detail parameter (default is "auto")
            detail = image_url.get("detail")
            if detail is None:
                detail = "auto"

            if url.startswith("https://"):
                return {
                    "type": "image_url",
                    "image_url": {"url": url, "detail": detail},
                }

            # url is a local path and needs to be encoded to base64
            url_path = os.path.join(media_folder, url)
            base64_image = encode_image(url_path)
            return {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{base64_image}",
                    "detail": detail,
                },
            }
        else:
            raise ValueError(f"Unsupported multimedia type: {type}")

process_response 

process_response(response: ChatCompletion | Completion) -> str | list[str]

Helper function to process the response from the OpenAI API.

Parameters:

Name Type Description Default
response ChatCompletion | Completion

The response from the OpenAI API

 required

Returns:

Type Description
str | list[str]

The processed response. If there are multiple responses, a list of strings is returned, otherwise a single string is returned
Source code in src/prompto/apis/openai/openai_utils.py 
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
def process_response(response: ChatCompletion | Completion) -> str | list[str]:
    """
    Helper function to process the response from the OpenAI API.

    Parameters
    ----------
    response : ChatCompletion | Completion
        The response from the OpenAI API

    Returns
    -------
    str | list[str]
        The processed response. If there are multiple responses,
        a list of strings is returned, otherwise a single string is returned
    """
    if isinstance(response, ChatCompletion):
        if len(response.choices) == 0:
            return ""
        elif len(response.choices) == 1:
            return response.choices[0].message.content
        else:
            return [choice.message.content for choice in response.choices]
    elif isinstance(response, Completion):
        if len(response.choices) == 0:
            return ""
        elif len(response.choices) == 1:
            return response.choices[0].text
        else:
            return [choice.text for choice in response.choices]
    else:
        raise ValueError(f"Unsupported response type: {type(response)}")