ruby-openai 4.3.2 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9007c29faed86a4792fd80cd1081ddf18be51f71700ca7569dc05088bdf711fa
-  data.tar.gz: 6d190ab521aeada561ddaf72a5922d7d603d799a3e2e841e49ad5d9942c97bba
+  metadata.gz: 6ea6e5d9149ffa94f53c0952491e827a5a082830cb5a4ecbdafe4e4d2523f54e
+  data.tar.gz: 1e8072b9fce1c48612b0120e1df4d6f45e422daec13a41e4b985f60d6cc07f6a
 SHA512:
-  metadata.gz: cf02b7a6170d0497365b6dc1ee93e647f62f5eaf3080f3e27df42c58200c34b395aa8b7d0bfa1cec521bd00f4ede3a49983f40e074b8bb1d6dcba0a40a3373a5
-  data.tar.gz: 63d37b64f16825ff36314a66bb75b3188916fa03d2ee25e78f7dc7605a6734976c3678ac01fd398d4e96b0166d22de47a0f940c018b081c120c30d063dbc4963
+  metadata.gz: 00b71588418d3c33fb2511147e9a500755cf864c1d4cd7c420599b7b7af7d10bd4bb0b1490ce5399efbf38ce2527461ad40c21f20685b6aba40db275d7c9c633
+  data.tar.gz: e2574855121d6ed5126aa809b32feab815b1bd8f668c9eff1d3f6c9e9a25ed83cbb45c19e1900695b814d79b708a9cedfaf911ea5112ba2ff6eadcc76332f980

data/.rubocop.yml

@@ -12,6 +12,11 @@ Layout/LineLength:
   Exclude:
     - "**/*.gemspec"
 
+Lint/AmbiguousOperator:
+  # https://github.com/rubocop/rubocop/issues/4294
+  Exclude:
+    - "lib/openai/client.rb"
+
 Metrics/AbcSize:
   Max: 20
 

data/CHANGELOG.md

