openai.rb 0.0.0 → 0.0.3

data/lib/openai/api/response.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class API
+    class Response
+      include Concord.new(:internal_data)
+      include AbstractType
+
+      class MissingFieldError < StandardError
+        include Anima.new(:path, :missing_key, :actual_payload)
+
+        def message
+          <<~ERROR
+            Missing field #{missing_key.inspect} in response payload!
+            Was attempting to access value at path `#{path}`.
+            Payload: #{JSON.pretty_generate(actual_payload)}
+          ERROR
+        end
+      end
+
+      class << self
+        private
+
+        attr_accessor :field_registry
+      end
+
+      def self.register_field(field_name)
+        self.field_registry ||= []
+        field_registry << field_name
+      end
+
+      def self.from_json(raw_json)
+        new(JSON.parse(raw_json, symbolize_names: true))
+      end
+
+      def initialize(internal_data)
+        super(IceNine.deep_freeze(internal_data))
+      end
+
+      def self.field(name, path: [name], wrapper: nil)
+        register_field(name)
+
+        define_method(name) do
+          field(path, wrapper: wrapper)
+        end
+      end
+
+      def self.optional_field(name, path: name, wrapper: nil)
+        register_field(name)
+
+        define_method(name) do
+          optional_field(path, wrapper: wrapper)
+        end
+      end
+
+      def original_payload
+        internal_data
+      end
+
+      def inspect
+        attr_list = field_list.map do |field_name|
+          "#{field_name}=#{__send__(field_name).inspect}"
+        end.join(' ')
+        "#<#{self.class} #{attr_list}>"
+      end
+
+      private
+
+      # We need to access the registry list from the instance for `#inspect`.
+      # It is just private in terms of the public API which is why we do this
+      # weird private dispatch on our own class.
+      def field_list
+        self.class.__send__(:field_registry)
+      end
+
+      def optional_field(key_path, wrapper: nil)
+        *head, tail = key_path
+
+        parent = field(head)
+        return unless parent.key?(tail)
+
+        wrap_value(parent.fetch(tail), wrapper)
+      end
+
+      def field(key_path, wrapper: nil)
+        value = key_path.reduce(internal_data) do |object, key|
+          object.fetch(key) do
+            raise MissingFieldError.new(
+              path: key_path,
+              missing_key: key,
+              actual_payload: internal_data
+            )
+          end
+        end
+
+        wrap_value(value, wrapper)
+      end
+
+      def wrap_value(value, wrapper)
+        return value unless wrapper
+
+        if value.instance_of?(Array)
+          value.map { |item| wrapper.new(item) }
+        else
+          wrapper.new(value)
+        end
+      end
+
+      class Usage < Response
+        field :prompt_tokens
+        field :completion_tokens
+        field :total_tokens
+      end
+
+      class Completion < Response
+        class Choice < Response
+          field :text
+          field :index
+          field :logprobs
+          field :finish_reason
+        end
+
+        field :id
+        field :object
+        field :created
+        field :model
+        field :choices, wrapper: Choice
+        optional_field :usage, wrapper: Usage
+
+        def choice
+          Util.one(choices)
+        end
+
+        # This is a convenience method for getting the response text when there is exactly
+        # one choice.
+        #
+        # @see #response
+        def response_text
+          choice.text
+        end
+      end
+
+      class ChatCompletion < Response
+        class Choice < Response
+          class Message < Response
+            field :role
+            field :content
+          end
+
+          field :index
+          field :message, wrapper: Message
+          field :finish_reason
+        end
+
+        field :id
+        field :object
+        field :created
+        field :choices, wrapper: Choice
+        field :usage, wrapper: Usage
+
+        # This is a convenience method for the common use case where you have exactly
+        # one choice and you want to get the message out.
+        #
+        # @see #response_text
+        def response
+          Util.one(choices).message
+        end
+
+        # This is a convenience method for getting the response text when there is exactly
+        # one choice.
+        #
+        # @see #response
+        def response_text
+          response.content
+        end
+      end
+
+      class ChatCompletionChunk < Response
+        class Delta < Response
+          optional_field :role
+          optional_field :_content, path: %i[content]
+
+          def content
+            _content.to_s
+          end
+        end
+
+        class Choice < Response
+          field :delta, wrapper: Delta
+        end
+
+        field :id
+        field :object
+        field :created
+        field :model
+        field :choices, wrapper: Choice
+
+        # This is a convenience method for the common use case where you have exactly
+        # one choice and you want to get the message out.
+        #
+        # @see #response_text
+        def response
+          Util.one(choices).delta
+        end
+
+        # This is a convenience method for getting the response text when there is exactly
+        # one choice.
+        #
+        # @see #response
+        def response_text
+          response.content
+        end
+      end
+
+      class Embedding < Response
+        class EmbeddingData < Response
+          field :object
+          field :embedding
+          field :index
+        end
+
+        class Usage < Response
+          field :prompt_tokens
+          field :total_tokens
+        end
+
+        field :object
+        field :data, wrapper: EmbeddingData
+        field :model
+        field :usage, wrapper: Usage
+      end
+
+      class Model < Response
+        field :id
+        field :object
+        field :owned_by
+        field :permission
+      end
+
+      class Moderation < Response
+        class Category < Response
+          field :hate
+          field :hate_threatening, path: %i[hate/threatening]
+          field :self_harm, path: %i[self-harm]
+          field :sexual
+          field :sexual_minors, path: %i[sexual/minors]
+          field :violence
+          field :violence_graphic, path: %i[violence/graphic]
+        end
+
+        class CategoryScore < Response
+          field :hate
+          field :hate_threatening, path: %i[hate/threatening]
+          field :self_harm, path: %i[self-harm]
+          field :sexual
+          field :sexual_minors, path: %i[sexual/minors]
+          field :violence
+          field :violence_graphic, path: %i[violence/graphic]
+        end
+
+        class Result < Response
+          field :categories, wrapper: Category
+          field :category_scores, wrapper: CategoryScore
+          field :flagged
+        end
+
+        field :id
+        field :model
+        field :results, wrapper: Result
+      end
+
+      class ListModel < Response
+        field :data, wrapper: Model
+      end
+
+      class Edit < Response
+        class Choice < Response
+          field :text
+          field :index
+        end
+
+        field :object
+        field :created
+        field :choices, wrapper: Choice
+        field :usage, wrapper: Usage
+      end
+
+      class ImageGeneration < Response
+        class Image < Response
+          field :url
+        end
+
+        field :created
+        field :data, wrapper: Image
+      end
+
+      class ImageEdit < Response
+        class ImageEditData < Response
+          field :url
+        end
+
+        field :created
+        field :data, wrapper: ImageEditData
+      end
+
+      class ImageVariation < Response
+        class ImageVariationData < Response
+          field :url
+        end
+
+        field :created
+        field :data, wrapper: ImageVariationData
+      end
+
+      class File < Response
+        field :id
+        field :object
+        field :bytes
+        field :created_at
+        field :filename
+        field :purpose
+        optional_field :deleted?, path: :deleted
+      end
+
+      class FileList < Response
+        field :data, wrapper: File
+        field :object
+      end
+
+      class FineTune < Response
+        class Event < Response
+          field :object
+          field :created_at
+          field :level
+          field :message
+        end
+
+        class Hyperparams < Response
+          field :batch_size
+          field :learning_rate_multiplier
+          field :n_epochs
+          field :prompt_loss_weight
+        end
+
+        class File < Response
+          field :id
+          field :object
+          field :bytes
+          field :created_at
+          field :filename
+          field :purpose
+        end
+
+        field :id
+        field :object
+        field :model
+        field :created_at
+        field :events, wrapper: Event
+        field :fine_tuned_model
+        field :hyperparams, wrapper: Hyperparams
+        field :organization_id
+        field :result_files, wrapper: File
+        field :status
+        field :validation_files, wrapper: File
+        field :training_files, wrapper: File
+        field :updated_at
+      end
+
+      class FineTuneList < Response
+        field :object
+        field :data, wrapper: FineTune
+      end
+
+      class FineTuneEventList < Response
+        field :data, wrapper: FineTune::Event
+        field :object
+      end
+
+      class Transcription < Response
+        field :text
+      end
+    end
+  end
+end

