replicate-client 0.1.0

data/lib/replicate-client/prediction.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module ReplicateClient
+  class Prediction
+    INDEX_PATH = "/predictions"
+
+    module Status
+      STARTING   = "starting"
+      PROCESSING = "processing"
+      SUCCEEDED  = "succeeded"
+      FAILED     = "failed"
+      CANCELED   = "canceled"
+    end
+
+    class << self
+      # Create a new prediction for a version.
+      #
+      # @param version [String, ReplicateClient::Version] The version of the model to use for the prediction.
+      # @param input [Hash] The input data for the prediction.
+      # @param webhook_url [String] The URL to send webhook events to.
+      # @param webhook_events_filter [Array<Symbol>] The events to send to the webhook.
+      #
+      # @return [ReplicateClient::Prediction]
+      def create!(version:, input:, webhook_url: nil, webhook_events_filter: nil)
+        args = {
+          version: version.is_a?(Model::Version) ? version.id : version,
+          input: input,
+          webhook: webhook_url || ReplicateClient.configuration.webhook_url,
+          webhook_events_filter: webhook_events_filter&.map(&:to_s)
+        }
+
+        prediction = ReplicateClient.client.post(INDEX_PATH, args)
+
+        new(prediction)
+      end
+
+      # Create a new prediction for a deployment.
+      #
+      # @param deployment [String, ReplicateClient::Deployment] The deployment to use for the prediction.
+      # @param input [Hash] The input data for the prediction.
+      # @param webhook_url [String] The URL to send webhook events to.
+      # @param webhook_events_filter [Array<Symbol>] The events to send to the webhook.
+      #
+      # @return [ReplicateClient::Prediction]
+      def create_for_deployment!(deployment:, input:, webhook_url: nil, webhook_events_filter: nil)
+        args = {
+          input: input,
+          webhook: webhook_url || ReplicateClient.configuration.webhook_url,
+          webhook_events_filter: webhook_events_filter&.map(&:to_s)
+        }
+
+        prediction = ReplicateClient.client.post("#{deployment.path}#{INDEX_PATH}", args)
+
+        new(prediction)
+      end
+
+      # Create a new prediction for a model.
+      #
+      # @param model [String, ReplicateClient::Model] The model to use for the prediction.
+      # @param input [Hash] The input data for the prediction.
+      # @param webhook_url [String] The URL to send webhook events to.
+      # @param webhook_events_filter [Array<Symbol>] The events to send to the webhook.
+      #
+      # @return [ReplicateClient::Prediction]
+      def create_for_official_model!(model:, input:, webhook_url: nil, webhook_events_filter: nil)
+        model_path = model.is_a?(Model) ? model.path : Model.build_path(**Model.parse_model_name(model))
+
+        args = {
+          input: input,
+          webhook: webhook_url || ReplicateClient.configuration.webhook_url,
+          webhook_events_filter: webhook_events_filter&.map(&:to_s)
+        }
+
+        prediction = ReplicateClient.client.post("#{model_path}#{INDEX_PATH}", args)
+
+        new(prediction)
+      end
+
+      # Find a prediction.
+      #
+      # @param id [String] The ID of the prediction.
+      #
+      # @return [ReplicateClient::Prediction]
+      def find(id)
+        attributes = ReplicateClient.client.get(build_path(id))
+        new(attributes)
+      end
+
+      # Find a prediction.
+      #
+      # @param id [String] The ID of the prediction.
+      #
+      # @return [ReplicateClient::Prediction]
+      def find_by!(id:)
+        find(id)
+      end
+
+      # Find a prediction.
+      #
+      # @param id [String] The ID of the prediction.
+      #
+      # @return [ReplicateClient::Prediction]
+      def find_by(id:)
+        find_by!(id: id)
+      rescue ReplicateClient::NotFoundError
+        nil
+      end
+
+      # Build the path for the prediction.
+      #
+      # @param id [String] The ID of the prediction.
+      #
+      # @return [String]
+      def build_path(id)
+        "#{INDEX_PATH}/#{id}"
+      end
+
+      # Cancel a prediction.
+      #
+      # @param id [String] The ID of the prediction.
+      #
+      # @return [void]
+      def cancel!(id)
+        ReplicateClient.client.post("#{build_path(id)}/cancel")
+      end
+    end
+
+    # The ID of the prediction.
+    #
+    # @return [String]
+    attr_accessor :id
+
+    # The version of the model used for the prediction.
+    #
+    # @return [String]
+    attr_accessor :version_id
+
+    # The model used for the prediction.
+    #
+    # @return [String]
+    attr_accessor :model_name
+
+    # The input data for the prediction.
+    #
+    # @return [Hash]
+    attr_accessor :input
+
+    # The output data for the prediction.
+    #
+    # @return [Hash]
+    attr_accessor :output
+
+    # The error message for the prediction.
+    #
+    # @return [String]
+    attr_accessor :error
+
+    # The status of the prediction.
+    #
+    # @return [String]
+    attr_accessor :status
+
+    # The date the prediction was created.
+    #
+    # @return [Time]
+    attr_accessor :created_at
+
+    # The date the prediction was removed.
+    #
+    # @return [Time]
+    attr_accessor :data_removed
+
+    # The date the prediction was started.
+    #
+    # @return [Time]
+    attr_accessor :started_at
+
+    # The date the prediction was completed.
+    #
+    # @return [Time]
+    attr_accessor :completed_at
+
+    # The metrics for the prediction.
+    #
+    # @return [Hash]
+    attr_accessor :metrics
+
+    # The URLs for the prediction.
+    #
+    # @return [Hash]
+    attr_accessor :urls
+
+    def initialize(attributes)
+      reset_attributes(attributes)
+    end
+
+    # Reload the prediction.
+    #
+    # @return [ReplicateClient::Prediction]
+    def reload!
+      attributes = ReplicateClient.client.get(Prediction.build_path(@id))
+      reset_attributes(attributes)
+    end
+
+    # The model used for the prediction.
+    #
+    # @return [ReplicateClient::Model]
+    def model
+      @model ||= Model.find(@model_name, version_id: @version_id)
+    end
+
+    # The version of the model used for the prediction.
+    #
+    # @return [ReplicateClient::Model::Version]
+    def version
+      @version ||= model.version
+    end
+
+    # Cancel the prediction.
+    #
+    # @return [void]
+    def cancel!
+      Prediction.cancel!(id)
+    end
+
+    # Check if the prediction is succeeded.
+    #
+    # @return [Boolean]
+    def succeeded?
+      status == Status::SUCCEEDED
+    end
+
+    # Check if the prediction is failed.
+    #
+    # @return [Boolean]
+    def failed?
+      status == Status::FAILED
+    end
+
+    # Check if the prediction is canceled.
+    #
+    # @return [Boolean]
+    def canceled?
+      status == Status::CANCELED
+    end
+
+    # Check if the prediction is starting.
+    #
+    # @return [Boolean]
+    def starting?
+      status == Status::STARTING
+    end
+
+    # Check if the prediction is processing.
+    #
+    # @return [Boolean]
+    def processing?
+      status == Status::PROCESSING
+    end
+
+    private
+
+    # Set the attributes of the prediction.
+    #
+    # @param attributes [Hash] The attributes of the prediction.
+    #
+    # @return [void]
+    def reset_attributes(attributes)
+      @id = attributes["id"]
+      @version_id = attributes["version"]
+      @model_name = attributes["model"]
+      @input = attributes["input"]
+      @output = attributes["output"]
+      @error = attributes["error"]
+      @status = attributes["status"]
+      @created_at = attributes["created_at"]
+      @data_removed = attributes["data_removed"]
+      @started_at = attributes["started_at"]
+      @completed_at = attributes["completed_at"]
+      @metrics = attributes["metrics"]
+      @urls = attributes["urls"]
+
+      @model = nil
+      @version = nil
+    end
+  end
+end

