openlayer 0.3.0 → 0.4.0

data/rbi/openlayer/models/projects/test_update_response.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Openlayer
+  module Models
+    module Projects
+      class TestUpdateResponse < Openlayer::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Openlayer::Models::Projects::TestUpdateResponse,
+              Openlayer::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :task_result_id
+
+        sig { params(task_result_id: String).void }
+        attr_writer :task_result_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :task_result_url
+
+        sig { params(task_result_url: String).void }
+        attr_writer :task_result_url
+
+        sig do
+          params(task_result_id: String, task_result_url: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(task_result_id: nil, task_result_url: nil)
+        end
+
+        sig do
+          override.returns({ task_result_id: String, task_result_url: String })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/models/storage/presigned_url_create_params.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Openlayer
+  module Models
+    module Storage
+      class PresignedURLCreateParams < Openlayer::Internal::Type::BaseModel
+        extend Openlayer::Internal::Type::RequestParameters::Converter
+        include Openlayer::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Openlayer::Storage::PresignedURLCreateParams,
+              Openlayer::Internal::AnyHash
+            )
+          end
+
+        # The name of the object.
+        sig { returns(String) }
+        attr_accessor :object_name
+
+        sig do
+          params(
+            object_name: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The name of the object.
+          object_name:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            { object_name: String, request_options: Openlayer::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/models/storage/presigned_url_create_response.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module Openlayer
+  module Models
+    module Storage
+      class PresignedURLCreateResponse < Openlayer::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Openlayer::Models::Storage::PresignedURLCreateResponse,
+              Openlayer::Internal::AnyHash
+            )
+          end
+
+        # The storage URI to send back to the backend after the upload was completed.
+        sig { returns(String) }
+        attr_accessor :storage_uri
+
+        # The presigned url.
+        sig { returns(String) }
+        attr_accessor :url
+
+        # Fields to include in the body of the upload. Only needed by s3
+        sig { returns(T.nilable(T.anything)) }
+        attr_reader :fields
+
+        sig { params(fields: T.anything).void }
+        attr_writer :fields
+
+        sig do
+          params(storage_uri: String, url: String, fields: T.anything).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The storage URI to send back to the backend after the upload was completed.
+          storage_uri:,
+          # The presigned url.
+          url:,
+          # Fields to include in the body of the upload. Only needed by s3
+          fields: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { storage_uri: String, url: String, fields: T.anything }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/models.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Openlayer
+  CommitRetrieveParams = Openlayer::Models::CommitRetrieveParams
+
+  Commits = Openlayer::Models::Commits
+
+  InferencePipelineDeleteParams =
+    Openlayer::Models::InferencePipelineDeleteParams
+
+  InferencePipelineRetrieveParams =
+    Openlayer::Models::InferencePipelineRetrieveParams
+
+  InferencePipelines = Openlayer::Models::InferencePipelines
+
+  InferencePipelineUpdateParams =
+    Openlayer::Models::InferencePipelineUpdateParams
+
+  ProjectCreateParams = Openlayer::Models::ProjectCreateParams
+
+  ProjectListParams = Openlayer::Models::ProjectListParams
+
+  Projects = Openlayer::Models::Projects
+
+  Storage = Openlayer::Models::Storage
+end

data/rbi/openlayer/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Openlayer
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Openlayer::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Openlayer::RequestOptions, Openlayer::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Openlayer::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Openlayer::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/openlayer/resources/commits/test_results.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Commits
+      class TestResults
+        # List the test results for a project commit (project version).
+        sig do
+          params(
+            project_version_id: String,
+            include_archived: T::Boolean,
+            page: Integer,
+            per_page: Integer,
+            status: Openlayer::Commits::TestResultListParams::Status::OrSymbol,
+            type: Openlayer::Commits::TestResultListParams::Type::OrSymbol,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Commits::TestResultListResponse)
+        end
+        def list(
+          # The project version (commit) id.
+          project_version_id,
+          # Filter for archived tests.
+          include_archived: nil,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          # Filter list of test results by status. Available statuses are `running`,
+          # `passing`, `failing`, `skipped`, and `error`.
+          status: nil,
+          # Filter objects by test type. Available types are `integrity`, `consistency`,
+          # `performance`, `fairness`, and `robustness`.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/commits.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Commits
+      sig { returns(Openlayer::Resources::Commits::TestResults) }
+      attr_reader :test_results
+
+      # Retrieve a project version (commit) by its id.
+      sig do
+        params(
+          project_version_id: String,
+          request_options: Openlayer::RequestOptions::OrHash
+        ).returns(Openlayer::Models::CommitRetrieveResponse)
+      end
+      def retrieve(
+        # The project version (commit) id.
+        project_version_id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Openlayer::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/inference_pipelines/data.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class InferencePipelines
+      class Data
+        # Publish an inference data point to an inference pipeline.
+        sig do
+          params(
+            inference_pipeline_id: String,
+            config:
+              T.any(
+                Openlayer::InferencePipelines::DataStreamParams::Config::LlmData::OrHash,
+                Openlayer::InferencePipelines::DataStreamParams::Config::TabularClassificationData::OrHash,
+                Openlayer::InferencePipelines::DataStreamParams::Config::TabularRegressionData::OrHash,
+                Openlayer::InferencePipelines::DataStreamParams::Config::TextClassificationData::OrHash
+              ),
+            rows: T::Array[T::Hash[Symbol, T.anything]],
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::InferencePipelines::DataStreamResponse)
+        end
+        def stream(
+          # The inference pipeline id (a UUID).
+          inference_pipeline_id,
+          # Configuration for the data stream. Depends on your **Openlayer project task
+          # type**.
+          config:,
+          # A list of inference data points with inputs and outputs
+          rows:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/inference_pipelines/rows.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class InferencePipelines
+      class Rows
+        # Update an inference data point in an inference pipeline.
+        sig do
+          params(
+            inference_pipeline_id: String,
+            inference_id: String,
+            row: T.anything,
+            config:
+              T.nilable(
+                Openlayer::InferencePipelines::RowUpdateParams::Config::OrHash
+              ),
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::InferencePipelines::RowUpdateResponse)
+        end
+        def update(
+          # Path param: The inference pipeline id (a UUID).
+          inference_pipeline_id,
+          # Query param: Specify the inference id as a query param.
+          inference_id:,
+          # Body param:
+          row:,
+          # Body param:
+          config: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/inference_pipelines/test_results.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class InferencePipelines
+      class TestResults
+        # List the latest test results for an inference pipeline.
+        sig do
+          params(
+            inference_pipeline_id: String,
+            page: Integer,
+            per_page: Integer,
+            status:
+              Openlayer::InferencePipelines::TestResultListParams::Status::OrSymbol,
+            type:
+              Openlayer::InferencePipelines::TestResultListParams::Type::OrSymbol,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(
+            Openlayer::Models::InferencePipelines::TestResultListResponse
+          )
+        end
+        def list(
+          # The inference pipeline id (a UUID).
+          inference_pipeline_id,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          # Filter list of test results by status. Available statuses are `running`,
+          # `passing`, `failing`, `skipped`, and `error`.
+          status: nil,
+          # Filter objects by test type. Available types are `integrity`, `consistency`,
+          # `performance`, `fairness`, and `robustness`.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/inference_pipelines.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class InferencePipelines
+      sig { returns(Openlayer::Resources::InferencePipelines::Data) }
+      attr_reader :data
+
+      sig { returns(Openlayer::Resources::InferencePipelines::Rows) }
+      attr_reader :rows
+
+      sig { returns(Openlayer::Resources::InferencePipelines::TestResults) }
+      attr_reader :test_results
+
+      # Retrieve inference pipeline.
+      sig do
+        params(
+          inference_pipeline_id: String,
+          expand:
+            T::Array[
+              Openlayer::InferencePipelineRetrieveParams::Expand::OrSymbol
+            ],
+          request_options: Openlayer::RequestOptions::OrHash
+        ).returns(Openlayer::Models::InferencePipelineRetrieveResponse)
+      end
+      def retrieve(
+        # The inference pipeline id (a UUID).
+        inference_pipeline_id,
+        # Expand specific nested objects.
+        expand: nil,
+        request_options: {}
+      )
+      end
+
+      # Update inference pipeline.
+      sig do
+        params(
+          inference_pipeline_id: String,
+          description: T.nilable(String),
+          name: String,
+          reference_dataset_uri: T.nilable(String),
+          request_options: Openlayer::RequestOptions::OrHash
+        ).returns(Openlayer::Models::InferencePipelineUpdateResponse)
+      end
+      def update(
+        # The inference pipeline id (a UUID).
+        inference_pipeline_id,
+        # The inference pipeline description.
+        description: nil,
+        # The inference pipeline name.
+        name: nil,
+        # The storage uri of your reference dataset. We recommend using the Python SDK or
+        # the UI to handle your reference dataset updates.
+        reference_dataset_uri: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete inference pipeline.
+      sig do
+        params(
+          inference_pipeline_id: String,
+          request_options: Openlayer::RequestOptions::OrHash
+        ).void
+      end
+      def delete(
+        # The inference pipeline id (a UUID).
+        inference_pipeline_id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Openlayer::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/projects/commits.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Projects
+      class Commits
+        # Create a new commit (project version) in a project.
+        sig do
+          params(
+            project_id: String,
+            commit: Openlayer::Projects::CommitCreateParams::Commit::OrHash,
+            storage_uri: String,
+            archived: T.nilable(T::Boolean),
+            deployment_status: String,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Projects::CommitCreateResponse)
+        end
+        def create(
+          # The project id.
+          project_id,
+          # The details of a commit (project version).
+          commit:,
+          # The storage URI where the commit bundle is stored.
+          storage_uri:,
+          # Whether the commit is archived.
+          archived: nil,
+          # The deployment status associated with the commit's model.
+          deployment_status: nil,
+          request_options: {}
+        )
+        end
+
+        # List the commits (project versions) in a project.
+        sig do
+          params(
+            project_id: String,
+            page: Integer,
+            per_page: Integer,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Projects::CommitListResponse)
+        end
+        def list(
+          # The project id.
+          project_id,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/resources/projects/inference_pipelines.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Projects
+      class InferencePipelines
+        # Create an inference pipeline in a project.
+        sig do
+          params(
+            project_id: String,
+            description: T.nilable(String),
+            name: String,
+            project:
+              T.nilable(
+                Openlayer::Projects::InferencePipelineCreateParams::Project::OrHash
+              ),
+            workspace:
+              T.nilable(
+                Openlayer::Projects::InferencePipelineCreateParams::Workspace::OrHash
+              ),
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(
+            Openlayer::Models::Projects::InferencePipelineCreateResponse
+          )
+        end
+        def create(
+          # The project id.
+          project_id,
+          # The inference pipeline description.
+          description:,
+          # The inference pipeline name.
+          name:,
+          project: nil,
+          workspace: nil,
+          request_options: {}
+        )
+        end
+
+        # List the inference pipelines in a project.
+        sig do
+          params(
+            project_id: String,
+            name: String,
+            page: Integer,
+            per_page: Integer,
+            request_options: Openlayer::RequestOptions::OrHash
+          ).returns(Openlayer::Models::Projects::InferencePipelineListResponse)
+        end
+        def list(
+          # The project id.
+          project_id,
+          # Filter list of items by name.
+          name: nil,
+          # The page to return in a paginated query.
+          page: nil,
+          # Maximum number of items to return per page.
+          per_page: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Openlayer::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end