es_cli 0.1.0

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default do
+  Rake::Task["test"].invoke
+  Rake::Task["lint"].invoke
+end
+
+task :test do
+  Rake::Task["spec"].invoke
+end
+
+task :lint do
+  RuboCop::RakeTask.new(:rubocop)
+  Rake::Task["rubocop"].invoke
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/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/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/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/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/assistants.rb

@@ -0,0 +1,29 @@
+module OpenAI
+  class Assistants
+    BETA_VERSION = "v2".freeze
+
+    def initialize(client:)
+      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+    end
+
+    def list
+      @client.get(path: "/assistants")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/assistants/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/assistants", parameters: parameters)
+    end
+
+    def modify(id:, parameters: {})
+      @client.json_post(path: "/assistants/#{id}", parameters: parameters)
+    end
+
+    def delete(id:)
+      @client.delete(path: "/assistants/#{id}")
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/audio.rb

@@ -0,0 +1,19 @@
+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
+
+    def speech(parameters: {})
+      @client.json_post(path: "/audio/speech", parameters: parameters)
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/batches.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Batches
+    def initialize(client:)
+      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+    end
+
+    def list(parameters: {})
+      @client.get(path: "/batches", parameters: parameters)
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/batches/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/batches", parameters: parameters)
+    end
+
+    def cancel(id:)
+      @client.post(path: "/batches/#{id}/cancel")
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/client.rb

@@ -0,0 +1,122 @@
+module OpenAI
+  class Client
+    include OpenAI::HTTP
+
+    SENSITIVE_ATTRIBUTES = %i[@access_token @organization_id @extra_headers].freeze
+    CONFIG_KEYS = %i[
+      api_type
+      api_version
+      access_token
+      log_errors
+      organization_id
+      uri_base
+      request_timeout
+      extra_headers
+    ].freeze
+    attr_reader *CONFIG_KEYS, :faraday_middleware
+
+    def initialize(config = {}, &faraday_middleware)
+      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].nil? ? OpenAI.configuration.send(key) : config[key]
+        )
+      end
+      @faraday_middleware = faraday_middleware
+    end
+
+    def chat(parameters: {})
+      json_post(path: "/chat/completions", parameters: parameters)
+    end
+
+    def embeddings(parameters: {})
+      json_post(path: "/embeddings", parameters: parameters)
+    end
+
+    def completions(parameters: {})
+      json_post(path: "/completions", parameters: parameters)
+    end
+
+    def audio
+      @audio ||= OpenAI::Audio.new(client: self)
+    end
+
+    def files
+      @files ||= OpenAI::Files.new(client: self)
+    end
+
+    def finetunes
+      @finetunes ||= OpenAI::Finetunes.new(client: self)
+    end
+
+    def images
+      @images ||= OpenAI::Images.new(client: self)
+    end
+
+    def models
+      @models ||= OpenAI::Models.new(client: self)
+    end
+
+    def assistants
+      @assistants ||= OpenAI::Assistants.new(client: self)
+    end
+
+    def threads
+      @threads ||= OpenAI::Threads.new(client: self)
+    end
+
+    def messages
+      @messages ||= OpenAI::Messages.new(client: self)
+    end
+
+    def runs
+      @runs ||= OpenAI::Runs.new(client: self)
+    end
+
+    def run_steps
+      @run_steps ||= OpenAI::RunSteps.new(client: self)
+    end
+
+    def vector_stores
+      @vector_stores ||= OpenAI::VectorStores.new(client: self)
+    end
+
+    def vector_store_files
+      @vector_store_files ||= OpenAI::VectorStoreFiles.new(client: self)
+    end
+
+    def vector_store_file_batches
+      @vector_store_file_batches ||= OpenAI::VectorStoreFileBatches.new(client: self)
+    end
+
+    def batches
+      @batches ||= OpenAI::Batches.new(client: self)
+    end
+
+    def moderations(parameters: {})
+      json_post(path: "/moderations", parameters: parameters)
+    end
+
+    def azure?
+      @api_type&.to_sym == :azure
+    end
+
+    def beta(apis)
+      dup.tap do |client|
+        client.add_headers("OpenAI-Beta": apis.map { |k, v| "#{k}=#{v}" }.join(";"))
+      end
+    end
+
+    def inspect
+      vars = instance_variables.map do |var|
+        value = instance_variable_get(var)
+
+        SENSITIVE_ATTRIBUTES.include?(var) ? "#{var}=[REDACTED]" : "#{var}=#{value.inspect}"
+      end
+
+      "#<#{self.class}:#{object_id} #{vars.join(', ')}>"
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/compatibility.rb

@@ -0,0 +1,10 @@
+module Ruby
+  module OpenAI
+    VERSION = ::OpenAI::VERSION
+
+    Error = ::OpenAI::Error
+    ConfigurationError = ::OpenAI::ConfigurationError
+    Configuration = ::OpenAI::Configuration
+    MiddlewareErrors = ::OpenAI::MiddlewareErrors
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/files.rb