data/lib/replicate-client/training.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module ReplicateClient
+  class Training
+    INDEX_PATH = "/trainings"
+
+    module Status
+      STARTING   = "starting"
+      PROCESSING = "processing"
+      SUCCEEDED  = "succeeded"
+      FAILED     = "failed"
+      CANCELED   = "canceled"
+    end
+
+    class << self
+      # List all trainings.
+      #
+      # @yield [ReplicateClient::Training] Yields a training.
+      #
+      # @return [void]
+      def auto_paging_each(&block)
+        cursor = nil
+
+        loop do
+          url_params = cursor ? "?cursor=#{cursor}" : ""
+          attributes = ReplicateClient.client.get("#{INDEX_PATH}#{url_params}")
+
+          trainings = attributes["results"].map { |training| new(training) }
+
+          trainings.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 training.
+      #
+      # @param owner [String] The owner of the model.
+      # @param name [String] The name of the model.
+      # @param version [ReplicateClient::Version, String] The version of the model to train.
+      # @param destination [ReplicateClient::Model, String] The destination model instance or string in "owner/name"
+      # format.
+      # @param input [Hash] The input data for the training.
+      # @param webhook [String, nil] A URL to receive webhook notifications.
+      # @param webhook_events_filter [Array, nil] The events to trigger webhook requests.
+      #
+      # @return [ReplicateClient::Training]
+      def create!(owner:, name:, version:, destination:, input:, webhook: nil, webhook_events_filter: nil)
+        destination_str = destination.is_a?(ReplicateClient::Model) ? destination.full_name : destination
+        version_id = version.is_a?(ReplicateClient::Model::Version) ? version.id : version
+
+        path = "/models/#{owner}/#{name}/versions/#{version_id}/trainings"
+        body = {
+          destination: destination_str,
+          input: input,
+          webhook: webhook,
+          webhook_events_filter: webhook_events_filter
+        }
+
+        attributes = ReplicateClient.client.post(path, body)
+        new(attributes)
+      end
+
+      # Create a new training for a specific model.
+      #
+      # @param model [ReplicateClient::Model, String] The model instance or a string representing the model ID.
+      # @param destination [ReplicateClient::Model, String] The destination model or full name in "owner/name" format.
+      # @param input [Hash] The input data for the training.
+      # @param webhook [String, nil] A URL to receive webhook notifications.
+      # @param webhook_events_filter [Array, nil] The events to trigger webhook requests.
+      #
+      # @return [ReplicateClient::Training]
+      def create_for_model!(model:, destination:, input:, webhook: nil, webhook_events_filter: nil)
+        model_instance = model.is_a?(ReplicateClient::Model) ? model : ReplicateClient::Model.find(model)
+        raise ArgumentError, "Invalid model" unless model_instance
+
+        create!(
+          owner: model_instance.owner,
+          name: model_instance.name,
+          version: model_instance.version_id,
+          destination: destination,
+          input: input,
+          webhook: webhook,
+          webhook_events_filter: webhook_events_filter
+        )
+      end
+
+      # Find a training by id.
+      #
+      # @param id [String] The id of the training.
+      #
+      # @return [ReplicateClient::Training]
+      def find(id)
+        path = build_path(id: id)
+        attributes = ReplicateClient.client.get(path)
+        new(attributes)
+      end
+
+      # Cancel a training.
+      #
+      # @param id [String] The id of the training.
+      #
+      # @return [void]
+      def cancel!(id)
+        path = "#{build_path(id: id)}/cancel"
+        ReplicateClient.client.post(path)
+      end
+
+      # Build the path for a specific training.
+      #
+      # @param id [String] The id of the training.
+      #
+      # @return [String]
+      def build_path(id:)
+        "#{INDEX_PATH}/#{id}"
+      end
+    end
+
+    # The unique identifier of the training.
+    #
+    # @return [String]
+    attr_accessor :id
+
+    # The full model name in the format "owner/name".
+    #
+    # @return [String]
+    attr_accessor :model
+
+    # The version ID of the model being trained.
+    #
+    # @return [String]
+    attr_accessor :version
+
+    # The input data provided for the training.
+    #
+    # @return [Hash]
+    attr_accessor :input
+
+    # The current status of the training.
+    # Possible values: "starting", "processing", "succeeded", "failed", "canceled".
+    #
+    # @return [String]
+    attr_accessor :status
+
+    # The timestamp when the training was created.
+    #
+    # @return [String]
+    attr_accessor :created_at
+
+    # The timestamp when the training was completed.
+    #
+    # @return [String, nil]
+    attr_accessor :completed_at
+
+    # The logs generated during the training process.
+    #
+    # @return [String]
+    attr_accessor :logs
+
+    # The error message, if any, encountered during the training process.
+    #
+    # @return [String, nil]
+    attr_accessor :error
+
+    # URLs related to the training, such as those for retrieving or canceling it.
+    #
+    # @return [Hash]
+    attr_accessor :urls
+
+    # Initialize a new training instance.
+    #
+    # @param attributes [Hash] The attributes of the training.
+    #
+    # @return [ReplicateClient::Training]
+    def initialize(attributes)
+      reset_attributes(attributes)
+    end
+
+    # Check if the training is starting.
+    #
+    # @return [Boolean]
+    def starting?
+      status == Status::STARTING
+    end
+
+    # Check if the training is processing.
+    #
+    # @return [Boolean]
+    def processing?
+      status == Status::PROCESSING
+    end
+
+    # Check if the training has succeeded.
+    #
+    # @return [Boolean]
+    def succeeded?
+      status == Status::SUCCEEDED
+    end
+
+    # Check if the training has failed.
+    #
+    # @return [Boolean]
+    def failed?
+      status == Status::FAILED
+    end
+
+    # Check if the training was canceled.
+    #
+    # @return [Boolean]
+    def canceled?
+      status == Status::CANCELED
+    end
+
+    # Cancel the training.
+    #
+    # @return [void]
+    def cancel!
+      ReplicateClient::Training.cancel!(id)
+    end
+
+    # Reload the training.
+    #
+    # @return [void]
+    def reload!
+      attributes = ReplicateClient.client.get(Training.build_path(id: id))
+      reset_attributes(attributes)
+    end
+
+    private
+
+    # Set the attributes of the training.
+    #
+    # @param attributes [Hash] The attributes of the training.
+    #
+    # @return [void]
+    def reset_attributes(attributes)
+      @id = attributes["id"]
+      @model = attributes["model"]
+      @version = attributes["version"]
+      @input = attributes["input"]
+      @status = attributes["status"]
+      @created_at = attributes["created_at"]
+      @completed_at = attributes["completed_at"]
+      @logs = attributes["logs"]
+      @error = attributes["error"]
+      @urls = attributes["urls"]
+    end
+  end
+end

