From 8295c08689e01d33e8b21fd93028da4df3e8269f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:14:38 +0000 Subject: [PATCH 1/2] feat: Cid/fetching endpoints --- .stats.yml | 6 +- lib/openlayer.rb | 2 + lib/openlayer/models.rb | 2 + ...rence_pipeline_retrieve_sessions_params.rb | 278 +++++++++ ...nce_pipeline_retrieve_sessions_response.rb | 121 ++++ ...nference_pipeline_retrieve_users_params.rb | 243 +++++++- .../resources/inference_pipelines.rb | 86 ++- rbi/openlayer/models.rbi | 3 + ...ence_pipeline_retrieve_sessions_params.rbi | 529 ++++++++++++++++++ ...ce_pipeline_retrieve_sessions_response.rbi | 175 ++++++ ...ference_pipeline_retrieve_users_params.rbi | 463 +++++++++++++++ .../resources/inference_pipelines.rbi | 103 +++- sig/openlayer/models.rbs | 2 + ...ence_pipeline_retrieve_sessions_params.rbs | 238 ++++++++ ...ce_pipeline_retrieve_sessions_response.rbs | 92 +++ ...ference_pipeline_retrieve_users_params.rbs | 204 ++++++- .../resources/inference_pipelines.rbs | 25 + .../resources/inference_pipelines_test.rb | 14 + 18 files changed, 2571 insertions(+), 15 deletions(-) create mode 100644 lib/openlayer/models/inference_pipeline_retrieve_sessions_params.rb create mode 100644 lib/openlayer/models/inference_pipeline_retrieve_sessions_response.rb create mode 100644 rbi/openlayer/models/inference_pipeline_retrieve_sessions_params.rbi create mode 100644 rbi/openlayer/models/inference_pipeline_retrieve_sessions_response.rbi create mode 100644 sig/openlayer/models/inference_pipeline_retrieve_sessions_params.rbs create mode 100644 sig/openlayer/models/inference_pipeline_retrieve_sessions_response.rbs diff --git a/.stats.yml b/.stats.yml index a47d0ba..9f47e6b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,3 +1,3 @@ -configured_endpoints: 28 -openapi_spec_hash: 5f7962599290c70cb47c05c3b29fdbd8 -config_hash: f1c0c034bd832878eb47146c51afdd55 +configured_endpoints: 29 +openapi_spec_hash: 20caa671b1b1a87c0a5cb6ebd7e4b064 +config_hash: aaf12ae1da71c62ca5195fc2b66f657c diff --git a/lib/openlayer.rb b/lib/openlayer.rb index 777f7f7..fe577ce 100644 --- a/lib/openlayer.rb +++ b/lib/openlayer.rb @@ -59,6 +59,8 @@ require_relative "openlayer/models/inference_pipeline_delete_params" require_relative "openlayer/models/inference_pipeline_retrieve_params" require_relative "openlayer/models/inference_pipeline_retrieve_response" +require_relative "openlayer/models/inference_pipeline_retrieve_sessions_params" +require_relative "openlayer/models/inference_pipeline_retrieve_sessions_response" require_relative "openlayer/models/inference_pipeline_retrieve_users_params" require_relative "openlayer/models/inference_pipeline_retrieve_users_response" require_relative "openlayer/models/inference_pipelines/data_stream_params" diff --git a/lib/openlayer/models.rb b/lib/openlayer/models.rb index 7f7034a..52340ad 100644 --- a/lib/openlayer/models.rb +++ b/lib/openlayer/models.rb @@ -47,6 +47,8 @@ module Openlayer InferencePipelineRetrieveParams = Openlayer::Models::InferencePipelineRetrieveParams + InferencePipelineRetrieveSessionsParams = Openlayer::Models::InferencePipelineRetrieveSessionsParams + InferencePipelineRetrieveUsersParams = Openlayer::Models::InferencePipelineRetrieveUsersParams InferencePipelines = Openlayer::Models::InferencePipelines diff --git a/lib/openlayer/models/inference_pipeline_retrieve_sessions_params.rb b/lib/openlayer/models/inference_pipeline_retrieve_sessions_params.rb new file mode 100644 index 0000000..a0c21e7 --- /dev/null +++ b/lib/openlayer/models/inference_pipeline_retrieve_sessions_params.rb @@ -0,0 +1,278 @@ +# frozen_string_literal: true + +module Openlayer + module Models + # @see Openlayer::Resources::InferencePipelines#retrieve_sessions + class InferencePipelineRetrieveSessionsParams < Openlayer::Internal::Type::BaseModel + extend Openlayer::Internal::Type::RequestParameters::Converter + include Openlayer::Internal::Type::RequestParameters + + # @!attribute inference_pipeline_id + # + # @return [String] + required :inference_pipeline_id, String + + # @!attribute asc + # Whether or not to sort on the sortColumn in ascending order. + # + # @return [Boolean, nil] + optional :asc, Openlayer::Internal::Type::Boolean + + # @!attribute page + # The page to return in a paginated query. + # + # @return [Integer, nil] + optional :page, Integer + + # @!attribute per_page + # Maximum number of items to return per page. + # + # @return [Integer, nil] + optional :per_page, Integer + + # @!attribute sort_column + # Name of the column to sort on + # + # @return [String, nil] + optional :sort_column, String + + # @!attribute column_filters + # + # @return [Array, nil] + optional :column_filters, + -> { + Openlayer::Internal::Type::ArrayOf[union: Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter] + }, + api_name: :columnFilters, + nil?: true + + # @!attribute exclude_row_id_list + # + # @return [Array, nil] + optional :exclude_row_id_list, + Openlayer::Internal::Type::ArrayOf[Integer], + api_name: :excludeRowIdList, + nil?: true + + # @!attribute not_search_query_and + # + # @return [Array, nil] + optional :not_search_query_and, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :notSearchQueryAnd, + nil?: true + + # @!attribute not_search_query_or + # + # @return [Array, nil] + optional :not_search_query_or, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :notSearchQueryOr, + nil?: true + + # @!attribute row_id_list + # + # @return [Array, nil] + optional :row_id_list, Openlayer::Internal::Type::ArrayOf[Integer], api_name: :rowIdList, nil?: true + + # @!attribute search_query_and + # + # @return [Array, nil] + optional :search_query_and, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :searchQueryAnd, + nil?: true + + # @!attribute search_query_or + # + # @return [Array, nil] + optional :search_query_or, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :searchQueryOr, + nil?: true + + # @!method initialize(inference_pipeline_id:, asc: nil, page: nil, per_page: nil, sort_column: nil, column_filters: nil, exclude_row_id_list: nil, not_search_query_and: nil, not_search_query_or: nil, row_id_list: nil, search_query_and: nil, search_query_or: nil, request_options: {}) + # @param inference_pipeline_id [String] + # + # @param asc [Boolean] Whether or not to sort on the sortColumn in ascending order. + # + # @param page [Integer] The page to return in a paginated query. + # + # @param per_page [Integer] Maximum number of items to return per page. + # + # @param sort_column [String] Name of the column to sort on + # + # @param column_filters [Array, nil] + # + # @param exclude_row_id_list [Array, nil] + # + # @param not_search_query_and [Array, nil] + # + # @param not_search_query_or [Array, nil] + # + # @param row_id_list [Array, nil] + # + # @param search_query_and [Array, nil] + # + # @param search_query_or [Array, nil] + # + # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}] + + module ColumnFilter + extend Openlayer::Internal::Type::Union + + variant -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter } + + variant -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter } + + variant -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter } + + class SetColumnFilter < Openlayer::Internal::Type::BaseModel + # @!attribute measurement + # The name of the column. + # + # @return [String] + required :measurement, String + + # @!attribute operator + # + # @return [Symbol, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator] + required :operator, + enum: -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator } + + # @!attribute value + # + # @return [Array] + required :value, + -> { Openlayer::Internal::Type::ArrayOf[union: Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Value] } + + # @!method initialize(measurement:, operator:, value:) + # @param measurement [String] The name of the column. + # + # @param operator [Symbol, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator] + # + # @param value [Array] + + # @see Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter#operator + module Operator + extend Openlayer::Internal::Type::Enum + + CONTAINS_NONE = :contains_none + CONTAINS_ANY = :contains_any + CONTAINS_ALL = :contains_all + ONE_OF = :one_of + NONE_OF = :none_of + + # @!method self.values + # @return [Array] + end + + module Value + extend Openlayer::Internal::Type::Union + + variant String + + variant Float + + # @!method self.variants + # @return [Array(String, Float)] + end + end + + class NumericColumnFilter < Openlayer::Internal::Type::BaseModel + # @!attribute measurement + # The name of the column. + # + # @return [String] + required :measurement, String + + # @!attribute operator + # + # @return [Symbol, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator] + required :operator, + enum: -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator } + + # @!attribute value + # + # @return [Float, nil] + required :value, Float, nil?: true + + # @!method initialize(measurement:, operator:, value:) + # @param measurement [String] The name of the column. + # + # @param operator [Symbol, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator] + # + # @param value [Float, nil] + + # @see Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter#operator + module Operator + extend Openlayer::Internal::Type::Enum + + GREATER = :> + GREATER_OR_EQUALS = :">=" + IS = :is + LESS = :< + LESS_OR_EQUALS = :"<=" + NOT_EQUALS = :"!=" + + # @!method self.values + # @return [Array] + end + end + + class StringColumnFilter < Openlayer::Internal::Type::BaseModel + # @!attribute measurement + # The name of the column. + # + # @return [String] + required :measurement, String + + # @!attribute operator + # + # @return [Symbol, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator] + required :operator, + enum: -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator } + + # @!attribute value + # + # @return [String, Boolean] + required :value, + union: -> { Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Value } + + # @!method initialize(measurement:, operator:, value:) + # @param measurement [String] The name of the column. + # + # @param operator [Symbol, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator] + # + # @param value [String, Boolean] + + # @see Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter#operator + module Operator + extend Openlayer::Internal::Type::Enum + + IS = :is + NOT_EQUALS = :"!=" + + # @!method self.values + # @return [Array] + end + + # @see Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter#value + module Value + extend Openlayer::Internal::Type::Union + + variant String + + variant Openlayer::Internal::Type::Boolean + + # @!method self.variants + # @return [Array(String, Boolean)] + end + end + + # @!method self.variants + # @return [Array(Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter, Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter)] + end + end + end +end diff --git a/lib/openlayer/models/inference_pipeline_retrieve_sessions_response.rb b/lib/openlayer/models/inference_pipeline_retrieve_sessions_response.rb new file mode 100644 index 0000000..dd58881 --- /dev/null +++ b/lib/openlayer/models/inference_pipeline_retrieve_sessions_response.rb @@ -0,0 +1,121 @@ +# frozen_string_literal: true + +module Openlayer + module Models + # @see Openlayer::Resources::InferencePipelines#retrieve_sessions + class InferencePipelineRetrieveSessionsResponse < Openlayer::Internal::Type::BaseModel + # @!attribute items + # Array of session aggregation data + # + # @return [Array] + required :items, + -> { Openlayer::Internal::Type::ArrayOf[Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item] } + + # @!method initialize(items:) + # @param items [Array] Array of session aggregation data + + class Item < Openlayer::Internal::Type::BaseModel + # @!attribute id + # The unique session identifier + # + # @return [String] + required :id, String + + # @!attribute cost + # Total cost for the session + # + # @return [Float] + required :cost, Float + + # @!attribute date_created + # Latest/most recent timestamp in the session + # + # @return [Time] + required :date_created, Time, api_name: :dateCreated + + # @!attribute date_of_first_record + # Timestamp of the first request in the session + # + # @return [Time] + required :date_of_first_record, Time, api_name: :dateOfFirstRecord + + # @!attribute date_of_last_record + # Timestamp of the last request in the session + # + # @return [Time] + required :date_of_last_record, Time, api_name: :dateOfLastRecord + + # @!attribute duration + # Duration between first and last request (in milliseconds) + # + # @return [Float] + required :duration, Float + + # @!attribute first_record + # The complete first record in the session + # + # @return [Hash{Symbol=>Object}] + required :first_record, + Openlayer::Internal::Type::HashOf[Openlayer::Internal::Type::Unknown], + api_name: :firstRecord + + # @!attribute last_record + # The complete last record in the session + # + # @return [Hash{Symbol=>Object}] + required :last_record, + Openlayer::Internal::Type::HashOf[Openlayer::Internal::Type::Unknown], + api_name: :lastRecord + + # @!attribute latency + # Total latency for the session (in milliseconds) + # + # @return [Float] + required :latency, Float + + # @!attribute records + # Total number of records/traces in the session + # + # @return [Integer] + required :records, Integer + + # @!attribute tokens + # Total token count for the session + # + # @return [Float] + required :tokens, Float + + # @!attribute user_ids + # List of unique user IDs that participated in this session + # + # @return [Array] + required :user_ids, Openlayer::Internal::Type::ArrayOf[String], api_name: :userIds + + # @!method initialize(id:, cost:, date_created:, date_of_first_record:, date_of_last_record:, duration:, first_record:, last_record:, latency:, records:, tokens:, user_ids:) + # @param id [String] The unique session identifier + # + # @param cost [Float] Total cost for the session + # + # @param date_created [Time] Latest/most recent timestamp in the session + # + # @param date_of_first_record [Time] Timestamp of the first request in the session + # + # @param date_of_last_record [Time] Timestamp of the last request in the session + # + # @param duration [Float] Duration between first and last request (in milliseconds) + # + # @param first_record [Hash{Symbol=>Object}] The complete first record in the session + # + # @param last_record [Hash{Symbol=>Object}] The complete last record in the session + # + # @param latency [Float] Total latency for the session (in milliseconds) + # + # @param records [Integer] Total number of records/traces in the session + # + # @param tokens [Float] Total token count for the session + # + # @param user_ids [Array] List of unique user IDs that participated in this session + end + end + end +end diff --git a/lib/openlayer/models/inference_pipeline_retrieve_users_params.rb b/lib/openlayer/models/inference_pipeline_retrieve_users_params.rb index 37f38b9..2eddaa8 100644 --- a/lib/openlayer/models/inference_pipeline_retrieve_users_params.rb +++ b/lib/openlayer/models/inference_pipeline_retrieve_users_params.rb @@ -12,6 +12,12 @@ class InferencePipelineRetrieveUsersParams < Openlayer::Internal::Type::BaseMode # @return [String] required :inference_pipeline_id, String + # @!attribute asc + # Whether or not to sort on the sortColumn in ascending order. + # + # @return [Boolean, nil] + optional :asc, Openlayer::Internal::Type::Boolean + # @!attribute page # The page to return in a paginated query. # @@ -24,14 +30,249 @@ class InferencePipelineRetrieveUsersParams < Openlayer::Internal::Type::BaseMode # @return [Integer, nil] optional :per_page, Integer - # @!method initialize(inference_pipeline_id:, page: nil, per_page: nil, request_options: {}) + # @!attribute sort_column + # Name of the column to sort on + # + # @return [String, nil] + optional :sort_column, String + + # @!attribute column_filters + # + # @return [Array, nil] + optional :column_filters, + -> { + Openlayer::Internal::Type::ArrayOf[union: Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter] + }, + api_name: :columnFilters, + nil?: true + + # @!attribute exclude_row_id_list + # + # @return [Array, nil] + optional :exclude_row_id_list, + Openlayer::Internal::Type::ArrayOf[Integer], + api_name: :excludeRowIdList, + nil?: true + + # @!attribute not_search_query_and + # + # @return [Array, nil] + optional :not_search_query_and, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :notSearchQueryAnd, + nil?: true + + # @!attribute not_search_query_or + # + # @return [Array, nil] + optional :not_search_query_or, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :notSearchQueryOr, + nil?: true + + # @!attribute row_id_list + # + # @return [Array, nil] + optional :row_id_list, Openlayer::Internal::Type::ArrayOf[Integer], api_name: :rowIdList, nil?: true + + # @!attribute search_query_and + # + # @return [Array, nil] + optional :search_query_and, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :searchQueryAnd, + nil?: true + + # @!attribute search_query_or + # + # @return [Array, nil] + optional :search_query_or, + Openlayer::Internal::Type::ArrayOf[String], + api_name: :searchQueryOr, + nil?: true + + # @!method initialize(inference_pipeline_id:, asc: nil, page: nil, per_page: nil, sort_column: nil, column_filters: nil, exclude_row_id_list: nil, not_search_query_and: nil, not_search_query_or: nil, row_id_list: nil, search_query_and: nil, search_query_or: nil, request_options: {}) # @param inference_pipeline_id [String] # + # @param asc [Boolean] Whether or not to sort on the sortColumn in ascending order. + # # @param page [Integer] The page to return in a paginated query. # # @param per_page [Integer] Maximum number of items to return per page. # + # @param sort_column [String] Name of the column to sort on + # + # @param column_filters [Array, nil] + # + # @param exclude_row_id_list [Array, nil] + # + # @param not_search_query_and [Array, nil] + # + # @param not_search_query_or [Array, nil] + # + # @param row_id_list [Array, nil] + # + # @param search_query_and [Array, nil] + # + # @param search_query_or [Array, nil] + # # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}] + + module ColumnFilter + extend Openlayer::Internal::Type::Union + + variant -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter } + + variant -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter } + + variant -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter } + + class SetColumnFilter < Openlayer::Internal::Type::BaseModel + # @!attribute measurement + # The name of the column. + # + # @return [String] + required :measurement, String + + # @!attribute operator + # + # @return [Symbol, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator] + required :operator, + enum: -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator } + + # @!attribute value + # + # @return [Array] + required :value, + -> { Openlayer::Internal::Type::ArrayOf[union: Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Value] } + + # @!method initialize(measurement:, operator:, value:) + # @param measurement [String] The name of the column. + # + # @param operator [Symbol, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator] + # + # @param value [Array] + + # @see Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter#operator + module Operator + extend Openlayer::Internal::Type::Enum + + CONTAINS_NONE = :contains_none + CONTAINS_ANY = :contains_any + CONTAINS_ALL = :contains_all + ONE_OF = :one_of + NONE_OF = :none_of + + # @!method self.values + # @return [Array] + end + + module Value + extend Openlayer::Internal::Type::Union + + variant String + + variant Float + + # @!method self.variants + # @return [Array(String, Float)] + end + end + + class NumericColumnFilter < Openlayer::Internal::Type::BaseModel + # @!attribute measurement + # The name of the column. + # + # @return [String] + required :measurement, String + + # @!attribute operator + # + # @return [Symbol, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator] + required :operator, + enum: -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator } + + # @!attribute value + # + # @return [Float, nil] + required :value, Float, nil?: true + + # @!method initialize(measurement:, operator:, value:) + # @param measurement [String] The name of the column. + # + # @param operator [Symbol, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator] + # + # @param value [Float, nil] + + # @see Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter#operator + module Operator + extend Openlayer::Internal::Type::Enum + + GREATER = :> + GREATER_OR_EQUALS = :">=" + IS = :is + LESS = :< + LESS_OR_EQUALS = :"<=" + NOT_EQUALS = :"!=" + + # @!method self.values + # @return [Array] + end + end + + class StringColumnFilter < Openlayer::Internal::Type::BaseModel + # @!attribute measurement + # The name of the column. + # + # @return [String] + required :measurement, String + + # @!attribute operator + # + # @return [Symbol, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator] + required :operator, + enum: -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator } + + # @!attribute value + # + # @return [String, Boolean] + required :value, + union: -> { Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Value } + + # @!method initialize(measurement:, operator:, value:) + # @param measurement [String] The name of the column. + # + # @param operator [Symbol, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator] + # + # @param value [String, Boolean] + + # @see Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter#operator + module Operator + extend Openlayer::Internal::Type::Enum + + IS = :is + NOT_EQUALS = :"!=" + + # @!method self.values + # @return [Array] + end + + # @see Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter#value + module Value + extend Openlayer::Internal::Type::Union + + variant String + + variant Openlayer::Internal::Type::Boolean + + # @!method self.variants + # @return [Array(String, Boolean)] + end + end + + # @!method self.variants + # @return [Array(Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter, Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter)] + end end end end diff --git a/lib/openlayer/resources/inference_pipelines.rb b/lib/openlayer/resources/inference_pipelines.rb index d1f9851..45ecb1c 100644 --- a/lib/openlayer/resources/inference_pipelines.rb +++ b/lib/openlayer/resources/inference_pipelines.rb @@ -88,19 +88,89 @@ def delete(inference_pipeline_id, params = {}) ) end + # Get aggregated session data for an inference pipeline with pagination and + # metadata. + # + # Returns a list of sessions for the inference pipeline, including activity + # statistics such as record counts, token usage, cost, latency, and the first and + # last records. + # + # @overload retrieve_sessions(inference_pipeline_id, asc: nil, page: nil, per_page: nil, sort_column: nil, column_filters: nil, exclude_row_id_list: nil, not_search_query_and: nil, not_search_query_or: nil, row_id_list: nil, search_query_and: nil, search_query_or: nil, request_options: {}) + # + # @param inference_pipeline_id [String] Path param: The inference pipeline id (a UUID). + # + # @param asc [Boolean] Query param: Whether or not to sort on the sortColumn in ascending order. + # + # @param page [Integer] Query param: The page to return in a paginated query. + # + # @param per_page [Integer] Query param: Maximum number of items to return per page. + # + # @param sort_column [String] Query param: Name of the column to sort on + # + # @param column_filters [Array, nil] Body param + # + # @param exclude_row_id_list [Array, nil] Body param + # + # @param not_search_query_and [Array, nil] Body param + # + # @param not_search_query_or [Array, nil] Body param + # + # @param row_id_list [Array, nil] Body param + # + # @param search_query_and [Array, nil] Body param + # + # @param search_query_or [Array, nil] Body param + # + # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil] + # + # @return [Openlayer::Models::InferencePipelineRetrieveSessionsResponse] + # + # @see Openlayer::Models::InferencePipelineRetrieveSessionsParams + def retrieve_sessions(inference_pipeline_id, params = {}) + query_params = [:asc, :page, :per_page, :sort_column] + parsed, options = Openlayer::InferencePipelineRetrieveSessionsParams.dump_request(params) + query = Openlayer::Internal::Util.encode_query_params(parsed.slice(*query_params)) + @client.request( + method: :post, + path: ["inference-pipelines/%1$s/sessions", inference_pipeline_id], + query: query.transform_keys(per_page: "perPage", sort_column: "sortColumn"), + body: parsed.except(*query_params), + model: Openlayer::Models::InferencePipelineRetrieveSessionsResponse, + options: options + ) + end + # Get aggregated user data for an inference pipeline with pagination and metadata. # # Returns a list of users who have interacted with the inference pipeline, # including their activity statistics such as session counts, record counts, token # usage, and costs. # - # @overload retrieve_users(inference_pipeline_id, page: nil, per_page: nil, request_options: {}) + # @overload retrieve_users(inference_pipeline_id, asc: nil, page: nil, per_page: nil, sort_column: nil, column_filters: nil, exclude_row_id_list: nil, not_search_query_and: nil, not_search_query_or: nil, row_id_list: nil, search_query_and: nil, search_query_or: nil, request_options: {}) # - # @param inference_pipeline_id [String] The inference pipeline id (a UUID). + # @param inference_pipeline_id [String] Path param: The inference pipeline id (a UUID). + # + # @param asc [Boolean] Query param: Whether or not to sort on the sortColumn in ascending order. + # + # @param page [Integer] Query param: The page to return in a paginated query. + # + # @param per_page [Integer] Query param: Maximum number of items to return per page. # - # @param page [Integer] The page to return in a paginated query. + # @param sort_column [String] Query param: Name of the column to sort on # - # @param per_page [Integer] Maximum number of items to return per page. + # @param column_filters [Array, nil] Body param + # + # @param exclude_row_id_list [Array, nil] Body param + # + # @param not_search_query_and [Array, nil] Body param + # + # @param not_search_query_or [Array, nil] Body param + # + # @param row_id_list [Array, nil] Body param + # + # @param search_query_and [Array, nil] Body param + # + # @param search_query_or [Array, nil] Body param # # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil] # @@ -108,12 +178,14 @@ def delete(inference_pipeline_id, params = {}) # # @see Openlayer::Models::InferencePipelineRetrieveUsersParams def retrieve_users(inference_pipeline_id, params = {}) + query_params = [:asc, :page, :per_page, :sort_column] parsed, options = Openlayer::InferencePipelineRetrieveUsersParams.dump_request(params) - query = Openlayer::Internal::Util.encode_query_params(parsed) + query = Openlayer::Internal::Util.encode_query_params(parsed.slice(*query_params)) @client.request( - method: :get, + method: :post, path: ["inference-pipelines/%1$s/users", inference_pipeline_id], - query: query.transform_keys(per_page: "perPage"), + query: query.transform_keys(per_page: "perPage", sort_column: "sortColumn"), + body: parsed.except(*query_params), model: Openlayer::Models::InferencePipelineRetrieveUsersResponse, options: options ) diff --git a/rbi/openlayer/models.rbi b/rbi/openlayer/models.rbi index 389d0e8..594eeb0 100644 --- a/rbi/openlayer/models.rbi +++ b/rbi/openlayer/models.rbi @@ -11,6 +11,9 @@ module Openlayer InferencePipelineRetrieveParams = Openlayer::Models::InferencePipelineRetrieveParams + InferencePipelineRetrieveSessionsParams = + Openlayer::Models::InferencePipelineRetrieveSessionsParams + InferencePipelineRetrieveUsersParams = Openlayer::Models::InferencePipelineRetrieveUsersParams diff --git a/rbi/openlayer/models/inference_pipeline_retrieve_sessions_params.rbi b/rbi/openlayer/models/inference_pipeline_retrieve_sessions_params.rbi new file mode 100644 index 0000000..796c9c0 --- /dev/null +++ b/rbi/openlayer/models/inference_pipeline_retrieve_sessions_params.rbi @@ -0,0 +1,529 @@ +# typed: strong + +module Openlayer + module Models + class InferencePipelineRetrieveSessionsParams < Openlayer::Internal::Type::BaseModel + extend Openlayer::Internal::Type::RequestParameters::Converter + include Openlayer::Internal::Type::RequestParameters + + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams, + Openlayer::Internal::AnyHash + ) + end + + sig { returns(String) } + attr_accessor :inference_pipeline_id + + # Whether or not to sort on the sortColumn in ascending order. + sig { returns(T.nilable(T::Boolean)) } + attr_reader :asc + + sig { params(asc: T::Boolean).void } + attr_writer :asc + + # The page to return in a paginated query. + sig { returns(T.nilable(Integer)) } + attr_reader :page + + sig { params(page: Integer).void } + attr_writer :page + + # Maximum number of items to return per page. + sig { returns(T.nilable(Integer)) } + attr_reader :per_page + + sig { params(per_page: Integer).void } + attr_writer :per_page + + # Name of the column to sort on + sig { returns(T.nilable(String)) } + attr_reader :sort_column + + sig { params(sort_column: String).void } + attr_writer :sort_column + + sig do + returns( + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter + ) + ] + ) + ) + end + attr_accessor :column_filters + + sig { returns(T.nilable(T::Array[Integer])) } + attr_accessor :exclude_row_id_list + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :not_search_query_and + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :not_search_query_or + + sig { returns(T.nilable(T::Array[Integer])) } + attr_accessor :row_id_list + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :search_query_and + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :search_query_or + + sig do + params( + inference_pipeline_id: String, + asc: T::Boolean, + page: Integer, + per_page: Integer, + sort_column: String, + column_filters: + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::OrHash + ) + ] + ), + exclude_row_id_list: T.nilable(T::Array[Integer]), + not_search_query_and: T.nilable(T::Array[String]), + not_search_query_or: T.nilable(T::Array[String]), + row_id_list: T.nilable(T::Array[Integer]), + search_query_and: T.nilable(T::Array[String]), + search_query_or: T.nilable(T::Array[String]), + request_options: Openlayer::RequestOptions::OrHash + ).returns(T.attached_class) + end + def self.new( + inference_pipeline_id:, + # Whether or not to sort on the sortColumn in ascending order. + asc: nil, + # The page to return in a paginated query. + page: nil, + # Maximum number of items to return per page. + per_page: nil, + # Name of the column to sort on + sort_column: nil, + column_filters: nil, + exclude_row_id_list: nil, + not_search_query_and: nil, + not_search_query_or: nil, + row_id_list: nil, + search_query_and: nil, + search_query_or: nil, + request_options: {} + ) + end + + sig do + override.returns( + { + inference_pipeline_id: String, + asc: T::Boolean, + page: Integer, + per_page: Integer, + sort_column: String, + column_filters: + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter + ) + ] + ), + exclude_row_id_list: T.nilable(T::Array[Integer]), + not_search_query_and: T.nilable(T::Array[String]), + not_search_query_or: T.nilable(T::Array[String]), + row_id_list: T.nilable(T::Array[Integer]), + search_query_and: T.nilable(T::Array[String]), + search_query_or: T.nilable(T::Array[String]), + request_options: Openlayer::RequestOptions + } + ) + end + def to_hash + end + + module ColumnFilter + extend Openlayer::Internal::Type::Union + + Variants = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter + ) + end + + class SetColumnFilter < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter, + Openlayer::Internal::AnyHash + ) + end + + # The name of the column. + sig { returns(String) } + attr_accessor :measurement + + sig do + returns( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::OrSymbol + ) + end + attr_accessor :operator + + sig do + returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + ) + end + attr_accessor :value + + sig do + params( + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::OrSymbol, + value: + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + ).returns(T.attached_class) + end + def self.new( + # The name of the column. + measurement:, + operator:, + value: + ) + end + + sig do + override.returns( + { + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::OrSymbol, + value: + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + } + ) + end + def to_hash + end + + module Operator + extend Openlayer::Internal::Type::Enum + + TaggedSymbol = + T.type_alias do + T.all( + Symbol, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator + ) + end + OrSymbol = T.type_alias { T.any(Symbol, String) } + + CONTAINS_NONE = + T.let( + :contains_none, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + CONTAINS_ANY = + T.let( + :contains_any, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + CONTAINS_ALL = + T.let( + :contains_all, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + ONE_OF = + T.let( + :one_of, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + NONE_OF = + T.let( + :none_of, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ] + ) + end + def self.values + end + end + + module Value + extend Openlayer::Internal::Type::Union + + Variants = T.type_alias { T.any(String, Float) } + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + ) + end + def self.variants + end + end + end + + class NumericColumnFilter < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter, + Openlayer::Internal::AnyHash + ) + end + + # The name of the column. + sig { returns(String) } + attr_accessor :measurement + + sig do + returns( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::OrSymbol + ) + end + attr_accessor :operator + + sig { returns(T.nilable(Float)) } + attr_accessor :value + + sig do + params( + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::OrSymbol, + value: T.nilable(Float) + ).returns(T.attached_class) + end + def self.new( + # The name of the column. + measurement:, + operator:, + value: + ) + end + + sig do + override.returns( + { + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::OrSymbol, + value: T.nilable(Float) + } + ) + end + def to_hash + end + + module Operator + extend Openlayer::Internal::Type::Enum + + TaggedSymbol = + T.type_alias do + T.all( + Symbol, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator + ) + end + OrSymbol = T.type_alias { T.any(Symbol, String) } + + GREATER = + T.let( + :">", + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + GREATER_OR_EQUALS = + T.let( + :">=", + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + IS = + T.let( + :is, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + LESS = + T.let( + :"<", + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + LESS_OR_EQUALS = + T.let( + :"<=", + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + NOT_EQUALS = + T.let( + :"!=", + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ] + ) + end + def self.values + end + end + end + + class StringColumnFilter < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter, + Openlayer::Internal::AnyHash + ) + end + + # The name of the column. + sig { returns(String) } + attr_accessor :measurement + + sig do + returns( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator::OrSymbol + ) + end + attr_accessor :operator + + sig do + returns( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Value::Variants + ) + end + attr_accessor :value + + sig do + params( + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator::OrSymbol, + value: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Value::Variants + ).returns(T.attached_class) + end + def self.new( + # The name of the column. + measurement:, + operator:, + value: + ) + end + + sig do + override.returns( + { + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator::OrSymbol, + value: + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Value::Variants + } + ) + end + def to_hash + end + + module Operator + extend Openlayer::Internal::Type::Enum + + TaggedSymbol = + T.type_alias do + T.all( + Symbol, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator + ) + end + OrSymbol = T.type_alias { T.any(Symbol, String) } + + IS = + T.let( + :is, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator::TaggedSymbol + ) + NOT_EQUALS = + T.let( + :"!=", + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator::TaggedSymbol + ) + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Operator::TaggedSymbol + ] + ) + end + def self.values + end + end + + module Value + extend Openlayer::Internal::Type::Union + + Variants = T.type_alias { T.any(String, T::Boolean) } + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::Value::Variants + ] + ) + end + def self.variants + end + end + end + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::Variants + ] + ) + end + def self.variants + end + end + end + end +end diff --git a/rbi/openlayer/models/inference_pipeline_retrieve_sessions_response.rbi b/rbi/openlayer/models/inference_pipeline_retrieve_sessions_response.rbi new file mode 100644 index 0000000..b902d73 --- /dev/null +++ b/rbi/openlayer/models/inference_pipeline_retrieve_sessions_response.rbi @@ -0,0 +1,175 @@ +# typed: strong + +module Openlayer + module Models + class InferencePipelineRetrieveSessionsResponse < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::Models::InferencePipelineRetrieveSessionsResponse, + Openlayer::Internal::AnyHash + ) + end + + # Array of session aggregation data + sig do + returns( + T::Array[ + Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item + ] + ) + end + attr_accessor :items + + sig do + params( + items: + T::Array[ + Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item::OrHash + ] + ).returns(T.attached_class) + end + def self.new( + # Array of session aggregation data + items: + ) + end + + sig do + override.returns( + { + items: + T::Array[ + Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item + ] + } + ) + end + def to_hash + end + + class Item < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item, + Openlayer::Internal::AnyHash + ) + end + + # The unique session identifier + sig { returns(String) } + attr_accessor :id + + # Total cost for the session + sig { returns(Float) } + attr_accessor :cost + + # Latest/most recent timestamp in the session + sig { returns(Time) } + attr_accessor :date_created + + # Timestamp of the first request in the session + sig { returns(Time) } + attr_accessor :date_of_first_record + + # Timestamp of the last request in the session + sig { returns(Time) } + attr_accessor :date_of_last_record + + # Duration between first and last request (in milliseconds) + sig { returns(Float) } + attr_accessor :duration + + # The complete first record in the session + sig { returns(T::Hash[Symbol, T.anything]) } + attr_accessor :first_record + + # The complete last record in the session + sig { returns(T::Hash[Symbol, T.anything]) } + attr_accessor :last_record + + # Total latency for the session (in milliseconds) + sig { returns(Float) } + attr_accessor :latency + + # Total number of records/traces in the session + sig { returns(Integer) } + attr_accessor :records + + # Total token count for the session + sig { returns(Float) } + attr_accessor :tokens + + # List of unique user IDs that participated in this session + sig { returns(T::Array[String]) } + attr_accessor :user_ids + + sig do + params( + id: String, + cost: Float, + date_created: Time, + date_of_first_record: Time, + date_of_last_record: Time, + duration: Float, + first_record: T::Hash[Symbol, T.anything], + last_record: T::Hash[Symbol, T.anything], + latency: Float, + records: Integer, + tokens: Float, + user_ids: T::Array[String] + ).returns(T.attached_class) + end + def self.new( + # The unique session identifier + id:, + # Total cost for the session + cost:, + # Latest/most recent timestamp in the session + date_created:, + # Timestamp of the first request in the session + date_of_first_record:, + # Timestamp of the last request in the session + date_of_last_record:, + # Duration between first and last request (in milliseconds) + duration:, + # The complete first record in the session + first_record:, + # The complete last record in the session + last_record:, + # Total latency for the session (in milliseconds) + latency:, + # Total number of records/traces in the session + records:, + # Total token count for the session + tokens:, + # List of unique user IDs that participated in this session + user_ids: + ) + end + + sig do + override.returns( + { + id: String, + cost: Float, + date_created: Time, + date_of_first_record: Time, + date_of_last_record: Time, + duration: Float, + first_record: T::Hash[Symbol, T.anything], + last_record: T::Hash[Symbol, T.anything], + latency: Float, + records: Integer, + tokens: Float, + user_ids: T::Array[String] + } + ) + end + def to_hash + end + end + end + end +end diff --git a/rbi/openlayer/models/inference_pipeline_retrieve_users_params.rbi b/rbi/openlayer/models/inference_pipeline_retrieve_users_params.rbi index 39c0777..2035447 100644 --- a/rbi/openlayer/models/inference_pipeline_retrieve_users_params.rbi +++ b/rbi/openlayer/models/inference_pipeline_retrieve_users_params.rbi @@ -17,6 +17,13 @@ module Openlayer sig { returns(String) } attr_accessor :inference_pipeline_id + # Whether or not to sort on the sortColumn in ascending order. + sig { returns(T.nilable(T::Boolean)) } + attr_reader :asc + + sig { params(asc: T::Boolean).void } + attr_writer :asc + # The page to return in a paginated query. sig { returns(T.nilable(Integer)) } attr_reader :page @@ -31,20 +38,89 @@ module Openlayer sig { params(per_page: Integer).void } attr_writer :per_page + # Name of the column to sort on + sig { returns(T.nilable(String)) } + attr_reader :sort_column + + sig { params(sort_column: String).void } + attr_writer :sort_column + + sig do + returns( + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter + ) + ] + ) + ) + end + attr_accessor :column_filters + + sig { returns(T.nilable(T::Array[Integer])) } + attr_accessor :exclude_row_id_list + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :not_search_query_and + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :not_search_query_or + + sig { returns(T.nilable(T::Array[Integer])) } + attr_accessor :row_id_list + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :search_query_and + + sig { returns(T.nilable(T::Array[String])) } + attr_accessor :search_query_or + sig do params( inference_pipeline_id: String, + asc: T::Boolean, page: Integer, per_page: Integer, + sort_column: String, + column_filters: + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::OrHash + ) + ] + ), + exclude_row_id_list: T.nilable(T::Array[Integer]), + not_search_query_and: T.nilable(T::Array[String]), + not_search_query_or: T.nilable(T::Array[String]), + row_id_list: T.nilable(T::Array[Integer]), + search_query_and: T.nilable(T::Array[String]), + search_query_or: T.nilable(T::Array[String]), request_options: Openlayer::RequestOptions::OrHash ).returns(T.attached_class) end def self.new( inference_pipeline_id:, + # Whether or not to sort on the sortColumn in ascending order. + asc: nil, # The page to return in a paginated query. page: nil, # Maximum number of items to return per page. per_page: nil, + # Name of the column to sort on + sort_column: nil, + column_filters: nil, + exclude_row_id_list: nil, + not_search_query_and: nil, + not_search_query_or: nil, + row_id_list: nil, + search_query_and: nil, + search_query_or: nil, request_options: {} ) end @@ -53,14 +129,401 @@ module Openlayer override.returns( { inference_pipeline_id: String, + asc: T::Boolean, page: Integer, per_page: Integer, + sort_column: String, + column_filters: + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter + ) + ] + ), + exclude_row_id_list: T.nilable(T::Array[Integer]), + not_search_query_and: T.nilable(T::Array[String]), + not_search_query_or: T.nilable(T::Array[String]), + row_id_list: T.nilable(T::Array[Integer]), + search_query_and: T.nilable(T::Array[String]), + search_query_or: T.nilable(T::Array[String]), request_options: Openlayer::RequestOptions } ) end def to_hash end + + module ColumnFilter + extend Openlayer::Internal::Type::Union + + Variants = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter + ) + end + + class SetColumnFilter < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter, + Openlayer::Internal::AnyHash + ) + end + + # The name of the column. + sig { returns(String) } + attr_accessor :measurement + + sig do + returns( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::OrSymbol + ) + end + attr_accessor :operator + + sig do + returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + ) + end + attr_accessor :value + + sig do + params( + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::OrSymbol, + value: + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + ).returns(T.attached_class) + end + def self.new( + # The name of the column. + measurement:, + operator:, + value: + ) + end + + sig do + override.returns( + { + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::OrSymbol, + value: + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + } + ) + end + def to_hash + end + + module Operator + extend Openlayer::Internal::Type::Enum + + TaggedSymbol = + T.type_alias do + T.all( + Symbol, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator + ) + end + OrSymbol = T.type_alias { T.any(Symbol, String) } + + CONTAINS_NONE = + T.let( + :contains_none, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + CONTAINS_ANY = + T.let( + :contains_any, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + CONTAINS_ALL = + T.let( + :contains_all, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + ONE_OF = + T.let( + :one_of, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + NONE_OF = + T.let( + :none_of, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ) + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Operator::TaggedSymbol + ] + ) + end + def self.values + end + end + + module Value + extend Openlayer::Internal::Type::Union + + Variants = T.type_alias { T.any(String, Float) } + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::Value::Variants + ] + ) + end + def self.variants + end + end + end + + class NumericColumnFilter < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter, + Openlayer::Internal::AnyHash + ) + end + + # The name of the column. + sig { returns(String) } + attr_accessor :measurement + + sig do + returns( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::OrSymbol + ) + end + attr_accessor :operator + + sig { returns(T.nilable(Float)) } + attr_accessor :value + + sig do + params( + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::OrSymbol, + value: T.nilable(Float) + ).returns(T.attached_class) + end + def self.new( + # The name of the column. + measurement:, + operator:, + value: + ) + end + + sig do + override.returns( + { + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::OrSymbol, + value: T.nilable(Float) + } + ) + end + def to_hash + end + + module Operator + extend Openlayer::Internal::Type::Enum + + TaggedSymbol = + T.type_alias do + T.all( + Symbol, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator + ) + end + OrSymbol = T.type_alias { T.any(Symbol, String) } + + GREATER = + T.let( + :">", + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + GREATER_OR_EQUALS = + T.let( + :">=", + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + IS = + T.let( + :is, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + LESS = + T.let( + :"<", + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + LESS_OR_EQUALS = + T.let( + :"<=", + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + NOT_EQUALS = + T.let( + :"!=", + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ) + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::Operator::TaggedSymbol + ] + ) + end + def self.values + end + end + end + + class StringColumnFilter < Openlayer::Internal::Type::BaseModel + OrHash = + T.type_alias do + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter, + Openlayer::Internal::AnyHash + ) + end + + # The name of the column. + sig { returns(String) } + attr_accessor :measurement + + sig do + returns( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator::OrSymbol + ) + end + attr_accessor :operator + + sig do + returns( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Value::Variants + ) + end + attr_accessor :value + + sig do + params( + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator::OrSymbol, + value: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Value::Variants + ).returns(T.attached_class) + end + def self.new( + # The name of the column. + measurement:, + operator:, + value: + ) + end + + sig do + override.returns( + { + measurement: String, + operator: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator::OrSymbol, + value: + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Value::Variants + } + ) + end + def to_hash + end + + module Operator + extend Openlayer::Internal::Type::Enum + + TaggedSymbol = + T.type_alias do + T.all( + Symbol, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator + ) + end + OrSymbol = T.type_alias { T.any(Symbol, String) } + + IS = + T.let( + :is, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator::TaggedSymbol + ) + NOT_EQUALS = + T.let( + :"!=", + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator::TaggedSymbol + ) + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Operator::TaggedSymbol + ] + ) + end + def self.values + end + end + + module Value + extend Openlayer::Internal::Type::Union + + Variants = T.type_alias { T.any(String, T::Boolean) } + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::Value::Variants + ] + ) + end + def self.variants + end + end + end + + sig do + override.returns( + T::Array[ + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::Variants + ] + ) + end + def self.variants + end + end end end end diff --git a/rbi/openlayer/resources/inference_pipelines.rbi b/rbi/openlayer/resources/inference_pipelines.rbi index b1794ec..8813ea5 100644 --- a/rbi/openlayer/resources/inference_pipelines.rbi +++ b/rbi/openlayer/resources/inference_pipelines.rbi @@ -70,6 +70,67 @@ module Openlayer ) end + # Get aggregated session data for an inference pipeline with pagination and + # metadata. + # + # Returns a list of sessions for the inference pipeline, including activity + # statistics such as record counts, token usage, cost, latency, and the first and + # last records. + sig do + params( + inference_pipeline_id: String, + asc: T::Boolean, + page: Integer, + per_page: Integer, + sort_column: String, + column_filters: + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::OrHash + ) + ] + ), + exclude_row_id_list: T.nilable(T::Array[Integer]), + not_search_query_and: T.nilable(T::Array[String]), + not_search_query_or: T.nilable(T::Array[String]), + row_id_list: T.nilable(T::Array[Integer]), + search_query_and: T.nilable(T::Array[String]), + search_query_or: T.nilable(T::Array[String]), + request_options: Openlayer::RequestOptions::OrHash + ).returns(Openlayer::Models::InferencePipelineRetrieveSessionsResponse) + end + def retrieve_sessions( + # Path param: The inference pipeline id (a UUID). + inference_pipeline_id, + # Query param: Whether or not to sort on the sortColumn in ascending order. + asc: nil, + # Query param: The page to return in a paginated query. + page: nil, + # Query param: Maximum number of items to return per page. + per_page: nil, + # Query param: Name of the column to sort on + sort_column: nil, + # Body param + column_filters: nil, + # Body param + exclude_row_id_list: nil, + # Body param + not_search_query_and: nil, + # Body param + not_search_query_or: nil, + # Body param + row_id_list: nil, + # Body param + search_query_and: nil, + # Body param + search_query_or: nil, + request_options: {} + ) + end + # Get aggregated user data for an inference pipeline with pagination and metadata. # # Returns a list of users who have interacted with the inference pipeline, @@ -78,18 +139,54 @@ module Openlayer sig do params( inference_pipeline_id: String, + asc: T::Boolean, page: Integer, per_page: Integer, + sort_column: String, + column_filters: + T.nilable( + T::Array[ + T.any( + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::OrHash, + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::OrHash + ) + ] + ), + exclude_row_id_list: T.nilable(T::Array[Integer]), + not_search_query_and: T.nilable(T::Array[String]), + not_search_query_or: T.nilable(T::Array[String]), + row_id_list: T.nilable(T::Array[Integer]), + search_query_and: T.nilable(T::Array[String]), + search_query_or: T.nilable(T::Array[String]), request_options: Openlayer::RequestOptions::OrHash ).returns(Openlayer::Models::InferencePipelineRetrieveUsersResponse) end def retrieve_users( - # The inference pipeline id (a UUID). + # Path param: The inference pipeline id (a UUID). inference_pipeline_id, - # The page to return in a paginated query. + # Query param: Whether or not to sort on the sortColumn in ascending order. + asc: nil, + # Query param: The page to return in a paginated query. page: nil, - # Maximum number of items to return per page. + # Query param: Maximum number of items to return per page. per_page: nil, + # Query param: Name of the column to sort on + sort_column: nil, + # Body param + column_filters: nil, + # Body param + exclude_row_id_list: nil, + # Body param + not_search_query_and: nil, + # Body param + not_search_query_or: nil, + # Body param + row_id_list: nil, + # Body param + search_query_and: nil, + # Body param + search_query_or: nil, request_options: {} ) end diff --git a/sig/openlayer/models.rbs b/sig/openlayer/models.rbs index e367a68..1078490 100644 --- a/sig/openlayer/models.rbs +++ b/sig/openlayer/models.rbs @@ -7,6 +7,8 @@ module Openlayer class InferencePipelineRetrieveParams = Openlayer::Models::InferencePipelineRetrieveParams + class InferencePipelineRetrieveSessionsParams = Openlayer::Models::InferencePipelineRetrieveSessionsParams + class InferencePipelineRetrieveUsersParams = Openlayer::Models::InferencePipelineRetrieveUsersParams module InferencePipelines = Openlayer::Models::InferencePipelines diff --git a/sig/openlayer/models/inference_pipeline_retrieve_sessions_params.rbs b/sig/openlayer/models/inference_pipeline_retrieve_sessions_params.rbs new file mode 100644 index 0000000..87d5b4e --- /dev/null +++ b/sig/openlayer/models/inference_pipeline_retrieve_sessions_params.rbs @@ -0,0 +1,238 @@ +module Openlayer + module Models + type inference_pipeline_retrieve_sessions_params = + { + inference_pipeline_id: String, + asc: bool, + page: Integer, + per_page: Integer, + sort_column: String, + column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::column_filter]?, + exclude_row_id_list: ::Array[Integer]?, + not_search_query_and: ::Array[String]?, + not_search_query_or: ::Array[String]?, + row_id_list: ::Array[Integer]?, + search_query_and: ::Array[String]?, + search_query_or: ::Array[String]? + } + & Openlayer::Internal::Type::request_parameters + + class InferencePipelineRetrieveSessionsParams < Openlayer::Internal::Type::BaseModel + extend Openlayer::Internal::Type::RequestParameters::Converter + include Openlayer::Internal::Type::RequestParameters + + attr_accessor inference_pipeline_id: String + + attr_reader asc: bool? + + def asc=: (bool) -> bool + + attr_reader page: Integer? + + def page=: (Integer) -> Integer + + attr_reader per_page: Integer? + + def per_page=: (Integer) -> Integer + + attr_reader sort_column: String? + + def sort_column=: (String) -> String + + attr_accessor column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::column_filter]? + + attr_accessor exclude_row_id_list: ::Array[Integer]? + + attr_accessor not_search_query_and: ::Array[String]? + + attr_accessor not_search_query_or: ::Array[String]? + + attr_accessor row_id_list: ::Array[Integer]? + + attr_accessor search_query_and: ::Array[String]? + + attr_accessor search_query_or: ::Array[String]? + + def initialize: ( + inference_pipeline_id: String, + ?asc: bool, + ?page: Integer, + ?per_page: Integer, + ?sort_column: String, + ?column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::column_filter]?, + ?exclude_row_id_list: ::Array[Integer]?, + ?not_search_query_and: ::Array[String]?, + ?not_search_query_or: ::Array[String]?, + ?row_id_list: ::Array[Integer]?, + ?search_query_and: ::Array[String]?, + ?search_query_or: ::Array[String]?, + ?request_options: Openlayer::request_opts + ) -> void + + def to_hash: -> { + inference_pipeline_id: String, + asc: bool, + page: Integer, + per_page: Integer, + sort_column: String, + column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::column_filter]?, + exclude_row_id_list: ::Array[Integer]?, + not_search_query_and: ::Array[String]?, + not_search_query_or: ::Array[String]?, + row_id_list: ::Array[Integer]?, + search_query_and: ::Array[String]?, + search_query_or: ::Array[String]?, + request_options: Openlayer::RequestOptions + } + + type column_filter = + Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter + | Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter + | Openlayer::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter + + module ColumnFilter + extend Openlayer::Internal::Type::Union + + type set_column_filter = + { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::operator, + value: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::value] + } + + class SetColumnFilter < Openlayer::Internal::Type::BaseModel + attr_accessor measurement: String + + attr_accessor operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::operator + + attr_accessor value: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::value] + + def initialize: ( + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::operator, + value: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::value] + ) -> void + + def to_hash: -> { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::operator, + value: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::value] + } + + type operator = + :contains_none | :contains_any | :contains_all | :one_of | :none_of + + module Operator + extend Openlayer::Internal::Type::Enum + + CONTAINS_NONE: :contains_none + CONTAINS_ANY: :contains_any + CONTAINS_ALL: :contains_all + ONE_OF: :one_of + NONE_OF: :none_of + + def self?.values: -> ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::operator] + end + + type value = String | Float + + module Value + extend Openlayer::Internal::Type::Union + + def self?.variants: -> ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::SetColumnFilter::value] + end + end + + type numeric_column_filter = + { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::operator, + value: Float? + } + + class NumericColumnFilter < Openlayer::Internal::Type::BaseModel + attr_accessor measurement: String + + attr_accessor operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::operator + + attr_accessor value: Float? + + def initialize: ( + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::operator, + value: Float? + ) -> void + + def to_hash: -> { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::operator, + value: Float? + } + + type operator = :> | :>= | :is | :< | :<= | :!= + + module Operator + extend Openlayer::Internal::Type::Enum + + GREATER: :> + GREATER_OR_EQUALS: :>= + IS: :is + LESS: :< + LESS_OR_EQUALS: :<= + NOT_EQUALS: :!= + + def self?.values: -> ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::NumericColumnFilter::operator] + end + end + + type string_column_filter = + { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::operator, + value: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::value + } + + class StringColumnFilter < Openlayer::Internal::Type::BaseModel + attr_accessor measurement: String + + attr_accessor operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::operator + + attr_accessor value: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::value + + def initialize: ( + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::operator, + value: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::value + ) -> void + + def to_hash: -> { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::operator, + value: Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::value + } + + type operator = :is | :!= + + module Operator + extend Openlayer::Internal::Type::Enum + + IS: :is + NOT_EQUALS: :!= + + def self?.values: -> ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::operator] + end + + type value = String | bool + + module Value + extend Openlayer::Internal::Type::Union + + def self?.variants: -> ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::ColumnFilter::StringColumnFilter::value] + end + end + + def self?.variants: -> ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::column_filter] + end + end + end +end diff --git a/sig/openlayer/models/inference_pipeline_retrieve_sessions_response.rbs b/sig/openlayer/models/inference_pipeline_retrieve_sessions_response.rbs new file mode 100644 index 0000000..53f6bb4 --- /dev/null +++ b/sig/openlayer/models/inference_pipeline_retrieve_sessions_response.rbs @@ -0,0 +1,92 @@ +module Openlayer + module Models + type inference_pipeline_retrieve_sessions_response = + { + items: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item] + } + + class InferencePipelineRetrieveSessionsResponse < Openlayer::Internal::Type::BaseModel + attr_accessor items: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item] + + def initialize: ( + items: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item] + ) -> void + + def to_hash: -> { + items: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item] + } + + type item = + { + id: String, + cost: Float, + date_created: Time, + date_of_first_record: Time, + date_of_last_record: Time, + duration: Float, + first_record: ::Hash[Symbol, top], + last_record: ::Hash[Symbol, top], + latency: Float, + records: Integer, + tokens: Float, + user_ids: ::Array[String] + } + + class Item < Openlayer::Internal::Type::BaseModel + attr_accessor id: String + + attr_accessor cost: Float + + attr_accessor date_created: Time + + attr_accessor date_of_first_record: Time + + attr_accessor date_of_last_record: Time + + attr_accessor duration: Float + + attr_accessor first_record: ::Hash[Symbol, top] + + attr_accessor last_record: ::Hash[Symbol, top] + + attr_accessor latency: Float + + attr_accessor records: Integer + + attr_accessor tokens: Float + + attr_accessor user_ids: ::Array[String] + + def initialize: ( + id: String, + cost: Float, + date_created: Time, + date_of_first_record: Time, + date_of_last_record: Time, + duration: Float, + first_record: ::Hash[Symbol, top], + last_record: ::Hash[Symbol, top], + latency: Float, + records: Integer, + tokens: Float, + user_ids: ::Array[String] + ) -> void + + def to_hash: -> { + id: String, + cost: Float, + date_created: Time, + date_of_first_record: Time, + date_of_last_record: Time, + duration: Float, + first_record: ::Hash[Symbol, top], + last_record: ::Hash[Symbol, top], + latency: Float, + records: Integer, + tokens: Float, + user_ids: ::Array[String] + } + end + end + end +end diff --git a/sig/openlayer/models/inference_pipeline_retrieve_users_params.rbs b/sig/openlayer/models/inference_pipeline_retrieve_users_params.rbs index 79fb6cf..bb42f2e 100644 --- a/sig/openlayer/models/inference_pipeline_retrieve_users_params.rbs +++ b/sig/openlayer/models/inference_pipeline_retrieve_users_params.rbs @@ -1,7 +1,20 @@ module Openlayer module Models type inference_pipeline_retrieve_users_params = - { inference_pipeline_id: String, page: Integer, per_page: Integer } + { + inference_pipeline_id: String, + asc: bool, + page: Integer, + per_page: Integer, + sort_column: String, + column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::column_filter]?, + exclude_row_id_list: ::Array[Integer]?, + not_search_query_and: ::Array[String]?, + not_search_query_or: ::Array[String]?, + row_id_list: ::Array[Integer]?, + search_query_and: ::Array[String]?, + search_query_or: ::Array[String]? + } & Openlayer::Internal::Type::request_parameters class InferencePipelineRetrieveUsersParams < Openlayer::Internal::Type::BaseModel @@ -10,6 +23,10 @@ module Openlayer attr_accessor inference_pipeline_id: String + attr_reader asc: bool? + + def asc=: (bool) -> bool + attr_reader page: Integer? def page=: (Integer) -> Integer @@ -18,19 +35,204 @@ module Openlayer def per_page=: (Integer) -> Integer + attr_reader sort_column: String? + + def sort_column=: (String) -> String + + attr_accessor column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::column_filter]? + + attr_accessor exclude_row_id_list: ::Array[Integer]? + + attr_accessor not_search_query_and: ::Array[String]? + + attr_accessor not_search_query_or: ::Array[String]? + + attr_accessor row_id_list: ::Array[Integer]? + + attr_accessor search_query_and: ::Array[String]? + + attr_accessor search_query_or: ::Array[String]? + def initialize: ( inference_pipeline_id: String, + ?asc: bool, ?page: Integer, ?per_page: Integer, + ?sort_column: String, + ?column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::column_filter]?, + ?exclude_row_id_list: ::Array[Integer]?, + ?not_search_query_and: ::Array[String]?, + ?not_search_query_or: ::Array[String]?, + ?row_id_list: ::Array[Integer]?, + ?search_query_and: ::Array[String]?, + ?search_query_or: ::Array[String]?, ?request_options: Openlayer::request_opts ) -> void def to_hash: -> { inference_pipeline_id: String, + asc: bool, page: Integer, per_page: Integer, + sort_column: String, + column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::column_filter]?, + exclude_row_id_list: ::Array[Integer]?, + not_search_query_and: ::Array[String]?, + not_search_query_or: ::Array[String]?, + row_id_list: ::Array[Integer]?, + search_query_and: ::Array[String]?, + search_query_or: ::Array[String]?, request_options: Openlayer::RequestOptions } + + type column_filter = + Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter + | Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter + | Openlayer::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter + + module ColumnFilter + extend Openlayer::Internal::Type::Union + + type set_column_filter = + { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::operator, + value: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::value] + } + + class SetColumnFilter < Openlayer::Internal::Type::BaseModel + attr_accessor measurement: String + + attr_accessor operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::operator + + attr_accessor value: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::value] + + def initialize: ( + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::operator, + value: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::value] + ) -> void + + def to_hash: -> { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::operator, + value: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::value] + } + + type operator = + :contains_none | :contains_any | :contains_all | :one_of | :none_of + + module Operator + extend Openlayer::Internal::Type::Enum + + CONTAINS_NONE: :contains_none + CONTAINS_ANY: :contains_any + CONTAINS_ALL: :contains_all + ONE_OF: :one_of + NONE_OF: :none_of + + def self?.values: -> ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::operator] + end + + type value = String | Float + + module Value + extend Openlayer::Internal::Type::Union + + def self?.variants: -> ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::SetColumnFilter::value] + end + end + + type numeric_column_filter = + { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::operator, + value: Float? + } + + class NumericColumnFilter < Openlayer::Internal::Type::BaseModel + attr_accessor measurement: String + + attr_accessor operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::operator + + attr_accessor value: Float? + + def initialize: ( + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::operator, + value: Float? + ) -> void + + def to_hash: -> { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::operator, + value: Float? + } + + type operator = :> | :>= | :is | :< | :<= | :!= + + module Operator + extend Openlayer::Internal::Type::Enum + + GREATER: :> + GREATER_OR_EQUALS: :>= + IS: :is + LESS: :< + LESS_OR_EQUALS: :<= + NOT_EQUALS: :!= + + def self?.values: -> ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::NumericColumnFilter::operator] + end + end + + type string_column_filter = + { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::operator, + value: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::value + } + + class StringColumnFilter < Openlayer::Internal::Type::BaseModel + attr_accessor measurement: String + + attr_accessor operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::operator + + attr_accessor value: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::value + + def initialize: ( + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::operator, + value: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::value + ) -> void + + def to_hash: -> { + measurement: String, + operator: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::operator, + value: Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::value + } + + type operator = :is | :!= + + module Operator + extend Openlayer::Internal::Type::Enum + + IS: :is + NOT_EQUALS: :!= + + def self?.values: -> ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::operator] + end + + type value = String | bool + + module Value + extend Openlayer::Internal::Type::Union + + def self?.variants: -> ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::ColumnFilter::StringColumnFilter::value] + end + end + + def self?.variants: -> ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::column_filter] + end end end end diff --git a/sig/openlayer/resources/inference_pipelines.rbs b/sig/openlayer/resources/inference_pipelines.rbs index c73670a..e9c5047 100644 --- a/sig/openlayer/resources/inference_pipelines.rbs +++ b/sig/openlayer/resources/inference_pipelines.rbs @@ -26,10 +26,35 @@ module Openlayer ?request_options: Openlayer::request_opts ) -> nil + def retrieve_sessions: ( + String inference_pipeline_id, + ?asc: bool, + ?page: Integer, + ?per_page: Integer, + ?sort_column: String, + ?column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveSessionsParams::column_filter]?, + ?exclude_row_id_list: ::Array[Integer]?, + ?not_search_query_and: ::Array[String]?, + ?not_search_query_or: ::Array[String]?, + ?row_id_list: ::Array[Integer]?, + ?search_query_and: ::Array[String]?, + ?search_query_or: ::Array[String]?, + ?request_options: Openlayer::request_opts + ) -> Openlayer::Models::InferencePipelineRetrieveSessionsResponse + def retrieve_users: ( String inference_pipeline_id, + ?asc: bool, ?page: Integer, ?per_page: Integer, + ?sort_column: String, + ?column_filters: ::Array[Openlayer::Models::InferencePipelineRetrieveUsersParams::column_filter]?, + ?exclude_row_id_list: ::Array[Integer]?, + ?not_search_query_and: ::Array[String]?, + ?not_search_query_or: ::Array[String]?, + ?row_id_list: ::Array[Integer]?, + ?search_query_and: ::Array[String]?, + ?search_query_or: ::Array[String]?, ?request_options: Openlayer::request_opts ) -> Openlayer::Models::InferencePipelineRetrieveUsersResponse diff --git a/test/openlayer/resources/inference_pipelines_test.rb b/test/openlayer/resources/inference_pipelines_test.rb index f912995..0c3aa57 100644 --- a/test/openlayer/resources/inference_pipelines_test.rb +++ b/test/openlayer/resources/inference_pipelines_test.rb @@ -79,6 +79,20 @@ def test_delete end end + def test_retrieve_sessions + response = @openlayer.inference_pipelines.retrieve_sessions("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") + + assert_pattern do + response => Openlayer::Models::InferencePipelineRetrieveSessionsResponse + end + + assert_pattern do + response => { + items: ^(Openlayer::Internal::Type::ArrayOf[Openlayer::Models::InferencePipelineRetrieveSessionsResponse::Item]) + } + end + end + def test_retrieve_users response = @openlayer.inference_pipelines.retrieve_users("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e") From a1d3ef5921beb20f617e79ffa535ec746a53b3ca Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:14:53 +0000 Subject: [PATCH 2/2] release: 0.12.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 8 ++++++++ Gemfile.lock | 2 +- README.md | 2 +- lib/openlayer/version.rb | 2 +- 5 files changed, 12 insertions(+), 4 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 95e4ab6..a713055 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.11.2" + ".": "0.12.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index a19f2f5..b7fb07d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.12.0 (2026-04-01) + +Full Changelog: [v0.11.2...v0.12.0](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.11.2...v0.12.0) + +### Features + +* Cid/fetching endpoints ([8295c08](https://github.com/openlayer-ai/openlayer-ruby/commit/8295c08689e01d33e8b21fd93028da4df3e8269f)) + ## 0.11.2 (2026-04-01) Full Changelog: [v0.11.1...v0.11.2](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.11.1...v0.11.2) diff --git a/Gemfile.lock b/Gemfile.lock index 3f638fb..5956b16 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: . specs: - openlayer (0.11.2) + openlayer (0.12.0) cgi connection_pool diff --git a/README.md b/README.md index 118ab12..4019fe0 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application ```ruby -gem "openlayer", "~> 0.11.2" +gem "openlayer", "~> 0.12.0" ``` diff --git a/lib/openlayer/version.rb b/lib/openlayer/version.rb index 1590eb6..c0b0ce3 100644 --- a/lib/openlayer/version.rb +++ b/lib/openlayer/version.rb @@ -1,5 +1,5 @@ # frozen_string_literal: true module Openlayer - VERSION = "0.11.2" + VERSION = "0.12.0" end