replicate-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d40274f18b3fca8f69b7a0e7614765150352ec1d828dedc6d4046605339833c
+  data.tar.gz: 991a137f2a20658ef3c85d95fbc230ac4528d63b29d1c01d6efdd07f1dcd1675
+SHA512:
+  metadata.gz: e89be0757da9ea93891a36126fefc72b5d26a5d2942477c7dd0c5a28978d31faf202b84743d6196c8d597e0703527e68538cfe483afc4d0c1526fb714e0c925d
+  data.tar.gz: d30afd20e196df7e169053d284ad9ab1d435876274763926e518e78661f2b3a156eaf9ffbc4b9ccd84955c7b22bc3abc979ca647f4c91ddf9404311cf0e3aad5

data/.rubocop.yml

@@ -0,0 +1,42 @@
+AllCops:
+  TargetRubyVersion: 3.3.9
+  NewCops: enable
+  SuggestExtensions: false
+
+Style/Documentation:
+  Enabled: false
+
+Bundler/OrderedGems:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/FrozenStringLiteralComment:
+  SafeAutoCorrect: true
+  EnforcedStyle: always_true
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/AccessorGrouping:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Style/HashSyntax:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    - "lib/replicate-client.rb"

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "minitest", "~> 5.0"
+gem "rake", "~> 13.0"
+gem "rubocop", "~> 1.21"

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    replicate-client (0.1.0)
+      faraday (>= 1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    faraday (2.10.1)
+      faraday-net_http (>= 2.0, < 3.2)
+      logger
+    faraday-net_http (3.1.1)
+      net-http
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    logger (1.6.0)
+    minitest (5.23.1)
+    net-http (0.4.1)
+      uri
+    parallel (1.24.0)
+    parser (3.3.1.0)
+      ast (~> 2.4.1)
+      racc
+    racc (1.8.0)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    regexp_parser (2.9.2)
+    rexml (3.2.8)
+      strscan (>= 3.0.9)
+    rubocop (1.64.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
+    ruby-progressbar (1.13.0)
+    strscan (3.1.0)
+    unicode-display_width (2.5.0)
+    uri (0.13.0)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-23
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  replicate-client!
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.5.7

data/README.md

@@ -0,0 +1,202 @@
+# ReplicateClient
+
+**🚧 This gem is still under development 🚧**
+
+## Installation
+
+Install the gem and add to the application"s Gemfile by executing:
+
+    $ bundle add replicate
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install replicate
+
+## Usage
+
+### Configuration
+
+You can configure the gem by calling the `#configure` method on the `ReplicateClient` module. The method accepts a block with the configuration options.
+
+```ruby
+ReplicateClient.configure do |config|
+  config.access_token = ENV["REPLICATE_ACCESS_TOKEN"] # Required
+  config.uri_base = "https://replicate.app/api/v1" # Optional
+  config.request_timeout = 5 # Optional (default: 120)
+  config.webhook_url = "https://example.com/replicate/webhook" # Optional
+end
+```
+
+### Get a model
+
+```ruby
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+model = ReplicateClient::Model.find_by(owner: "stability-ai", name: "sdxl")
+model = ReplicateClient::Model.find_by(owner: "stability-ai", name: "sdxl", version_id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+```
+
+### Get a model version
+
+```ruby
+version = ReplicateClient::Model::Version.find_by(owner: "stability-ai", name: "sdxl", version_id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+
+model = ReplicateClient::Model.find_by(owner: "stability-ai", name: "sdxl", version_id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+version = model.version
+```
+
+### Get the latest version of a model
+
+```ruby
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+version = model.latest_version
+```
+
+### Get list of model versions
+
+```ruby
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+versions = model.versions
+```
+
+### Paginate through all models
+
+```ruby
+ReplicateClient::Model.auto_paging_each do |model|
+  puts model.name
+end
+```
+
+### Create a prediction
+
+```ruby
+version = ReplicateClient::Model::Version.find_by(owner: "stability-ai", name: "sdxl", version_id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+prediction = version.create_prediction!(input: { my: "input" })
+
+prediction = version.create_prediction!(input: { my: "input" }, webhook_url: "https://example.com/replicate/webhook")
+
+prediction = version.create_prediction!(input: { my: "input" }, webhook_url: "https://example.com/replicate/webhook", webhook_events_filter: ["start", "completed"])
+
+prediction = ReplicateClient::Prediction.create!(version: version, input: { my: "input" })
+
+prediction = ReplicateClient::Prediction.create!(version: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc", input: { my: "input" })
+
+deployment = ReplicateClient::Deployment.find("851-labs/my-deployment")
+prediction = deployment.create_prediction!(input: { my: "input" })
+
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+prediction = model.create_prediction!(input: { my: "input" })
+
+prediction = ReplicateClient::Prediction.create_for_official_model!(model: "stability-ai/sdxl", input: { my: "input" })
+```
+
+### Get a prediction
+
+```ruby
+prediction = ReplicateClient::Prediction.find("7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+
+prediction = ReplicateClient::Prediction.find_by(id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+
+prediction = ReplicateClient::Prediction.find_by!(id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+```
+
+### Reload a resource
+
+```ruby
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+model.reload!
+
+version = ReplicateClient::Model::Version.find_by(owner: "stability-ai", name: "sdxl", version_id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+version.reload!
+
+prediction = ReplicateClient::Prediction.find("7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+prediction.reload!
+```
+
+### Delete a resource
+
+```ruby
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+model.delete!
+```
+
+### Get available hardware
+
+```ruby
+hardware = ReplicateClient::Hardware.all
+```
+
+### Create a deployment
+
+```ruby
+deployment = ReplicateClient::Deployment.create!(name: "851-deployment", model: "stability-ai/sdxl", hardware: "gpu-t4", min_instances: 1, max_instances: 1)
+
+model = ReplicateClient::Model.find("stability-ai/sdxl")
+deployment = ReplicateClient::Deployment.create!(name: "851-deployment", model: model, hardware: "gpu-t4", min_instances: 1, max_instances: 1)
+
+hardware = ReplicateClient::Hardware.all.first
+deployment = ReplicateClient::Deployment.create!(name: "851-deployment", model: model, hardware: hardware, min_instances: 1, max_instances: 1)
+```
+
+### Get a deployment
+
+```ruby
+deployment = ReplicateClient::Deployment.find("851-labs/my-deployment")
+
+deployment = ReplicateClient::Deployment.find_by(owner: "851-labs", name: "my-deployment")
+
+deployment = ReplicateClient::Deployment.find_by!(owner: "851-labs", name: "my-deployment")
+```
+
+### Paginate through all deployments
+
+```ruby
+ReplicateClient::Deployment.auto_paging_each do |deployment|
+  puts deployment.name
+end
+```
+
+### Create a training
+
+```ruby
+training = ReplicateClient::Training.create!(owner: "851-labs", name: "my-training", version: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc", destination: "851-labs/my-new-model", input: {})
+
+sdxl = ReplicateClient::Model::Version.find_by(owner: "stability-ai", name: "sdxl", version_id: "7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc")
+destination_model = ReplicateClient::Model.find("851-labs/my-new-model")
+training = ReplicateClient::Training.create!(owner: "851-labs", name: "my-training", version: version, destination: destination_model, input: {})
+
+sdxl = ReplicateClient::Model.find("stability-ai/sdxl")
+destination_model = ReplicateClient::Model.find("851-labs/my-new-model")
+training = ReplicateClient::Training.create_for_model!(model: sdxl, destination: destination_model, input: {})
+```
+
+### Get a training
+
+```ruby
+training = ReplicateClient::Training.find("b3kgfb2y9nrm00chdnkaam2dvz")
+```
+
+### Paginate through all trainings
+
+```ruby
+ReplicateClient::Training.auto_paging_each do |training|
+  puts training.name
+end
+```
+
+### Cancel a training
+
+```ruby
+training = ReplicateClient::Training.find("b3kgfb2y9nrm00chdnkaam2dvz")
+training.cancel!
+```
+
+## Warning
+
+Official models will not have vesions. The version id will be nil.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/replicate-client/client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ReplicateClient
+  class Client
+    # Initialize the client.
+    #
+    # @param configuration [ReplicateClient::Configuration] The configuration for the client.
+    #
+    # @return [ReplicateClient::Client]
+    def initialize(configuration = ReplicateClient.configuration)
+      @configuration = configuration
+    end
+
+    # Make a POST request to the API.
+    #
+    # @param path [String] The path to the API endpoint.
+    # @param payload [Hash] The payload to send to the API.
+    #
+    # @return [Hash] The response from the API.
+    def post(path, payload)
+      response = connection.post(build_url(path)) do |request|
+        request.headers["Authorization"] = "Bearer #{@configuration.access_token}"
+        request.headers["Content-Type"] = "application/json"
+        request.headers["Accept"] = "application/json"
+        request.body = payload.compact.to_json
+      end
+
+      handle_error(response) unless response.success?
+
+      JSON.parse(response.body)
+    end
+
+    # Make a GET request to the API.
+    #
+    # @param path [String] The path to the API endpoint.
+    #
+    # @return [Hash] The response from the API.
+    def get(path)
+      puts "GET #{path}"
+
+      response = connection.get(build_url(path)) do |request|
+        request.headers["Authorization"] = "Bearer #{@configuration.access_token}"
+        request.headers["Content-Type"] = "application/json"
+      end
+
+      handle_error(response) unless response.success?
+
+      JSON.parse(response.body)
+    end
+
+    # Make a DELETE request to the API.
+    #
+    # @param path [String] The path to the API endpoint.
+    #
+    # @return [void]
+    def delete(path)
+      response = connection.delete(build_url(path)) do |request|
+        request.headers["Authorization"] = "Bearer #{@configuration.access_token}"
+        request.headers["Content-Type"] = "application/json"
+      end
+
+      handle_error(response) unless response.success?
+    end
+
+    def patch(path, payload)
+      response = connection.patch(build_url(path)) do |request|
+        request.headers["Authorization"] = "Bearer #{@configuration.access_token}"
+        request.headers["Content-Type"] = "application/json"
+        request.headers["Accept"] = "application/json"
+        request.body = payload.compact.to_json
+      end
+
+      handle_error(response) unless response.success?
+
+      JSON.parse(response.body)
+    end
+
+    # Handle errors from the API.
+    #
+    # @param response [Faraday::Response] The response from the API.
+    #
+    # @return [void]
+    def handle_error(response)
+      case response.status
+      when 401
+        raise UnauthorizedError, response.body
+      when 403
+        raise ForbiddenError, response.body
+      when 404
+        raise NotFoundError, response.body
+      else
+        raise ServerError, response.body
+      end
+    end
+
+    private
+
+    # Build the URL for the API.
+    #
+    # @param path [String] The path to the API endpoint.
+    def build_url(path)
+      "#{@configuration.uri_base}#{path}"
+    end
+
+    # Create a connection to the API.
+    #
+    # @return [Faraday::Connection]
+    def connection
+      Faraday.new do |faraday|
+        faraday.request :url_encoded
+        faraday.options.timeout = @configuration.request_timeout
+        faraday.options.open_timeout = @configuration.request_timeout
+      end
+    end
+  end
+end

data/lib/replicate-client/deployment.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module ReplicateClient
+  class Deployment
+    INDEX_PATH = "/deployments"
+
+    class << self
+      # List all deployments.
+      #
+      # @yield [ReplicateClient::Deployment] Yields a deployment.
+      #
+      # @return [void]
+      def auto_paging_each(&block)
+        cursor = nil
+
+        loop do
+          url_params = cursor ? "?cursor=#{cursor}" : ""
+          attributes = ReplicateClient.client.get("#{INDEX_PATH}#{url_params}")
+
+          deployments = attributes["results"].map { |deployment| new(deployment) }
+
+          deployments.each(&block)
+
+          cursor = attributes["next"] ? URI.decode_www_form(URI.parse(attributes["next"]).query).to_h["cursor"] : nil
+          break if cursor.nil?
+        end
+      end
+
+      # Create a new deployment.
+      #
+      # @param name [String] The name of the deployment.
+      # @param model [ReplicateClient::Model, String] The model identifier in "owner/name" format.
+      # @param version_id [String, nil] The version ID of the model.
+      # @param hardware [ReplicateClient::Hardware, String] The hardware SKU.
+      # @param min_instances [Integer] The minimum number of instances.
+      # @param max_instances [Integer] The maximum number of instances.
+      #
+      # @return [ReplicateClient::Deployment]
+      def create!(name:, model:, hardware:, min_instances:, max_instances:, version_id: nil)
+        model_full_name = model.is_a?(Model) ? model.full_name : model
+        hardware_sku = hardware.is_a?(Hardware) ? hardware.sku : hardware
+        version = if version_id
+                    version_id
+                  elsif model.is_a?(Model)
+                    model.version_id
+                  else
+                    Model.find(model).latest_version.id
+                  end
+
+        body = {
+          name: name,
+          model: model_full_name,
+          version: version,
+          hardware: hardware_sku,
+          min_instances: min_instances,
+          max_instances: max_instances
+        }
+
+        attributes = ReplicateClient.client.post(INDEX_PATH, body)
+        new(attributes)
+      end
+
+      # Find a deployment by owner and name.
+      #
+      # @param full_name [String] The full name of the deployment in "owner/name" format.
+      #
+      # @return [ReplicateClient::Deployment]
+      def find(full_name)
+        path = build_path(**parse_full_name(full_name))
+        attributes = ReplicateClient.client.get(path)
+        new(attributes)
+      end
+
+      # Find a deployment by owner and name.
+      #
+      # @param owner [String] The owner of the deployment.
+      # @param name [String] The name of the deployment.
+      #
+      # @return [ReplicateClient::Deployment]
+      def find_by!(owner:, name:)
+        path = build_path(owner: owner, name: name)
+        attributes = ReplicateClient.client.get(path)
+        new(attributes)
+      end
+
+      # Find a deployment by owner and name.
+      #
+      # @param owner [String] The owner of the deployment.
+      # @param name [String] The name of the deployment.
+      #
+      # @return [ReplicateClient::Deployment, nil]
+      def find_by(owner:, name:)
+        find_by!(owner: owner, name: name)
+      rescue ReplicateClient::NotFoundError
+        nil
+      end
+
+      # Delete a deployment.
+      #
+      # @param owner [String] The owner of the deployment.
+      # @param name [String] The name of the deployment.
+      #
+      # @return [void]
+      def destroy!(owner:, name:)
+        path = build_path(owner: owner, name: name)
+        ReplicateClient.client.delete(path)
+      end
+
+      # Build the path for a specific deployment.
+      #
+      # @param owner [String] The owner of the deployment.
+      # @param name [String] The name of the deployment.
+      #
+      # @return [String]
+      def build_path(owner:, name:)
+        "#{INDEX_PATH}/#{owner}/#{name}"
+      end
+
+      # Parse the full name for a deployment.
+      #
+      # @param full_name [String] The full name of the deployment.
+      #
+      # @return [Hash]
+      def parse_full_name(full_name)
+        parts = full_name.split("/")
+        { owner: parts[0], name: parts[1] }
+      end
+    end
+
+    # Attributes for deployment.
+    attr_accessor :owner, :name, :current_release
+
+    # Initialize a new deployment instance.
+    #
+    # @param attributes [Hash] The attributes of the deployment.
+    #
+    # @return [ReplicateClient::Deployment]
+    def initialize(attributes)
+      reset_attributes(attributes)
+    end
+
+    # Destroy the deployment.
+    #
+    # @return [void]
+    def destroy!
+      self.class.destroy!(owner: owner, name: name)
+    end
+
+    # Update the deployment.
+    #
+    # @param hardware [String, nil] The hardware SKU.
+    # @param min_instances [Integer, nil] The minimum number of instances.
+    # @param max_instances [Integer, nil] The maximum number of instances.
+    # @param version [ReplicateClient::Version, String, nil] The version ID of the model.
+    #
+    # @return [void]
+    def update!(hardware: nil, min_instances: nil, max_instances: nil, version: nil)
+      version_id = version.is_a?(Version) ? version.id : version
+      path = build_path(owner: owner, name: name)
+      body = {
+        hardware: hardware,
+        min_instances: min_instances,
+        max_instances: max_instances,
+        version: version_id
+      }.compact
+
+      attributes = ReplicateClient.client.patch(path, body)
+      reset_attributes(attributes)
+    end
+
+    # Reload the deployment.
+    #
+    # @return [void]
+    def reload!
+      attributes = ReplicateClient.client.get(path)
+      reset_attributes(attributes)
+    end
+
+    # Build the path for the deployment.
+    #
+    # @return [String]
+    def path
+      self.class.build_path(owner: owner, name: name)
+    end
+
+    # Create prediction for the deployment.
+    #
+    # @param input [Hash] The input for the prediction.
+    # @param webhook_url [String, nil] The URL to send webhook events to.
+    # @param webhook_events_filter [Array<String>, nil] The events to send to the webhook.
+    #
+    # @return [ReplicateClient::Prediction]
+    def create_prediction!(input, webhook_url: nil, webhook_events_filter: nil)
+      Prediction.create_for_deployment!(
+        deployment: self,
+        input: input,
+        webhook_url: webhook_url,
+        webhook_events_filter: webhook_events_filter
+      )
+    end
+
+    private
+
+    # Set the attributes of the deployment.
+    #
+    # @param attributes [Hash] The attributes of the deployment.
+    #
+    # @return [void]
+    def reset_attributes(attributes)
+      @owner = attributes["owner"]
+      @name = attributes["name"]
+      @current_release = attributes["current_release"]
+    end
+  end
+end