openlayer 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9124105239930d01d444266033af79f2e1d2a7e6048b587e13dc6cfa1d00a0c3
-  data.tar.gz: 869c8e6a79e351d2b5047272558e4b33fb7e794276731cfbe4e246410804d57b
+  metadata.gz: 697a21d4d40c619479976e24865b8d944ff8937614f74c4e35542a3c13674241
+  data.tar.gz: 8ca429adee40471cb39fa618f1fcf9b4a08df9cedb9c19095510c975f7e3d762
 SHA512:
-  metadata.gz: aaa1a3ec31f4dd6ef75ba1f3acd5d50cb49318ac899dd3ec0442ddbe332abebe1ff6c39b042f4cc9ec66b05bd59790baf4bcf2ebe26f601b36d823e228940f0a
-  data.tar.gz: 7d76c46e8c8b5d468a16421dc9d859c6768cdb1981afcd72b73cbfcfa307d3bdce1cd37f16066f4b46d7ab248ab1aef2cfe6f79ae20cee2ec0a72fc71fe667ed
+  metadata.gz: 8b3b455c4a3188442002783b8060fe880f50a9915f61c3b6f6bac7611d28c637798507610852f97df9a4dcfffa2b47b080165089a3feae8509c45a115688fc04
+  data.tar.gz: 04ef2610d79655ac61a2a450b82b772aaf98251bf52a44a74084bc70c4e9a5614f36d214f8553ee742e299ab29cd3282ce33857580670d5ef4dfc583e45f6117

data/.ignore