@@ -5,7 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [4.3.1] - 2023-08-13
+## [5.1.0] - 2023-08-20
+
+### Added
+
+- Added rough_token_count to estimate tokens in a string according to OpenAI's "rules of thumb". Thank you to [@jamiemccarthy](https://github.com/jamiemccarthy) for the idea and implementation!
+
+## [5.0.0] - 2023-08-14
+
+### Added
+
+- Support multi-tenant use of the gem! Each client now holds its own config, so you can create unlimited clients in the same project, for example to Azure and OpenAI, or for different headers, access keys, etc.
+- [BREAKING-ish] This change should only break your usage of ruby-openai if you are directly calling class methods like `OpenAI::Client.get` for some reason, as they are now instance methods. Normal usage of the gem should be unaffected, just you can make new clients and they'll keep their own config if you want, overriding the global config.
+- Huge thanks to [@petergoldstein](https://github.com/petergoldstein) for his original work on this, [@cthulhu](https://github.com/cthulhu) for testing and many others for reviews and suggestions.
+
+### Changed
+
+- [BREAKING] Move audio related method to Audio model from Client model. You will need to update your code to handle this change, changing `client.translate` to `client.audio.translate` and `client.transcribe` to `client.audio.transcribe`.
+
+## [4.3.2] - 2023-08-14
 
 ### Fixed
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-openai (4.3.2)
+    ruby-openai (5.1.0)
       faraday (>= 1)
       faraday-multipart (>= 1)
 

data/README.md

@@ -24,13 +24,17 @@ gem "ruby-openai"
 
 And then execute:
 
+```bash
 $ bundle install
+```
 
 ### Gem install
 
 Or install with:
 
+```bash
 $ gem install ruby-openai
+```
 
 and require with:
 
@@ -68,6 +72,12 @@ Then you can create a client like this:
 client = OpenAI::Client.new
 ```
 
+You can still override the config defaults when making new clients; any options not included will fall back to any global config set with OpenAI.configure. e.g. in this example the organization_id, request_timeout, etc. will fallback to any set globally using OpenAI.configure, with only the access_token overridden:
+
+```ruby
+client = OpenAI::Client.new(access_token: "access_token_goes_here")
+```
+
 #### Custom timeout or base URI
 
 The default timeout for any request using this library is 120 seconds. You can change that by passing a number of seconds to the `request_timeout` when initializing the client. You can also change the base URI used for all requests, eg. to use observability tools like [Helicone](https://docs.helicone.ai/quickstart/integrate-in-one-line-of-code), and add arbitrary other headers e.g. for [openai-caching-proxy-worker](https://github.com/6/openai-caching-proxy-worker):
@@ -80,7 +90,8 @@ client = OpenAI::Client.new(
     extra_headers: {
       "X-Proxy-TTL" => "43200", # For https://github.com/6/openai-caching-proxy-worker#specifying-a-cache-ttl
       "X-Proxy-Refresh": "true", # For https://github.com/6/openai-caching-proxy-worker#refreshing-the-cache
-      "Helicone-Auth": "Bearer HELICONE_API_KEY" # For https://docs.helicone.ai/getting-started/integration-method/openai-proxy
+      "Helicone-Auth": "Bearer HELICONE_API_KEY", # For https://docs.helicone.ai/getting-started/integration-method/openai-proxy
+      "helicone-stream-force-format" => "true", # Use this with Helicone otherwise streaming drops chunks # https://github.com/alexrudall/ruby-openai/issues/251
     }
 )
 ```
@@ -116,6 +127,18 @@ To use the [Azure OpenAI Service](https://learn.microsoft.com/en-us/azure/cognit
 
 where `AZURE_OPENAI_URI` is e.g. `https://custom-domain.openai.azure.com/openai/deployments/gpt-35-turbo`
 
+### Counting Tokens
+
+OpenAI parses prompt text into [tokens](https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them), which are words or portions of words. (These tokens are unrelated to your API access_token.) Counting tokens can help you estimate your [costs](https://openai.com/pricing). It can also help you ensure your prompt text size is within the max-token limits of your model's context window, and choose an appropriate [`max_tokens`](https://platform.openai.com/docs/api-reference/chat/create#chat/create-max_tokens) completion parameter so your response will fit as well.
+
+To estimate the token-count of your text:
+
+```ruby
+OpenAI.rough_token_count("Your text")
+```
+
+If you need a more accurate count, try [tiktoken_ruby](https://github.com/IAPark/tiktoken_ruby).
+
 ### Models
 
 There are different models that can be used to generate text. For a full list and to retrieve information about a single model:
@@ -174,7 +197,7 @@ client.chat(
 # => "Anna is a young woman in her mid-twenties, with wavy chestnut hair that falls to her shoulders..."
 ```
 
-Note: the API docs state that token usage is included in the streamed chat chunk objects, but this doesn't currently appear to be the case. If you need to work out how many tokens are being used while streaming, try [tiktoken_ruby](https://github.com/IAPark/tiktoken_ruby).
+Note: the API docs state that token usage is included in the streamed chat chunk objects, but this doesn't currently appear to be the case. To count tokens while streaming, try `OpenAI.rough_token_count` or [tiktoken_ruby](https://github.com/IAPark/tiktoken_ruby).
 
 ### Functions
 
@@ -411,7 +434,7 @@ Whisper is a speech to text model that can be used to generate text based on aud
 The translations API takes as input the audio file in any of the supported languages and transcribes the audio into English.
 
 ```ruby
-response = client.translate(
+response = client.audio.translate(
     parameters: {
         model: "whisper-1",
         file: File.open("path_to_file", "rb"),
@@ -425,7 +448,7 @@ puts response["text"]
 The transcriptions API takes as input the audio file you want to transcribe and returns the text in the desired output file format.
 
 ```ruby
-response = client.transcribe(
+response = client.audio.transcribe(
     parameters: {
         model: "whisper-1",
         file: File.open("path_to_file", "rb"),

data/lib/openai/audio.rb

@@ -0,0 +1,15 @@
+module OpenAI
+  class Audio
+    def initialize(client:)
+      @client = client
+    end
+
+    def transcribe(parameters: {})
+      @client.multipart_post(path: "/audio/transcriptions", parameters: parameters)
+    end
+
+    def translate(parameters: {})
+      @client.multipart_post(path: "/audio/translations", parameters: parameters)
+    end
+  end
+end

data/lib/openai/client.rb

@@ -1,58 +1,68 @@
 module OpenAI
   class Client
-    extend OpenAI::HTTP
+    include OpenAI::HTTP
 
-    def initialize(access_token: nil, organization_id: nil, uri_base: nil, request_timeout: nil,
-                   extra_headers: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
-      OpenAI.configuration.uri_base = uri_base if uri_base
-      OpenAI.configuration.request_timeout = request_timeout if request_timeout
-      OpenAI.configuration.extra_headers = extra_headers if extra_headers
+    CONFIG_KEYS = %i[
+      api_type
+      api_version
+      access_token
+      organization_id
+      uri_base
+      request_timeout
+      extra_headers
+    ].freeze
+    attr_reader *CONFIG_KEYS
+
+    def initialize(config = {})
+      CONFIG_KEYS.each do |key|
+        # Set instance variables like api_type & access_token. Fall back to global config
+        # if not present.
+        instance_variable_set("@#{key}", config[key] || OpenAI.configuration.send(key))
+      end
     end
 
     def chat(parameters: {})
-      OpenAI::Client.json_post(path: "/chat/completions", parameters: parameters)
+      json_post(path: "/chat/completions", parameters: parameters)
     end
 
     def completions(parameters: {})
-      OpenAI::Client.json_post(path: "/completions", parameters: parameters)
+      json_post(path: "/completions", parameters: parameters)
     end
 
     def edits(parameters: {})
-      OpenAI::Client.json_post(path: "/edits", parameters: parameters)
+      json_post(path: "/edits", parameters: parameters)
     end
 
     def embeddings(parameters: {})
-      OpenAI::Client.json_post(path: "/embeddings", parameters: parameters)
+      json_post(path: "/embeddings", parameters: parameters)
+    end
+
+    def audio
+      @audio ||= OpenAI::Audio.new(client: self)
     end
 
     def files
-      @files ||= OpenAI::Files.new
+      @files ||= OpenAI::Files.new(client: self)
     end
 
     def finetunes
-      @finetunes ||= OpenAI::Finetunes.new
+      @finetunes ||= OpenAI::Finetunes.new(client: self)
     end
 
     def images
-      @images ||= OpenAI::Images.new
+      @images ||= OpenAI::Images.new(client: self)
     end
 
     def models
-      @models ||= OpenAI::Models.new
+      @models ||= OpenAI::Models.new(client: self)
     end
 
     def moderations(parameters: {})
-      OpenAI::Client.json_post(path: "/moderations", parameters: parameters)
-    end
-
-    def transcribe(parameters: {})
-      OpenAI::Client.multipart_post(path: "/audio/transcriptions", parameters: parameters)
+      json_post(path: "/moderations", parameters: parameters)
     end
 
-    def translate(parameters: {})
-      OpenAI::Client.multipart_post(path: "/audio/translations", parameters: parameters)
+    def azure?
+      @api_type&.to_sym == :azure
     end
   end
 end

data/lib/openai/files.rb

@@ -1,33 +1,32 @@
 module OpenAI
   class Files
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client:)
+      @client = client
     end
 
     def list
-      OpenAI::Client.get(path: "/files")
+      @client.get(path: "/files")
     end
 
     def upload(parameters: {})
       validate(file: parameters[:file])
 
-      OpenAI::Client.multipart_post(
+      @client.multipart_post(
         path: "/files",
         parameters: parameters.merge(file: File.open(parameters[:file]))
       )
     end
 
     def retrieve(id:)
-      OpenAI::Client.get(path: "/files/#{id}")
+      @client.get(path: "/files/#{id}")
     end
 
     def content(id:)
-      OpenAI::Client.get(path: "/files/#{id}/content")
+      @client.get(path: "/files/#{id}/content")
     end
 
     def delete(id:)
-      OpenAI::Client.delete(path: "/files/#{id}")
+      @client.delete(path: "/files/#{id}")
     end
 
     private

data/lib/openai/finetunes.rb

@@ -1,28 +1,27 @@
 module OpenAI
   class Finetunes
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client:)
+      @client = client
     end
 
     def list
-      OpenAI::Client.get(path: "/fine-tunes")
+      @client.get(path: "/fine-tunes")
     end
 
     def create(parameters: {})
-      OpenAI::Client.json_post(path: "/fine-tunes", parameters: parameters)
+      @client.json_post(path: "/fine-tunes", parameters: parameters)
     end
 
     def retrieve(id:)
-      OpenAI::Client.get(path: "/fine-tunes/#{id}")
+      @client.get(path: "/fine-tunes/#{id}")
     end
 
     def cancel(id:)
-      OpenAI::Client.multipart_post(path: "/fine-tunes/#{id}/cancel")
+      @client.multipart_post(path: "/fine-tunes/#{id}/cancel")
     end
 
     def events(id:)
-      OpenAI::Client.get(path: "/fine-tunes/#{id}/events")
+      @client.get(path: "/fine-tunes/#{id}/events")
     end
 
     def delete(fine_tuned_model:)
@@ -30,7 +29,7 @@ module OpenAI
         raise ArgumentError, "Please give a fine_tuned_model name, not a fine-tune ID"
       end
 
-      OpenAI::Client.delete(path: "/models/#{fine_tuned_model}")
+      @client.delete(path: "/models/#{fine_tuned_model}")
     end
   end
 end

data/lib/openai/http.rb

@@ -64,40 +64,40 @@ module OpenAI
 
     def conn(multipart: false)
       Faraday.new do |f|
-        f.options[:timeout] = OpenAI.configuration.request_timeout
+        f.options[:timeout] = @request_timeout
         f.request(:multipart) if multipart
       end
     end
 
     def uri(path:)
-      if OpenAI.configuration.api_type == :azure
-        base = File.join(OpenAI.configuration.uri_base, path)
-        "#{base}?api-version=#{OpenAI.configuration.api_version}"
+      if azure?
+        base = File.join(@uri_base, path)
+        "#{base}?api-version=#{@api_version}"
       else
-        File.join(OpenAI.configuration.uri_base, OpenAI.configuration.api_version, path)
+        File.join(@uri_base, @api_version, path)
       end
     end
 
     def headers
-      if OpenAI.configuration.api_type == :azure
+      if azure?
         azure_headers
       else
         openai_headers
-      end.merge(OpenAI.configuration.extra_headers || {})
+      end.merge(@extra_headers || {})
     end
 
     def openai_headers
       {
         "Content-Type" => "application/json",
-        "Authorization" => "Bearer #{OpenAI.configuration.access_token}",
-        "OpenAI-Organization" => OpenAI.configuration.organization_id
+        "Authorization" => "Bearer #{@access_token}",
+        "OpenAI-Organization" => @organization_id
       }
     end
 
     def azure_headers
       {
         "Content-Type" => "application/json",
-        "api-key" => OpenAI.configuration.access_token
+        "api-key" => @access_token
       }
     end
 

data/lib/openai/images.rb

@@ -1,20 +1,19 @@
 module OpenAI
   class Images
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client: nil)
+      @client = client
     end
 
     def generate(parameters: {})
-      OpenAI::Client.json_post(path: "/images/generations", parameters: parameters)
+      @client.json_post(path: "/images/generations", parameters: parameters)
     end
 
     def edit(parameters: {})
-      OpenAI::Client.multipart_post(path: "/images/edits", parameters: open_files(parameters))
+      @client.multipart_post(path: "/images/edits", parameters: open_files(parameters))
     end
 
     def variations(parameters: {})
-      OpenAI::Client.multipart_post(path: "/images/variations", parameters: open_files(parameters))
+      @client.multipart_post(path: "/images/variations", parameters: open_files(parameters))
     end
 
     private

data/lib/openai/models.rb

@@ -1,16 +1,15 @@
 module OpenAI
   class Models
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client:)
+      @client = client
     end
 
     def list
-      OpenAI::Client.get(path: "/models")
+      @client.get(path: "/models")
     end
 
     def retrieve(id:)
-      OpenAI::Client.get(path: "/models/#{id}")
+      @client.get(path: "/models/#{id}")
     end
   end
 end

data/lib/openai/version.rb

@@ -1,3 +1,3 @@
 module OpenAI
-  VERSION = "4.3.2".freeze
+  VERSION = "5.1.0".freeze
 end

data/lib/openai.rb

@@ -7,6 +7,7 @@ require_relative "openai/files"
 require_relative "openai/finetunes"
 require_relative "openai/images"
 require_relative "openai/models"
+require_relative "openai/audio"
 require_relative "openai/version"
 
 module OpenAI
@@ -51,4 +52,16 @@ module OpenAI
   def self.configure
     yield(configuration)
   end
+
+  # Estimate the number of tokens in a string, using the rules of thumb from OpenAI:
+  # https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them
+  def self.rough_token_count(content = "")
+    raise ArgumentError, "rough_token_count requires a string" unless content.is_a? String
+    return 0 if content.empty?
+
+    count_by_chars = content.size / 4.0
+    count_by_words = content.split.size * 4.0 / 3
+    estimate = ((count_by_chars + count_by_words) / 2.0).round
+    [1, estimate].max
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-openai
 version: !ruby/object:Gem::Version
-  version: 4.3.2
+  version: 5.1.0
 platform: ruby
 authors:
 - Alex
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-14 00:00:00.000000000 Z
+date: 2023-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -63,6 +63,7 @@ files:
 - bin/console
 - bin/setup
 - lib/openai.rb
+- lib/openai/audio.rb
 - lib/openai/client.rb
 - lib/openai/compatibility.rb
 - lib/openai/files.rb