mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
2133 lines
74 KiB
Go
2133 lines
74 KiB
Go
/*
|
|
Hanzo Cloud API
|
|
|
|
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
|
|
API version: v1
|
|
*/
|
|
|
|
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
|
|
|
package hanzoai
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// EvalAPIService EvalAPI service
|
|
type EvalAPIService service
|
|
|
|
type EvalAPIDeleteEvalDatasetsByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
name string
|
|
}
|
|
|
|
func (r EvalAPIDeleteEvalDatasetsByNameRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteEvalDatasetsByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteEvalDatasetsByName Removes the named dataset of the caller's org AND all of its examples, in one transaction.
|
|
|
|
Removes the named dataset of the caller's org AND all of its
|
|
examples, in one transaction.
|
|
|
|
This is not a detach: the examples are gone with the set, so a dataset cannot
|
|
be resurrected by re-creating the name. A name this org does not have is 404 —
|
|
never a silent success — and a name belonging to another tenant is the same
|
|
404, because the delete is predicated on the validated org. Requires a
|
|
validated principal; 401 without one. Runs and scores already recorded against
|
|
the dataset are telemetry events and are NOT deleted with it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset the URL names.
|
|
@return EvalAPIDeleteEvalDatasetsByNameRequest
|
|
*/
|
|
func (a *EvalAPIService) DeleteEvalDatasetsByName(ctx context.Context, name string) EvalAPIDeleteEvalDatasetsByNameRequest {
|
|
return EvalAPIDeleteEvalDatasetsByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *EvalAPIService) DeleteEvalDatasetsByNameExecute(r EvalAPIDeleteEvalDatasetsByNameRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.DeleteEvalDatasetsByName")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/datasets/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalDatasetsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
limit *int64
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalDatasetsRequest) Limit(limit int64) EvalAPIGetEvalDatasetsRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalDatasetsRequest) Execute() (*EvalDatasetList, *http.Response, error) {
|
|
return r.ApiService.GetEvalDatasetsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalDatasets Is the datasets your org has, each with its name, description, metadata and timestamps.
|
|
|
|
Is the datasets your org has, each with its name, description,
|
|
metadata and timestamps.
|
|
|
|
It is the only way to enumerate what an org holds. Requires a validated
|
|
principal; 401 without one. Every row is filtered on the validated org, so
|
|
there is no parameter that reaches another tenant's datasets. The item count is
|
|
NOT populated here — read one dataset to get it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalDatasetsRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalDatasets(ctx context.Context) EvalAPIGetEvalDatasetsRequest {
|
|
return EvalAPIGetEvalDatasetsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalDatasetList
|
|
func (a *EvalAPIService) GetEvalDatasetsExecute(r EvalAPIGetEvalDatasetsRequest) (*EvalDatasetList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalDatasetList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalDatasets")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/datasets"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalDatasetsByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
name string
|
|
}
|
|
|
|
func (r EvalAPIGetEvalDatasetsByNameRequest) Execute() (*EvalDatasetView, *http.Response, error) {
|
|
return r.ApiService.GetEvalDatasetsByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalDatasetsByName Returns one dataset of the caller's org by name, together with its live item count — the one read that answers how big the set actually is.
|
|
|
|
Returns one dataset of the caller's org by name, together with its
|
|
live item count — the one read that answers how big the set actually is.
|
|
|
|
A name this org does not have is 404, which is also what another tenant's
|
|
dataset looks like from here. Requires a validated principal; 401 without one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset the URL names.
|
|
@return EvalAPIGetEvalDatasetsByNameRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalDatasetsByName(ctx context.Context, name string) EvalAPIGetEvalDatasetsByNameRequest {
|
|
return EvalAPIGetEvalDatasetsByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalDatasetView
|
|
func (a *EvalAPIService) GetEvalDatasetsByNameExecute(r EvalAPIGetEvalDatasetsByNameRequest) (*EvalDatasetView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalDatasetView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalDatasetsByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/datasets/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalDatasetsByNameItemsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
name string
|
|
limit *int64
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalDatasetsByNameItemsRequest) Limit(limit int64) EvalAPIGetEvalDatasetsByNameItemsRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalDatasetsByNameItemsRequest) Execute() (*EvalItemList, *http.Response, error) {
|
|
return r.ApiService.GetEvalDatasetsByNameItemsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalDatasetsByNameItems Is the examples in one of your datasets — the set is named in the path, because this collection only exists inside one.
|
|
|
|
Is the examples in one of your datasets — the set is named in the
|
|
path, because this collection only exists inside one.
|
|
|
|
Archived examples are included, so the caller sees the whole set rather than
|
|
only what a run would use. Requires a validated principal; 401 without one, and
|
|
the read is filtered on the validated org, so naming another tenant's dataset
|
|
returns nothing rather than its contents.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Dataset is the set to read, from the path — this collection only exists inside one.
|
|
@return EvalAPIGetEvalDatasetsByNameItemsRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalDatasetsByNameItems(ctx context.Context, name string) EvalAPIGetEvalDatasetsByNameItemsRequest {
|
|
return EvalAPIGetEvalDatasetsByNameItemsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalItemList
|
|
func (a *EvalAPIService) GetEvalDatasetsByNameItemsExecute(r EvalAPIGetEvalDatasetsByNameItemsRequest) (*EvalItemList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalItemList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalDatasetsByNameItems")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/datasets/{name}/items"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalEvaluatorsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
limit *int64
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalEvaluatorsRequest) Limit(limit int64) EvalAPIGetEvalEvaluatorsRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalEvaluatorsRequest) Execute() (*EvalEvaluatorList, *http.Response, error) {
|
|
return r.ApiService.GetEvalEvaluatorsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalEvaluators Is the judges your org has defined, each with its judge model, criteria and the score name it writes under.
|
|
|
|
Is the judges your org has defined, each with its judge model,
|
|
criteria and the score name it writes under.
|
|
|
|
Requires a validated principal; 401 without one, and the listing is filtered on
|
|
the validated org.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalEvaluatorsRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalEvaluators(ctx context.Context) EvalAPIGetEvalEvaluatorsRequest {
|
|
return EvalAPIGetEvalEvaluatorsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalEvaluatorList
|
|
func (a *EvalAPIService) GetEvalEvaluatorsExecute(r EvalAPIGetEvalEvaluatorsRequest) (*EvalEvaluatorList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalEvaluatorList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalEvaluators")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/evaluators"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalMetricsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
range_ *string
|
|
interval *string
|
|
}
|
|
|
|
// Range is 24h (the default), 7d or 30d. Anything else normalises to 24h rather than failing, so the board always has a valid window.
|
|
func (r EvalAPIGetEvalMetricsRequest) Range_(range_ string) EvalAPIGetEvalMetricsRequest {
|
|
r.range_ = &range_
|
|
return r
|
|
}
|
|
|
|
// Interval overrides the bucket the series is grouped into: \"hour\" or \"day\". Any other value leaves the range's own default in place.
|
|
func (r EvalAPIGetEvalMetricsRequest) Interval(interval string) EvalAPIGetEvalMetricsRequest {
|
|
r.interval = &interval
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalMetricsRequest) Execute() (*EvalBoard, *http.Response, error) {
|
|
return r.ApiService.GetEvalMetricsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalMetrics Is your org's AI overview board over a window: totals (generations, prompt and completion tokens, cost in cents, errors, success rate, distinct models and users), a gap-filled time series, a per-model breakdown with the long tail folded into \"other\", and latency percentiles read from the GenAI spans.
|
|
|
|
Is your org's AI overview board over a window: totals
|
|
(generations, prompt and completion tokens, cost in cents, errors, success
|
|
rate, distinct models and users), a gap-filled time series, a per-model
|
|
breakdown with the long tail folded into "other", and latency percentiles read
|
|
from the GenAI spans.
|
|
|
|
The window the answer was actually computed over is echoed back, so a client
|
|
never has to infer it. A platform admin sees the board across ALL orgs;
|
|
everyone else sees their own.
|
|
|
|
The board is HONEST-EMPTY where it cannot be computed: with no datastore wired,
|
|
or under a named project scope the usage ledger does not yet carry, it answers a
|
|
valid board with zero totals and a flat series rather than a fabricated number
|
|
or a 500. Requires a validated principal; 401 without one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalMetricsRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalMetrics(ctx context.Context) EvalAPIGetEvalMetricsRequest {
|
|
return EvalAPIGetEvalMetricsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalBoard
|
|
func (a *EvalAPIService) GetEvalMetricsExecute(r EvalAPIGetEvalMetricsRequest) (*EvalBoard, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalBoard
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalMetrics")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/metrics"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.range_ != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "range", r.range_, "form", "")
|
|
}
|
|
if r.interval != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "interval", r.interval, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalRubricsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
limit *int64
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalRubricsRequest) Limit(limit int64) EvalAPIGetEvalRubricsRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalRubricsRequest) Execute() (*EvalScoreConfigList, *http.Response, error) {
|
|
return r.ApiService.GetEvalRubricsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalRubrics Is the score shapes your org has declared — each name's data type, its numeric bounds and its allowed categories.
|
|
|
|
Is the score shapes your org has declared — each name's data
|
|
type, its numeric bounds and its allowed categories.
|
|
|
|
Requires a validated principal; 401 without one, and the listing is filtered on
|
|
the validated org.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalRubricsRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalRubrics(ctx context.Context) EvalAPIGetEvalRubricsRequest {
|
|
return EvalAPIGetEvalRubricsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalScoreConfigList
|
|
func (a *EvalAPIService) GetEvalRubricsExecute(r EvalAPIGetEvalRubricsRequest) (*EvalScoreConfigList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalScoreConfigList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalRubrics")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/rubrics"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalRunsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
datasetName *string
|
|
limit *int64
|
|
}
|
|
|
|
// Dataset narrows to the runs against one dataset.
|
|
func (r EvalAPIGetEvalRunsRequest) DatasetName(datasetName string) EvalAPIGetEvalRunsRequest {
|
|
r.datasetName = &datasetName
|
|
return r
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalRunsRequest) Limit(limit int64) EvalAPIGetEvalRunsRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalRunsRequest) Execute() (*EvalRuns, *http.Response, error) {
|
|
return r.ApiService.GetEvalRunsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalRuns Is your past runs and how they scored — the dataset and model, the judge model, how many examples were attempted and how many scored, the average score, and when it happened.
|
|
|
|
Is your past runs and how they scored — the dataset and model, the
|
|
judge model, how many examples were attempted and how many scored, the average
|
|
score, and when it happened.
|
|
|
|
Requires a validated principal; 401 without one, and rows are filtered on the
|
|
validated org. These records come from the metastore rather than the datastore,
|
|
so they are readable on a deployment with no telemetry wired — but a run's
|
|
traces and scores are not.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalRunsRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalRuns(ctx context.Context) EvalAPIGetEvalRunsRequest {
|
|
return EvalAPIGetEvalRunsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalRuns
|
|
func (a *EvalAPIService) GetEvalRunsExecute(r EvalAPIGetEvalRunsRequest) (*EvalRuns, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalRuns
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalRuns")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/runs"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.datasetName != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "datasetName", r.datasetName, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalScoresRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
name *string
|
|
runName *string
|
|
traceId *string
|
|
limit *int64
|
|
}
|
|
|
|
// Name narrows to one score name.
|
|
func (r EvalAPIGetEvalScoresRequest) Name(name string) EvalAPIGetEvalScoresRequest {
|
|
r.name = &name
|
|
return r
|
|
}
|
|
|
|
// RunName narrows to the scores of one run.
|
|
func (r EvalAPIGetEvalScoresRequest) RunName(runName string) EvalAPIGetEvalScoresRequest {
|
|
r.runName = &runName
|
|
return r
|
|
}
|
|
|
|
// TraceID narrows to the scores on one model call.
|
|
func (r EvalAPIGetEvalScoresRequest) TraceId(traceId string) EvalAPIGetEvalScoresRequest {
|
|
r.traceId = &traceId
|
|
return r
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalScoresRequest) Limit(limit int64) EvalAPIGetEvalScoresRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalScoresRequest) Execute() (*EvalScoreList, *http.Response, error) {
|
|
return r.ApiService.GetEvalScoresExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalScores Is the score events your org has recorded, narrowed by any of name, runName and traceId.
|
|
|
|
Is the score events your org has recorded, narrowed by any of name,
|
|
runName and traceId.
|
|
|
|
The org is bound as an authoritative predicate on the query, never taken from a
|
|
header, so a filter can narrow the caller's own scores but can never widen past
|
|
them. Requires a validated principal; 401 without one. Scores live in the
|
|
datastore, so a deployment with none wired answers 503 rather than an empty
|
|
page that would read as "no scores".
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalScoresRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalScores(ctx context.Context) EvalAPIGetEvalScoresRequest {
|
|
return EvalAPIGetEvalScoresRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalScoreList
|
|
func (a *EvalAPIService) GetEvalScoresExecute(r EvalAPIGetEvalScoresRequest) (*EvalScoreList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalScoreList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalScores")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/scores"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.name != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "name", r.name, "form", "")
|
|
}
|
|
if r.runName != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "runName", r.runName, "form", "")
|
|
}
|
|
if r.traceId != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "traceId", r.traceId, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIGetEvalTracesRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
sessionId *string
|
|
runName *string
|
|
datasetName *string
|
|
limit *int64
|
|
}
|
|
|
|
// SessionID narrows to one session, which for an evaluation is one run.
|
|
func (r EvalAPIGetEvalTracesRequest) SessionId(sessionId string) EvalAPIGetEvalTracesRequest {
|
|
r.sessionId = &sessionId
|
|
return r
|
|
}
|
|
|
|
// RunName narrows to the calls one run made.
|
|
func (r EvalAPIGetEvalTracesRequest) RunName(runName string) EvalAPIGetEvalTracesRequest {
|
|
r.runName = &runName
|
|
return r
|
|
}
|
|
|
|
// Dataset narrows to the calls made against one dataset.
|
|
func (r EvalAPIGetEvalTracesRequest) DatasetName(datasetName string) EvalAPIGetEvalTracesRequest {
|
|
r.datasetName = &datasetName
|
|
return r
|
|
}
|
|
|
|
// Limit caps the rows returned. It defaults to 100 and is capped at 500; a non-positive or unparseable value falls back to the default rather than failing, because a typo about paging is not a reason to refuse a read.
|
|
func (r EvalAPIGetEvalTracesRequest) Limit(limit int64) EvalAPIGetEvalTracesRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIGetEvalTracesRequest) Execute() (*EvalTraceList, *http.Response, error) {
|
|
return r.ApiService.GetEvalTracesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetEvalTraces Is the traces behind your evaluations — one per model call an evaluation made, carrying its input, output, model and timing — narrowed by any of sessionId, runName and datasetName.
|
|
|
|
Is the traces behind your evaluations — one per model call an
|
|
evaluation made, carrying its input, output, model and timing — narrowed by any
|
|
of sessionId, runName and datasetName.
|
|
|
|
Scoped by org AND by project: the project is the caller's server-minted scope,
|
|
not a parameter, so it cannot be widened by asking. Requires a validated
|
|
principal; 401 without one. Traces live in the datastore, so a deployment with
|
|
none wired answers 503 rather than an empty page.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIGetEvalTracesRequest
|
|
*/
|
|
func (a *EvalAPIService) GetEvalTraces(ctx context.Context) EvalAPIGetEvalTracesRequest {
|
|
return EvalAPIGetEvalTracesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalTraceList
|
|
func (a *EvalAPIService) GetEvalTracesExecute(r EvalAPIGetEvalTracesRequest) (*EvalTraceList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalTraceList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.GetEvalTraces")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/traces"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.sessionId != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "sessionId", r.sessionId, "form", "")
|
|
}
|
|
if r.runName != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "runName", r.runName, "form", "")
|
|
}
|
|
if r.datasetName != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "datasetName", r.datasetName, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIPostEvalDatasetsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
evalDatasetReq *EvalDatasetReq
|
|
}
|
|
|
|
func (r EvalAPIPostEvalDatasetsRequest) EvalDatasetReq(evalDatasetReq EvalDatasetReq) EvalAPIPostEvalDatasetsRequest {
|
|
r.evalDatasetReq = &evalDatasetReq
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalDatasetsRequest) Execute() (*EvalDatasetView, *http.Response, error) {
|
|
return r.ApiService.PostEvalDatasetsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostEvalDatasets Writes a dataset — the named set of graded examples a run scores a model against — under the caller's org and answers 201 with it.
|
|
|
|
Writes a dataset — the named set of graded examples a run scores
|
|
a model against — under the caller's org and answers 201 with it.
|
|
|
|
The NAME is the key, not an id: posting a name the org already has updates that
|
|
dataset's description and metadata and keeps its original creation time, so this
|
|
is create-or-edit and never a duplicate. Its items are untouched.
|
|
|
|
Requires a validated principal; 401 without one. The org comes from the
|
|
validated owner claim, never from a client X-Org-Id, so a dataset can only ever
|
|
be written under the caller's own tenant. A description over 64 KiB is 400.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIPostEvalDatasetsRequest
|
|
*/
|
|
func (a *EvalAPIService) PostEvalDatasets(ctx context.Context) EvalAPIPostEvalDatasetsRequest {
|
|
return EvalAPIPostEvalDatasetsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalDatasetView
|
|
func (a *EvalAPIService) PostEvalDatasetsExecute(r EvalAPIPostEvalDatasetsRequest) (*EvalDatasetView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalDatasetView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.PostEvalDatasets")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/datasets"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.evalDatasetReq == nil {
|
|
return localVarReturnValue, nil, reportError("evalDatasetReq is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.evalDatasetReq
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIPostEvalDatasetsByNameItemsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
name string
|
|
evalItemReq *EvalItemReq
|
|
}
|
|
|
|
func (r EvalAPIPostEvalDatasetsByNameItemsRequest) EvalItemReq(evalItemReq EvalItemReq) EvalAPIPostEvalDatasetsByNameItemsRequest {
|
|
r.evalItemReq = &evalItemReq
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalDatasetsByNameItemsRequest) Execute() (*EvalItemView, *http.Response, error) {
|
|
return r.ApiService.PostEvalDatasetsByNameItemsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostEvalDatasetsByNameItems Writes one graded example — its input, its expected output, free-form metadata and a status — into the dataset named in the path, and answers 201 with it.
|
|
|
|
Writes one graded example — its input, its expected output,
|
|
free-form metadata and a status — into the dataset named in the path, and
|
|
answers 201 with it.
|
|
|
|
That dataset MUST already exist for this org: an unknown one is 404, never a
|
|
silent create. Requires a validated principal; 401 without one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name
|
|
@return EvalAPIPostEvalDatasetsByNameItemsRequest
|
|
*/
|
|
func (a *EvalAPIService) PostEvalDatasetsByNameItems(ctx context.Context, name string) EvalAPIPostEvalDatasetsByNameItemsRequest {
|
|
return EvalAPIPostEvalDatasetsByNameItemsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalItemView
|
|
func (a *EvalAPIService) PostEvalDatasetsByNameItemsExecute(r EvalAPIPostEvalDatasetsByNameItemsRequest) (*EvalItemView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalItemView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.PostEvalDatasetsByNameItems")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/datasets/{name}/items"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.evalItemReq == nil {
|
|
return localVarReturnValue, nil, reportError("evalItemReq is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.evalItemReq
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIPostEvalEvaluatorsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
evalEvaluatorReq *EvalEvaluatorReq
|
|
}
|
|
|
|
func (r EvalAPIPostEvalEvaluatorsRequest) EvalEvaluatorReq(evalEvaluatorReq EvalEvaluatorReq) EvalAPIPostEvalEvaluatorsRequest {
|
|
r.evalEvaluatorReq = &evalEvaluatorReq
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalEvaluatorsRequest) Execute() (*EvalEvaluatorView, *http.Response, error) {
|
|
return r.ApiService.PostEvalEvaluatorsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostEvalEvaluators Saves a reusable judge for the caller's org — the judge model and the written criteria it grades against — and answers 201 with it.
|
|
|
|
Saves a reusable judge for the caller's org — the judge model
|
|
and the written criteria it grades against — and answers 201 with it.
|
|
|
|
Like a dataset, the NAME is the key: re-posting a name edits that judge rather
|
|
than adding a second one. Requires a validated principal; 401 without one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIPostEvalEvaluatorsRequest
|
|
*/
|
|
func (a *EvalAPIService) PostEvalEvaluators(ctx context.Context) EvalAPIPostEvalEvaluatorsRequest {
|
|
return EvalAPIPostEvalEvaluatorsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalEvaluatorView
|
|
func (a *EvalAPIService) PostEvalEvaluatorsExecute(r EvalAPIPostEvalEvaluatorsRequest) (*EvalEvaluatorView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalEvaluatorView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.PostEvalEvaluators")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/evaluators"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.evalEvaluatorReq == nil {
|
|
return localVarReturnValue, nil, reportError("evalEvaluatorReq is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.evalEvaluatorReq
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIPostEvalRubricsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
evalScoreConfigReq *EvalScoreConfigReq
|
|
}
|
|
|
|
func (r EvalAPIPostEvalRubricsRequest) EvalScoreConfigReq(evalScoreConfigReq EvalScoreConfigReq) EvalAPIPostEvalRubricsRequest {
|
|
r.evalScoreConfigReq = &evalScoreConfigReq
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalRubricsRequest) Execute() (*EvalScoreConfigView, *http.Response, error) {
|
|
return r.ApiService.PostEvalRubricsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostEvalRubrics Defines the shape of one score name for the caller's org and answers 201 with it.
|
|
|
|
Defines the shape of one score name for the caller's org and
|
|
answers 201 with it.
|
|
|
|
This is the integrity contract, not documentation: once a rubric exists for a
|
|
name, every score recorded under that name is checked against it and the
|
|
rubric's data type is AUTHORITATIVE — a caller cannot claim a different one.
|
|
Out-of-range values, unlisted labels and non-finite numbers are refused at
|
|
write time.
|
|
|
|
A CATEGORICAL rubric with no categories is 400, as is a non-finite bound or a
|
|
minValue above maxValue. Requires a validated principal; 401 without one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIPostEvalRubricsRequest
|
|
*/
|
|
func (a *EvalAPIService) PostEvalRubrics(ctx context.Context) EvalAPIPostEvalRubricsRequest {
|
|
return EvalAPIPostEvalRubricsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalScoreConfigView
|
|
func (a *EvalAPIService) PostEvalRubricsExecute(r EvalAPIPostEvalRubricsRequest) (*EvalScoreConfigView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalScoreConfigView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.PostEvalRubrics")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/rubrics"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.evalScoreConfigReq == nil {
|
|
return localVarReturnValue, nil, reportError("evalScoreConfigReq is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.evalScoreConfigReq
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIPostEvalRunsRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
evalRunRequest *EvalRunRequest
|
|
authorization *string
|
|
}
|
|
|
|
func (r EvalAPIPostEvalRunsRequest) EvalRunRequest(evalRunRequest EvalRunRequest) EvalAPIPostEvalRunsRequest {
|
|
r.evalRunRequest = &evalRunRequest
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalRunsRequest) Authorization(authorization string) EvalAPIPostEvalRunsRequest {
|
|
r.authorization = &authorization
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalRunsRequest) Execute() (*EvalRunSummary, *http.Response, error) {
|
|
return r.ApiService.PostEvalRunsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostEvalRuns Runs a real evaluation and answers the summary when it is finished — this is synchronous work, not a job id.
|
|
|
|
Runs a real evaluation and answers the summary when it is finished —
|
|
this is synchronous work, not a job id.
|
|
|
|
For each ACTIVE example in the dataset it calls the model under test, records a
|
|
trace, calls the LLM-as-judge, and records the judge's score with its
|
|
reasoning. The answer carries the per-item results (item id, trace id, score,
|
|
output or error) alongside items, scored and avgScore.
|
|
|
|
The dataset must belong to the caller's org (404 otherwise) and must have at
|
|
least one ACTIVE example (422 otherwise).
|
|
|
|
It runs as YOU: the caller's own Authorization bearer drives the model gateway,
|
|
so a request without one is 401 rather than a run made anonymously or under a
|
|
service identity. Only a non-reversible hash of that credential is recorded on
|
|
the traces.
|
|
|
|
Bounded and honest about it: an org may have at most 4 runs in flight and the
|
|
fifth is 429 rather than queued, and the whole run is capped at 10 minutes —
|
|
examples past the deadline come back with an error instead of a score, and
|
|
scored counts only real successes. A run where NOTHING scored answers 502, not
|
|
a 200 that looks like an evaluation. A run must be able to persist what it
|
|
produces, so a deployment with no datastore wired is 503 up front. Requires a
|
|
validated principal; 401 without one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIPostEvalRunsRequest
|
|
*/
|
|
func (a *EvalAPIService) PostEvalRuns(ctx context.Context) EvalAPIPostEvalRunsRequest {
|
|
return EvalAPIPostEvalRunsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalRunSummary
|
|
func (a *EvalAPIService) PostEvalRunsExecute(r EvalAPIPostEvalRunsRequest) (*EvalRunSummary, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalRunSummary
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.PostEvalRuns")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/runs"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.evalRunRequest == nil {
|
|
return localVarReturnValue, nil, reportError("evalRunRequest is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
if r.authorization != nil {
|
|
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
|
|
}
|
|
// body params
|
|
localVarPostBody = r.evalRunRequest
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
if localVarHTTPResponse.StatusCode == 502 {
|
|
var v EvalRunSummary
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type EvalAPIPostEvalScoresRequest struct {
|
|
ctx context.Context
|
|
ApiService *EvalAPIService
|
|
evalScoreReq *EvalScoreReq
|
|
}
|
|
|
|
func (r EvalAPIPostEvalScoresRequest) EvalScoreReq(evalScoreReq EvalScoreReq) EvalAPIPostEvalScoresRequest {
|
|
r.evalScoreReq = &evalScoreReq
|
|
return r
|
|
}
|
|
|
|
func (r EvalAPIPostEvalScoresRequest) Execute() (*EvalScoreView, *http.Response, error) {
|
|
return r.ApiService.PostEvalScoresExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostEvalScores Files one score event for the caller's org and answers 201 with it.
|
|
|
|
Files one score event for the caller's org and answers 201 with it.
|
|
|
|
This is how human review and out-of-band graders land beside the automatic
|
|
ones: name the score, give it a value (or a stringValue for a categorical
|
|
label), and attach it to a trace, a run, a dataset example, or any combination.
|
|
|
|
Scores are validated fail-closed. A value must be FINITE — NaN and Inf are 400
|
|
— and if the org has declared a rubric for this name, that rubric decides the
|
|
type and the value must satisfy it: inside the numeric bounds, or one of the
|
|
allowed categories. A caller cannot override the declared type by sending a
|
|
different dataType.
|
|
|
|
A score is TELEMETRY, not metadata, so it needs the datastore: a deployment
|
|
with none wired answers 503 rather than accepting a score it cannot persist.
|
|
Requires a validated principal; 401 without one, and the org is stamped from
|
|
the validated claim rather than read off the body.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return EvalAPIPostEvalScoresRequest
|
|
*/
|
|
func (a *EvalAPIService) PostEvalScores(ctx context.Context) EvalAPIPostEvalScoresRequest {
|
|
return EvalAPIPostEvalScoresRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return EvalScoreView
|
|
func (a *EvalAPIService) PostEvalScoresExecute(r EvalAPIPostEvalScoresRequest) (*EvalScoreView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *EvalScoreView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EvalAPIService.PostEvalScores")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/eval/scores"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.evalScoreReq == nil {
|
|
return localVarReturnValue, nil, reportError("evalScoreReq is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.evalScoreReq
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|