openai.rb 0.0.0 → 0.0.3

data/lib/openai/api/cache.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class API
+    class Cache
+      include Concord.new(:client, :cache)
+
+      def get(route)
+        read_cache_or_apply(verb: :get, route: route) do
+          client.get(route)
+        end
+      end
+
+      # Caching is a no-op for delete requests since caching a delete does
+      # not really make sense
+      def delete(...)
+        client.delete(...)
+      end
+
+      def post(route, **body)
+        read_cache_or_apply(verb: :post, route: route, body: body, format: :json) do
+          client.post(route, **body)
+        end
+      end
+
+      def post_form_multipart(route, **body)
+        read_cache_or_apply(verb: :post, route: route, body: body, format: :form) do
+          client.post_form_multipart(route, **body)
+        end
+      end
+
+      private
+
+      def read_cache_or_apply(...)
+        target = cache_target(...).unique_id
+
+        if cache.cached?(target)
+          cache.read(target)
+        else
+          yield.tap do |result|
+            cache.write(target, result)
+          end
+        end
+      end
+
+      def cache_target(verb:, route:, body: nil, format: nil)
+        Target.new(
+          verb: verb,
+          api_key: client.api_key,
+          route: route,
+          body: body,
+          format: format
+        )
+      end
+
+      class Target
+        include Anima.new(:verb, :api_key, :route, :body, :format)
+        include Memoizable
+
+        def unique_id
+          serialized = JSON.dump(serialize_for_cache)
+          digest = Digest::SHA256.hexdigest(serialized)
+          bare_route = route.delete_prefix('/v1/')
+          prefix = "#{verb}_#{bare_route}".gsub('/', '_')
+          fingerprint = digest.slice(0, 8)
+
+          "#{prefix}_#{fingerprint}"
+        end
+        memoize :unique_id
+
+        def serialize_for_cache
+          data = to_h
+          if data[:body]
+            data[:body] = data[:body].transform_values do |value|
+              if value.instance_of?(HTTP::FormData::File)
+                Digest::SHA256.hexdigest(value.to_s)
+              else
+                value
+              end
+            end
+          end
+          data
+        end
+      end
+
+      class Strategy
+        include AbstractType
+
+        abstract_method :cached?
+        abstract_method :read
+        abstract_method :write
+
+        class Memory < self
+          include Concord.new(:cache)
+
+          def initialize
+            super({})
+          end
+
+          def cached?(target)
+            cache.key?(target)
+          end
+
+          def write(target, result)
+            cache[target] = result
+          end
+
+          def read(target)
+            cache.fetch(target)
+          end
+        end
+
+        class FileSystem < self
+          include Concord.new(:cache_dir)
+
+          def cached?(target)
+            cache_file(target).file?
+          end
+
+          def write(target, result)
+            cache_file(target).write(result)
+          end
+
+          def read(target)
+            cache_file(target).read
+          end
+
+          private
+
+          def cache_file(target)
+            cache_dir.join("#{target}.json")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openai/api/client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class API
+    class Client
+      include Concord.new(:api_key, :http)
+
+      public :api_key
+
+      HOST = Addressable::URI.parse('https://api.openai.com/v1')
+
+      def initialize(api_key, http: HTTP)
+        super(api_key, http)
+      end
+
+      def inspect
+        "#<#{self.class}>"
+      end
+
+      def get(route)
+        unwrap_response(json_http_client.get(url_for(route)))
+      end
+
+      def delete(route)
+        unwrap_response(json_http_client.delete(url_for(route)))
+      end
+
+      def post(route, **body)
+        url = url_for(route)
+        if block_given?
+          json_http_client.persistent(url) do |connection|
+            response = connection.post(url, json: body)
+
+            # Data comes in as JSON frames like so:
+            #
+            #   data: {"choices": [{"text": "He"}]}
+            #   data: {"choices": [{"text": "llo, "}]}
+            #   data: {"choices": [{"text": "Wor"}]}
+            #   data: {"choices": [{"text": "ld!"}]}
+            #   data: [DONE]
+            #
+            # (The actual frames are fully formed JSON objects just like a
+            # non-streamed response, the examples above are just for brevity)
+            response.body.each do |chunk|
+              chunk.split("\n\n").each do |part|
+                frame = part.delete_prefix('data: ').strip
+
+                yield(frame) unless frame == '[DONE]' || frame.empty?
+              end
+            end
+          end
+
+          # Return nil since we aren't reconstructing what the API would have
+          # returned if we had not streamed the response
+          nil
+        else
+          unwrap_response(json_http_client.post(url, json: body))
+        end
+      end
+
+      def post_form_multipart(route, **body)
+        unwrap_response(http_client.post(url_for(route), form: body))
+      end
+
+      private
+
+      def url_for(route)
+        HOST.join(route).to_str
+      end
+
+      def unwrap_response(response)
+        raise API::Error.parse(response) unless response.status.success?
+
+        response.body.to_str
+      end
+
+      def json_http_client
+        http_client.headers('Content-Type' => 'application/json')
+      end
+
+      def http_client
+        http.headers('Authorization' => "Bearer #{api_key}")
+      end
+    end
+  end
+end