@@ -0,0 +1,2 @@
+rbi/*
+sig/*

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 0.4.0 (2025-10-02)
+
+Full Changelog: [v0.0.2...v0.4.0](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.0.2...v0.4.0)
+
+### Chores
+
+* update readme ([102f6fb](https://github.com/openlayer-ai/openlayer-ruby/commit/102f6fb531cc81b046d27550788d508015c3674c))
+
+## 0.0.2 (2025-10-02)
+
+Full Changelog: [v0.0.1...v0.0.2](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.0.1...v0.0.2)
+
+### Bug Fixes
+
+* coroutine leaks from connection pool ([c916cc0](https://github.com/openlayer-ai/openlayer-ruby/commit/c916cc0e7726963d08eefec4edca704a26393419))
+
+
+### Chores
+
+* configure new SDK language ([844cad0](https://github.com/openlayer-ai/openlayer-ruby/commit/844cad0761a069778244da35537b74ae6ceb56b5))
+* update SDK settings ([3185146](https://github.com/openlayer-ai/openlayer-ruby/commit/318514613db1e7f5f63067383d35852413c9b02d))

data/README.md

@@ -1,73 +1,314 @@
-# Openlayer
-Openlayer is a Ruby gem that provides a wrapper for the Openlayer HTTP API. It allows you to connect to Openlayer and interact with its features. Please note that this gem is currently in the early stages of development.
+# Openlayer Ruby API library
 
+The Openlayer Ruby library provides convenient access to the Openlayer REST API from any Ruby 3.2.0+ application. It ships with comprehensive types & docstrings in Yard, RBS, and RBI – [see below](https://github.com/openlayer-ai/openlayer-ruby#Sorbet) for usage with Sorbet. The standard library's `net/http` is used as the HTTP transport, with connection pooling via the `connection_pool` gem.
+
+It is generated with [Stainless](https://www.stainless.com/).
+
+## Documentation
+
+Documentation for releases of this gem can be found [on RubyDoc](https://gemdocs.org/gems/openlayer).
+
+The REST API documentation can be found on [openlayer.com](https://openlayer.com/docs/api-reference/rest/overview).
 
 ## Installation
-Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add openlayer
+To use this gem, install via Bundler by adding the following to your application's `Gemfile`:
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+<!-- x-release-please-start-version -->
 
-    $ gem install openlayer
+```ruby
+gem "openlayer", "~> 0.4.0"
+```
+
+<!-- x-release-please-end -->
 
 ## Usage
 
-### Inference Monitoring Mode
 ```ruby
-client = Openlayer::Client.new(api_key: "YOUR_OPENLAYER_API_KEY")
-inference_pipeline = client.inference_pipeline("YOUR_INFERENCE_PIPELINE_ID")
-inference_pipeline.stream_data(
-    {
-        rows: [...],
-        config: {...}
+require "bundler/setup"
+require "openlayer"
+
+openlayer = Openlayer::Client.new(
+  api_key: ENV["OPENLAYER_API_KEY"] # This is the default and can be omitted
+)
+
+response = openlayer.inference_pipelines.data.stream(
+  "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+  config: {
+    inputVariableNames: ["user_query"],
+    outputColumnName: "output",
+    numOfTokenColumnName: "tokens",
+    costColumnName: "cost",
+    timestampColumnName: "timestamp"
+  },
+  rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}]
+)
+
+puts(response.success)
+```
+
+### Handling errors
+
+When the library is unable to connect to the API, or if the API returns a non-success status code (i.e., 4xx or 5xx response), a subclass of `Openlayer::Errors::APIError` will be thrown:
+
+```ruby
+begin
+  data = openlayer.inference_pipelines.data.stream(
+    "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+    config: {
+      inputVariableNames: ["user_query"],
+      outputColumnName: "output",
+      numOfTokenColumnName: "tokens",
+      costColumnName: "cost",
+      timestampColumnName: "timestamp"
+    },
+    rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}]
+  )
+rescue Openlayer::Errors::APIConnectionError => e
+  puts("The server could not be reached")
+  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
+rescue Openlayer::Errors::RateLimitError => e
+  puts("A 429 status code was received; we should back off a bit.")
+rescue Openlayer::Errors::APIStatusError => e
+  puts("Another non-200-range status code was received")
+  puts(e.status)
+end
+```
+
+Error codes are as follows:
+
+| Cause            | Error Type                 |
+| ---------------- | -------------------------- |
+| HTTP 400         | `BadRequestError`          |
+| HTTP 401         | `AuthenticationError`      |
+| HTTP 403         | `PermissionDeniedError`    |
+| HTTP 404         | `NotFoundError`            |
+| HTTP 409         | `ConflictError`            |
+| HTTP 422         | `UnprocessableEntityError` |
+| HTTP 429         | `RateLimitError`           |
+| HTTP >= 500      | `InternalServerError`      |
+| Other HTTP error | `APIStatusError`           |
+| Timeout          | `APITimeoutError`          |
+| Network error    | `APIConnectionError`       |
+
+### Retries
+
+Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
+
+Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors, and timeouts will all be retried by default.
+
+You can use the `max_retries` option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+openlayer = Openlayer::Client.new(
+  max_retries: 0 # default is 2
+)
+
+# Or, configure per-request:
+openlayer.inference_pipelines.data.stream(
+  "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+  config: {
+    inputVariableNames: ["user_query"],
+    outputColumnName: "output",
+    numOfTokenColumnName: "tokens",
+    costColumnName: "cost",
+    timestampColumnName: "timestamp"
+  },
+  rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}],
+  request_options: {max_retries: 5}
+)
+```
+
+### Timeouts
+
+By default, requests will time out after 60 seconds. You can use the timeout option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+openlayer = Openlayer::Client.new(
+  timeout: nil # default is 60
+)
+
+# Or, configure per-request:
+openlayer.inference_pipelines.data.stream(
+  "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+  config: {
+    inputVariableNames: ["user_query"],
+    outputColumnName: "output",
+    numOfTokenColumnName: "tokens",
+    costColumnName: "cost",
+    timestampColumnName: "timestamp"
+  },
+  rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}],
+  request_options: {timeout: 5}
+)
+```
+
+On timeout, `Openlayer::Errors::APITimeoutError` is raised.
+
+Note that requests that time out are retried by default.
+
+## Advanced concepts
+
+### BaseModel
+
+All parameter and response objects inherit from `Openlayer::Internal::Type::BaseModel`, which provides several conveniences, including:
+
+1. All fields, including unknown ones, are accessible with `obj[:prop]` syntax, and can be destructured with `obj => {prop: prop}` or pattern-matching syntax.
+
+2. Structural equivalence for equality; if two API calls return the same values, comparing the responses with == will return true.
+
+3. Both instances and the classes themselves can be pretty-printed.
+
+4. Helpers such as `#to_h`, `#deep_to_h`, `#to_json`, and `#to_yaml`.
+
+### Making custom or undocumented requests
+
+#### Undocumented properties
+
+You can send undocumented parameters to any endpoint, and read undocumented response properties, like so:
+
+Note: the `extra_` parameters of the same name overrides the documented parameters.
+
+```ruby
+response =
+  openlayer.inference_pipelines.data.stream(
+    "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+    config: {
+      inputVariableNames: ["user_query"],
+      outputColumnName: "output",
+      numOfTokenColumnName: "tokens",
+      costColumnName: "cost",
+      timestampColumnName: "timestamp"
+    },
+    rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}],
+    request_options: {
+      extra_query: {my_query_parameter: value},
+      extra_body: {my_body_parameter: value},
+      extra_headers: {"my-header": value}
     }
+  )
+
+puts(response[:my_undocumented_property])
+```
+
+#### Undocumented request params
+
+If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a request, as seen in the examples above.
+
+#### Undocumented endpoints
+
+To make requests to undocumented endpoints while retaining the benefit of auth, retries, and so on, you can make requests using `client.request`, like so:
+
+```ruby
+response = client.request(
+  method: :post,
+  path: '/undocumented/endpoint',
+  query: {"dog": "woof"},
+  headers: {"useful-header": "interesting-value"},
+  body: {"hello": "world"}
 )
 ```
 
+### Concurrency & connection pooling
 
+The `Openlayer::Client` instances are threadsafe, but are only are fork-safe when there are no in-flight HTTP requests.
 
-### Projects
-#### Load Project
-Loads an existing project from the Openlayer platform.
+Each instance of `Openlayer::Client` has its own HTTP connection pool with a default size of 99. As such, we recommend instantiating the client once per application in most settings.
+
+When all available connections from the pool are checked out, requests wait for a new connection to become available, with queue time counting towards the request timeout.
+
+Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
+
+## Sorbet
+
+This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitions, and has no dependency on sorbet-runtime.
+
+You can provide typesafe request parameters like so:
 
 ```ruby
-client = Openlayer::Client.new(api_key: "YOUR_OPENLAYER_API_KEY")
-project = client.load_project(name: "your_project_name")
+openlayer.inference_pipelines.data.stream(
+  "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+  config: Openlayer::InferencePipelines::DataStreamParams::Config::LlmData.new(
+    input_variable_names: ["user_query"],
+    output_column_name: "output",
+    num_of_token_column_name: "tokens",
+    cost_column_name: "cost",
+    timestamp_column_name: "timestamp"
+  ),
+  rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}]
+)
 ```
 
-#### Development Mode for CI/CD
+Or, equivalently:
+
 ```ruby
-client = Openlayer::Client.new(api_key: "YOUR_OPENLAYER_API_KEY")
-project = client.load_project(name: "your_project_name")
+# Hashes work, but are not typesafe:
+openlayer.inference_pipelines.data.stream(
+  "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+  config: {
+    inputVariableNames: ["user_query"],
+    outputColumnName: "output",
+    numOfTokenColumnName: "tokens",
+    costColumnName: "cost",
+    timestampColumnName: "timestamp"
+  },
+  rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}]
+)
+
+# You can also splat a full Params class:
+params = Openlayer::InferencePipelines::DataStreamParams.new(
+  config: Openlayer::InferencePipelines::DataStreamParams::Config::LlmData.new(
+    input_variable_names: ["user_query"],
+    output_column_name: "output",
+    num_of_token_column_name: "tokens",
+    cost_column_name: "cost",
+    timestamp_column_name: "timestamp"
+  ),
+  rows: [{user_query: "what is the meaning of life?", output: "42", tokens: 7, cost: 0.02, timestamp: 1610000000}]
+)
+openlayer.inference_pipelines.data.stream("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", **params)
+```
 
+### Enums
 
-project.add_dataset(file_path: "DATASET_FILE_PATH", dataset_config_file_path: "DATASET_CONFIG_FILE_PATH")
-project.add_model(model_config_file_path: "MODEL_CONFIG_PATH")
-project.commit(message: "This is a commit message")
-version = project.push
+Since this library does not depend on `sorbet-runtime`, it cannot provide [`T::Enum`](https://sorbet.org/docs/tenum) instances. Instead, we provide "tagged symbols" instead, which is always a primitive at runtime:
 
-version.wait_for_completion(timeout: 500)
-version.print_test_report
+```ruby
+# :"llm-base"
+puts(Openlayer::ProjectCreateParams::TaskType::LLM_BASE)
 
-if version.failing_test_count > 0:
-    puts "Failing pipeline due to failing goals."
-    exit(1)
+# Revealed type: `T.all(Openlayer::ProjectCreateParams::TaskType, Symbol)`
+T.reveal_type(Openlayer::ProjectCreateParams::TaskType::LLM_BASE)
 ```
 
-- Check the example in `examples/staging` for what the YAMLs look like.
-- Check the [Dataset Config](https://docs.openlayer.com/how-to-guides/write-dataset-configs/llm-dataset-config) and the [Model Config](https://docs.openlayer.com/how-to-guides/write-model-configs/llm-config) docs on Openlayer to see additional attributes for the configs.
+Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
+
+```ruby
+# Using the enum constants preserves the tagged type information:
+openlayer.projects.create(
+  task_type: Openlayer::ProjectCreateParams::TaskType::LLM_BASE,
+  # …
+)
+
+# Literal values are also permissible:
+openlayer.projects.create(
+  task_type: :"llm-base",
+  # …
+)
+```
 
-## Development
+## Versioning
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the library is in initial development and has a major version of `0`, APIs may change at any time.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` type definitions to be non-breaking changes.
 
-## Contributing
+## Requirements
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/TelosLabs/openlayer.
+Ruby 3.2.0 or higher.
 
-## License
+## Contributing
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+See [the contributing documentation](https://github.com/openlayer-ai/openlayer-ruby/tree/main/CONTRIBUTING.md)

data/SECURITY.md

@@ -0,0 +1,27 @@
+# Security Policy
+
+## Reporting Security Issues
+
+This SDK is generated by [Stainless Software Inc](http://stainless.com). Stainless takes security seriously, and encourages you to report any security vulnerability promptly so that appropriate action can be taken.
+
+To report a security issue, please contact the Stainless team at security@stainless.com.
+
+## Responsible Disclosure
+
+We appreciate the efforts of security researchers and individuals who help us maintain the security of
+SDKs we generate. If you believe you have found a security vulnerability, please adhere to responsible
+disclosure practices by allowing us a reasonable amount of time to investigate and address the issue
+before making any information public.
+
+## Reporting Non-SDK Related Security Issues
+
+If you encounter security issues that are not directly related to SDKs but pertain to the services
+or products provided by Openlayer, please follow the respective company's security reporting guidelines.
+
+### Openlayer Terms and Policies
+
+Please contact support@openlayer.com for any questions or concerns regarding the security of our services.
+
+---
+
+Thank you for helping us keep the SDKs and systems they interact with secure.

data/lib/openlayer/client.rb

@@ -1,77 +1,82 @@
 # frozen_string_literal: true
 
-require "faraday"
-require "faraday/multipart"
-
 module Openlayer
-  class Client
-    BASE_URL = "https://api.openlayer.com/v1/"
+  class Client < Openlayer::Internal::Transport::BaseClient
+    # Default max number of retries to attempt after a failed retryable request.
+    DEFAULT_MAX_RETRIES = 2
 
-    attr_reader :api_key, :adapter
+    # Default per-request timeout.
+    DEFAULT_TIMEOUT_IN_SECONDS = 60.0
 
-    def initialize(api_key:, adapter: Faraday.default_adapter, stubs: nil)
-      @api_key = api_key
-      @adapter = adapter
-      @stubs = stubs
-    end
+    # Default initial retry delay in seconds.
+    # Overall delay is calculated using exponential backoff + jitter.
+    DEFAULT_INITIAL_RETRY_DELAY = 0.5
 
-    def inference_pipeline(inference_pipeline_id)
-      InferencePipeline.new(self, inference_pipeline_id)
-    end
+    # Default max retry delay in seconds.
+    DEFAULT_MAX_RETRY_DELAY = 8.0
 
-    def load_project(name:)
-      Project.from_response self, connection.get("projects", project_search_params(name: name))
-    end
+    # @return [String, nil]
+    attr_reader :api_key
 
-    def presigned_url(object_name: nil, workspace_id: nil)
-      handle_response connection.post(
-        "storage/presigned-url?objectName=staging", presigned_url_params(object_name: object_name,
-                                                                         workspace_id: workspace_id)
-      )
-    end
+    # @return [Openlayer::Resources::Projects]
+    attr_reader :projects
 
-    def load_project_version(id:, payload: {})
-      ProjectVersion.from_response self, connection.post("projects/#{id}/versions", payload)
-    end
+    # @return [Openlayer::Resources::Commits]
+    attr_reader :commits
 
-    def connection
-      @connection ||= Faraday.new do |conn|
-        conn.url_prefix = BASE_URL
-        conn.request :authorization, "Bearer", api_key
-        conn.request :json
-        conn.response :json, content_type: "application/json"
-        conn.adapter adapter, @stubs
-      end
-    end
+    # @return [Openlayer::Resources::InferencePipelines]
+    attr_reader :inference_pipelines
 
-    private
+    # @return [Openlayer::Resources::Storage]
+    attr_reader :storage
 
-    def project_search_params(name:)
-      { version: "0.1.0a25", name: name }
-    end
+    # @api private
+    #
+    # @return [Hash{String=>String}]
+    private def auth_headers
+      return {} if @api_key.nil?
 
-    def presigned_url_params(object_name: nil, workspace_id: nil)
-      { "objectName": object_name, "workspaceId": workspace_id, version: "0.1.0a25" }.compact
+      {"authorization" => "Bearer #{@api_key}"}
     end
 
-    def handle_response(response)
-      message = response.body["error"]
-      case response.status
-      when 200
-        response.body
-      when 401
-        raise Error, message
-      when 404
-        raise Error, message
-      when 422
-        raise Error, message
-      when 500
-        raise Error, message
-      when 200..299
-        response.body
-      else
-        raise Error, message
-      end
+    # Creates and returns a new client for interacting with the API.
+    #
+    # @param api_key [String, nil] Defaults to `ENV["OPENLAYER_API_KEY"]`
+    #
+    # @param base_url [String, nil] Override the default base URL for the API, e.g.,
+    # `"https://api.example.com/v2/"`. Defaults to `ENV["OPENLAYER_BASE_URL"]`
+    #
+    # @param max_retries [Integer] Max number of retries to attempt after a failed retryable request.
+    #
+    # @param timeout [Float]
+    #
+    # @param initial_retry_delay [Float]
+    #
+    # @param max_retry_delay [Float]
+    def initialize(
+      api_key: ENV["OPENLAYER_API_KEY"],
+      base_url: ENV["OPENLAYER_BASE_URL"],
+      max_retries: self.class::DEFAULT_MAX_RETRIES,
+      timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+    )
+      base_url ||= "https://api.openlayer.com/v1"
+
+      @api_key = api_key&.to_s
+
+      super(
+        base_url: base_url,
+        timeout: timeout,
+        max_retries: max_retries,
+        initial_retry_delay: initial_retry_delay,
+        max_retry_delay: max_retry_delay
+      )
+
+      @projects = Openlayer::Resources::Projects.new(client: self)
+      @commits = Openlayer::Resources::Commits.new(client: self)
+      @inference_pipelines = Openlayer::Resources::InferencePipelines.new(client: self)
+      @storage = Openlayer::Resources::Storage.new(client: self)
     end
   end
 end