openai/openai-python
Publicmirrored from https://github.com/openai/openai-pythonAvailable
openai/api_resources/file.py
261lines · modecode
| 1 | import json |
| 2 | import os |
| 3 | from typing import cast |
| 4 | |
| 5 | import openai |
| 6 | from openai import api_requestor, util, error |
| 7 | from openai.api_resources.abstract import DeletableAPIResource, ListableAPIResource |
| 8 | from openai.util import ApiType |
| 9 | |
| 10 | |
| 11 | class File(ListableAPIResource, DeletableAPIResource): |
| 12 | OBJECT_NAME = "files" |
| 13 | |
| 14 | @classmethod |
| 15 | def __prepare_file_create( |
| 16 | cls, |
| 17 | file, |
| 18 | purpose, |
| 19 | model=None, |
| 20 | api_key=None, |
| 21 | api_base=None, |
| 22 | api_type=None, |
| 23 | api_version=None, |
| 24 | organization=None, |
| 25 | user_provided_filename=None, |
| 26 | ): |
| 27 | requestor = api_requestor.APIRequestor( |
| 28 | api_key, |
| 29 | api_base=api_base or openai.api_base, |
| 30 | api_type=api_type, |
| 31 | api_version=api_version, |
| 32 | organization=organization, |
| 33 | ) |
| 34 | typed_api_type, api_version = cls._get_api_type_and_version( |
| 35 | api_type, api_version |
| 36 | ) |
| 37 | |
| 38 | if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD): |
| 39 | base = cls.class_url() |
| 40 | url = "/%s%s?api-version=%s" % (cls.azure_api_prefix, base, api_version) |
| 41 | elif typed_api_type == ApiType.OPEN_AI: |
| 42 | url = cls.class_url() |
| 43 | else: |
| 44 | raise error.InvalidAPIType("Unsupported API type %s" % api_type) |
| 45 | |
| 46 | # Set the filename on 'purpose' and 'model' to None so they are |
| 47 | # interpreted as form data. |
| 48 | files = [("purpose", (None, purpose))] |
| 49 | if model is not None: |
| 50 | files.append(("model", (None, model))) |
| 51 | if user_provided_filename is not None: |
| 52 | files.append( |
| 53 | ("file", (user_provided_filename, file, "application/octet-stream")) |
| 54 | ) |
| 55 | else: |
| 56 | files.append(("file", ("file", file, "application/octet-stream"))) |
| 57 | |
| 58 | return requestor, url, files |
| 59 | |
| 60 | @classmethod |
| 61 | def create( |
| 62 | cls, |
| 63 | file, |
| 64 | purpose, |
| 65 | model=None, |
| 66 | api_key=None, |
| 67 | api_base=None, |
| 68 | api_type=None, |
| 69 | api_version=None, |
| 70 | organization=None, |
| 71 | user_provided_filename=None, |
| 72 | ): |
| 73 | requestor, url, files = cls.__prepare_file_create( |
| 74 | file, |
| 75 | purpose, |
| 76 | model, |
| 77 | api_key, |
| 78 | api_base, |
| 79 | api_type, |
| 80 | api_version, |
| 81 | organization, |
| 82 | user_provided_filename, |
| 83 | ) |
| 84 | response, _, api_key = requestor.request("post", url, files=files) |
| 85 | return util.convert_to_openai_object( |
| 86 | response, api_key, api_version, organization |
| 87 | ) |
| 88 | |
| 89 | @classmethod |
| 90 | async def acreate( |
| 91 | cls, |
| 92 | file, |
| 93 | purpose, |
| 94 | model=None, |
| 95 | api_key=None, |
| 96 | api_base=None, |
| 97 | api_type=None, |
| 98 | api_version=None, |
| 99 | organization=None, |
| 100 | user_provided_filename=None, |
| 101 | ): |
| 102 | requestor, url, files = cls.__prepare_file_create( |
| 103 | file, |
| 104 | purpose, |
| 105 | model, |
| 106 | api_key, |
| 107 | api_base, |
| 108 | api_type, |
| 109 | api_version, |
| 110 | organization, |
| 111 | user_provided_filename, |
| 112 | ) |
| 113 | response, _, api_key = await requestor.arequest("post", url, files=files) |
| 114 | return util.convert_to_openai_object( |
| 115 | response, api_key, api_version, organization |
| 116 | ) |
| 117 | |
| 118 | @classmethod |
| 119 | def __prepare_file_download( |
| 120 | cls, |
| 121 | id, |
| 122 | api_key=None, |
| 123 | api_base=None, |
| 124 | api_type=None, |
| 125 | api_version=None, |
| 126 | organization=None, |
| 127 | ): |
| 128 | requestor = api_requestor.APIRequestor( |
| 129 | api_key, |
| 130 | api_base=api_base or openai.api_base, |
| 131 | api_type=api_type, |
| 132 | api_version=api_version, |
| 133 | organization=organization, |
| 134 | ) |
| 135 | typed_api_type, api_version = cls._get_api_type_and_version( |
| 136 | api_type, api_version |
| 137 | ) |
| 138 | |
| 139 | if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD): |
| 140 | base = cls.class_url() |
| 141 | url = f"/{cls.azure_api_prefix}{base}/{id}/content?api-version={api_version}" |
| 142 | elif typed_api_type == ApiType.OPEN_AI: |
| 143 | url = f"{cls.class_url()}/{id}/content" |
| 144 | else: |
| 145 | raise error.InvalidAPIType("Unsupported API type %s" % api_type) |
| 146 | |
| 147 | return requestor, url |
| 148 | |
| 149 | @classmethod |
| 150 | def download( |
| 151 | cls, |
| 152 | id, |
| 153 | api_key=None, |
| 154 | api_base=None, |
| 155 | api_type=None, |
| 156 | api_version=None, |
| 157 | organization=None, |
| 158 | ): |
| 159 | requestor, url = cls.__prepare_file_download( |
| 160 | id, api_key, api_base, api_type, api_version, organization |
| 161 | ) |
| 162 | |
| 163 | result = requestor.request_raw("get", url) |
| 164 | if not 200 <= result.status_code < 300: |
| 165 | raise requestor.handle_error_response( |
| 166 | result.content, |
| 167 | result.status_code, |
| 168 | json.loads(cast(bytes, result.content)), |
| 169 | result.headers, |
| 170 | stream_error=False, |
| 171 | ) |
| 172 | return result.content |
| 173 | |
| 174 | @classmethod |
| 175 | async def adownload( |
| 176 | cls, |
| 177 | id, |
| 178 | api_key=None, |
| 179 | api_base=None, |
| 180 | api_type=None, |
| 181 | api_version=None, |
| 182 | organization=None, |
| 183 | ): |
| 184 | requestor, url = cls.__prepare_file_download( |
| 185 | id, api_key, api_base, api_type, api_version, organization |
| 186 | ) |
| 187 | |
| 188 | async with api_requestor.aiohttp_session() as session: |
| 189 | result = await requestor.arequest_raw("get", url, session) |
| 190 | if not 200 <= result.status < 300: |
| 191 | raise requestor.handle_error_response( |
| 192 | result.content, |
| 193 | result.status, |
| 194 | json.loads(cast(bytes, result.content)), |
| 195 | result.headers, |
| 196 | stream_error=False, |
| 197 | ) |
| 198 | return result.content |
| 199 | |
| 200 | @classmethod |
| 201 | def __find_matching_files(cls, name, all_files, purpose): |
| 202 | matching_files = [] |
| 203 | basename = os.path.basename(name) |
| 204 | for f in all_files: |
| 205 | if f["purpose"] != purpose: |
| 206 | continue |
| 207 | file_basename = os.path.basename(f["filename"]) |
| 208 | if file_basename != basename: |
| 209 | continue |
| 210 | if "bytes" in f and f["bytes"] != bytes: |
| 211 | continue |
| 212 | if "size" in f and int(f["size"]) != bytes: |
| 213 | continue |
| 214 | matching_files.append(f) |
| 215 | return matching_files |
| 216 | |
| 217 | @classmethod |
| 218 | def find_matching_files( |
| 219 | cls, |
| 220 | name, |
| 221 | bytes, |
| 222 | purpose, |
| 223 | api_key=None, |
| 224 | api_base=None, |
| 225 | api_type=None, |
| 226 | api_version=None, |
| 227 | organization=None, |
| 228 | ): |
| 229 | """Find already uploaded files with the same name, size, and purpose.""" |
| 230 | all_files = cls.list( |
| 231 | api_key=api_key, |
| 232 | api_base=api_base or openai.api_base, |
| 233 | api_type=api_type, |
| 234 | api_version=api_version, |
| 235 | organization=organization, |
| 236 | ).get("data", []) |
| 237 | return cls.__find_matching_files(name, all_files, purpose) |
| 238 | |
| 239 | @classmethod |
| 240 | async def afind_matching_files( |
| 241 | cls, |
| 242 | name, |
| 243 | bytes, |
| 244 | purpose, |
| 245 | api_key=None, |
| 246 | api_base=None, |
| 247 | api_type=None, |
| 248 | api_version=None, |
| 249 | organization=None, |
| 250 | ): |
| 251 | """Find already uploaded files with the same name, size, and purpose.""" |
| 252 | all_files = ( |
| 253 | await cls.alist( |
| 254 | api_key=api_key, |
| 255 | api_base=api_base or openai.api_base, |
| 256 | api_type=api_type, |
| 257 | api_version=api_version, |
| 258 | organization=organization, |
| 259 | ) |
| 260 | ).get("data", []) |
| 261 | return cls.__find_matching_files(name, all_files, purpose) |
| 262 | |