openai 0.1.0.pre.beta.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ba805ae8e6f4df5c9841fb6090b236260bd18fbe153384e0396b32066ffce31
-  data.tar.gz: 27f85ceb73e0786bb00dea663b7ff0f0448353492a303a7e6c69dfeea88602f9
+  metadata.gz: fc9304025c682d75de3129464936ea78f4dd4557eede83d2d7991c5eff42fc12
+  data.tar.gz: 75a67fb05f17a2c21b6e4921ee4c182148b0946bcbe759943d8ffb1a60198f89
 SHA512:
-  metadata.gz: 7013889e012df8330fb56c9c01096609605e93d48a015cec57d88615c17a9a4efdaf7f10f1889ceb939b415add8d8ae99ec8a81d8ce4a329060e3d6200fb72a1
-  data.tar.gz: 33fd292fb5210647c8e8820f02d208834009b7252263461ae2286ccffc4938a9201bfb6d48fed64e8d96433f6bea2a1206f8dc033dcca3c2953b3378423c5d63
+  metadata.gz: dcfa0890195ceaf0518f43383e3b7e1816a3fcba9872f90f2cd9b1966bf67b386c9020363bc43c3958a40caa085d5a1a23517cb8284e556cd0622a9471554e3b
+  data.tar.gz: 4fac147f449433f8e483646407ea4cba9b3b467b8c0b6e29bc986612f68b20e9adf83964898639f9fdbd3ac0232375d69046c3eb7207ebc9d7052f97c91b4317

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in openai.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 TODO: Nilesh Trivedi
+
+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.

data/README.md

@@ -1,323 +1,48 @@
-# OpenAI Ruby API library
+# Openai
 