data/lib/openai/api.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class API
+    include Concord.new(:client)
+
+    class Error < StandardError
+      include Concord::Public.new(:http_response)
+
+      def self.parse(http_response)
+        data = JSON.parse(http_response.body.to_s, symbolize_names: true)
+        if data.dig(:error, :code) == 'context_length_exceeded'
+          Error::ContextLengthExceeded.new(http_response)
+        else
+          new(http_response)
+        end
+      rescue JSON::ParserError
+        new(http_response)
+      end
+
+      def message
+        <<~ERROR
+          Unexpected response status! Expected 2xx but got: #{http_response.status}
+
+          Body:
+
+          #{http_response.body}
+        ERROR
+      end
+
+      class ContextLengthExceeded < self
+      end
+    end
+
+    def completions
+      API::Completion.new(client)
+    end
+
+    def chat_completions
+      API::ChatCompletion.new(client)
+    end
+
+    def embeddings
+      API::Embedding.new(client)
+    end
+
+    def models
+      API::Model.new(client)
+    end
+
+    def edits
+      API::Edit.new(client)
+    end
+
+    def files
+      API::File.new(client)
+    end
+
+    def fine_tunes
+      API::FineTune.new(client)
+    end
+
+    def images
+      API::Image.new(client)
+    end
+
+    def audio
+      API::Audio.new(client)
+    end
+
+    def moderations
+      API::Moderation.new(client)
+    end
+  end
+end