data/lib/replicate-client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ReplicateClient
+  VERSION = "0.1.0"
+end

data/lib/replicate-client.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "time"
+
+require_relative "replicate-client/client"
+require_relative "replicate-client/prediction"
+require_relative "replicate-client/version"
+require_relative "replicate-client/model"
+require_relative "replicate-client/hardware"
+require_relative "replicate-client/training"
+require_relative "replicate-client/deployment"
+
+module ReplicateClient
+  class Error < StandardError; end
+  class UnauthorizedError < Error; end
+  class NotFoundError < Error; end
+  class ServerError < Error; end
+  class ConfigurationError < Error; end
+  class ForbiddenError < Error; end
+
+  class Configuration
+    DEFAULT_URI_BASE = "https://api.replicate.com/v1"
+    DEFAULT_REQUEST_TIMEOUT = 120
+
+    # The access token for the API.
+    #
+    # @return [String]
+    attr_accessor :access_token
+
+    # The base URI for the API.
+    #
+    # @return [String]
+    attr_accessor :uri_base
+
+    # The request timeout in seconds.
+    #
+    # @return [Integer]
+    attr_accessor :request_timeout
+
+    # The URL to send webhook events to.
+    #
+    # @return [String]
+    attr_accessor :webhook_url
+
+    # Initialize the configuration.
+    #
+    # @return [ReplicateClient::Configuration]
+    def initialize
+      @access_token = nil
+      @webhook_url = nil
+      @uri_base = DEFAULT_URI_BASE
+      @request_timeout = DEFAULT_REQUEST_TIMEOUT
+    end
+  end
+
+  class << self
+    # The configuration for the client.
+    #
+    # @return [ReplicateClient::Configuration]
+    attr_accessor :configuration
+
+    # Configure the client.
+    #
+    # @yield [ReplicateClient::Configuration] The configuration for the client.
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    # The client for the API.
+    #
+    # @return [ReplicateClient::Client]
+    def client
+      @client ||= Client.new(configuration)
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: replicate-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dylan Player
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description:
+email:
+- dylan@851.sh
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/replicate-client.rb
+- lib/replicate-client/client.rb
+- lib/replicate-client/deployment.rb
+- lib/replicate-client/hardware.rb
+- lib/replicate-client/model.rb
+- lib/replicate-client/model/version.rb
+- lib/replicate-client/prediction.rb
+- lib/replicate-client/training.rb
+- lib/replicate-client/version.rb
+homepage: https://github.com/851-labs/replicate
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/851-labs/replicate
+  source_code_uri: https://github.com/851-labs/replicate
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Ruby client for Replicate API.
+test_files: []