-The OpenAI Ruby library provides convenient access to the OpenAI REST API from any Ruby 3.2.0+ application. It ships with comprehensive types & docstrings in Yard, RBS, and RBI – [see below](https://github.com/openai/openai-ruby#Sorbet) for usage with Sorbet. The standard library's `net/http` is used as the HTTP transport, with connection pooling via the `connection_pool` gem.
-
-## Documentation
-
-Documentation for releases of this gem can be found [on RubyDoc](https://gemdocs.org/gems/openai).
-
-The REST API documentation can be found on [platform.openai.com](https://platform.openai.com/docs).
+This is a wrapper for calling OpenAI and GPT-3's HTTP APIs. API docs are available here: https://beta.openai.com/api-docs
 
 ## Installation
 
-ℹ️ The `openai` gem is not yet available on [rubygems.org](https://rubygems.org).
-
-To use this gem, install via Bundler by adding the following to your application's `Gemfile`:
-
-<!-- x-release-please-start-version -->
+Add this line to your application's Gemfile:
 
 ```ruby
-gem "openai", github: "openai/openai-ruby", branch: "main"
+gem 'openai'
 ```
 
-<!-- x-release-please-end -->
-
-## Usage
-
-```ruby
-require "bundler/setup"
-require "openai"
-
-openai = OpenAI::Client.new(
-  api_key: ENV["OPENAI_API_KEY"] # This is the default and can be omitted
-)
+And then execute:
 
-chat_completion = openai.chat.completions.create(
-  messages: [{role: "user", content: "Say this is a test"}],
-  model: :"gpt-4.1"
-)
+    $ bundle
 
-puts(chat_completion)
-```
+Or install it yourself as:
 
-### Streaming
+    $ gem install openai
 
-We provide support for streaming responses using Server-Sent Events (SSE).
-
-**coming soon:** `openai.chat.completions.stream` will soon come with Python SDK-style higher-level streaming responses support.
-
-```ruby
-stream = openai.chat.completions.stream_raw(
-  messages: [{role: "user", content: "Say this is a test"}],
-  model: :"gpt-4.1"
-)
-
-stream.each do |completion|
-  puts(completion)
-end
-```
-
-### Pagination
-
-List methods in the OpenAI API are paginated.
-
-This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:
-
-```ruby
-page = openai.fine_tuning.jobs.list(limit: 20)
-
-# Fetch single item from page.
-job = page.data[0]
-puts(job.id)
-
-# Automatically fetches more pages as needed.
-page.auto_paging_each do |job|
-  puts(job.id)
-end
-```
-
-Alternatively, you can use the `#next_page?` and `#next_page` methods for more granular control working with pages.
-
-```ruby
-if page.next_page?
-  new_page = page.next_page
-  puts(new_page.data[0].id)
-end
-```
-
-### File uploads
-
-Request parameters that correspond to file uploads can be passed as raw contents, a [`Pathname`](https://rubyapi.org/3.2/o/pathname) instance, [`StringIO`](https://rubyapi.org/3.2/o/stringio), or more.
-
-```ruby
-require "pathname"
-
-# Use `Pathname` to send the filename and/or avoid paging a large file into memory:
-file_object = openai.files.create(file: Pathname("input.jsonl"), purpose: "fine-tune")
-
-# Alternatively, pass file contents or a `StringIO` directly:
-file_object = openai.files.create(file: File.read("input.jsonl"), purpose: "fine-tune")
-
-# Or, to control the filename and/or content type:
-file = OpenAI::FilePart.new(File.read("input.jsonl"), filename: "input.jsonl", content_type: "…")
-file_object = openai.files.create(file: file, purpose: "fine-tune")
-
-puts(file_object.id)
-```
-
-Note that you can also pass a raw `IO` descriptor, but this disables retries, as the library can't be sure if the descriptor is a file or pipe (which cannot be rewound).
-
-### Handling errors
-
-When the library is unable to connect to the API, or if the API returns a non-success status code (i.e., 4xx or 5xx response), a subclass of `OpenAI::Errors::APIError` will be thrown:
-
-```ruby
-begin
-  job = openai.fine_tuning.jobs.create(model: :"babbage-002", training_file: "file-abc123")
-rescue OpenAI::Errors::APIConnectionError => e
-  puts("The server could not be reached")
-  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
-rescue OpenAI::Errors::RateLimitError => e
-  puts("A 429 status code was received; we should back off a bit.")
-rescue OpenAI::Errors::APIStatusError => e
-  puts("Another non-200-range status code was received")
-  puts(e.status)
-end
-```
-
-Error codes are as follows:
-
-| Cause            | Error Type                 |
-| ---------------- | -------------------------- |
-| HTTP 400         | `BadRequestError`          |
-| HTTP 401         | `AuthenticationError`      |
-| HTTP 403         | `PermissionDeniedError`    |
-| HTTP 404         | `NotFoundError`            |
-| HTTP 409         | `ConflictError`            |
-| HTTP 422         | `UnprocessableEntityError` |
-| HTTP 429         | `RateLimitError`           |
-| HTTP >= 500      | `InternalServerError`      |
-| Other HTTP error | `APIStatusError`           |
-| Timeout          | `APITimeoutError`          |
-| Network error    | `APIConnectionError`       |
-
-### Retries
-
-Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
-
-Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors, and timeouts will all be retried by default.
-
-You can use the `max_retries` option to configure or disable this:
-
-```ruby
-# Configure the default for all requests:
-openai = OpenAI::Client.new(
-  max_retries: 0 # default is 2
-)
-
-# Or, configure per-request:
-openai.chat.completions.create(
-  messages: [{role: "user", content: "How can I get the name of the current day in JavaScript?"}],
-  model: :"gpt-4.1",
-  request_options: {max_retries: 5}
-)
-```
-
-### Timeouts
-
-By default, requests will time out after 600 seconds. You can use the timeout option to configure or disable this:
-
-```ruby
-# Configure the default for all requests:
-openai = OpenAI::Client.new(
-  timeout: nil # default is 600
-)
-
-# Or, configure per-request:
-openai.chat.completions.create(
-  messages: [{role: "user", content: "How can I list all files in a directory using Python?"}],
-  model: :"gpt-4.1",
-  request_options: {timeout: 5}
-)
-```
-
-On timeout, `OpenAI::Errors::APITimeoutError` is raised.
-
-Note that requests that time out are retried by default.
-
-## Advanced concepts
-
-### BaseModel
-
-All parameter and response objects inherit from `OpenAI::Internal::Type::BaseModel`, which provides several conveniences, including:
-
-1. All fields, including unknown ones, are accessible with `obj[:prop]` syntax, and can be destructured with `obj => {prop: prop}` or pattern-matching syntax.
-
-2. Structural equivalence for equality; if two API calls return the same values, comparing the responses with == will return true.
-
-3. Both instances and the classes themselves can be pretty-printed.
-
-4. Helpers such as `#to_h`, `#deep_to_h`, `#to_json`, and `#to_yaml`.
-
-### Making custom or undocumented requests
-
-#### Undocumented properties
-
-You can send undocumented parameters to any endpoint, and read undocumented response properties, like so:
-
-Note: the `extra_` parameters of the same name overrides the documented parameters.
-
-```ruby
-chat_completion =
-  openai.chat.completions.create(
-    messages: [{role: "user", content: "How can I get the name of the current day in JavaScript?"}],
-    model: :"gpt-4.1",
-    request_options: {
-      extra_query: {my_query_parameter: value},
-      extra_body: {my_body_parameter: value},
-      extra_headers: {"my-header": value}
-    }
-  )
-
-puts(chat_completion[:my_undocumented_property])
-```
-
-#### Undocumented request params
-
-If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a request, as seen in the examples above.
-
-#### Undocumented endpoints
-
-To make requests to undocumented endpoints while retaining the benefit of auth, retries, and so on, you can make requests using `client.request`, like so:
-
-```ruby
-response = client.request(
-  method: :post,
-  path: '/undocumented/endpoint',
-  query: {"dog": "woof"},
-  headers: {"useful-header": "interesting-value"},
-  body: {"hello": "world"}
-)
-```
-
-### Concurrency & connection pooling
-
-The `OpenAI::Client` instances are threadsafe, but are only fork-safe when there are no in-flight HTTP requests.
-
-Each instance of `OpenAI::Client` has its own HTTP connection pool with a default size of 99. As such, we recommend instantiating the client once per application in most settings.
-
-When all available connections from the pool are checked out, requests wait for a new connection to become available, with queue time counting towards the request timeout.
-
-Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
-
-## Sorbet
-
-This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitions and has no dependency on sorbet-runtime.
-
-You can provide typesafe request parameters like so:
+## Usage
 
-```ruby
-openai.chat.completions.create(
-  messages: [OpenAI::Chat::ChatCompletionUserMessageParam.new(role: "user", content: "Say this is a test")],
-  model: :"gpt-4.1"
-)
 ```
-
-Or, equivalently:
-
-```ruby
-# Hashes work, but are not typesafe:
-openai.chat.completions.create(
-  messages: [{role: "user", content: "Say this is a test"}],
-  model: :"gpt-4.1"
-)
-
-# You can also splat a full Params class:
-params = OpenAI::Chat::CompletionCreateParams.new(
-  messages: [OpenAI::Chat::ChatCompletionUserMessageParam.new(role: "user", content: "Say this is a test")],
-  model: :"gpt-4.1"
-)
-openai.chat.completions.create(**params)
+require 'openai'
+client = Openai::Client.new(pk: "your_public_key", sk: "your_secret_key")
+completions = client.completions(prompt: "Have you wondered why", max_tokens: 10)
 ```
 
-### Enums
-
-Since this library does not depend on `sorbet-runtime`, it cannot provide [`T::Enum`](https://sorbet.org/docs/tenum) instances. Instead, we provide "tagged symbols" instead, which is always a primitive at runtime:
+This should return a Hash which is something like:
 
-```ruby
-# :low
-puts(OpenAI::ReasoningEffort::LOW)
-
-# Revealed type: `T.all(OpenAI::ReasoningEffort, Symbol)`
-T.reveal_type(OpenAI::ReasoningEffort::LOW)
 ```
+=> {"id"=>"cmpl-LMDA7GAlzSHvB6ZEUeFwvipv", "object"=>"text_completion", "created"=>1595276408, "model"=>"davinci:2020-05-03", "choices"=>[{"text"=>" airlines charge more for certain seats?\n\nOne", "index"=>0, "logprobs"=>nil, "finish_reason"=>"length"}]}
 
-Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
-
-```ruby
-# Using the enum constants preserves the tagged type information:
-openai.chat.completions.create(
-  reasoning_effort: OpenAI::ReasoningEffort::LOW,
-  # …
-)
-
-# Literal values are also permissible:
-openai.chat.completions.create(
-  reasoning_effort: :low,
-  # …
-)
 ```
 
-## Versioning
+## Development
 
-This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the library is in initial development and has a major version of `0`, APIs may change at any time.
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` type definitions to be non-breaking changes.
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Requirements
+## Contributing
 
-Ruby 3.2.0 or higher.
+Bug reports and pull requests are welcome on GitHub at https://github.com/nileshtrivedi/openai.
 
-## Contributing
+## License
 
-See [the contributing documentation](https://github.com/openai/openai-ruby/tree/main/CONTRIBUTING.md).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "openai"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/openai/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
-module OpenAI
-  VERSION = "0.1.0.pre.beta.2"
+module Openai
+  VERSION = "0.1.0"
 end