The Hanzo Ruby library provides convenient access to the Hanzo REST API from any Ruby 3.1.0+ application.
It is generated with Stainless.
Documentation for released of this gem can be found on RubyDoc.
The underlying REST API documentation can be found on docs.hanzo.ai.
To use this gem, install via Bundler by adding the following to your application's Gemfile:
gem "hanzoai", "~> 0.1.0.pre.alpha.3"To fetch an initial copy of the gem:
bundle installrequire "bundler/setup"
require "hanzoai"
hanzo = Hanzoai::Client.new(
api_key: "My API Key", # defaults to ENV["HANZO_API_KEY"]
environment: "sandbox" # defaults to "production"
)
response = hanzo.get_home
puts(response)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 Hanzoai::Error will be thrown:
begin
client = hanzo.get_home
rescue Hanzoai::Errors::APIError => e
puts(e.status) # 400
endError codes are as followed:
| 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 |
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:
# Configure the default for all requests:
hanzo = Hanzoai::Client.new(
max_retries: 0 # default is 2
)
# Or, configure per-request:
hanzo.get_home(request_options: {max_retries: 5})By default, requests will time out after 60 seconds.
Timeouts are applied separately to the initial connection and the overall request time, so in some cases a request could wait 2*timeout seconds before it fails.
You can use the timeout option to configure or disable this:
# Configure the default for all requests:
hanzo = Hanzoai::Client.new(
timeout: nil # default is 60
)
# Or, configure per-request:
hanzo.get_home(request_options: {timeout: 5})This library includes Solargraph support for both auto completion and go to definition.
gem "solargraph", group: :developmentAfter Solargraph is installed, you must populate its index either via the provided editor command, or by running the following in your terminal:
bundle exec solargraph gemsOtherwise Solargraph will not be able to provide type information or auto-completion for any non-indexed libraries.
This library is written with Sorbet type definitions. However, there is no runtime dependency on the sorbet-runtime.
What this means is that while you can use Sorbet to type check your code statically, and benefit from the Sorbet Language Server in your editor, there is no runtime type checking and execution overhead from Sorbet itself.
Due to limitations with the Sorbet type system, where a method otherwise can take an instance of Hanzoai::BaseModel class, you will need to use the ** splat operator to pass the arguments:
Please follow Sorbet's setup guides for best experience.
params = Hanzoai::Models::ClientGetHomeParams.new
hanzo.get_home(**params)Note: This library emits an intentional warning under the tapioca toolchain. This is normal, and does not impact functionality.
The Ruby LSP has best effort support for inferring type information from Ruby code, and as such it may not always be able to provide accurate type information.
This library is typed for convenient access to the documented API.
If you need to access undocumented endpoints, params, or response properties, the library can still be used.
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 requests as seen in examples above.
To make requests to undocumented endpoints, you can make requests using client.request. Options on the client will be respected (such as retries) when making this request.
response =
client.request(
method: :post,
path: '/undocumented/endpoint',
query: {"dog": "woof"},
headers: {"useful-header": "interesting-value"},
body: {"he": "llo"},
)The Hanzoai::Client instances are thread-safe, and should be re-used across multiple threads. By default, each Client have their own HTTP connection pool, with a maximum number of connections equal to thread count.
When the maximum number of connections has been checked out from the connection pool, the Client will wait for an in use connection to become available. The queue time for this mechanism is accounted for by the per-request timeout.
Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
Currently, Hanzoai::Client instances are only fork-safe if there are no in-flight HTTP requests.
This package follows SemVer conventions. As the library is in initial development and has a major version of 0, APIs may change at any time.
This package considers improvements to the (non-runtime) *.rbi and *.rbs type definitions to be non-breaking changes.
Ruby 3.1.0 or higher.