cohere-ai 1.0.0

data/cohere-ai.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'static/gem'
+
+Gem::Specification.new do |spec|
+  spec.name    = Cohere::GEM[:name]
+  spec.version = Cohere::GEM[:version]
+  spec.authors = [Cohere::GEM[:author]]
+
+  spec.summary = Cohere::GEM[:summary]
+  spec.description = Cohere::GEM[:description]
+
+  spec.homepage = Cohere::GEM[:github]
+
+  spec.license = Cohere::GEM[:license]
+
+  spec.required_ruby_version = Gem::Requirement.new(">= #{Cohere::GEM[:ruby]}")
+
+  spec.metadata['allowed_push_host'] = Cohere::GEM[:gem_server]
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = Cohere::GEM[:github]
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+
+  spec.require_paths = ['ports/dsl']
+
+  spec.add_dependency 'faraday', '~> 2.8', '>= 2.8.1'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/components/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cohere
+  module Errors
+    class CohereError < StandardError
+      def initialize(message = nil)
+        super(message)
+      end
+    end
+
+    class MissingAPIKeyError < CohereError; end
+    class BlockWithoutServerSentEventsError < CohereError; end
+
+    class RequestError < CohereError
+      attr_reader :request, :payload
+
+      def initialize(message = nil, request: nil, payload: nil)
+        @request = request
+        @payload = payload
+
+        super(message)
+      end
+    end
+  end
+end

data/controllers/client.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+require_relative '../ports/dsl/cohere-ai/errors'
+
+module Cohere
+  module Controllers
+    class Client
+      DEFAULT_ADDRESS = 'https://api.cohere.ai'
+
+      ALLOWED_REQUEST_OPTIONS = %i[timeout open_timeout read_timeout write_timeout].freeze
+
+      def initialize(config)
+        @api_key = config.dig(:credentials, :api_key)
+        @server_sent_events = config.dig(:options, :server_sent_events)
+
+        @address = if config[:credentials][:address].nil? || config[:credentials][:address].to_s.strip.empty?
+                     "#{DEFAULT_ADDRESS}/"
+                   else
+                     "#{config[:credentials][:address].to_s.sub(%r{/$}, '')}/"
+                   end
+
+        if @api_key.nil? && @address == "#{DEFAULT_ADDRESS}/"
+          raise MissingAPIKeyError, 'Missing API Key, which is required.'
+        end
+
+        @request_options = config.dig(:options, :connection, :request)
+
+        @request_options = if @request_options.is_a?(Hash)
+                             @request_options.select do |key, _|
+                               ALLOWED_REQUEST_OPTIONS.include?(key)
+                             end
+                           else
+                             {}
+                           end
+      end
+
+      def chat(payload, server_sent_events: nil, &callback)
+        server_sent_events = false if payload[:stream] != true
+        request('v1/chat', payload, server_sent_events:, &callback)
+      end
+
+      def generate(payload, server_sent_events: nil, &callback)
+        server_sent_events = false if payload[:stream] != true
+        request('v1/generate', payload, server_sent_events:, &callback)
+      end
+
+      def embed(payload, _server_sent_events: nil, &callback)
+        request('v1/embed', payload, server_sent_events: false, &callback)
+      end
+
+      def rerank(payload, _server_sent_events: nil, &callback)
+        request('v1/rerank', payload, server_sent_events: false, &callback)
+      end
+
+      def classify(payload, _server_sent_events: nil, &callback)
+        request('v1/classify', payload, server_sent_events: false, &callback)
+      end
+
+      def detect_language(payload, _server_sent_events: nil, &callback)
+        request('v1/detect-language', payload, server_sent_events: false, &callback)
+      end
+
+      def summarize(payload, _server_sent_events: nil, &callback)
+        request('v1/summarize', payload, server_sent_events: false, &callback)
+      end
+
+      def tokenize(payload, _server_sent_events: nil, &callback)
+        request('v1/tokenize', payload, server_sent_events: false, &callback)
+      end
+
+      def detokenize(payload, _server_sent_events: nil, &callback)
+        request('v1/detokenize', payload, server_sent_events: false, &callback)
+      end
+
+      def request(path, payload = nil, server_sent_events: nil, request_method: 'POST', &callback)
+        server_sent_events_enabled = server_sent_events.nil? ? @server_sent_events : server_sent_events
+        url = "#{@address}#{path}"
+
+        if !callback.nil? && !server_sent_events_enabled
+          raise BlockWithoutServerSentEventsError,
+                'You are trying to use a block without Server Sent Events (SSE) enabled.'
+        end
+
+        results = []
+
+        method_to_call = request_method.to_s.strip.downcase.to_sym
+
+        response = Faraday.new(request: @request_options) do |faraday|
+          faraday.response :raise_error
+        end.send(method_to_call) do |request|
+          request.url url
+          request.headers['Content-Type'] = 'application/json'
+
+          request.headers['Authorization'] = "Bearer #{@api_key}" unless @api_key.nil?
+
+          request.body = payload.to_json unless payload.nil?
+
+          if server_sent_events_enabled
+            request.options.on_data = proc do |chunk, bytes, env|
+              if env && env.status != 200
+                raise_error = Faraday::Response::RaiseError.new
+                raise_error.on_complete(env.merge(body: chunk))
+              end
+
+              result = { event: safe_parse_json(chunk), raw: { chunk:, bytes:, env: } }
+
+              callback.call(result[:event], result[:raw]) unless callback.nil?
+
+              results << result
+            end
+          end
+        end
+
+        return safe_parse_json(response.body) unless server_sent_events_enabled
+
+        results.map { |result| result[:event] }
+      rescue Faraday::ServerError => e
+        raise RequestError.new(e.message, request: e, payload:)
+      end
+
+      def safe_parse_json(raw)
+        raw.start_with?('{', '[') ? JSON.parse(raw) : raw
+      rescue JSON::ParserError
+        raw
+      end
+    end
+  end
+end