data/lib/openai/api/resource.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+class OpenAI
+  class API
+    class Resource
+      include Concord.new(:client)
+      include AbstractType
+
+      private
+
+      def post(...)
+        client.post(...)
+      end
+
+      def post_form_multipart(...)
+        client.post_form_multipart(...)
+      end
+
+      def get(...)
+        client.get(...)
+      end
+
+      def form_file(path)
+        absolute_path = Pathname.new(path).expand_path.to_s
+        HTTP::FormData::File.new(absolute_path)
+      end
+
+      def create_and_maybe_stream(
+        endpoint,
+        full_response_type:, stream: false,
+        chunk_response_type: full_response_type,
+        **kwargs
+      )
+        payload = kwargs.merge(stream: stream)
+
+        raise 'Streaming responses require a block' if stream && !block_given?
+        raise 'Non-streaming responses do not support blocks' if !stream && block_given?
+
+        if stream
+          post(endpoint, **payload) do |chunk|
+            yield(chunk_response_type.from_json(chunk))
+          end
+
+          nil
+        else
+          full_response_type.from_json(
+            post(endpoint, **payload)
+          )
+        end
+      end
+    end
+
+    class Completion < Resource
+      def create(model:, **kwargs, &block)
+        create_and_maybe_stream(
+          '/v1/completions',
+          model: model,
+          full_response_type: Response::Completion,
+          **kwargs,
+          &block
+        )
+      end
+    end
+
+    class ChatCompletion < Resource
+      def create(model:, messages:, **kwargs, &block)
+        create_and_maybe_stream(
+          '/v1/chat/completions',
+          model: model,
+          messages: messages,
+          full_response_type: Response::ChatCompletion,
+          chunk_response_type: Response::ChatCompletionChunk,
+          **kwargs,
+          &block
+        )
+      end
+    end
+
+    class Embedding < Resource
+      def create(model:, input:, **kwargs)
+        Response::Embedding.from_json(
+          post('/v1/embeddings', model: model, input: input, **kwargs)
+        )
+      end
+    end
+
+    class Model < Resource
+      def list
+        Response::ListModel.from_json(get('/v1/models'))
+      end
+
+      def fetch(model_id)
+        Response::Model.from_json(
+          get("/v1/models/#{model_id}")
+        )
+      end
+    end
+
+    class Moderation < Resource
+      def create(input:, model:)
+        Response::Moderation.from_json(
+          post('/v1/moderations', input: input, model: model)
+        )
+      end
+    end
+
+    class Edit < Resource
+      def create(model:, instruction:, **kwargs)
+        Response::Edit.from_json(
+          post('/v1/edits', model: model, instruction: instruction, **kwargs)
+        )
+      end
+    end
+
+    class File < Resource
+      def create(file:, purpose:)
+        Response::File.from_json(
+          post_form_multipart('/v1/files', file: form_file(file), purpose: purpose)
+        )
+      end
+
+      def list
+        Response::FileList.from_json(
+          get('/v1/files')
+        )
+      end
+
+      def delete(file_id)
+        Response::File.from_json(
+          client.delete("/v1/files/#{file_id}")
+        )
+      end
+
+      def fetch(file_id)
+        Response::File.from_json(
+          get("/v1/files/#{file_id}")
+        )
+      end
+
+      def get_content(file_id)
+        get("/v1/files/#{file_id}/content")
+      end
+    end
+
+    class FineTune < Resource
+      def list
+        Response::FineTuneList.from_json(
+          get('/v1/fine-tunes')
+        )
+      end
+
+      def create(training_file:, **kwargs)
+        Response::FineTune.from_json(
+          post('/v1/fine-tunes', training_file: training_file, **kwargs)
+        )
+      end
+
+      def fetch(fine_tune_id)
+        Response::FineTune.from_json(
+          get("/v1/fine-tunes/#{fine_tune_id}")
+        )
+      end
+
+      def cancel(fine_tune_id)
+        Response::FineTune.from_json(
+          post("/v1/fine-tunes/#{fine_tune_id}/cancel")
+        )
+      end
+
+      def list_events(fine_tune_id)
+        Response::FineTuneEventList.from_json(
+          get("/v1/fine-tunes/#{fine_tune_id}/events")
+        )
+      end
+    end
+
+    class Image < Resource
+      def create(prompt:, **kwargs)
+        Response::ImageGeneration.from_json(
+          post('/v1/images/generations', prompt: prompt, **kwargs)
+        )
+      end
+
+      def create_variation(image:, **kwargs)
+        Response::ImageVariation.from_json(
+          post_form_multipart('/v1/images/variations', {
+                                image: form_file(image),
+                                **kwargs
+                              })
+        )
+      end
+
+      def edit(image:, prompt:, mask: nil, **kwargs)
+        params = {
+          image: form_file(image),
+          prompt: prompt,
+          **kwargs
+        }
+
+        params[:mask] = form_file(mask) if mask
+
+        Response::ImageEdit.from_json(
+          post_form_multipart('/v1/images/edits', **params)
+        )
+      end
+    end
+
+    class Audio < Resource
+      def transcribe(file:, model:, **kwargs)
+        Response::Transcription.from_json(
+          post_form_multipart(
+            '/v1/audio/transcriptions',
+            file: form_file(file),
+            model: model,
+            **kwargs
+          )
+        )
+      end
+
+      def translate(file:, model:, **kwargs)
+        Response::Transcription.from_json(
+          post_form_multipart(
+            '/v1/audio/translations',
+            file: form_file(file),
+            model: model,
+            **kwargs
+          )
+        )
+      end
+    end
+  end
+end