Class: OpenAI::Resources::Files

Inherits:
Object
  • Object
show all
Defined in:
lib/openai/resources/files.rb,
sig/openai/resources/files.rbs

Overview

Files are used to upload documents that can be used with features like Assistants and Fine-tuning.

Instance Method Summary collapse

Constructor Details

#initialize(client:) ⇒ Files

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of Files.

Parameters:



209
210
211
 
# File 'lib/openai/resources/files.rb', line 209

def initialize(client:)
  @client = client
end

Instance Method Details

#content(file_id, request_options: {}) ⇒ StringIO

Returns a response containing the contents of the specified file.

Parameters:

  • file_id (String) —

    The ID of the file to use for this request.

  • request_options (OpenAI::RequestOptions, Hash{Symbol=>Object}, nil)

Returns:

  • (StringIO)

See Also:



158
159
160
161
162
163
164
165
166
167
 
# File 'lib/openai/resources/files.rb', line 158

def content(file_id, params = {})
  @client.request(
    method: :get,
    path: ["files/%1$s/content", file_id],
    headers: {"accept" => "application/binary"},
    model: StringIO,
    security: {bearer_auth: true},
    options: params[:request_options]
  )
end

#create(file:, purpose:, expires_after: nil, request_options: {}) ⇒ OpenAI::Models::FileObject

Some parameter documentations has been truncated, see Models::FileCreateParams for more details.

Upload a file that can be used across various endpoints. Individual files can be up to 512 MB, and each project can store up to 2.5 TB of files in total. There is no organization-wide storage limit. Uploads to this endpoint are rate-limited to 1,000 requests per minute per authenticated user.

  • The Assistants API supports files up to 2 million tokens and of specific file types. See the Assistants Tools guide for details.
  • The Fine-tuning API only supports .jsonl files. The input also has certain required formats for fine-tuning chat or completions models.
  • The Batch API only supports .jsonl files up to 200 MB in size. The input also has a specific required format.
  • For Retrieval or file_search ingestion, upload files here first. If you need to attach multiple uploaded files to the same vector store, use /vector_stores/{vector_store_id}/file_batches instead of attaching them one by one. Vector store attachment has separate limits from file upload, including 2,000 attached files per minute per organization.

Please contact us if you need to increase these storage limits.

String, StringIO, and pathless IO inputs are sent with generic upload metadata. Use OpenAI::FilePart when you need to override the filename or content type.

Parameters:

Returns:

See Also:



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/openai/resources/files.rb', line 58

def create(params)
  parsed, options = OpenAI::FileCreateParams.dump_request(params)
  @client.request(
    method: :post,
    path: "files",
    headers: {"content-type" => "multipart/form-data"},
    body: parsed,
    model: OpenAI::FileObject,
    security: {bearer_auth: true},
    options: options
  )
end

#delete(file_id, request_options: {}) ⇒ OpenAI::Models::FileDeleted

Delete a file and remove it from all vector stores.

Parameters:

  • file_id (String) —

    The ID of the file to use for this request.

  • request_options (OpenAI::RequestOptions, Hash{Symbol=>Object}, nil)

Returns:

See Also:



137
138
139
140
141
142
143
144
145
 
# File 'lib/openai/resources/files.rb', line 137

def delete(file_id, params = {})
  @client.request(
    method: :delete,
    path: ["files/%1$s", file_id],
    model: OpenAI::FileDeleted,
    security: {bearer_auth: true},
    options: params[:request_options]
  )
end

#list(after: nil, limit: nil, order: nil, purpose: nil, request_options: {}) ⇒ OpenAI::Internal::CursorPage<OpenAI::Models::FileObject>

Some parameter documentations has been truncated, see Models::FileListParams for more details.

Returns a list of files.

Parameters:

  • after (String) —

    A cursor for use in pagination. after is an object ID that defines your place

  • limit (Integer) —

    A limit on the number of objects to be returned. Limit can range between 1 and 1

  • order (Symbol, OpenAI::Models::FileListParams::Order) —

    Sort order by the created_at timestamp of the objects. asc for ascending ord

  • purpose (String) —

    Only return files with the given purpose.

  • request_options (OpenAI::RequestOptions, Hash{Symbol=>Object}, nil)

Returns:

See Also:



112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/openai/resources/files.rb', line 112

def list(params = {})
  parsed, options = OpenAI::FileListParams.dump_request(params)
  query = OpenAI::Internal::Util.encode_query_params(parsed)
  @client.request(
    method: :get,
    path: "files",
    query: query,
    page: OpenAI::Internal::CursorPage,
    model: OpenAI::FileObject,
    security: {bearer_auth: true},
    options: options
  )
end

#retrieve(file_id, request_options: {}) ⇒ OpenAI::Models::FileObject

Returns information about a specific file.

Parameters:

  • file_id (String) —

    The ID of the file to use for this request.

  • request_options (OpenAI::RequestOptions, Hash{Symbol=>Object}, nil)

Returns:

See Also:



82
83
84
85
86
87
88
89
90
 
# File 'lib/openai/resources/files.rb', line 82

def retrieve(file_id, params = {})
  @client.request(
    method: :get,
    path: ["files/%1$s", file_id],
    model: OpenAI::FileObject,
    security: {bearer_auth: true},
    options: params[:request_options]
  )
end

#wait_for_processing(file_id, poll_interval: nil, timeout: 1800.0, request_options: {}) ⇒ OpenAI::Models::FileObject

Wait for an uploaded file to finish processing.

The returned file may have an error status; callers should inspect the status before using it. Polling intervals and the overall timeout are in seconds. Finite timeouts include authentication and request replay time and disable transport retries so the deadline remains strict. Set timeout to nil to wait indefinitely and retain configured transport retries.

Parameters:

  • file_id (String) —

    The ID of the file to wait for.

  • poll_interval (Integer, Float, nil) (defaults to: nil) —

    How often to retrieve the file. When omitted, the SDK honors the server's polling hint and otherwise waits 5 seconds.

  • timeout (Integer, Float, nil) (defaults to: OpenAI::Internal::Poller::DEFAULT_TIMEOUT) —

    Maximum total time to poll. Defaults to 30 minutes. Set to nil to wait indefinitely.

  • request_options (OpenAI::RequestOptions, Hash{Symbol=>Object}, nil) (defaults to: {})

Returns:

Raises:



191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/openai/resources/files.rb', line 191

def wait_for_processing(
  file_id,
  poll_interval: nil,
  timeout: OpenAI::Internal::Poller::DEFAULT_TIMEOUT,
  request_options: {}
)
  OpenAI::Helpers::ResourcePolling.wait_for_file(
    self,
    file_id,
    poll_interval: poll_interval,
    timeout: timeout,
    request_options: request_options
  )
end