data/ports/dsl/cohere-ai/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../../../components/errors'
+
+include Cohere::Errors

data/ports/dsl/cohere-ai.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../static/gem'
+require_relative '../../controllers/client'
+
+module Cohere
+  def self.new(...)
+    Controllers::Client.new(...)
+  end
+
+  def self.version
+    Cohere::GEM[:version]
+  end
+end

data/static/gem.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Cohere
+  GEM = {
+    name: 'cohere-ai',
+    version: '1.0.0',
+    author: 'gbaptista',
+    summary: 'Interact with Cohere AI.',
+    description: "A Ruby gem for interacting with Cohere AI platform.",
+    github: 'https://github.com/gbaptista/cohere-ai',
+    gem_server: 'https://rubygems.org',
+    license: 'MIT',
+    ruby: '3.1.0'
+  }.freeze
+end

data/tasks/generate-readme.clj

@@ -0,0 +1,39 @@
+(require '[clojure.string :as str])
+
+(defn slugify [text]
+  (-> text
+      (clojure.string/lower-case)
+      (clojure.string/replace " " "-")
+      (clojure.string/replace #"[^a-z0-9\-_]" "")))
+
+(defn remove-code-blocks [content]
+  (let [code-block-regex #"(?s)```.*?```"]
+    (clojure.string/replace content code-block-regex "")))
+
+(defn process-line [line]
+  (when-let [[_ hashes title] (re-find #"^(\#{2,}) (.+)" line)]
+    (let [link (slugify title)]
+      {:level (count hashes) :title title :link link})))
+
+(defn create-index [content]
+  (let [processed-content (remove-code-blocks content)
+        processed-lines (->> processed-content
+                             clojure.string/split-lines
+                             (map process-line)
+                             (remove nil?))]
+    (->> processed-lines
+         (map (fn [{:keys [level title link]}]
+                (str (apply str (repeat (* 4 (- level 2)) " "))
+                     "- ["
+                     title
+                     "](#"
+                     link
+                     ")")))
+         (clojure.string/join "\n"))))
+
+
+(let [content         (slurp "template.md")
+      index           (create-index content)
+      updated-content (clojure.string/replace content "{index}" index)]
+  (spit "README.md" updated-content)
+  (println "README.md successfully generated."))