defmodule ExOpenAi.Api do
@moduledoc """
The main module for the ExOpenAi API client.
Provides a wrapper around Httpoison for making requests to the OpenAI API.
"""
# use HTTPoison.Base
use Tesla
alias Tesla.Multipart
alias ExOpenAi.Config
alias ExOpenAi.Parser
alias ExOpenAi.URLGenerator, as: URL
alias ExOpenAi.StreamProcessor
@type data :: map | list
@doc """
Create a new resource in the OpenAI API with a POST request.
## Examples
ExOpenAi.Api.create(ExOpenAi.Completion, [prompt: "tell me a joke", max_tokens: 500])
{:ok, %Completion{ ... }}
ExOpenAi.Api.create(ExOpenAi.Completion, [])
{:error, %{"model" => "model is required"}, 400}
"""
@spec create(atom, data :: list | map, list) :: Parser.success() | Parser.error()
def create(module, data, options \\ []) do
data = format_data(data)
url = module
|> URL.infer_url()
client()
|> post!(url, data, options)
|> Parser.parse(module, options[:simple])
end
# %{messages: [%{role: "use", content: "what is 2 + 2?"}], model: "gpt-4-turbo"}
@doc """
Creates a stream using the provided module, data, and options.
The stream is created using the `Stream.resource/3` function, where the initial function posts the data with `Api.post!/4`, the intermediate function processes the async response with `StreamProcessor.handle_async_response/2`, and the after function closes the async response with `StreamProcessor.close_async_response/1`.
## Parameters
* `module` - The module to be used for handling the data stream.
* `data` - A keyword list containing the data to be sent in the request.
* `options` - An optional keyword list of additional options for the request.
## Returns
* A stream that is created using the `Stream.resource/3` function, allowing processing of the data as it is received.
## Usage
This function is used to create a stream with the specified module, process ID, data, and options. This enables efficient handling of streaming data from the OpenAI API.
## Note that this is the only function that uses HTTPoison, Tesla does not have good support for streaming.
"""
@spec create_stream(atom, data :: list | map, list) :: any()
def create_stream(module, data, options \\ []) do
data =
cond do
is_list(data) ->
data
|> Keyword.put(:stream, true)
is_map(data) ->
data
|> Map.put(:stream, true)
end
|> format_data()
|> Jason.encode!()
url =
module
|> URL.infer_url()
Stream.resource(
fn ->
HTTPoison.post!(url, data, process_request_headers(options),
stream_to: self(),
async: :once,
recv_timeout: Config.timeout()
)
end,
&StreamProcessor.handle_async_response(&1, module),
&StreamProcessor.close_async_response/1
)
end
@doc """
Create with a file upload.
Thing to note:
- The `file` parameter is required
- Additional data that has a list of binaries in it is currently supported. But if the nature of the form shifts so that nested data within a value may not work.
## Examples
ExOpenAi.Api.create_with_file(ExOpenAi.Completion, [prompt: "tell me a joke", max_tokens: 500])
{:ok, %Completion{ ... }}
ExOpenAi.Api.create_with_file(ExOpenAi.Completion, [])
{:error, %{"model" => "model is required"}, 400}
"""
@spec create_with_file(atom, data :: list | map, atom, list) :: Parser.success() | Parser.error()
def create_with_file(module, data, file_key \\ :atom, options \\ [])
def create_with_file(module, data, file_key, options) when is_list(data) do
# path to file
file = Keyword.get(data, file_key)
mp = Multipart.new()
|> Multipart.add_file(file, name: Atom.to_string(file_key))
additional_data =
data
|> Keyword.delete(file_key)
|> Enum.reduce(mp, fn
{k, v}, acc when is_list(v) ->
Enum.reduce(v, acc, fn v, acc -> Multipart.add_field(acc, "#{k}[]", v) end)
{k, v}, acc ->
acc
|> Multipart.add_field(k, v)
end)
url = module
|> URL.infer_url()
client()
|> post!(url, additional_data, options)
|> Parser.parse(module, options[:simple])
end
def create_with_file(module, data, file_key, options) when is_map(data) do
create_with_file(module, Map.to_list(data), file_key, options)
end
@doc """
List all the resource in the OpenAI API.
## Examples
ExOpenAi.Api.list(ExOpenAi.Completion)
{:ok, [%Completion{ ... }]}
"""
@spec list(atom, list) :: Parser.success() | Parser.error()
def list(module, options \\ []) do
url = module
|> URL.infer_url()
client()
|> get!(url, options)
|> Parser.parse_list(module, options[:simple])
end
@doc """
Retrieve a resource from the OpenAI API.
## Examples
ExOpenAi.Api.retrieve(ExOpenAi.Modle, "gpt-4-turbo")
{:ok, %Completion{ ... }}
"""
@spec retrieve(atom, String.t(), list) :: Parser.success() | Parser.error()
def retrieve(module, id, options \\ []) do
url = module
|> URL.infer_url()
client()
|> get!(url <> "/" <> id, options)
|> Parser.parse(module, options[:simple])
end
@doc """
Delete a resource from the OpenAI API.
## Examples
ExOpenAi.Api.delete(ExOpenAi.Modle, "gpt-4-turbo")
{:ok, %Completion{ ... }}
"""
@spec remove(atom, String.t(), list) :: Parser.success() | Parser.error()
def remove(module, id, options \\ []) do
url = module
|> URL.infer_url()
client()
|> delete!(url <> "/" <> id, options)
|> Parser.parse_delete()
end
@doc """
Builds the authorization header for the request.
"""
@spec auth_header(options :: list) :: list
def auth_header(options \\ []) do
auth_header([], {options[:api_key], options[:organization]})
end
@doc """
Builds the actual authorization header for the request.
## Examples
iex> ExOpenAi.Api.auth_header([], {"api123", "org345"})
[{"Authorization", "Bearer api123"}, {"OpenAI-Organization", "org345"}]
iex> ExOpenAi.Api.auth_header([], {"api123", nil})
[{"Authorization", "Bearer api123"}]
"""
@spec auth_header(header :: list, tuple()) :: list
def auth_header(headers, {api_key, organzation}) do
headers
|> put_header("Authorization", "Bearer #{api_key}")
|> put_header("OpenAI-Organization", organzation)
end
defp put_header(headers, _key, value) when is_nil(value), do: headers
defp put_header(headers, key, value), do: headers ++ [{key, value}]
@spec format_data(list | map) :: binary
def format_data(data)
def format_data(data) when is_list(data) do
data
|> Map.new()
end
def format_data(data) when is_map(data), do: data
def ensure_valid_filename(filename) do
URI.encode(filename)
end
###
# TESLA API
###
def process_request_headers(headers \\ []) do
headers
|> Keyword.put(:"Content-Type", "application/json")
|> auth_header({Config.api_key(), Config.organization()})
end
def client() do
[
{Tesla.Middleware.Timeout, timeout: Config.timeout()},
{Tesla.Middleware.Headers, process_request_headers()},
Tesla.Middleware.EncodeJson
]
|> Tesla.client()
end
end