data/lib/openai/chat.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class Chat
+    include Anima.new(:messages, :api_settings, :openai, :config)
+    using Util::Colorize
+
+    def initialize(messages:, settings: {}, config: Config.create, **kwargs)
+      messages = messages.map do |msg|
+        if msg.is_a?(Hash)
+          Message.new(msg)
+        else
+          msg
+        end
+      end
+
+      super(
+        messages: messages,
+        api_settings: settings,
+        config: config,
+        **kwargs
+      )
+    end
+
+    def configure(**configuration)
+      with(config: config.with(configuration))
+    end
+
+    def add_user_message(message)
+      add_message('user', message)
+    end
+    alias user add_user_message
+
+    def add_system_message(message)
+      add_message('system', message)
+    end
+    alias system add_system_message
+
+    def add_assistant_message(message)
+      add_message('assistant', message)
+    end
+    alias assistant add_assistant_message
+
+    def submit
+      openai.logger.info("[Chat] [tokens=#{total_tokens}] Submitting messages:\n\n#{to_log_format}")
+
+      begin
+        response = openai.api.chat_completions.create(
+          **api_settings,
+          messages: raw_messages
+        )
+      rescue OpenAI::API::Error::ContextLengthExceeded
+        raise 'Context length exceeded.'
+        openai.logger.warn('[Chat] Context length exceeded. Shifting chat')
+        return shift_history.submit
+      end
+
+      msg = response.choices.first.message
+
+      add_message(msg.role, msg.content).tap do |new_chat|
+        openai.logger.info("[Chat] Response:\n\n#{new_chat.last_message.to_log_format(config)}")
+      end
+    end
+
+    def last_message
+      messages.last
+    end
+
+    def to_log_format
+      messages.map do |msg|
+        msg.to_log_format(config)
+      end.join("\n\n")
+    end
+
+    private
+
+    def shift_history
+      drop_index = messages.index { |msg| msg.role != 'system' }
+      new_messages = messages.slice(0...drop_index) + messages.slice((drop_index + 1)..)
+
+      with(messages: new_messages)
+    end
+
+    def total_tokens
+      openai.tokens.for_model(api_settings.fetch(:model)).num_tokens(messages.map(&:content).join(' '))
+    end
+
+    def raw_messages
+      messages.map(&:to_h)
+    end
+
+    def add_message(role, content)
+      with_message(role: role, content: content)
+    end
+
+    def with_message(message)
+      with(messages: messages + [message])
+    end
+
+    class Config
+      include Anima.new(:assistant_name)
+
+      def self.create
+        new(assistant_name: 'assistant')
+      end
+    end
+
+    class Message
+      include Anima.new(:role, :content)
+
+      def to_log_format(config)
+        prefix =
+          case role
+          when 'user' then "#{role}:".upcase.green
+          when 'system' then "#{role}:".upcase.yellow
+          when 'assistant' then "#{config.assistant_name}:".upcase.red
+          else
+            raise "Unknown role: #{role}"
+          end
+
+        "#{prefix} #{content}"
+      end
+    end
+  end
+end

data/lib/openai/tokenizer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class Tokenizer
+    include Equalizer.new
+
+    UnknownModel = Class.new(StandardError)
+    UnknownEncoding = Class.new(StandardError)
+
+    def for_model(model)
+      encoding = Tiktoken.encoding_for_model(model)
+      raise UnknownModel, "Invalid model name or not recognized by Tiktoken: #{model.inspect}" if encoding.nil?
+
+      Encoding.new(encoding.name)
+    end
+
+    def get(encoding_name)
+      encoding = Tiktoken.get_encoding(encoding_name)
+      if encoding.nil?
+        raise UnknownEncoding,
+              "Invalid encoding name or not recognized by Tiktoken: #{encoding_name.inspect}"
+      end
+
+      Encoding.new(encoding.name)
+    end
+
+    class Encoding
+      include Concord.new(:name)
+
+      def encode(text)
+        encoder.encode(text)
+      end
+      alias tokenize encode
+
+      def decode(tokens)
+        encoder.decode(tokens)
+      end
+
+      def num_tokens(text)
+        encode(text).size
+      end
+
+      private
+
+      def encoder
+        Tiktoken.get_encoding(name)
+      end
+    end
+  end
+end

data/lib/openai/util.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class OpenAI
+  module Util
+    OneError = Class.new(ArgumentError)
+
+    def self.one(list)
+      raise OneError, "Expected exactly one element, got #{list.size}" unless list.size == 1
+
+      list.first
+    end
+
+    module Colorize
+      refine String do
+        def red
+          colorize(31)
+        end
+
+        def green
+          colorize(32)
+        end
+
+        def yellow
+          colorize(33)
+        end
+
+        def blue
+          colorize(34)
+        end
+
+        def magenta
+          colorize(35)
+        end
+
+        def cyan
+          colorize(36)
+        end
+
+        private
+
+        def colorize(color_code)
+          "\e[#{color_code}m#{self}\e[0m"
+        end
+      end
+    end
+  end
+end

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class OpenAI
-  VERSION = '0.0.0'
+  VERSION = '0.0.3'
 end