mistral-ai 1.0.0

data/controllers/client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'event_stream_parser'
+require 'faraday'
+require 'json'
+
+require_relative '../ports/dsl/mistral-ai/errors'
+
+module Mistral
+  module Controllers
+    class Client
+      DEFAULT_ADDRESS = 'https://api.mistral.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_completions(payload, server_sent_events: nil, &callback)
+        server_sent_events = false if payload[:stream] != true
+        request('v1/chat/completions', payload, server_sent_events:, &callback)
+      end
+
+      def embeddings(payload, server_sent_events: nil, &callback)
+        request('v1/embeddings', payload, server_sent_events: false, &callback)
+      end
+
+      def request(path, payload, server_sent_events: nil, &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 = []
+
+        response = Faraday.new(request: @request_options) do |faraday|
+          faraday.response :raise_error
+        end.post 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
+
+          if server_sent_events_enabled
+            parser = EventStreamParser::Parser.new
+
+            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
+
+              parser.feed(chunk) do |type, data, id, reconnection_time|
+                parsed_data = safe_parse_json(data)
+
+                if parsed_data != '[DONE]'
+                  result = {
+                    event: safe_parse_json(data),
+                    parsed: { type:, data:, id:, reconnection_time: },
+                    raw: { chunk:, bytes:, env: }
+                  }
+
+                  callback.call(result[:event], result[:parsed], result[:raw]) unless callback.nil?
+
+                  results << result
+
+                  parsed_data['choices'].find do |candidate|
+                    !candidate['finish_reason'].nil? && candidate['finish_reason'] != ''
+                  end
+                end
+              end
+            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/mistral-ai.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'static/gem'
+
+Gem::Specification.new do |spec|
+  spec.name    = Mistral::GEM[:name]
+  spec.version = Mistral::GEM[:version]
+  spec.authors = [Mistral::GEM[:author]]
+
+  spec.summary = Mistral::GEM[:summary]
+  spec.description = Mistral::GEM[:description]
+
+  spec.homepage = Mistral::GEM[:github]
+
+  spec.license = Mistral::GEM[:license]
+
+  spec.required_ruby_version = Gem::Requirement.new(">= #{Mistral::GEM[:ruby]}")
+
+  spec.metadata['allowed_push_host'] = Mistral::GEM[:gem_server]
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = Mistral::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 'event_stream_parser', '~> 1.0'
+  spec.add_dependency 'faraday', '~> 2.8', '>= 2.8.1'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

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

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

data/ports/dsl/mistral-ai.rb

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

data/static/gem.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mistral
+  GEM = {
+    name: 'mistral-ai',
+    version: '1.0.0',
+    author: 'gbaptista',
+    summary: 'Interact with Mistral AI.',
+    description: "A Ruby gem for interacting with Mistral AI's large language models.",
+    github: 'https://github.com/gbaptista/mistral-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."))