@@ -0,0 +1,75 @@
+module OpenAI
+  class Files
+    PURPOSES = %w[
+      assistants
+      batch
+      fine-tune
+      vision
+    ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def list(parameters: {})
+      @client.get(path: "/files", parameters: parameters)
+    end
+
+    def upload(parameters: {})
+      file_input = parameters[:file]
+      file = prepare_file_input(file_input: file_input)
+
+      validate(file: file, purpose: parameters[:purpose], file_input: file_input)
+
+      @client.multipart_post(
+        path: "/files",
+        parameters: parameters.merge(file: file)
+      )
+    ensure
+      file.close if file.is_a?(File)
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/files/#{id}")
+    end
+
+    def content(id:)
+      @client.get(path: "/files/#{id}/content")
+    end
+
+    def delete(id:)
+      @client.delete(path: "/files/#{id}")
+    end
+
+    private
+
+    def prepare_file_input(file_input:)
+      if file_input.is_a?(String)
+        File.open(file_input)
+      elsif file_input.respond_to?(:read) && file_input.respond_to?(:rewind)
+        file_input
+      else
+        raise ArgumentError, "Invalid file - must be a StringIO object or a path to a file."
+      end
+    end
+
+    def validate(file:, purpose:, file_input:)
+      raise ArgumentError, "`file` is required" if file.nil?
+      unless PURPOSES.include?(purpose)
+        raise ArgumentError, "`purpose` must be one of `#{PURPOSES.join(',')}`"
+      end
+
+      validate_jsonl(file: file) if file_input.is_a?(String) && file_input.end_with?(".jsonl")
+    end
+
+    def validate_jsonl(file:)
+      file.each_line.with_index do |line, index|
+        JSON.parse(line)
+      rescue JSON::ParserError => e
+        raise JSON::ParserError, "#{e.message} - found on line #{index + 1} of #{file}"
+      end
+    ensure
+      file.rewind
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/finetunes.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Finetunes
+    def initialize(client:)
+      @client = client
+    end
+
+    def list
+      @client.get(path: "/fine_tuning/jobs")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/fine_tuning/jobs", parameters: parameters)
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/fine_tuning/jobs/#{id}")
+    end
+
+    def cancel(id:)
+      @client.json_post(path: "/fine_tuning/jobs/#{id}/cancel", parameters: {})
+    end
+
+    def list_events(id:)
+      @client.get(path: "/fine_tuning/jobs/#{id}/events")
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/http.rb

@@ -0,0 +1,134 @@
+require "event_stream_parser"
+
+require_relative "http_headers"
+
+module OpenAI
+  module HTTP
+    include HTTPHeaders
+
+    def get(path:, parameters: nil)
+      parse_jsonl(conn.get(uri(path: path), parameters) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def post(path:)
+      parse_jsonl(conn.post(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def json_post(path:, parameters:, query_parameters: {})
+      conn.post(uri(path: path)) do |req|
+        configure_json_post_request(req, parameters)
+        req.params = req.params.merge(query_parameters)
+      end&.body
+    end
+
+    def multipart_post(path:, parameters: nil)
+      conn(multipart: true).post(uri(path: path)) do |req|
+        req.headers = headers.merge({ "Content-Type" => "multipart/form-data" })
+        req.body = multipart_parameters(parameters)
+      end&.body
+    end
+
+    def delete(path:)
+      conn.delete(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body
+    end
+
+    private
+
+    def parse_jsonl(response)
+      return unless response
+      return response unless response.is_a?(String)
+
+      # Convert a multiline string of JSON objects to a JSON array.
+      response = response.gsub("}\n{", "},{").prepend("[").concat("]")
+
+      JSON.parse(response)
+    end
+
+    # Given a proc, returns an outer proc that can be used to iterate over a JSON stream of chunks.
+    # For each chunk, the inner user_proc is called giving it the JSON object. The JSON object could
+    # be a data object or an error object as described in the OpenAI API documentation.
+    #
+    # @param user_proc [Proc] The inner proc to call for each JSON object in the chunk.
+    # @return [Proc] An outer proc that iterates over a raw stream, converting it to JSON.
+    def to_json_stream(user_proc:)
+      parser = EventStreamParser::Parser.new
+
+      proc do |chunk, _bytes, env|
+        if env && env.status != 200
+          raise_error = Faraday::Response::RaiseError.new
+          raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+        end
+
+        parser.feed(chunk) do |_type, data|
+          user_proc.call(JSON.parse(data)) unless data == "[DONE]"
+        end
+      end
+    end
+
+    def conn(multipart: false)
+      connection = Faraday.new do |f|
+        f.options[:timeout] = @request_timeout
+        f.request(:multipart) if multipart
+        f.use MiddlewareErrors if @log_errors
+        f.response :raise_error
+        f.response :json
+      end
+
+      @faraday_middleware&.call(connection)
+
+      connection
+    end
+
+    def uri(path:)
+      if azure?
+        base = File.join(@uri_base, path)
+        "#{base}?api-version=#{@api_version}"
+      elsif @uri_base.include?(@api_version)
+        File.join(@uri_base, path)
+      else
+        File.join(@uri_base, @api_version, path)
+      end
+    end
+
+    def multipart_parameters(parameters)
+      parameters&.transform_values do |value|
+        next value unless value.respond_to?(:close) # File or IO object.
+
+        # Faraday::UploadIO does not require a path, so we will pass it
+        # only if it is available. This allows StringIO objects to be
+        # passed in as well.
+        path = value.respond_to?(:path) ? value.path : nil
+        # Doesn't seem like OpenAI needs mime_type yet, so not worth
+        # the library to figure this out. Hence the empty string
+        # as the second argument.
+        Faraday::UploadIO.new(value, "", path)
+      end
+    end
+
+    def configure_json_post_request(req, parameters)
+      req_parameters = parameters.dup
+
+      if parameters[:stream].respond_to?(:call)
+        req.options.on_data = to_json_stream(user_proc: parameters[:stream])
+        req_parameters[:stream] = true # Necessary to tell OpenAI to stream.
+      elsif parameters[:stream]
+        raise ArgumentError, "The stream parameter must be a Proc or have a #call method"
+      end
+
+      req.headers = headers
+      req.body = req_parameters.to_json
+    end
+
+    def try_parse_json(maybe_json)
+      JSON.parse(maybe_json)
+    rescue JSON::ParserError
+      maybe_json
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/http_headers.rb

@@ -0,0 +1,36 @@
+module OpenAI
+  module HTTPHeaders
+    def add_headers(headers)
+      @extra_headers = extra_headers.merge(headers.transform_keys(&:to_s))
+    end
+
+    private
+
+    def headers
+      if azure?
+        azure_headers
+      else
+        openai_headers
+      end.merge(extra_headers)
+    end
+
+    def openai_headers
+      {
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{@access_token}",
+        "OpenAI-Organization" => @organization_id
+      }.compact
+    end
+
+    def azure_headers
+      {
+        "Content-Type" => "application/json",
+        "api-key" => @access_token
+      }
+    end
+
+    def extra_headers
+      @extra_headers ||= {}
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/images.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Images
+    def initialize(client: nil)
+      @client = client
+    end
+
+    def generate(parameters: {})
+      @client.json_post(path: "/images/generations", parameters: parameters)
+    end
+
+    def edit(parameters: {})
+      @client.multipart_post(path: "/images/edits", parameters: open_files(parameters))
+    end
+
+    def variations(parameters: {})
+      @client.multipart_post(path: "/images/variations", parameters: open_files(parameters))
+    end
+
+    private
+
+    def open_files(parameters)
+      parameters = parameters.merge(image: File.open(parameters[:image]))
+      parameters = parameters.merge(mask: File.open(parameters[:mask])) if parameters[:mask]
+      parameters
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/messages.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Messages
+    def initialize(client:)
+      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+    end
+
+    def list(thread_id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/messages", parameters: parameters)
+    end
+
+    def retrieve(thread_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/messages/#{id}")
+    end
+
+    def create(thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/messages", parameters: parameters)
+    end
+
+    def modify(thread_id:, id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/messages/#{id}", parameters: parameters)
+    end
+
+    def delete(thread_id:, id:)
+      @client.delete(path: "/threads/#{thread_id}/messages/#{id}")
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/models.rb

@@ -0,0 +1,15 @@
+module OpenAI
+  class Models
+    def initialize(client:)
+      @client = client
+    end
+
+    def list
+      @client.get(path: "/models")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/models/#{id}")
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/run_steps.rb

@@ -0,0 +1,15 @@
+module OpenAI
+  class RunSteps
+    def initialize(client:)
+      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+    end
+
+    def list(thread_id:, run_id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps", parameters: parameters)
+    end
+
+    def retrieve(thread_id:, run_id:, id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps/#{id}", parameters: parameters)
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/runs.rb

@@ -0,0 +1,37 @@
+module OpenAI
+  class Runs
+    def initialize(client:)
+      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+    end
+
+    def list(thread_id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/runs", parameters: parameters)
+    end
+
+    def retrieve(thread_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{id}")
+    end
+
+    def create(thread_id:, parameters: {}, query_parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs", parameters: parameters,
+                        query_parameters: query_parameters)
+    end
+
+    def modify(id:, thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs/#{id}", parameters: parameters)
+    end
+
+    def cancel(id:, thread_id:)
+      @client.post(path: "/threads/#{thread_id}/runs/#{id}/cancel")
+    end
+
+    def create_thread_and_run(parameters: {})
+      @client.json_post(path: "/threads/runs", parameters: parameters)
+    end
+
+    def submit_tool_outputs(thread_id:, run_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs/#{run_id}/submit_tool_outputs",
+                        parameters: parameters)
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ruby-openai-7.3.1/lib/openai/threads.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Threads
+    def initialize(client:)
+      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/threads/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/threads", parameters: parameters)
+    end
+
+    def modify(id:, parameters: {})
+      @client.json_post(path: "/threads/#{id}", parameters: parameters)
+    end
+
+    def delete(id:)
+      @client.delete(path: "/threads/#{id}")
+    end
+  end
+end