cwevals

package module
v0.0.1-beta.4 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 17, 2026 License: Apache-2.0 Imports: 19 Imported by: 0

README

CoreWeave Evaluations Go API Library

Go Reference

The CoreWeave Evaluations Go library provides convenient access to the CoreWeave Evaluations REST API from applications written in Go.

It is generated with Stainless.

Installation

import (
	"github.com/wandb/cwevals-go" // imported as cwevals
)

Or to pin the version:

go get -u 'github.com/wandb/cwevals-go@v0.0.1-beta.4'

Requirements

This library requires Go 1.26.2+.

Usage

The full API of this library can be found in api.md.

package main

import (
	"context"
	"fmt"

	"github.com/wandb/cwevals-go"
	"github.com/wandb/cwevals-go/option"
)

func main() {
	client := cwevals.NewClient(
		option.WithUsername("My Username"),
		option.WithAPIKey("My API Key"), // defaults to os.LookupEnv("WANDB_API_KEY")
	)
	service, err := client.Service.Get(context.TODO())
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", service.Message)
}

Request fields

All request parameters are wrapped in a generic Field type, which we use to distinguish zero values from null or omitted fields.

This prevents accidentally sending a zero value if you forget a required parameter, and enables explicitly sending null, false, '', or 0 on optional parameters. Any field not specified is not sent.

To construct fields with values, use the helpers String(), Int(), Float(), or most commonly, the generic F[T](). To send a null, use Null[T](), and to send a nonconforming value, use Raw[T](any). For example:

params := FooParams{
	Name: cwevals.F("hello"),

	// Explicitly send `"description": null`
	Description: cwevals.Null[string](),

	Point: cwevals.F(cwevals.Point{
		X: cwevals.Int(0),
		Y: cwevals.Int(1),

		// In cases where the API specifies a given type,
		// but you want to send something else, use `Raw`:
		Z: cwevals.Raw[int64](0.01), // sends a float
	}),
}
Response objects

All fields in response structs are value types (not pointers or wrappers).

If a given field is null, not present, or invalid, the corresponding field will simply be its zero value.

All response structs also include a special JSON field, containing more detailed information about each property, which you can use like so:

if res.Name == "" {
	// true if `"name"` is either not present or explicitly null
	res.JSON.Name.IsNull()

	// true if the `"name"` key was not present in the response JSON at all
	res.JSON.Name.IsMissing()

	// When the API returns data that cannot be coerced to the expected type:
	if res.JSON.Name.IsInvalid() {
		raw := res.JSON.Name.Raw()

		legacyName := struct{
			First string `json:"first"`
			Last  string `json:"last"`
		}{}
		json.Unmarshal([]byte(raw), &legacyName)
		name = legacyName.First + " " + legacyName.Last
	}
}

These .JSON structs also include an Extras map containing any properties in the json response that were not specified in the struct. This can be useful for API features not yet present in the SDK.

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()
RequestOptions

This library uses the functional options pattern. Functions defined in the option package return a RequestOption, which is a closure that mutates a RequestConfig. These options can be supplied to the client or at individual requests. For example:

client := cwevals.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Service.Get(context.TODO(), ...,
	// Override the header
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Add an undocumented field to the request body, using sjson syntax
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

See the full list of request options.

Pagination

This library provides some conveniences for working with paginated list endpoints.

You can use .ListAutoPaging() methods to iterate through items across all pages:

Or you can use simple .List() methods to fetch a single page and receive a standard response object with additional helper methods like .GetNextPage(), e.g.:

Errors

When the API returns a non-success status code, we return an error with type *cwevals.Error. This contains the StatusCode, *http.Request, and *http.Response values of the request, as well as the JSON of the error body (much like other response objects in the SDK).

To handle errors, we recommend that you use the errors.As pattern:

_, err := client.Service.Get(context.TODO())
if err != nil {
	var apierr *cwevals.Error
	if errors.As(err, &apierr) {
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // GET "/": 400 Bad Request { ... }
}

When other errors occur, they are returned unwrapped; for example, if HTTP transport fails, you might receive *url.Error wrapping *net.OpError.

Timeouts

Requests do not time out by default; use context to configure a timeout for a request lifecycle.

Note that if a request is retried, the context timeout does not start over. To set a per-retry timeout, use option.WithRequestTimeout().

// This sets the timeout for the request, including all the retries.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
client.Service.Get(
	ctx,
	// This sets the per-retry timeout
	option.WithRequestTimeout(20*time.Second),
)
File uploads

Request parameters that correspond to file uploads in multipart requests are typed as param.Field[io.Reader]. The contents of the io.Reader will by default be sent as a multipart form part with the file name of "anonymous_file" and content-type of "application/octet-stream".

The file name and content-type can be customized by implementing Name() string or ContentType() string on the run-time type of io.Reader. Note that os.File implements Name() string, so a file returned by os.Open will be sent with the file name on disk.

We also provide a helper cwevals.FileParam(reader io.Reader, filename string, contentType string) which can be used to wrap any io.Reader with the appropriate file name and content type.

Retries

Certain errors will be automatically retried 2 times by default, with a short exponential backoff. We retry by default all connection errors, 408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors.

You can use the WithMaxRetries option to configure or disable this:

// Configure the default for all requests:
client := cwevals.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Service.Get(context.TODO(), option.WithMaxRetries(5))
Accessing raw response data (e.g. response headers)

You can access the raw HTTP response data by using the option.WithResponseInto() request option. This is useful when you need to examine response headers, status codes, or other details.

// Create a variable to store the HTTP response
var response *http.Response
service, err := client.Service.Get(context.TODO(), option.WithResponseInto(&response))
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", service)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)
Making custom/undocumented requests

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.

Undocumented endpoints

To make requests to undocumented endpoints, you can use client.Get, client.Post, and other HTTP verbs. RequestOptions on the client, such as retries, will be respected when making these requests.

var (
    // params can be an io.Reader, a []byte, an encoding/json serializable object,
    // or a "…Params" struct defined in this library.
    params map[string]interface{}

    // result can be an []byte, *http.Response, a encoding/json deserializable object,
    // or a model defined in this library.
    result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
    …
}
Undocumented request params

To make requests using undocumented parameters, you may use either the option.WithQuerySet() or the option.WithJSONSet() methods.

params := FooNewParams{
    ID:   cwevals.F("id_xxxx"),
    Data: cwevals.F(FooNewParamsData{
        FirstName: cwevals.F("John"),
    }),
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))
Undocumented response properties

To access undocumented response properties, you may either access the raw JSON of the response as a string with result.JSON.RawJSON(), or get the raw JSON of a particular field on the result with result.JSON.Foo.Raw().

Any fields that are not present on the response struct will be saved and can be accessed by result.JSON.ExtraFields() which returns the extra fields as a map[string]Field.

Middleware

We provide option.WithMiddleware which applies the given middleware to requests.

func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
	// Before the request
	start := time.Now()
	LogReq(req)

	// Forward the request to the next handler
	res, err = next(req)

	// Handle stuff after the request
	end := time.Now()
	LogRes(res, err, start - end)

    return res, err
}

client := cwevals.NewClient(
	option.WithMiddleware(Logger),
)

When multiple middlewares are provided as variadic arguments, the middlewares are applied left to right. If option.WithMiddleware is given multiple times, for example first in the client then the method, the middleware in the client will run first and the middleware given in the method will run next.

You may also replace the default http.Client with option.WithHTTPClient(client). Only one http client is accepted (this overwrites any previous client) and receives requests after any middleware has been applied.

Semantic versioning

This package generally follows SemVer conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes to library internals which are technically public but not intended or documented for external use. (Please open a GitHub issue to let us know if you are relying on such internals.)
  2. Changes that we do not expect to impact the vast majority of users in practice.

We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

We are keen for your feedback; please open an issue with questions, bugs, or suggestions.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Bool

func Bool(value bool) param.Field[bool]

Bool is a param field helper which helps specify bools.

func DefaultClientOptions

func DefaultClientOptions() []option.RequestOption

DefaultClientOptions read from the environment (WANDB_API_KEY, WANDB_ACCESS_TOKEN, CES_BASE_URL). This should be used to initialize new clients.

func F

func F[T any](value T) param.Field[T]

F is a param field helper used to initialize a param.Field generic struct. This helps specify null, zero values, and overrides, as well as normal values. You can read more about this in our README.

func FileParam

func FileParam(reader io.Reader, filename string, contentType string) param.Field[io.Reader]

FileParam is a param field helper which helps files with a mime content-type.

func Float

func Float(value float64) param.Field[float64]

Float is a param field helper which helps specify floats.

func Int

func Int(value int64) param.Field[int64]

Int is a param field helper which helps specify integers. This is particularly helpful when specifying integer constants for fields.

func Null

func Null[T any]() param.Field[T]

Null is a param field helper which explicitly sends null to the API.

func Raw

func Raw[T any](value any) param.Field[T]

Raw is a param field helper for specifying values for fields when the type you are looking to send is different from the type that is specified in the SDK. For example, if the type of the field is an integer, but you want to send a float, you could do that by setting the corresponding field with Raw[int](0.5).

func String

func String(value string) param.Field[string]

String is a param field helper which helps specify strings.

Types

type CaseFieldValueArrayParam

type CaseFieldValueArrayParam []interface{}

func (CaseFieldValueArrayParam) ImplementsCaseFieldValueUnionParam

func (r CaseFieldValueArrayParam) ImplementsCaseFieldValueUnionParam()

type CaseFieldValueExtensionType

type CaseFieldValueExtensionType string
const (
	CaseFieldValueExtensionTypeWandbImage    CaseFieldValueExtensionType = "wandb-image"
	CaseFieldValueExtensionTypeWandbAudio    CaseFieldValueExtensionType = "wandb-audio"
	CaseFieldValueExtensionTypeWandbVideo    CaseFieldValueExtensionType = "wandb-video"
	CaseFieldValueExtensionTypeWandbHTML     CaseFieldValueExtensionType = "wandb-html"
	CaseFieldValueExtensionTypeWandbBokeh    CaseFieldValueExtensionType = "wandb-bokeh"
	CaseFieldValueExtensionTypeWandbObject3d CaseFieldValueExtensionType = "wandb-object3d"
	CaseFieldValueExtensionTypeWandbMolecule CaseFieldValueExtensionType = "wandb-molecule"
)

func (CaseFieldValueExtensionType) IsKnown

func (r CaseFieldValueExtensionType) IsKnown() bool

type CaseFieldValueMapParam

type CaseFieldValueMapParam map[string]interface{}

func (CaseFieldValueMapParam) ImplementsCaseFieldValueUnionParam

func (r CaseFieldValueMapParam) ImplementsCaseFieldValueUnionParam()

type CaseFieldValueParam

type CaseFieldValueParam struct {
	ExtensionType param.Field[CaseFieldValueExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[CaseFieldValueSchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                      `json:"sha256"         api:"required"`
	Size          param.Field[int64]                       `json:"size"           api:"required"`
	// Row comparison across EvaluationVersions ignores this property.
	Uri         param.Field[string]                    `json:"uri"           api:"required"`
	WbMediaType param.Field[CaseFieldValueWbMediaType] `json:"wb_media_type" api:"required"`
	Boxes       param.Field[interface{}]               `json:"boxes"`
	Caption     param.Field[string]                    `json:"caption"`
	Format      param.Field[string]                    `json:"format"`
	Height      param.Field[int64]                     `json:"height"`
	Masks       param.Field[interface{}]               `json:"masks"`
	Width       param.Field[int64]                     `json:"width"`
}

A value in a top-level Case input or output field.

func (CaseFieldValueParam) ImplementsCaseFieldValueUnionParam

func (r CaseFieldValueParam) ImplementsCaseFieldValueUnionParam()

func (CaseFieldValueParam) MarshalJSON

func (r CaseFieldValueParam) MarshalJSON() (data []byte, err error)

type CaseFieldValueSchemaVersion

type CaseFieldValueSchemaVersion int64
const (
	CaseFieldValueSchemaVersion1 CaseFieldValueSchemaVersion = 1
)

func (CaseFieldValueSchemaVersion) IsKnown

func (r CaseFieldValueSchemaVersion) IsKnown() bool

type CaseFieldValueUnionParam

type CaseFieldValueUnionParam interface {
	ImplementsCaseFieldValueUnionParam()
}

A value in a top-level Case input or output field.

Satisfied by WandbImageV1Param, WandbAudioV1Param, WandbVideoV1Param, WandbHTMLV1Param, WandbBokehV1Param, WandbObject3dV1Param, WandbMoleculeV1Param, shared.UnionBool, shared.UnionFloat, shared.UnionString, CaseFieldValueArrayParam, CaseFieldValueMapParam, CaseFieldValueParam.

Use [Raw()] to specify an arbitrary value for this param

type CaseFieldValueWbMediaType

type CaseFieldValueWbMediaType string
const (
	CaseFieldValueWbMediaTypeImageFile    CaseFieldValueWbMediaType = "image-file"
	CaseFieldValueWbMediaTypeAudioFile    CaseFieldValueWbMediaType = "audio-file"
	CaseFieldValueWbMediaTypeVideoFile    CaseFieldValueWbMediaType = "video-file"
	CaseFieldValueWbMediaTypeHTMLFile     CaseFieldValueWbMediaType = "html-file"
	CaseFieldValueWbMediaTypeBokehFile    CaseFieldValueWbMediaType = "bokeh-file"
	CaseFieldValueWbMediaTypeObject3DFile CaseFieldValueWbMediaType = "object3D-file"
	CaseFieldValueWbMediaTypeMoleculeFile CaseFieldValueWbMediaType = "molecule-file"
)

func (CaseFieldValueWbMediaType) IsKnown

func (r CaseFieldValueWbMediaType) IsKnown() bool

type CaseGetParams

type CaseGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type CaseGetResponse

type CaseGetResponse struct {
	Attributes map[string]interface{} `json:"attributes"  api:"required"`
	CaseID     string                 `json:"case_id"     api:"required"          format:"uuid"`
	CommitID   int64                  `json:"commit_id"   api:"required"`
	ExampleKey string                 `json:"example_key" api:"required,nullable"`
	Input      interface{}            `json:"input"       api:"required"`
	// Namespace that assigned the scope reference.
	Namespace CaseGetResponseNamespace `json:"namespace" api:"required"`
	Output    interface{}              `json:"output"    api:"required"`
	ScopeRef  string                   `json:"scope_ref" api:"required"`
	Variant   string                   `json:"variant"   api:"required,nullable"`
	JSON      caseGetResponseJSON      `json:"-"`
}

func (*CaseGetResponse) UnmarshalJSON

func (r *CaseGetResponse) UnmarshalJSON(data []byte) (err error)

type CaseGetResponseNamespace

type CaseGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	CaseGetResponseNamespaceWandb CaseGetResponseNamespace = "wandb"
)

func (CaseGetResponseNamespace) IsKnown

func (r CaseGetResponseNamespace) IsKnown() bool

type CaseService

type CaseService struct {
	Options []option.RequestOption
}

CaseService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCaseService method instead.

func NewCaseService

func NewCaseService(opts ...option.RequestOption) (r *CaseService)

NewCaseService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CaseService) Get

func (r *CaseService) Get(
	ctx context.Context,
	caseID string,
	query CaseGetParams,
	opts ...option.RequestOption,
) (res *CaseGetResponse, err error)

Returns one published case, including its input, output, variant, attributes, and the commit that published it.

The response has no tags. Read a case's tags through a dataset version.

type CaseValueArrayParam

type CaseValueArrayParam []interface{}

func (CaseValueArrayParam) ImplementsCaseValueUnionParam

func (r CaseValueArrayParam) ImplementsCaseValueUnionParam()

type CaseValueMapParam

type CaseValueMapParam map[string]CaseFieldValueUnionParam

func (CaseValueMapParam) ImplementsCaseValueUnionParam

func (r CaseValueMapParam) ImplementsCaseValueUnionParam()

type CaseValueUnionParam

type CaseValueUnionParam interface {
	ImplementsCaseValueUnionParam()
}

A Case input or output value.

Satisfied by CaseValueMapParam, shared.UnionBool, shared.UnionFloat, shared.UnionString, CaseValueArrayParam.

type Client

type Client struct {
	Options      []option.RequestOption
	Service      *ServiceService
	Verification *VerificationService
	Datasets     *DatasetService
	Cases        *CaseService
	Tags         *TagService
	Comparisons  *ComparisonService
	Scorers      *ScorerService
	Scores       *ScoreService
	Evaluations  *EvaluationService
	EvalTables   *EvalTableService
}

Client creates a struct with services and top level methods that help with interacting with the CoreWeave Evaluations API. You should not instantiate this client directly, and instead use the NewClient method instead.

func NewClient

func NewClient(opts ...option.RequestOption) (r *Client)

NewClient generates a new client with the default option read from the environment (WANDB_API_KEY, WANDB_ACCESS_TOKEN, CES_BASE_URL). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) Delete

func (r *Client) Delete(
	ctx context.Context,
	path string,
	params interface{},
	res interface{},
	opts ...option.RequestOption,
) error

Delete makes a DELETE request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Execute

func (r *Client) Execute(
	ctx context.Context,
	method string,
	path string,
	params interface{},
	res interface{},
	opts ...option.RequestOption,
) error

Execute makes a request with the given context, method, URL, request params, response, and request options. This is useful for hitting undocumented endpoints while retaining the base URL, auth, retries, and other options from the client.

If a byte slice or an io.Reader is supplied to params, it will be used as-is for the request body.

The params is by default serialized into the body using encoding/json. If your type implements a MarshalJSON function, it will be used instead to serialize the request. If a URLQuery method is implemented, the returned url.Values will be used as query strings to the url.

If your params struct uses param.Field, you must provide either [MarshalJSON], [URLQuery], and/or [MarshalForm] functions. It is undefined behavior to use a struct uses param.Field without specifying how it is serialized.

Any "…Params" object defined in this library can be used as the request argument. Note that 'path' arguments will not be forwarded into the url.

The response body will be deserialized into the res variable, depending on its type:

  • A pointer to a *http.Response is populated by the raw response.
  • A pointer to a byte array will be populated with the contents of the request body.
  • A pointer to any other type uses this library's default JSON decoding, which respects UnmarshalJSON if it is defined on the type.
  • A nil value will not read the response body.

For even greater flexibility, see option.WithResponseInto and option.WithResponseBodyInto.

func (*Client) Get

func (r *Client) Get(
	ctx context.Context,
	path string,
	params interface{},
	res interface{},
	opts ...option.RequestOption,
) error

Get makes a GET request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Patch

func (r *Client) Patch(
	ctx context.Context,
	path string,
	params interface{},
	res interface{},
	opts ...option.RequestOption,
) error

Patch makes a PATCH request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Post

func (r *Client) Post(
	ctx context.Context,
	path string,
	params interface{},
	res interface{},
	opts ...option.RequestOption,
) error

Post makes a POST request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Put

func (r *Client) Put(
	ctx context.Context,
	path string,
	params interface{},
	res interface{},
	opts ...option.RequestOption,
) error

Put makes a PUT request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

type ComparisonGetParams

type ComparisonGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type ComparisonGetResponse

type ComparisonGetResponse struct {
	Attributes   map[string]interface{}        `json:"attributes"    api:"required"`
	CommitID     int64                         `json:"commit_id"     api:"required"`
	ComparisonID string                        `json:"comparison_id" api:"required" format:"uuid"`
	Members      []ComparisonGetResponseMember `json:"members"       api:"required"`
	// Namespace that assigned the scope reference.
	Namespace ComparisonGetResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                         `json:"scope_ref" api:"required"`
	JSON      comparisonGetResponseJSON      `json:"-"`
}

func (*ComparisonGetResponse) UnmarshalJSON

func (r *ComparisonGetResponse) UnmarshalJSON(data []byte) (err error)

type ComparisonGetResponseMember

type ComparisonGetResponseMember struct {
	CaseID string                          `json:"case_id" api:"required" format:"uuid"`
	Role   string                          `json:"role"    api:"nullable"`
	JSON   comparisonGetResponseMemberJSON `json:"-"`
}

func (*ComparisonGetResponseMember) UnmarshalJSON

func (r *ComparisonGetResponseMember) UnmarshalJSON(data []byte) (err error)

type ComparisonGetResponseNamespace

type ComparisonGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	ComparisonGetResponseNamespaceWandb ComparisonGetResponseNamespace = "wandb"
)

func (ComparisonGetResponseNamespace) IsKnown

type ComparisonNewParams

type ComparisonNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID     param.Field[string]                          `path:"scope_id" api:"required"`
	Comparisons param.Field[[]ComparisonNewParamsComparison] `                api:"required" json:"comparisons"`
}

func (ComparisonNewParams) MarshalJSON

func (r ComparisonNewParams) MarshalJSON() (data []byte, err error)

type ComparisonNewParamsComparison

type ComparisonNewParamsComparison struct {
	Members    param.Field[[]ComparisonNewParamsComparisonsMember] `json:"members"    api:"required"`
	Attributes param.Field[map[string]interface{}]                 `json:"attributes"`
}

func (ComparisonNewParamsComparison) MarshalJSON

func (r ComparisonNewParamsComparison) MarshalJSON() (data []byte, err error)

type ComparisonNewParamsComparisonsMember

type ComparisonNewParamsComparisonsMember struct {
	CaseID param.Field[string] `json:"case_id" api:"required" format:"uuid"`
	// Optional label for this case's role in the comparison. The service does not
	// impose a vocabulary for roles.
	Role param.Field[string] `json:"role"`
}

func (ComparisonNewParamsComparisonsMember) MarshalJSON

func (r ComparisonNewParamsComparisonsMember) MarshalJSON() (data []byte, err error)

type ComparisonNewResponse

type ComparisonNewResponse struct {
	CommitID           int64                     `json:"commit_id"            api:"required"`
	ComparisonIDs      []string                  `json:"comparison_ids"       api:"required" format:"uuid"`
	PublishOperationID string                    `json:"publish_operation_id" api:"required" format:"uuid"`
	JSON               comparisonNewResponseJSON `json:"-"`
}

func (*ComparisonNewResponse) UnmarshalJSON

func (r *ComparisonNewResponse) UnmarshalJSON(data []byte) (err error)

type ComparisonService

type ComparisonService struct {
	Options []option.RequestOption
}

ComparisonService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewComparisonService method instead.

func NewComparisonService

func NewComparisonService(opts ...option.RequestOption) (r *ComparisonService)

NewComparisonService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ComparisonService) Get

func (r *ComparisonService) Get(
	ctx context.Context,
	comparisonID string,
	query ComparisonGetParams,
	opts ...option.RequestOption,
) (res *ComparisonGetResponse, err error)

Returns a published comparison, its member cases in submitted order, and any role labels and attributes.

func (*ComparisonService) New

Groups existing, published cases into comparisons that can be scored together. Each member can have a role label to distinguish its part in the comparison.

The response returns comparison IDs in request order. Cases are grouped by explicit membership, not by matching `example_key` values.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetCaseAddParams

type DatasetCaseAddParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string]                     `path:"scope_id" api:"required"`
	Cases   param.Field[[]DatasetCaseAddParamsCase] `                api:"required" json:"cases"`
	// Derives an example key for each case from a hash of its input, so row comparison
	// can match cases by input. Each top-level extension field hashes by its identity,
	// which leaves out file locations. Numbers hash as float64, so integers that
	// differ only beyond 2^53 derive the same example key, and a number never matches
	// a string. Log numeric identifiers as strings. A case with a null input gets no
	// example key. Without it, a case logged without an example key matches only
	// itself, in versions that read its dataset.
	ExampleKeyFields param.Field[[]DatasetCaseAddParamsExampleKeyField] `json:"example_key_fields"`
}

func (DatasetCaseAddParams) MarshalJSON

func (r DatasetCaseAddParams) MarshalJSON() (data []byte, err error)

type DatasetCaseAddParamsCase

type DatasetCaseAddParamsCase struct {
	Attributes param.Field[map[string]interface{}] `json:"attributes"`
	// Reference to the case's example in external data, such as an S3 object key or
	// row index.
	//
	// - The service stores the reference but does not fetch the example.
	// - Example keys need not be unique. Row comparison matches cases by example key.
	// - A case with no input can use this reference to identify its example.
	//
	// Omit or send null when no example reference applies. Omit on every case when the
	// request sets example_key_fields.
	ExampleKey param.Field[string] `json:"example_key"`
	// Input data for this case, such as a prompt or feature values.
	//
	// For JSON objects:
	//
	//   - Top-level field names must contain 1 to 512 Unicode characters, with no
	//     leading or trailing whitespace.
	//   - All numeric fields are inferred as number, even whole-valued literals.
	//   - Queries use float64 numbers, which can round integers beyond 2^53. The stored
	//     JSON remains exact.
	//
	// Omit to store null.
	Input param.Field[CaseValueUnionParam] `json:"input"`
	// Output recorded for this case, such as a model response.
	//
	// For JSON objects:
	//
	//   - Top-level field names must contain 1 to 512 Unicode characters, with no
	//     leading or trailing whitespace.
	//   - All numeric fields are inferred as number, even whole-valued literals.
	//   - Queries use float64 numbers, which can round integers beyond 2^53. The stored
	//     JSON remains exact.
	//
	// Omit to store null.
	Output param.Field[CaseValueUnionParam] `json:"output"`
	// Tag names for this case. The service trims each name, drops repeats, and matches
	// names case-sensitively.
	Tags param.Field[[]string] `json:"tags"`
	// Trajectory to add this case to. It must belong to the same dataset. Omit or send
	// null for a case outside any trajectory.
	TrajectoryID param.Field[string] `json:"trajectory_id" format:"uuid"`
	// Model, agent, prompt, or checkpoint this case evaluates. Leading and trailing
	// whitespace are not allowed. Omit or send null when no variant applies.
	Variant param.Field[string] `json:"variant"`
}

func (DatasetCaseAddParamsCase) MarshalJSON

func (r DatasetCaseAddParamsCase) MarshalJSON() (data []byte, err error)

type DatasetCaseAddParamsExampleKeyField

type DatasetCaseAddParamsExampleKeyField string
const (
	DatasetCaseAddParamsExampleKeyFieldInput DatasetCaseAddParamsExampleKeyField = "input"
)

func (DatasetCaseAddParamsExampleKeyField) IsKnown

type DatasetCaseAddResponse

type DatasetCaseAddResponse struct {
	CaseIDs            []string                   `json:"case_ids"             api:"required" format:"uuid"`
	CommitID           int64                      `json:"commit_id"            api:"required"`
	PublishOperationID string                     `json:"publish_operation_id" api:"required" format:"uuid"`
	JSON               datasetCaseAddResponseJSON `json:"-"`
}

func (*DatasetCaseAddResponse) UnmarshalJSON

func (r *DatasetCaseAddResponse) UnmarshalJSON(data []byte) (err error)

type DatasetCaseService

type DatasetCaseService struct {
	Options []option.RequestOption
	Tags    *DatasetCaseTagService
}

DatasetCaseService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetCaseService method instead.

func NewDatasetCaseService

func NewDatasetCaseService(opts ...option.RequestOption) (r *DatasetCaseService)

NewDatasetCaseService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetCaseService) Add

func (r *DatasetCaseService) Add(
	ctx context.Context,
	datasetID string,
	params DatasetCaseAddParams,
	opts ...option.RequestOption,
) (res *DatasetCaseAddResponse, err error)

Stores a batch of cases. Each case contains an input, an output, and optional metadata, such as the model or checkpoint that produced the output.

Top-level fields in input and output objects are added to the dataset's field catalog. The response returns case IDs in request order.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetCaseTagService

type DatasetCaseTagService struct {
	Options []option.RequestOption
}

DatasetCaseTagService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetCaseTagService method instead.

func NewDatasetCaseTagService

func NewDatasetCaseTagService(opts ...option.RequestOption) (r *DatasetCaseTagService)

NewDatasetCaseTagService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetCaseTagService) Update

Atomically adds tags to and removes tags from cases in the dataset's pending version. Published dataset versions keep their tags. The response lists cases in request order, each with its tags after the edit sorted by name.

Concurrent writes to the same dataset apply in turn. A case that is not in the dataset returns 404. A case that would hold more than 10 tags returns 400. Adding a tag a case already has, or removing one it lacks, changes nothing. If any item is invalid, no tags change. A retry with the same Idempotency-Key replays the first response.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetCaseTagUpdateParams

type DatasetCaseTagUpdateParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Tag edits to apply. Each case ID must be unique.
	Cases param.Field[[]DatasetCaseTagUpdateParamsCase] `json:"cases" api:"required"`
}

func (DatasetCaseTagUpdateParams) MarshalJSON

func (r DatasetCaseTagUpdateParams) MarshalJSON() (data []byte, err error)

type DatasetCaseTagUpdateParamsCase

type DatasetCaseTagUpdateParamsCase struct {
	CaseID param.Field[string] `json:"case_id" api:"required" format:"uuid"`
	// Tag names to add to this case. The service trims each name, drops repeats, and
	// matches names case-sensitively.
	Add param.Field[[]string] `json:"add"`
	// Tag names to remove from this case. The service trims each name, drops repeats,
	// and matches names case-sensitively.
	Remove param.Field[[]string] `json:"remove"`
}

func (DatasetCaseTagUpdateParamsCase) MarshalJSON

func (r DatasetCaseTagUpdateParamsCase) MarshalJSON() (data []byte, err error)

type DatasetCaseTagUpdateResponse

type DatasetCaseTagUpdateResponse struct {
	Cases              []DatasetCaseTagUpdateResponseCase `json:"cases"                api:"required"`
	CommitID           int64                              `json:"commit_id"            api:"required"`
	PublishOperationID string                             `json:"publish_operation_id" api:"required" format:"uuid"`
	JSON               datasetCaseTagUpdateResponseJSON   `json:"-"`
}

func (*DatasetCaseTagUpdateResponse) UnmarshalJSON

func (r *DatasetCaseTagUpdateResponse) UnmarshalJSON(data []byte) (err error)

type DatasetCaseTagUpdateResponseCase

type DatasetCaseTagUpdateResponseCase struct {
	CaseID string                               `json:"case_id" api:"required" format:"uuid"`
	Tags   []string                             `json:"tags"    api:"required"`
	JSON   datasetCaseTagUpdateResponseCaseJSON `json:"-"`
}

func (*DatasetCaseTagUpdateResponseCase) UnmarshalJSON

func (r *DatasetCaseTagUpdateResponseCase) UnmarshalJSON(data []byte) (err error)

type DatasetDeleteParams

type DatasetDeleteParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type DatasetFieldNewParams

type DatasetFieldNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string]                       `path:"scope_id" api:"required"`
	Fields  param.Field[[]DatasetFieldNewParamsField] `                api:"required" json:"fields"`
}

func (DatasetFieldNewParams) MarshalJSON

func (r DatasetFieldNewParams) MarshalJSON() (data []byte, err error)

type DatasetFieldNewParamsField

type DatasetFieldNewParamsField struct {
	Name      param.Field[string]                               `json:"name"       api:"required"`
	Source    param.Field[DatasetFieldNewParamsFieldsSource]    `json:"source"     api:"required"`
	ValueType param.Field[DatasetFieldNewParamsFieldsValueType] `json:"value_type" api:"required"`
}

func (DatasetFieldNewParamsField) MarshalJSON

func (r DatasetFieldNewParamsField) MarshalJSON() (data []byte, err error)

type DatasetFieldNewParamsFieldsSource

type DatasetFieldNewParamsFieldsSource string
const (
	DatasetFieldNewParamsFieldsSourceInput  DatasetFieldNewParamsFieldsSource = "input"
	DatasetFieldNewParamsFieldsSourceOutput DatasetFieldNewParamsFieldsSource = "output"
)

func (DatasetFieldNewParamsFieldsSource) IsKnown

type DatasetFieldNewParamsFieldsValueType

type DatasetFieldNewParamsFieldsValueType string
const (
	DatasetFieldNewParamsFieldsValueTypeBoolean DatasetFieldNewParamsFieldsValueType = "boolean"
	DatasetFieldNewParamsFieldsValueTypeInteger DatasetFieldNewParamsFieldsValueType = "integer"
	DatasetFieldNewParamsFieldsValueTypeNumber  DatasetFieldNewParamsFieldsValueType = "number"
	DatasetFieldNewParamsFieldsValueTypeString  DatasetFieldNewParamsFieldsValueType = "string"
	DatasetFieldNewParamsFieldsValueTypeJson    DatasetFieldNewParamsFieldsValueType = "json"
)

func (DatasetFieldNewParamsFieldsValueType) IsKnown

type DatasetFieldNewResponse

type DatasetFieldNewResponse struct {
	Fields []DatasetFieldNewResponseField `json:"fields" api:"required"`
	JSON   datasetFieldNewResponseJSON    `json:"-"`
}

func (*DatasetFieldNewResponse) UnmarshalJSON

func (r *DatasetFieldNewResponse) UnmarshalJSON(data []byte) (err error)

type DatasetFieldNewResponseField

type DatasetFieldNewResponseField struct {
	DatasetFieldID int64                                  `json:"dataset_field_id" api:"required"`
	Name           string                                 `json:"name"             api:"required"`
	Source         DatasetFieldNewResponseFieldsSource    `json:"source"           api:"required"`
	ValueType      DatasetFieldNewResponseFieldsValueType `json:"value_type"       api:"required"`
	JSON           datasetFieldNewResponseFieldJSON       `json:"-"`
}

func (*DatasetFieldNewResponseField) UnmarshalJSON

func (r *DatasetFieldNewResponseField) UnmarshalJSON(data []byte) (err error)

type DatasetFieldNewResponseFieldsSource

type DatasetFieldNewResponseFieldsSource string
const (
	DatasetFieldNewResponseFieldsSourceInput  DatasetFieldNewResponseFieldsSource = "input"
	DatasetFieldNewResponseFieldsSourceOutput DatasetFieldNewResponseFieldsSource = "output"
)

func (DatasetFieldNewResponseFieldsSource) IsKnown

type DatasetFieldNewResponseFieldsValueType

type DatasetFieldNewResponseFieldsValueType string
const (
	DatasetFieldNewResponseFieldsValueTypeBoolean DatasetFieldNewResponseFieldsValueType = "boolean"
	DatasetFieldNewResponseFieldsValueTypeInteger DatasetFieldNewResponseFieldsValueType = "integer"
	DatasetFieldNewResponseFieldsValueTypeNumber  DatasetFieldNewResponseFieldsValueType = "number"
	DatasetFieldNewResponseFieldsValueTypeString  DatasetFieldNewResponseFieldsValueType = "string"
	DatasetFieldNewResponseFieldsValueTypeJson    DatasetFieldNewResponseFieldsValueType = "json"
)

func (DatasetFieldNewResponseFieldsValueType) IsKnown

type DatasetFieldService

type DatasetFieldService struct {
	Options []option.RequestOption
}

DatasetFieldService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetFieldService method instead.

func NewDatasetFieldService

func NewDatasetFieldService(opts ...option.RequestOption) (r *DatasetFieldService)

NewDatasetFieldService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetFieldService) New

func (r *DatasetFieldService) New(
	ctx context.Context,
	datasetID string,
	params DatasetFieldNewParams,
	opts ...option.RequestOption,
) (res *DatasetFieldNewResponse, err error)

Declares input or output fields on the dataset's pending version so you can choose their types before adding cases.

Repeating an identical declaration makes no change. A declaration that conflicts with an existing field's type is rejected.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetGetParams

type DatasetGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type DatasetGetResponse

type DatasetGetResponse struct {
	Attributes map[string]interface{} `json:"attributes" api:"required"`
	CreatedAt  time.Time              `json:"created_at" api:"required" format:"date-time"`
	DatasetID  string                 `json:"dataset_id" api:"required" format:"uuid"`
	// ID of the current pending dataset version. Publishing this version freezes its
	// contents and opens a new pending version.
	HeadVersionID string `json:"head_version_id" api:"required" format:"uuid"`
	Name          string `json:"name"            api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetGetResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                      `json:"scope_ref" api:"required"`
	JSON      datasetGetResponseJSON      `json:"-"`
}

func (*DatasetGetResponse) UnmarshalJSON

func (r *DatasetGetResponse) UnmarshalJSON(data []byte) (err error)

type DatasetGetResponseNamespace

type DatasetGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	DatasetGetResponseNamespaceWandb DatasetGetResponseNamespace = "wandb"
)

func (DatasetGetResponseNamespace) IsKnown

func (r DatasetGetResponseNamespace) IsKnown() bool

type DatasetListParams

type DatasetListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Lists only Datasets with exactly this name. Omit to list every Dataset in the
	// scope.
	Name param.Field[string] `query:"name"`
}

func (DatasetListParams) URLQuery

func (r DatasetListParams) URLQuery() (v url.Values)

URLQuery serializes DatasetListParams's query parameters as `url.Values`.

type DatasetListResponse

type DatasetListResponse struct {
	Datasets   []DatasetListResponseDataset `json:"datasets"    api:"required"`
	NextCursor string                       `json:"next_cursor"`
	JSON       datasetListResponseJSON      `json:"-"`
}

func (*DatasetListResponse) UnmarshalJSON

func (r *DatasetListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetListResponseDataset

type DatasetListResponseDataset struct {
	Attributes map[string]interface{} `json:"attributes" api:"required"`
	CreatedAt  time.Time              `json:"created_at" api:"required" format:"date-time"`
	DatasetID  string                 `json:"dataset_id" api:"required" format:"uuid"`
	// ID of the current pending dataset version. Publishing this version freezes its
	// contents and opens a new pending version.
	HeadVersionID string `json:"head_version_id" api:"required" format:"uuid"`
	Name          string `json:"name"            api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetListResponseDatasetsNamespace `json:"namespace" api:"required"`
	ScopeRef  string                               `json:"scope_ref" api:"required"`
	JSON      datasetListResponseDatasetJSON       `json:"-"`
}

func (*DatasetListResponseDataset) UnmarshalJSON

func (r *DatasetListResponseDataset) UnmarshalJSON(data []byte) (err error)

type DatasetListResponseDatasetsNamespace

type DatasetListResponseDatasetsNamespace string

Namespace that assigned the scope reference.

const (
	DatasetListResponseDatasetsNamespaceWandb DatasetListResponseDatasetsNamespace = "wandb"
)

func (DatasetListResponseDatasetsNamespace) IsKnown

type DatasetNewParams

type DatasetNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID    param.Field[string]                 `path:"scope_id" api:"required"`
	Name       param.Field[string]                 `                api:"required" json:"name"`
	Attributes param.Field[map[string]interface{}] `                               json:"attributes"`
	// Location of externally stored data, such as s3://bucket/prefix/ or
	// hf://datasets/org/name. The service stores this URI as metadata and does not
	// read from it. Dataset versions inherit it until you supply a replacement when
	// publishing a version.
	Uri param.Field[string] `json:"uri" format:"uri"`
}

func (DatasetNewParams) MarshalJSON

func (r DatasetNewParams) MarshalJSON() (data []byte, err error)

type DatasetNewResponse

type DatasetNewResponse struct {
	Attributes map[string]interface{} `json:"attributes" api:"required"`
	CreatedAt  time.Time              `json:"created_at" api:"required" format:"date-time"`
	DatasetID  string                 `json:"dataset_id" api:"required" format:"uuid"`
	// ID of the current pending dataset version. Publishing this version freezes its
	// contents and opens a new pending version.
	HeadVersionID string `json:"head_version_id" api:"required" format:"uuid"`
	Name          string `json:"name"            api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetNewResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                      `json:"scope_ref" api:"required"`
	JSON      datasetNewResponseJSON      `json:"-"`
}

func (*DatasetNewResponse) UnmarshalJSON

func (r *DatasetNewResponse) UnmarshalJSON(data []byte) (err error)

type DatasetNewResponseNamespace

type DatasetNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	DatasetNewResponseNamespaceWandb DatasetNewResponseNamespace = "wandb"
)

func (DatasetNewResponseNamespace) IsKnown

func (r DatasetNewResponseNamespace) IsKnown() bool

type DatasetService

type DatasetService struct {
	Options      []option.RequestOption
	Cases        *DatasetCaseService
	Fields       *DatasetFieldService
	Versions     *DatasetVersionService
	Trajectories *DatasetTrajectoryService
}

DatasetService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetService method instead.

func NewDatasetService

func NewDatasetService(opts ...option.RequestOption) (r *DatasetService)

NewDatasetService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetService) Delete

func (r *DatasetService) Delete(
	ctx context.Context,
	datasetID string,
	body DatasetDeleteParams,
	opts ...option.RequestOption,
) (err error)

Soft-deletes the Dataset. It, its DatasetVersions, their Cases pages, their case Tag lists, and their fields then return 404, and writes to them are rejected with 404. A Dataset that an Evaluation or EvalTable still sources returns 409 resource_in_use. Delete those Evaluations first. Cases stay readable by ID, and Comparisons and Scores are unchanged. An absent or already deleted Dataset returns 404. A retry with the same Idempotency-Key replays the first response.

func (*DatasetService) Get

func (r *DatasetService) Get(
	ctx context.Context,
	datasetID string,
	query DatasetGetParams,
	opts ...option.RequestOption,
) (res *DatasetGetResponse, err error)

Returns the dataset metadata and the ID of its current pending version in `head_version_id`. The response `ETag` contains the same version ID.

func (*DatasetService) List

func (r *DatasetService) List(
	ctx context.Context,
	params DatasetListParams,
	opts ...option.RequestOption,
) (res *DatasetListResponse, err error)

Pages the scope's Datasets, including those EvalTables created, in ID order. IDs are time-ordered, so the order approximates creation order. A scope without Datasets returns an empty page.

func (*DatasetService) New

func (r *DatasetService) New(
	ctx context.Context,
	params DatasetNewParams,
	opts ...option.RequestOption,
) (res *DatasetNewResponse, err error)

Creates a named collection for cases and an empty, pending first version. Add cases to the dataset, then create a dataset version when you need a reproducible snapshot.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

func (*DatasetService) Update

func (r *DatasetService) Update(
	ctx context.Context,
	datasetID string,
	params DatasetUpdateParams,
	opts ...option.RequestOption,
) (res *DatasetUpdateResponse, err error)

Replaces the Dataset's name, attributes, or both. Omitted fields keep their values, and attributes are replaced as a whole object. A body without either field is rejected. Versions, Cases, and the head version are unchanged, so the ETag stays the same. Concurrent updates are last-writer-wins. A retry with the same Idempotency-Key replays the first response.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetTrajectoryCaseListParams

type DatasetTrajectoryCaseListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (DatasetTrajectoryCaseListParams) URLQuery

func (r DatasetTrajectoryCaseListParams) URLQuery() (v url.Values)

URLQuery serializes DatasetTrajectoryCaseListParams's query parameters as `url.Values`.

type DatasetTrajectoryCaseListResponse

type DatasetTrajectoryCaseListResponse struct {
	Cases      []DatasetTrajectoryCaseListResponseCase `json:"cases"       api:"required"`
	NextCursor string                                  `json:"next_cursor"`
	JSON       datasetTrajectoryCaseListResponseJSON   `json:"-"`
}

func (*DatasetTrajectoryCaseListResponse) UnmarshalJSON

func (r *DatasetTrajectoryCaseListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetTrajectoryCaseListResponseCase

type DatasetTrajectoryCaseListResponseCase struct {
	Attributes map[string]interface{} `json:"attributes" api:"required"`
	CaseID     string                 `json:"case_id"    api:"required" format:"uuid"`
	// Trajectories nested under this trajectory whose root is this case, in the order
	// they were created. Empty when there are none.
	ChildTrajectoryIDs []string    `json:"child_trajectory_ids" api:"required"          format:"uuid"`
	CommitID           int64       `json:"commit_id"            api:"required"`
	ExampleKey         string      `json:"example_key"          api:"required,nullable"`
	Input              interface{} `json:"input"                api:"required"`
	Output             interface{} `json:"output"               api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                  `json:"tags"    api:"required"`
	Variant string                                    `json:"variant" api:"required,nullable"`
	JSON    datasetTrajectoryCaseListResponseCaseJSON `json:"-"`
}

func (*DatasetTrajectoryCaseListResponseCase) UnmarshalJSON

func (r *DatasetTrajectoryCaseListResponseCase) UnmarshalJSON(data []byte) (err error)

type DatasetTrajectoryCaseService

type DatasetTrajectoryCaseService struct {
	Options []option.RequestOption
}

DatasetTrajectoryCaseService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetTrajectoryCaseService method instead.

func NewDatasetTrajectoryCaseService

func NewDatasetTrajectoryCaseService(opts ...option.RequestOption) (r *DatasetTrajectoryCaseService)

NewDatasetTrajectoryCaseService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetTrajectoryCaseService) List

Returns the trajectory's published cases in the order they were created. The root case is not listed.

Pass the returned `next_cursor` as `cursor` to read the next page. The last page has no `next_cursor`.

type DatasetTrajectoryGetParams

type DatasetTrajectoryGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type DatasetTrajectoryGetResponse

type DatasetTrajectoryGetResponse struct {
	CommitID  int64  `json:"commit_id"  api:"required"`
	DatasetID string `json:"dataset_id" api:"required" format:"uuid"`
	// 0 for a top-level trajectory, otherwise one more than its parent's.
	Depth int64  `json:"depth" api:"required"`
	Name  string `json:"name"  api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetTrajectoryGetResponseNamespace `json:"namespace" api:"required"`
	// Null for a top-level trajectory.
	ParentTrajectoryID string                           `json:"parent_trajectory_id" api:"required,nullable" format:"uuid"`
	RootCaseID         string                           `json:"root_case_id"         api:"required"          format:"uuid"`
	ScopeRef           string                           `json:"scope_ref"            api:"required"`
	TrajectoryID       string                           `json:"trajectory_id"        api:"required"          format:"uuid"`
	JSON               datasetTrajectoryGetResponseJSON `json:"-"`
}

func (*DatasetTrajectoryGetResponse) UnmarshalJSON

func (r *DatasetTrajectoryGetResponse) UnmarshalJSON(data []byte) (err error)

type DatasetTrajectoryGetResponseNamespace

type DatasetTrajectoryGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	DatasetTrajectoryGetResponseNamespaceWandb DatasetTrajectoryGetResponseNamespace = "wandb"
)

func (DatasetTrajectoryGetResponseNamespace) IsKnown

type DatasetTrajectoryListParams

type DatasetTrajectoryListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (DatasetTrajectoryListParams) URLQuery

func (r DatasetTrajectoryListParams) URLQuery() (v url.Values)

URLQuery serializes DatasetTrajectoryListParams's query parameters as `url.Values`.

type DatasetTrajectoryListResponse

type DatasetTrajectoryListResponse struct {
	Trajectories []DatasetTrajectoryListResponseTrajectory `json:"trajectories" api:"required"`
	NextCursor   string                                    `json:"next_cursor"`
	JSON         datasetTrajectoryListResponseJSON         `json:"-"`
}

func (*DatasetTrajectoryListResponse) UnmarshalJSON

func (r *DatasetTrajectoryListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetTrajectoryListResponseTrajectory

type DatasetTrajectoryListResponseTrajectory struct {
	CommitID  int64  `json:"commit_id"  api:"required"`
	DatasetID string `json:"dataset_id" api:"required" format:"uuid"`
	// 0 for a top-level trajectory, otherwise one more than its parent's.
	Depth int64  `json:"depth" api:"required"`
	Name  string `json:"name"  api:"required"`
	// Null for a top-level trajectory.
	ParentTrajectoryID string                                      `json:"parent_trajectory_id" api:"required,nullable" format:"uuid"`
	RootCaseID         string                                      `json:"root_case_id"         api:"required"          format:"uuid"`
	TrajectoryID       string                                      `json:"trajectory_id"        api:"required"          format:"uuid"`
	JSON               datasetTrajectoryListResponseTrajectoryJSON `json:"-"`
}

func (*DatasetTrajectoryListResponseTrajectory) UnmarshalJSON

func (r *DatasetTrajectoryListResponseTrajectory) UnmarshalJSON(data []byte) (err error)

type DatasetTrajectoryNewParams

type DatasetTrajectoryNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID      param.Field[string]                                 `path:"scope_id" api:"required"`
	Trajectories param.Field[[]DatasetTrajectoryNewParamsTrajectory] `                api:"required" json:"trajectories"`
}

func (DatasetTrajectoryNewParams) MarshalJSON

func (r DatasetTrajectoryNewParams) MarshalJSON() (data []byte, err error)

type DatasetTrajectoryNewParamsTrajectory

type DatasetTrajectoryNewParamsTrajectory struct {
	// Display name. It need not be unique.
	Name param.Field[string] `json:"name" api:"required"`
	// Case the trajectory starts from. It must be a published case of the same
	// dataset. Several trajectories can share a root.
	RootCaseID param.Field[string] `json:"root_case_id" api:"required" format:"uuid"`
	// Published trajectory of the same dataset to nest this trajectory under. Omit or
	// send null for a top-level trajectory.
	ParentTrajectoryID param.Field[string] `json:"parent_trajectory_id" format:"uuid"`
}

func (DatasetTrajectoryNewParamsTrajectory) MarshalJSON

func (r DatasetTrajectoryNewParamsTrajectory) MarshalJSON() (data []byte, err error)

type DatasetTrajectoryNewResponse

type DatasetTrajectoryNewResponse struct {
	CommitID           int64                            `json:"commit_id"            api:"required"`
	PublishOperationID string                           `json:"publish_operation_id" api:"required" format:"uuid"`
	TrajectoryIDs      []string                         `json:"trajectory_ids"       api:"required" format:"uuid"`
	JSON               datasetTrajectoryNewResponseJSON `json:"-"`
}

func (*DatasetTrajectoryNewResponse) UnmarshalJSON

func (r *DatasetTrajectoryNewResponse) UnmarshalJSON(data []byte) (err error)

type DatasetTrajectoryService

type DatasetTrajectoryService struct {
	Options []option.RequestOption
	Cases   *DatasetTrajectoryCaseService
}

DatasetTrajectoryService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetTrajectoryService method instead.

func NewDatasetTrajectoryService

func NewDatasetTrajectoryService(opts ...option.RequestOption) (r *DatasetTrajectoryService)

NewDatasetTrajectoryService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetTrajectoryService) Get

Returns one published trajectory, including its dataset, its root case, and the commit that published it.

func (*DatasetTrajectoryService) List

Returns the dataset's published trajectories in the order they were created.

Pass the returned `next_cursor` as `cursor` to read the next page. The last page has no `next_cursor`.

func (*DatasetTrajectoryService) New

Creates trajectories, each a run of the dataset's cases that follows a root case. Add cases to a trajectory with create-cases. A trajectory that names a parent_trajectory_id must start from one of the parent's cases, and it is nested one level below the parent.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetUpdateParams

type DatasetUpdateParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Replaces the attributes as a whole object. Omit to keep them.
	Attributes param.Field[map[string]interface{}] `json:"attributes"`
	// Replaces the name. Omit to keep it.
	Name param.Field[string] `json:"name"`
}

func (DatasetUpdateParams) MarshalJSON

func (r DatasetUpdateParams) MarshalJSON() (data []byte, err error)

type DatasetUpdateResponse

type DatasetUpdateResponse struct {
	Attributes map[string]interface{} `json:"attributes" api:"required"`
	CreatedAt  time.Time              `json:"created_at" api:"required" format:"date-time"`
	DatasetID  string                 `json:"dataset_id" api:"required" format:"uuid"`
	// ID of the current pending dataset version. Publishing this version freezes its
	// contents and opens a new pending version.
	HeadVersionID string `json:"head_version_id" api:"required" format:"uuid"`
	Name          string `json:"name"            api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetUpdateResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                         `json:"scope_ref" api:"required"`
	JSON      datasetUpdateResponseJSON      `json:"-"`
}

func (*DatasetUpdateResponse) UnmarshalJSON

func (r *DatasetUpdateResponse) UnmarshalJSON(data []byte) (err error)

type DatasetUpdateResponseNamespace

type DatasetUpdateResponseNamespace string

Namespace that assigned the scope reference.

const (
	DatasetUpdateResponseNamespaceWandb DatasetUpdateResponseNamespace = "wandb"
)

func (DatasetUpdateResponseNamespace) IsKnown

type DatasetVersionCaseListParams

type DatasetVersionCaseListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (DatasetVersionCaseListParams) URLQuery

func (r DatasetVersionCaseListParams) URLQuery() (v url.Values)

URLQuery serializes DatasetVersionCaseListParams's query parameters as `url.Values`.

type DatasetVersionCaseListResponse

type DatasetVersionCaseListResponse struct {
	Cases      []DatasetVersionCaseListResponseCase `json:"cases"       api:"required"`
	NextCursor string                               `json:"next_cursor"`
	JSON       datasetVersionCaseListResponseJSON   `json:"-"`
}

func (*DatasetVersionCaseListResponse) UnmarshalJSON

func (r *DatasetVersionCaseListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionCaseListResponseCase

type DatasetVersionCaseListResponseCase struct {
	Attributes map[string]interface{} `json:"attributes"  api:"required"`
	CaseID     string                 `json:"case_id"     api:"required"          format:"uuid"`
	CommitID   int64                  `json:"commit_id"   api:"required"`
	ExampleKey string                 `json:"example_key" api:"required,nullable"`
	Input      interface{}            `json:"input"       api:"required"`
	Output     interface{}            `json:"output"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                               `json:"tags"    api:"required"`
	Variant string                                 `json:"variant" api:"required,nullable"`
	JSON    datasetVersionCaseListResponseCaseJSON `json:"-"`
}

func (*DatasetVersionCaseListResponseCase) UnmarshalJSON

func (r *DatasetVersionCaseListResponseCase) UnmarshalJSON(data []byte) (err error)

type DatasetVersionCaseSearchParams

type DatasetVersionCaseSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (DatasetVersionCaseSearchParams) MarshalJSON

func (r DatasetVersionCaseSearchParams) MarshalJSON() (data []byte, err error)

type DatasetVersionCaseSearchResponse

type DatasetVersionCaseSearchResponse struct {
	Cases      []DatasetVersionCaseSearchResponseCase `json:"cases"       api:"required"`
	NextCursor string                                 `json:"next_cursor"`
	JSON       datasetVersionCaseSearchResponseJSON   `json:"-"`
}

func (*DatasetVersionCaseSearchResponse) UnmarshalJSON

func (r *DatasetVersionCaseSearchResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionCaseSearchResponseCase

type DatasetVersionCaseSearchResponseCase struct {
	Attributes map[string]interface{} `json:"attributes"  api:"required"`
	CaseID     string                 `json:"case_id"     api:"required"          format:"uuid"`
	CommitID   int64                  `json:"commit_id"   api:"required"`
	ExampleKey string                 `json:"example_key" api:"required,nullable"`
	Input      interface{}            `json:"input"       api:"required"`
	Output     interface{}            `json:"output"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                 `json:"tags"    api:"required"`
	Variant string                                   `json:"variant" api:"required,nullable"`
	JSON    datasetVersionCaseSearchResponseCaseJSON `json:"-"`
}

func (*DatasetVersionCaseSearchResponseCase) UnmarshalJSON

func (r *DatasetVersionCaseSearchResponseCase) UnmarshalJSON(data []byte) (err error)

type DatasetVersionCaseService

type DatasetVersionCaseService struct {
	Options []option.RequestOption
	Tags    *DatasetVersionCaseTagService
}

DatasetVersionCaseService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetVersionCaseService method instead.

func NewDatasetVersionCaseService

func NewDatasetVersionCaseService(opts ...option.RequestOption) (r *DatasetVersionCaseService)

NewDatasetVersionCaseService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetVersionCaseService) List

Returns cases in dataset position order unless `order_by` is set.

  • A published version uses its recorded publication cutoff. Cases added later are not included.
  • A pending version uses the scope's latest published commit on each request. Later pages can include newly published cases.

`filter` and `order_by` use the same syntax as list-eval-table-version-rows, without Score columns. Cases with equal sort values stay in dataset position order.

Pass the returned `next_cursor` as `cursor` to read the next page, with the same `filter` and `order_by`. The last page has no `next_cursor`.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/cases/search` operation.

func (*DatasetVersionCaseService) Search

Returns the same cases as list-dataset-version-cases, with the filter, sort order, and pagination parameters supplied in a JSON body. Use this operation when the parameters are too large for a URL.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type DatasetVersionCaseTagListParams

type DatasetVersionCaseTagListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (DatasetVersionCaseTagListParams) URLQuery

func (r DatasetVersionCaseTagListParams) URLQuery() (v url.Values)

URLQuery serializes DatasetVersionCaseTagListParams's query parameters as `url.Values`.

type DatasetVersionCaseTagListResponse

type DatasetVersionCaseTagListResponse struct {
	Tags       []DatasetVersionCaseTagListResponseTag `json:"tags"        api:"required"`
	NextCursor string                                 `json:"next_cursor"`
	JSON       datasetVersionCaseTagListResponseJSON  `json:"-"`
}

func (*DatasetVersionCaseTagListResponse) UnmarshalJSON

func (r *DatasetVersionCaseTagListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionCaseTagListResponseTag

type DatasetVersionCaseTagListResponseTag struct {
	// Number of cases in this dataset version that have this tag.
	Count int64                                    `json:"count" api:"required"`
	Name  string                                   `json:"name"  api:"required"`
	JSON  datasetVersionCaseTagListResponseTagJSON `json:"-"`
}

func (*DatasetVersionCaseTagListResponseTag) UnmarshalJSON

func (r *DatasetVersionCaseTagListResponseTag) UnmarshalJSON(data []byte) (err error)

type DatasetVersionCaseTagService

type DatasetVersionCaseTagService struct {
	Options []option.RequestOption
}

DatasetVersionCaseTagService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetVersionCaseTagService method instead.

func NewDatasetVersionCaseTagService

func NewDatasetVersionCaseTagService(opts ...option.RequestOption) (r *DatasetVersionCaseTagService)

NewDatasetVersionCaseTagService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetVersionCaseTagService) List

Returns every tag on at least one of this version's cases and the number of cases that have it, most-used first. Tags with equal `count` are sorted by name.

  • A published version uses its recorded publication cutoff.
  • A pending version uses the scope's latest published commit at the first page. Later pages read at that same commit, so counts from cases published since then are not included. If the version is published before the listing ends, a later page can return 400. Restart the listing without a cursor.

Pass the returned `next_cursor` as `cursor` to read the next page. The last page has no `next_cursor`.

type DatasetVersionFieldListParams

type DatasetVersionFieldListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type DatasetVersionFieldListResponse

type DatasetVersionFieldListResponse struct {
	Fields []DatasetVersionFieldListResponseField `json:"fields" api:"required"`
	JSON   datasetVersionFieldListResponseJSON    `json:"-"`
}

func (*DatasetVersionFieldListResponse) UnmarshalJSON

func (r *DatasetVersionFieldListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionFieldListResponseField

type DatasetVersionFieldListResponseField struct {
	DatasetFieldID int64                                          `json:"dataset_field_id" api:"required"`
	Name           string                                         `json:"name"             api:"required"`
	Source         DatasetVersionFieldListResponseFieldsSource    `json:"source"           api:"required"`
	ValueType      DatasetVersionFieldListResponseFieldsValueType `json:"value_type"       api:"required"`
	JSON           datasetVersionFieldListResponseFieldJSON       `json:"-"`
}

func (*DatasetVersionFieldListResponseField) UnmarshalJSON

func (r *DatasetVersionFieldListResponseField) UnmarshalJSON(data []byte) (err error)

type DatasetVersionFieldListResponseFieldsSource

type DatasetVersionFieldListResponseFieldsSource string
const (
	DatasetVersionFieldListResponseFieldsSourceInput  DatasetVersionFieldListResponseFieldsSource = "input"
	DatasetVersionFieldListResponseFieldsSourceOutput DatasetVersionFieldListResponseFieldsSource = "output"
)

func (DatasetVersionFieldListResponseFieldsSource) IsKnown

type DatasetVersionFieldListResponseFieldsValueType

type DatasetVersionFieldListResponseFieldsValueType string
const (
	DatasetVersionFieldListResponseFieldsValueTypeBoolean DatasetVersionFieldListResponseFieldsValueType = "boolean"
	DatasetVersionFieldListResponseFieldsValueTypeInteger DatasetVersionFieldListResponseFieldsValueType = "integer"
	DatasetVersionFieldListResponseFieldsValueTypeNumber  DatasetVersionFieldListResponseFieldsValueType = "number"
	DatasetVersionFieldListResponseFieldsValueTypeString  DatasetVersionFieldListResponseFieldsValueType = "string"
	DatasetVersionFieldListResponseFieldsValueTypeJson    DatasetVersionFieldListResponseFieldsValueType = "json"
)

func (DatasetVersionFieldListResponseFieldsValueType) IsKnown

type DatasetVersionFieldService

type DatasetVersionFieldService struct {
	Options []option.RequestOption
}

DatasetVersionFieldService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetVersionFieldService method instead.

func NewDatasetVersionFieldService

func NewDatasetVersionFieldService(opts ...option.RequestOption) (r *DatasetVersionFieldService)

NewDatasetVersionFieldService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetVersionFieldService) List

Returns the input and output field names and types recorded in this dataset version.

type DatasetVersionGetParams

type DatasetVersionGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type DatasetVersionGetResponse

type DatasetVersionGetResponse struct {
	CaseCount        int64     `json:"case_count"         api:"required"`
	CreatedAt        time.Time `json:"created_at"         api:"required" format:"date-time"`
	DatasetID        string    `json:"dataset_id"         api:"required" format:"uuid"`
	DatasetVersionID string    `json:"dataset_version_id" api:"required" format:"uuid"`
	// Publication cutoff used to read this version. A published snapshot excludes
	// later writes.
	LastCommitID int64 `json:"last_commit_id" api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetVersionGetResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                             `json:"scope_ref" api:"required"`
	// pending means this version can still change. published means its contents are
	// frozen.
	Status          DatasetVersionGetResponseStatus `json:"status"            api:"required"`
	TrajectoryCount int64                           `json:"trajectory_count"  api:"required"`
	Uri             string                          `json:"uri"               api:"required,nullable"`
	VersionSequence int64                           `json:"version_sequence"  api:"required"`
	ParentVersionID string                          `json:"parent_version_id"                         format:"uuid"`
	JSON            datasetVersionGetResponseJSON   `json:"-"`
}

func (*DatasetVersionGetResponse) UnmarshalJSON

func (r *DatasetVersionGetResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionGetResponseNamespace

type DatasetVersionGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	DatasetVersionGetResponseNamespaceWandb DatasetVersionGetResponseNamespace = "wandb"
)

func (DatasetVersionGetResponseNamespace) IsKnown

type DatasetVersionGetResponseStatus

type DatasetVersionGetResponseStatus string

pending means this version can still change. published means its contents are frozen.

const (
	DatasetVersionGetResponseStatusPending   DatasetVersionGetResponseStatus = "pending"
	DatasetVersionGetResponseStatusPublished DatasetVersionGetResponseStatus = "published"
)

func (DatasetVersionGetResponseStatus) IsKnown

type DatasetVersionListParams

type DatasetVersionListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (DatasetVersionListParams) URLQuery

func (r DatasetVersionListParams) URLQuery() (v url.Values)

URLQuery serializes DatasetVersionListParams's query parameters as `url.Values`.

type DatasetVersionListResponse

type DatasetVersionListResponse struct {
	DatasetVersions []DatasetVersionListResponseDatasetVersion `json:"dataset_versions" api:"required"`
	NextCursor      string                                     `json:"next_cursor"`
	JSON            datasetVersionListResponseJSON             `json:"-"`
}

func (*DatasetVersionListResponse) UnmarshalJSON

func (r *DatasetVersionListResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionListResponseDatasetVersion

type DatasetVersionListResponseDatasetVersion struct {
	CaseCount        int64     `json:"case_count"         api:"required"`
	CreatedAt        time.Time `json:"created_at"         api:"required" format:"date-time"`
	DatasetID        string    `json:"dataset_id"         api:"required" format:"uuid"`
	DatasetVersionID string    `json:"dataset_version_id" api:"required" format:"uuid"`
	// Publication cutoff used to read this version. A published snapshot excludes
	// later writes.
	LastCommitID int64 `json:"last_commit_id" api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetVersionListResponseDatasetVersionsNamespace `json:"namespace" api:"required"`
	ScopeRef  string                                             `json:"scope_ref" api:"required"`
	// pending means this version can still change. published means its contents are
	// frozen.
	Status          DatasetVersionListResponseDatasetVersionsStatus `json:"status"            api:"required"`
	TrajectoryCount int64                                           `json:"trajectory_count"  api:"required"`
	Uri             string                                          `json:"uri"               api:"required,nullable"`
	VersionSequence int64                                           `json:"version_sequence"  api:"required"`
	ParentVersionID string                                          `json:"parent_version_id"                         format:"uuid"`
	JSON            datasetVersionListResponseDatasetVersionJSON    `json:"-"`
}

func (*DatasetVersionListResponseDatasetVersion) UnmarshalJSON

func (r *DatasetVersionListResponseDatasetVersion) UnmarshalJSON(data []byte) (err error)

type DatasetVersionListResponseDatasetVersionsNamespace

type DatasetVersionListResponseDatasetVersionsNamespace string

Namespace that assigned the scope reference.

const (
	DatasetVersionListResponseDatasetVersionsNamespaceWandb DatasetVersionListResponseDatasetVersionsNamespace = "wandb"
)

func (DatasetVersionListResponseDatasetVersionsNamespace) IsKnown

type DatasetVersionListResponseDatasetVersionsStatus

type DatasetVersionListResponseDatasetVersionsStatus string

pending means this version can still change. published means its contents are frozen.

const (
	DatasetVersionListResponseDatasetVersionsStatusPending   DatasetVersionListResponseDatasetVersionsStatus = "pending"
	DatasetVersionListResponseDatasetVersionsStatusPublished DatasetVersionListResponseDatasetVersionsStatus = "published"
)

func (DatasetVersionListResponseDatasetVersionsStatus) IsKnown

type DatasetVersionNewParams

type DatasetVersionNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Location of this version's externally stored data, such as
	// hf://datasets/org/name@revision. The service stores this URI as metadata and
	// does not read from it.
	//
	//   - Omit or send null to keep the current dataset head's URI.
	//   - Supplying a URI replaces it for this version, and later versions inherit the
	//     replacement.
	//   - This operation cannot clear an existing URI.
	Uri param.Field[string] `json:"uri" format:"uri"`
}

func (DatasetVersionNewParams) MarshalJSON

func (r DatasetVersionNewParams) MarshalJSON() (data []byte, err error)

type DatasetVersionNewResponse

type DatasetVersionNewResponse struct {
	CaseCount        int64     `json:"case_count"         api:"required"`
	CreatedAt        time.Time `json:"created_at"         api:"required" format:"date-time"`
	DatasetID        string    `json:"dataset_id"         api:"required" format:"uuid"`
	DatasetVersionID string    `json:"dataset_version_id" api:"required" format:"uuid"`
	// Publication cutoff used to read this version. A published snapshot excludes
	// later writes.
	LastCommitID int64 `json:"last_commit_id" api:"required"`
	// Namespace that assigned the scope reference.
	Namespace DatasetVersionNewResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                             `json:"scope_ref" api:"required"`
	// pending means this version can still change. published means its contents are
	// frozen.
	Status          DatasetVersionNewResponseStatus `json:"status"            api:"required"`
	TrajectoryCount int64                           `json:"trajectory_count"  api:"required"`
	Uri             string                          `json:"uri"               api:"required,nullable"`
	VersionSequence int64                           `json:"version_sequence"  api:"required"`
	ParentVersionID string                          `json:"parent_version_id"                         format:"uuid"`
	JSON            datasetVersionNewResponseJSON   `json:"-"`
}

func (*DatasetVersionNewResponse) UnmarshalJSON

func (r *DatasetVersionNewResponse) UnmarshalJSON(data []byte) (err error)

type DatasetVersionNewResponseNamespace

type DatasetVersionNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	DatasetVersionNewResponseNamespaceWandb DatasetVersionNewResponseNamespace = "wandb"
)

func (DatasetVersionNewResponseNamespace) IsKnown

type DatasetVersionNewResponseStatus

type DatasetVersionNewResponseStatus string

pending means this version can still change. published means its contents are frozen.

const (
	DatasetVersionNewResponseStatusPending   DatasetVersionNewResponseStatus = "pending"
	DatasetVersionNewResponseStatusPublished DatasetVersionNewResponseStatus = "published"
)

func (DatasetVersionNewResponseStatus) IsKnown

type DatasetVersionService

type DatasetVersionService struct {
	Options []option.RequestOption
	Cases   *DatasetVersionCaseService
	Fields  *DatasetVersionFieldService
}

DatasetVersionService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDatasetVersionService method instead.

func NewDatasetVersionService

func NewDatasetVersionService(opts ...option.RequestOption) (r *DatasetVersionService)

NewDatasetVersionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DatasetVersionService) Get

func (r *DatasetVersionService) Get(
	ctx context.Context,
	datasetVersionID string,
	query DatasetVersionGetParams,
	opts ...option.RequestOption,
) (res *DatasetVersionGetResponse, err error)

Returns a dataset version's metadata, publication status, and case and trajectory counts. A `pending` version can still change. A `published` version is an immutable snapshot.

func (*DatasetVersionService) List

Pages the Dataset's published DatasetVersions in the order they were published, each shaped like get-dataset-version. The pending head is not listed. Read it through the Dataset's head_version_id. An absent Dataset or one outside the requested scope returns 404.

func (*DatasetVersionService) New

Freezes the dataset's current pending version, including its cases, fields, and publication cutoff. The published version is immutable. The dataset gets a new pending version for later writes.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type Error

type Error = apierror.Error

type EvalTableColumnNewParams

type EvalTableColumnNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Input and output columns to declare, with a name and value type for each.
	DatasetFields param.Field[[]EvalTableColumnNewParamsDatasetField] `json:"dataset_fields"`
	// Named score columns to declare, with the value type each score must use.
	Scorers param.Field[[]EvalTableColumnNewParamsScorer] `json:"scorers"`
}

func (EvalTableColumnNewParams) MarshalJSON

func (r EvalTableColumnNewParams) MarshalJSON() (data []byte, err error)

type EvalTableColumnNewParamsDatasetField

type EvalTableColumnNewParamsDatasetField struct {
	Name   param.Field[string]                                      `json:"name"   api:"required"`
	Source param.Field[EvalTableColumnNewParamsDatasetFieldsSource] `json:"source" api:"required"`
	// JSON type accepted by this column. Use json for ordinary JSON fields and for
	// media extension values.
	ValueType param.Field[EvalTableColumnNewParamsDatasetFieldsValueType] `json:"value_type" api:"required"`
	// Version of the media format. Set together with extension_type. Omit both for an
	// ordinary field.
	ExtensionSchemaVersion param.Field[int64] `json:"extension_schema_version"`
	// Media format stored in this field. Set together with extension_schema_version.
	// Omit both for an ordinary field.
	ExtensionType param.Field[EvalTableColumnNewParamsDatasetFieldsExtensionType] `json:"extension_type"`
}

func (EvalTableColumnNewParamsDatasetField) MarshalJSON

func (r EvalTableColumnNewParamsDatasetField) MarshalJSON() (data []byte, err error)

type EvalTableColumnNewParamsDatasetFieldsExtensionType

type EvalTableColumnNewParamsDatasetFieldsExtensionType string

Media format stored in this field. Set together with extension_schema_version. Omit both for an ordinary field.

const (
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbImage    EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-image"
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbAudio    EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-audio"
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbVideo    EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-video"
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbHTML     EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-html"
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbBokeh    EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-bokeh"
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbObject3d EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-object3d"
	EvalTableColumnNewParamsDatasetFieldsExtensionTypeWandbMolecule EvalTableColumnNewParamsDatasetFieldsExtensionType = "wandb-molecule"
)

func (EvalTableColumnNewParamsDatasetFieldsExtensionType) IsKnown

type EvalTableColumnNewParamsDatasetFieldsSource

type EvalTableColumnNewParamsDatasetFieldsSource string
const (
	EvalTableColumnNewParamsDatasetFieldsSourceInput  EvalTableColumnNewParamsDatasetFieldsSource = "input"
	EvalTableColumnNewParamsDatasetFieldsSourceOutput EvalTableColumnNewParamsDatasetFieldsSource = "output"
)

func (EvalTableColumnNewParamsDatasetFieldsSource) IsKnown

type EvalTableColumnNewParamsDatasetFieldsValueType

type EvalTableColumnNewParamsDatasetFieldsValueType string

JSON type accepted by this column. Use json for ordinary JSON fields and for media extension values.

const (
	EvalTableColumnNewParamsDatasetFieldsValueTypeBoolean EvalTableColumnNewParamsDatasetFieldsValueType = "boolean"
	EvalTableColumnNewParamsDatasetFieldsValueTypeInteger EvalTableColumnNewParamsDatasetFieldsValueType = "integer"
	EvalTableColumnNewParamsDatasetFieldsValueTypeNumber  EvalTableColumnNewParamsDatasetFieldsValueType = "number"
	EvalTableColumnNewParamsDatasetFieldsValueTypeString  EvalTableColumnNewParamsDatasetFieldsValueType = "string"
	EvalTableColumnNewParamsDatasetFieldsValueTypeJson    EvalTableColumnNewParamsDatasetFieldsValueType = "json"
)

func (EvalTableColumnNewParamsDatasetFieldsValueType) IsKnown

type EvalTableColumnNewParamsScorer

type EvalTableColumnNewParamsScorer struct {
	// Name used as a key in each row's scores object. Leading and trailing whitespace
	// are not allowed.
	Name      param.Field[string]                                   `json:"name"       api:"required"`
	ValueType param.Field[EvalTableColumnNewParamsScorersValueType] `json:"value_type" api:"required"`
	// Whether higher scores in this column are better. Only boolean, integer, and
	// number columns accept it. A column already registered with a different value, or
	// with none, returns 400. To change it, create a scorer version with the new value
	// and select it with add-evaluation-scorers. Omit it to accept the registered
	// value, or to leave a new column without a direction.
	HigherIsBetter param.Field[bool] `json:"higher_is_better"`
}

func (EvalTableColumnNewParamsScorer) MarshalJSON

func (r EvalTableColumnNewParamsScorer) MarshalJSON() (data []byte, err error)

type EvalTableColumnNewParamsScorersValueType

type EvalTableColumnNewParamsScorersValueType string
const (
	EvalTableColumnNewParamsScorersValueTypeBoolean EvalTableColumnNewParamsScorersValueType = "boolean"
	EvalTableColumnNewParamsScorersValueTypeInteger EvalTableColumnNewParamsScorersValueType = "integer"
	EvalTableColumnNewParamsScorersValueTypeNumber  EvalTableColumnNewParamsScorersValueType = "number"
	EvalTableColumnNewParamsScorersValueTypeString  EvalTableColumnNewParamsScorersValueType = "string"
)

func (EvalTableColumnNewParamsScorersValueType) IsKnown

type EvalTableColumnNewResponse

type EvalTableColumnNewResponse struct {
	DatasetFields []EvalTableColumnNewResponseDatasetField `json:"dataset_fields" api:"required"`
	Scorers       []EvalTableColumnNewResponseScorer       `json:"scorers"        api:"required"`
	JSON          evalTableColumnNewResponseJSON           `json:"-"`
}

func (*EvalTableColumnNewResponse) UnmarshalJSON

func (r *EvalTableColumnNewResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableColumnNewResponseDatasetField

type EvalTableColumnNewResponseDatasetField struct {
	Name   string                                        `json:"name"   api:"required"`
	Source EvalTableColumnNewResponseDatasetFieldsSource `json:"source" api:"required"`
	// json may represent an extension-backed field or an ordinary JSON field.
	ValueType EvalTableColumnNewResponseDatasetFieldsValueType `json:"value_type" api:"required"`
	// Extension schema version. Omitted for ordinary fields.
	ExtensionSchemaVersion int64 `json:"extension_schema_version"`
	// Extension schema type. Omitted for ordinary fields.
	ExtensionType EvalTableColumnNewResponseDatasetFieldsExtensionType `json:"extension_type"`
	JSON          evalTableColumnNewResponseDatasetFieldJSON           `json:"-"`
}

func (*EvalTableColumnNewResponseDatasetField) UnmarshalJSON

func (r *EvalTableColumnNewResponseDatasetField) UnmarshalJSON(data []byte) (err error)

type EvalTableColumnNewResponseDatasetFieldsExtensionType

type EvalTableColumnNewResponseDatasetFieldsExtensionType string

Extension schema type. Omitted for ordinary fields.

const (
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbImage    EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-image"
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbAudio    EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-audio"
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbVideo    EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-video"
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbHTML     EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-html"
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbBokeh    EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-bokeh"
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbObject3d EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-object3d"
	EvalTableColumnNewResponseDatasetFieldsExtensionTypeWandbMolecule EvalTableColumnNewResponseDatasetFieldsExtensionType = "wandb-molecule"
)

func (EvalTableColumnNewResponseDatasetFieldsExtensionType) IsKnown

type EvalTableColumnNewResponseDatasetFieldsSource

type EvalTableColumnNewResponseDatasetFieldsSource string
const (
	EvalTableColumnNewResponseDatasetFieldsSourceInput  EvalTableColumnNewResponseDatasetFieldsSource = "input"
	EvalTableColumnNewResponseDatasetFieldsSourceOutput EvalTableColumnNewResponseDatasetFieldsSource = "output"
)

func (EvalTableColumnNewResponseDatasetFieldsSource) IsKnown

type EvalTableColumnNewResponseDatasetFieldsValueType

type EvalTableColumnNewResponseDatasetFieldsValueType string

json may represent an extension-backed field or an ordinary JSON field.

const (
	EvalTableColumnNewResponseDatasetFieldsValueTypeNull    EvalTableColumnNewResponseDatasetFieldsValueType = "null"
	EvalTableColumnNewResponseDatasetFieldsValueTypeBoolean EvalTableColumnNewResponseDatasetFieldsValueType = "boolean"
	EvalTableColumnNewResponseDatasetFieldsValueTypeInteger EvalTableColumnNewResponseDatasetFieldsValueType = "integer"
	EvalTableColumnNewResponseDatasetFieldsValueTypeNumber  EvalTableColumnNewResponseDatasetFieldsValueType = "number"
	EvalTableColumnNewResponseDatasetFieldsValueTypeString  EvalTableColumnNewResponseDatasetFieldsValueType = "string"
	EvalTableColumnNewResponseDatasetFieldsValueTypeJson    EvalTableColumnNewResponseDatasetFieldsValueType = "json"
)

func (EvalTableColumnNewResponseDatasetFieldsValueType) IsKnown

type EvalTableColumnNewResponseScorer

type EvalTableColumnNewResponseScorer struct {
	// Whether higher scores in this column are better, from the selected scorer
	// version. Null when that version does not set it, so its scores have no
	// direction.
	HigherIsBetter  bool                                       `json:"higher_is_better"  api:"required,nullable"`
	Name            string                                     `json:"name"              api:"required"`
	ScorerID        string                                     `json:"scorer_id"         api:"required"          format:"uuid"`
	ScorerVersionID string                                     `json:"scorer_version_id" api:"required"          format:"uuid"`
	ValueType       EvalTableColumnNewResponseScorersValueType `json:"value_type"        api:"required"`
	JSON            evalTableColumnNewResponseScorerJSON       `json:"-"`
}

func (*EvalTableColumnNewResponseScorer) UnmarshalJSON

func (r *EvalTableColumnNewResponseScorer) UnmarshalJSON(data []byte) (err error)

type EvalTableColumnNewResponseScorersValueType

type EvalTableColumnNewResponseScorersValueType string
const (
	EvalTableColumnNewResponseScorersValueTypeBoolean EvalTableColumnNewResponseScorersValueType = "boolean"
	EvalTableColumnNewResponseScorersValueTypeInteger EvalTableColumnNewResponseScorersValueType = "integer"
	EvalTableColumnNewResponseScorersValueTypeNumber  EvalTableColumnNewResponseScorersValueType = "number"
	EvalTableColumnNewResponseScorersValueTypeString  EvalTableColumnNewResponseScorersValueType = "string"
)

func (EvalTableColumnNewResponseScorersValueType) IsKnown

type EvalTableColumnService

type EvalTableColumnService struct {
	Options []option.RequestOption
}

EvalTableColumnService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableColumnService method instead.

func NewEvalTableColumnService

func NewEvalTableColumnService(opts ...option.RequestOption) (r *EvalTableColumnService)

NewEvalTableColumnService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableColumnService) New

Declares typed input and output fields and named score columns for an evaluation table. Use this operation when you want to choose column types explicitly, or to say whether higher scores in a column are better.

`Idempotency-Key` is required, but this operation does not replay an earlier response or check whether the key was used with different content.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvalTableNewParams

type EvalTableNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID    param.Field[string]                 `path:"scope_id" api:"required"`
	Name       param.Field[string]                 `                api:"required" json:"name"`
	Attributes param.Field[map[string]interface{}] `                               json:"attributes"`
	// Location of externally stored data, such as s3://bucket/prefix/ or
	// hf://datasets/org/name. The service stores this URI as metadata and does not
	// read from it. Dataset versions inherit it until you supply a replacement when
	// publishing a version.
	Uri param.Field[string] `json:"uri" format:"uri"`
}

func (EvalTableNewParams) MarshalJSON

func (r EvalTableNewParams) MarshalJSON() (data []byte, err error)

type EvalTableNewResponse

type EvalTableNewResponse struct {
	Attributes   map[string]interface{} `json:"attributes"    api:"required"`
	DatasetID    string                 `json:"dataset_id"    api:"required" format:"uuid"`
	EvaluationID string                 `json:"evaluation_id" api:"required" format:"uuid"`
	Name         string                 `json:"name"          api:"required"`
	// Namespace that assigned the scope reference.
	Namespace EvalTableNewResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                        `json:"scope_ref" api:"required"`
	JSON      evalTableNewResponseJSON      `json:"-"`
}

func (*EvalTableNewResponse) UnmarshalJSON

func (r *EvalTableNewResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableNewResponseNamespace

type EvalTableNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvalTableNewResponseNamespaceWandb EvalTableNewResponseNamespace = "wandb"
)

func (EvalTableNewResponseNamespace) IsKnown

func (r EvalTableNewResponseNamespace) IsKnown() bool

type EvalTableRowAddParams

type EvalTableRowAddParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string]                     `path:"scope_id" api:"required"`
	Rows    param.Field[[]EvalTableRowAddParamsRow] `                api:"required" json:"rows"`
}

func (EvalTableRowAddParams) MarshalJSON

func (r EvalTableRowAddParams) MarshalJSON() (data []byte, err error)

type EvalTableRowAddParamsRow

type EvalTableRowAddParamsRow struct {
	// Score values keyed by scorer name. Use an empty object for a row with no scores.
	// Keys must not have leading or trailing whitespace.
	Scores     param.Field[map[string]interface{}] `json:"scores"     api:"required"`
	Attributes param.Field[map[string]interface{}] `json:"attributes"`
	// Reference to the row's example in external data, such as a row index, for a row
	// without input.
	//
	//   - The service stores the reference but does not fetch the example.
	//   - Example keys need not be unique. Row comparison matches rows by example key.
	//   - A row with an input must omit it. The service derives that row's example key
	//     from a hash of its input, so row comparison matches rows by input. Each
	//     top-level extension field hashes by its identity, which leaves out file
	//     locations. Numbers hash as float64, so integers that differ only beyond 2^53
	//     derive the same example key, and a number never matches a string. Log numeric
	//     identifiers as strings.
	//   - A row with neither matches only itself, in versions of the same eval table.
	//
	// Omit or send null when no example reference applies.
	ExampleKey param.Field[string] `json:"example_key"`
	// Input data for this case, such as a prompt or feature values.
	//
	// For JSON objects:
	//
	//   - Top-level field names must contain 1 to 512 Unicode characters, with no
	//     leading or trailing whitespace.
	//   - All numeric fields are inferred as number, even whole-valued literals.
	//   - Queries use float64 numbers, which can round integers beyond 2^53. The stored
	//     JSON remains exact.
	//
	// Omit to store null.
	Input param.Field[CaseValueUnionParam] `json:"input"`
	// Output recorded for this case, such as a model response.
	//
	// For JSON objects:
	//
	//   - Top-level field names must contain 1 to 512 Unicode characters, with no
	//     leading or trailing whitespace.
	//   - All numeric fields are inferred as number, even whole-valued literals.
	//   - Queries use float64 numbers, which can round integers beyond 2^53. The stored
	//     JSON remains exact.
	//
	// Omit to store null.
	Output param.Field[CaseValueUnionParam] `json:"output"`
	// Model, agent, prompt, or checkpoint this case evaluates. Leading and trailing
	// whitespace are not allowed. Omit or send null when no variant applies.
	Variant param.Field[string] `json:"variant"`
}

func (EvalTableRowAddParamsRow) MarshalJSON

func (r EvalTableRowAddParamsRow) MarshalJSON() (data []byte, err error)

type EvalTableRowAddResponse

type EvalTableRowAddResponse struct {
	CaseIDs  []string                    `json:"case_ids"  api:"required" format:"uuid"`
	ScoreIDs []string                    `json:"score_ids" api:"required" format:"uuid"`
	JSON     evalTableRowAddResponseJSON `json:"-"`
}

func (*EvalTableRowAddResponse) UnmarshalJSON

func (r *EvalTableRowAddResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableRowListParams

type EvalTableRowListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `query:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvalTableRowListParams) URLQuery

func (r EvalTableRowListParams) URLQuery() (v url.Values)

URLQuery serializes EvalTableRowListParams's query parameters as `url.Values`.

type EvalTableRowListResponse

type EvalTableRowListResponse struct {
	Rows       []EvalTableRowListResponseRow `json:"rows"        api:"required"`
	NextCursor string                        `json:"next_cursor"`
	JSON       evalTableRowListResponseJSON  `json:"-"`
}

func (*EvalTableRowListResponse) UnmarshalJSON

func (r *EvalTableRowListResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableRowListResponseRow

type EvalTableRowListResponseRow struct {
	Attributes map[string]interface{}              `json:"attributes"  api:"required"`
	CaseID     string                              `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                              `json:"example_key" api:"required,nullable"`
	Input      interface{}                         `json:"input"       api:"required"`
	Output     interface{}                         `json:"output"      api:"required"`
	Scores     []EvalTableRowListResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                        `json:"tags"    api:"required"`
	Variant string                          `json:"variant" api:"required,nullable"`
	JSON    evalTableRowListResponseRowJSON `json:"-"`
}

func (*EvalTableRowListResponseRow) UnmarshalJSON

func (r *EvalTableRowListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvalTableRowListResponseRowsScore

type EvalTableRowListResponseRowsScore struct {
	ID              string                                `json:"id"                api:"required" format:"uuid"`
	ScorerID        string                                `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                           `json:"value"             api:"required"`
	JSON            evalTableRowListResponseRowsScoreJSON `json:"-"`
}

func (*EvalTableRowListResponseRowsScore) UnmarshalJSON

func (r *EvalTableRowListResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvalTableRowSearchParams

type EvalTableRowSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `json:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvalTableRowSearchParams) MarshalJSON

func (r EvalTableRowSearchParams) MarshalJSON() (data []byte, err error)

type EvalTableRowSearchResponse

type EvalTableRowSearchResponse struct {
	Rows       []EvalTableRowSearchResponseRow `json:"rows"        api:"required"`
	NextCursor string                          `json:"next_cursor"`
	JSON       evalTableRowSearchResponseJSON  `json:"-"`
}

func (*EvalTableRowSearchResponse) UnmarshalJSON

func (r *EvalTableRowSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableRowSearchResponseRow

type EvalTableRowSearchResponseRow struct {
	Attributes map[string]interface{}                `json:"attributes"  api:"required"`
	CaseID     string                                `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                `json:"example_key" api:"required,nullable"`
	Input      interface{}                           `json:"input"       api:"required"`
	Output     interface{}                           `json:"output"      api:"required"`
	Scores     []EvalTableRowSearchResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                          `json:"tags"    api:"required"`
	Variant string                            `json:"variant" api:"required,nullable"`
	JSON    evalTableRowSearchResponseRowJSON `json:"-"`
}

func (*EvalTableRowSearchResponseRow) UnmarshalJSON

func (r *EvalTableRowSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvalTableRowSearchResponseRowsScore

type EvalTableRowSearchResponseRowsScore struct {
	ID              string                                  `json:"id"                api:"required" format:"uuid"`
	ScorerID        string                                  `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                  `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                             `json:"value"             api:"required"`
	JSON            evalTableRowSearchResponseRowsScoreJSON `json:"-"`
}

func (*EvalTableRowSearchResponseRowsScore) UnmarshalJSON

func (r *EvalTableRowSearchResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvalTableRowService

type EvalTableRowService struct {
	Options []option.RequestOption
}

EvalTableRowService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableRowService method instead.

func NewEvalTableRowService

func NewEvalTableRowService(opts ...option.RequestOption) (r *EvalTableRowService)

NewEvalTableRowService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableRowService) Add

func (r *EvalTableRowService) Add(
	ctx context.Context,
	evaluationID string,
	params EvalTableRowAddParams,
	opts ...option.RequestOption,
) (res *EvalTableRowAddResponse, err error)

Stores rows with their inputs, outputs, and named scores. This operation adds data without creating a frozen version. A score column whose selected scorer version cannot score cases returns 400, and no case is stored.

**Retrying an append:** Cases and scores are published separately. An error can occur after the cases have been stored. Retry with the same `Idempotency-Key` and the same rows to finish the append without duplicating those cases.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

func (*EvalTableRowService) List

func (r *EvalTableRowService) List(
	ctx context.Context,
	evaluationID string,
	params EvalTableRowListParams,
	opts ...option.RequestOption,
) (res *EvalTableRowListResponse, err error)

Reads every row and Score published so far without cutting a version, so a client can read a table while it is still being written. The first page pins that data, and later pages read the same rows and Scores. If the Evaluation's Scorer selection changes between pages, such as when a new Score column appears, a continuation returns 400 and the read must start again without a cursor. `filter` and `order_by` use the same syntax as list-eval-table-version-rows.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/rows/search` operation.

func (*EvalTableRowService) Search

func (r *EvalTableRowService) Search(
	ctx context.Context,
	evaluationID string,
	params EvalTableRowSearchParams,
	opts ...option.RequestOption,
) (res *EvalTableRowSearchResponse, err error)

Reads the same latest data as list-eval-table-rows. `filter` and `order_by` use the same AIP-style syntax as the GET route. Filtering and ordering apply before pagination.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvalTableService

type EvalTableService struct {
	Options  []option.RequestOption
	Columns  *EvalTableColumnService
	Rows     *EvalTableRowService
	Versions *EvalTableVersionService
}

EvalTableService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableService method instead.

func NewEvalTableService

func NewEvalTableService(opts ...option.RequestOption) (r *EvalTableService)

NewEvalTableService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableService) New

Creates a dataset and a live evaluation together so you can log inputs, outputs, and scores as rows.

Use the returned `evaluation_id` for this table's column, row, and version operations. The returned `dataset_id` identifies the underlying dataset.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvalTableVersionColumnGetParams

type EvalTableVersionColumnGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvalTableVersionColumnGetResponse

type EvalTableVersionColumnGetResponse struct {
	DatasetFields       []EvalTableVersionColumnGetResponseDatasetField `json:"dataset_fields"        api:"required"`
	EvaluationID        string                                          `json:"evaluation_id"         api:"required" format:"uuid"`
	EvaluationVersionID string                                          `json:"evaluation_version_id" api:"required" format:"uuid"`
	Scorers             []EvalTableVersionColumnGetResponseScorer       `json:"scorers"               api:"required"`
	JSON                evalTableVersionColumnGetResponseJSON           `json:"-"`
}

func (*EvalTableVersionColumnGetResponse) UnmarshalJSON

func (r *EvalTableVersionColumnGetResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionColumnGetResponseDatasetField

type EvalTableVersionColumnGetResponseDatasetField struct {
	Name   string                                               `json:"name"   api:"required"`
	Source EvalTableVersionColumnGetResponseDatasetFieldsSource `json:"source" api:"required"`
	// json may represent an extension-backed field or an ordinary JSON field.
	ValueType EvalTableVersionColumnGetResponseDatasetFieldsValueType `json:"value_type" api:"required"`
	// Extension schema version. Omitted for ordinary fields.
	ExtensionSchemaVersion int64 `json:"extension_schema_version"`
	// Extension schema type. Omitted for ordinary fields.
	ExtensionType EvalTableVersionColumnGetResponseDatasetFieldsExtensionType `json:"extension_type"`
	JSON          evalTableVersionColumnGetResponseDatasetFieldJSON           `json:"-"`
}

func (*EvalTableVersionColumnGetResponseDatasetField) UnmarshalJSON

func (r *EvalTableVersionColumnGetResponseDatasetField) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionColumnGetResponseDatasetFieldsExtensionType

type EvalTableVersionColumnGetResponseDatasetFieldsExtensionType string

Extension schema type. Omitted for ordinary fields.

const (
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbImage    EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-image"
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbAudio    EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-audio"
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbVideo    EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-video"
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbHTML     EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-html"
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbBokeh    EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-bokeh"
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbObject3d EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-object3d"
	EvalTableVersionColumnGetResponseDatasetFieldsExtensionTypeWandbMolecule EvalTableVersionColumnGetResponseDatasetFieldsExtensionType = "wandb-molecule"
)

func (EvalTableVersionColumnGetResponseDatasetFieldsExtensionType) IsKnown

type EvalTableVersionColumnGetResponseDatasetFieldsSource

type EvalTableVersionColumnGetResponseDatasetFieldsSource string
const (
	EvalTableVersionColumnGetResponseDatasetFieldsSourceInput  EvalTableVersionColumnGetResponseDatasetFieldsSource = "input"
	EvalTableVersionColumnGetResponseDatasetFieldsSourceOutput EvalTableVersionColumnGetResponseDatasetFieldsSource = "output"
)

func (EvalTableVersionColumnGetResponseDatasetFieldsSource) IsKnown

type EvalTableVersionColumnGetResponseDatasetFieldsValueType

type EvalTableVersionColumnGetResponseDatasetFieldsValueType string

json may represent an extension-backed field or an ordinary JSON field.

const (
	EvalTableVersionColumnGetResponseDatasetFieldsValueTypeNull    EvalTableVersionColumnGetResponseDatasetFieldsValueType = "null"
	EvalTableVersionColumnGetResponseDatasetFieldsValueTypeBoolean EvalTableVersionColumnGetResponseDatasetFieldsValueType = "boolean"
	EvalTableVersionColumnGetResponseDatasetFieldsValueTypeInteger EvalTableVersionColumnGetResponseDatasetFieldsValueType = "integer"
	EvalTableVersionColumnGetResponseDatasetFieldsValueTypeNumber  EvalTableVersionColumnGetResponseDatasetFieldsValueType = "number"
	EvalTableVersionColumnGetResponseDatasetFieldsValueTypeString  EvalTableVersionColumnGetResponseDatasetFieldsValueType = "string"
	EvalTableVersionColumnGetResponseDatasetFieldsValueTypeJson    EvalTableVersionColumnGetResponseDatasetFieldsValueType = "json"
)

func (EvalTableVersionColumnGetResponseDatasetFieldsValueType) IsKnown

type EvalTableVersionColumnGetResponseScorer

type EvalTableVersionColumnGetResponseScorer struct {
	// Whether higher scores in this column are better, from the selected scorer
	// version. Null when that version does not set it, so its scores have no
	// direction.
	HigherIsBetter  bool                                              `json:"higher_is_better"  api:"required,nullable"`
	Name            string                                            `json:"name"              api:"required"`
	ScorerID        string                                            `json:"scorer_id"         api:"required"          format:"uuid"`
	ScorerVersionID string                                            `json:"scorer_version_id" api:"required"          format:"uuid"`
	ValueType       EvalTableVersionColumnGetResponseScorersValueType `json:"value_type"        api:"required"`
	JSON            evalTableVersionColumnGetResponseScorerJSON       `json:"-"`
}

func (*EvalTableVersionColumnGetResponseScorer) UnmarshalJSON

func (r *EvalTableVersionColumnGetResponseScorer) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionColumnGetResponseScorersValueType

type EvalTableVersionColumnGetResponseScorersValueType string
const (
	EvalTableVersionColumnGetResponseScorersValueTypeBoolean EvalTableVersionColumnGetResponseScorersValueType = "boolean"
	EvalTableVersionColumnGetResponseScorersValueTypeInteger EvalTableVersionColumnGetResponseScorersValueType = "integer"
	EvalTableVersionColumnGetResponseScorersValueTypeNumber  EvalTableVersionColumnGetResponseScorersValueType = "number"
	EvalTableVersionColumnGetResponseScorersValueTypeString  EvalTableVersionColumnGetResponseScorersValueType = "string"
)

func (EvalTableVersionColumnGetResponseScorersValueType) IsKnown

type EvalTableVersionColumnService

type EvalTableVersionColumnService struct {
	Options []option.RequestOption
}

EvalTableVersionColumnService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableVersionColumnService method instead.

func NewEvalTableVersionColumnService

func NewEvalTableVersionColumnService(opts ...option.RequestOption) (r *EvalTableVersionColumnService)

NewEvalTableVersionColumnService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableVersionColumnService) Get

Returns the input, output, and score columns selected by the frozen evaluation table version.

type EvalTableVersionNewParams

type EvalTableVersionNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvalTableVersionNewResponse

type EvalTableVersionNewResponse struct {
	DatasetVersionID    string                          `json:"dataset_version_id"    api:"required" format:"uuid"`
	EvaluationVersionID string                          `json:"evaluation_version_id" api:"required" format:"uuid"`
	JSON                evalTableVersionNewResponseJSON `json:"-"`
}

func (*EvalTableVersionNewResponse) UnmarshalJSON

func (r *EvalTableVersionNewResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareListParams

type EvalTableVersionRowCompareListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated EvaluationVersion IDs to compare with the reference, in result
	// order.
	CompareTo param.Field[[]string] `query:"compare_to" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvalTableVersionRowCompareListParams) URLQuery

URLQuery serializes EvalTableVersionRowCompareListParams's query parameters as `url.Values`.

type EvalTableVersionRowCompareListResponse

type EvalTableVersionRowCompareListResponse struct {
	Rows []EvalTableVersionRowCompareListResponseRow `json:"rows" api:"required"`
	// Matched rows across every page.
	TotalRows  int64                                      `json:"total_rows"  api:"required"`
	NextCursor string                                     `json:"next_cursor"`
	JSON       evalTableVersionRowCompareListResponseJSON `json:"-"`
}

func (*EvalTableVersionRowCompareListResponse) UnmarshalJSON

func (r *EvalTableVersionRowCompareListResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareListResponseRow

type EvalTableVersionRowCompareListResponseRow struct {
	// Identifies the matched row within this comparison: the hash of its example key
	// in hex, a colon, and its occurrence within each version, counted from 0. A row
	// written before the service hashed example keys has its Case ID, a colon, and its
	// version's index in evaluations instead.
	ID string `json:"id" api:"required"`
	// One entry per compared version, reference first.
	Evaluations []EvalTableVersionRowCompareListResponseRowsEvaluation `json:"evaluations" api:"required"`
	// The input of the first version with the row. Rows matched by a client example
	// key can differ in input.
	Input interface{}                                   `json:"input" api:"required"`
	JSON  evalTableVersionRowCompareListResponseRowJSON `json:"-"`
}

func (*EvalTableVersionRowCompareListResponseRow) UnmarshalJSON

func (r *EvalTableVersionRowCompareListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareListResponseRowsEvaluation

type EvalTableVersionRowCompareListResponseRowsEvaluation struct {
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Absent when this version has no row with the example key.
	Row  EvalTableVersionRowCompareListResponseRowsEvaluationsRow `json:"row"`
	JSON evalTableVersionRowCompareListResponseRowsEvaluationJSON `json:"-"`
}

func (*EvalTableVersionRowCompareListResponseRowsEvaluation) UnmarshalJSON

func (r *EvalTableVersionRowCompareListResponseRowsEvaluation) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareListResponseRowsEvaluationsRow

type EvalTableVersionRowCompareListResponseRowsEvaluationsRow struct {
	Attributes map[string]interface{}                                          `json:"attributes"  api:"required"`
	CaseID     string                                                          `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                                          `json:"example_key" api:"required,nullable"`
	Output     interface{}                                                     `json:"output"      api:"required"`
	Scores     []EvalTableVersionRowCompareListResponseRowsEvaluationsRowScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                                     `json:"tags"    api:"required"`
	Variant string                                                       `json:"variant" api:"required,nullable"`
	JSON    evalTableVersionRowCompareListResponseRowsEvaluationsRowJSON `json:"-"`
}

Absent when this version has no row with the example key.

func (*EvalTableVersionRowCompareListResponseRowsEvaluationsRow) UnmarshalJSON

type EvalTableVersionRowCompareListResponseRowsEvaluationsRowScore

type EvalTableVersionRowCompareListResponseRowsEvaluationsRowScore struct {
	ID              string                                                            `json:"id"                api:"required" format:"uuid"`
	ScorerID        string                                                            `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                                            `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                                       `json:"value"             api:"required"`
	JSON            evalTableVersionRowCompareListResponseRowsEvaluationsRowScoreJSON `json:"-"`
}

func (*EvalTableVersionRowCompareListResponseRowsEvaluationsRowScore) UnmarshalJSON

type EvalTableVersionRowCompareSearchParams

type EvalTableVersionRowCompareSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// EvaluationVersion IDs to compare with the reference, in result order.
	CompareTo param.Field[[]string] `json:"compare_to" api:"required" format:"uuid"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvalTableVersionRowCompareSearchParams) MarshalJSON

func (r EvalTableVersionRowCompareSearchParams) MarshalJSON() (data []byte, err error)

type EvalTableVersionRowCompareSearchResponse

type EvalTableVersionRowCompareSearchResponse struct {
	Rows []EvalTableVersionRowCompareSearchResponseRow `json:"rows" api:"required"`
	// Matched rows across every page.
	TotalRows  int64                                        `json:"total_rows"  api:"required"`
	NextCursor string                                       `json:"next_cursor"`
	JSON       evalTableVersionRowCompareSearchResponseJSON `json:"-"`
}

func (*EvalTableVersionRowCompareSearchResponse) UnmarshalJSON

func (r *EvalTableVersionRowCompareSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareSearchResponseRow

type EvalTableVersionRowCompareSearchResponseRow struct {
	// Identifies the matched row within this comparison: the hash of its example key
	// in hex, a colon, and its occurrence within each version, counted from 0. A row
	// written before the service hashed example keys has its Case ID, a colon, and its
	// version's index in evaluations instead.
	ID string `json:"id" api:"required"`
	// One entry per compared version, reference first.
	Evaluations []EvalTableVersionRowCompareSearchResponseRowsEvaluation `json:"evaluations" api:"required"`
	// The input of the first version with the row. Rows matched by a client example
	// key can differ in input.
	Input interface{}                                     `json:"input" api:"required"`
	JSON  evalTableVersionRowCompareSearchResponseRowJSON `json:"-"`
}

func (*EvalTableVersionRowCompareSearchResponseRow) UnmarshalJSON

func (r *EvalTableVersionRowCompareSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareSearchResponseRowsEvaluation

type EvalTableVersionRowCompareSearchResponseRowsEvaluation struct {
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Absent when this version has no row with the example key.
	Row  EvalTableVersionRowCompareSearchResponseRowsEvaluationsRow `json:"row"`
	JSON evalTableVersionRowCompareSearchResponseRowsEvaluationJSON `json:"-"`
}

func (*EvalTableVersionRowCompareSearchResponseRowsEvaluation) UnmarshalJSON

func (r *EvalTableVersionRowCompareSearchResponseRowsEvaluation) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowCompareSearchResponseRowsEvaluationsRow

type EvalTableVersionRowCompareSearchResponseRowsEvaluationsRow struct {
	Attributes map[string]interface{}                                            `json:"attributes"  api:"required"`
	CaseID     string                                                            `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                                            `json:"example_key" api:"required,nullable"`
	Output     interface{}                                                       `json:"output"      api:"required"`
	Scores     []EvalTableVersionRowCompareSearchResponseRowsEvaluationsRowScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                                       `json:"tags"    api:"required"`
	Variant string                                                         `json:"variant" api:"required,nullable"`
	JSON    evalTableVersionRowCompareSearchResponseRowsEvaluationsRowJSON `json:"-"`
}

Absent when this version has no row with the example key.

func (*EvalTableVersionRowCompareSearchResponseRowsEvaluationsRow) UnmarshalJSON

type EvalTableVersionRowCompareSearchResponseRowsEvaluationsRowScore

type EvalTableVersionRowCompareSearchResponseRowsEvaluationsRowScore struct {
	ID              string                                                              `json:"id"                api:"required" format:"uuid"`
	ScorerID        string                                                              `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                                              `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                                         `json:"value"             api:"required"`
	JSON            evalTableVersionRowCompareSearchResponseRowsEvaluationsRowScoreJSON `json:"-"`
}

func (*EvalTableVersionRowCompareSearchResponseRowsEvaluationsRowScore) UnmarshalJSON

type EvalTableVersionRowCompareService

type EvalTableVersionRowCompareService struct {
	Options []option.RequestOption
}

EvalTableVersionRowCompareService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableVersionRowCompareService method instead.

func NewEvalTableVersionRowCompareService

func NewEvalTableVersionRowCompareService(opts ...option.RequestOption) (r *EvalTableVersionRowCompareService)

NewEvalTableVersionRowCompareService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableVersionRowCompareService) List

Matches the reference version's rows with each compared version's rows by example key, and pages through the union. A case logged without an example key but with an input matches by the key derived from that input when it was appended as an eval table row or written with `example_key_fields`. Any other case without an example key matches only itself, in versions that read its dataset. The k-th copy of an example key in one version matches the k-th copy in another. Each version reads its cases and selected scores at its own cutoff. A row written before the service hashed example keys matches no other row.

`filter` uses the rows operations' columns, without a version qualifier. Each version's row is tested on its own, and a row is kept, with every version's values, when any version's row passes. A version without a filter column reads as null in it.

`order_by` names one column of one compared version, as in `v."<evaluation_version_id>".s.accuracy desc` or `v."<evaluation_version_id>".example_key`. Rows without that version sort last. Without `order_by`, rows follow the reference's order, then each later version's rows that earlier versions lack. Filtering and ordering apply before pagination, and every page reports the total.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/rows/compare/search` operation.

func (*EvalTableVersionRowCompareService) Search

Returns the same comparison as compare-eval-table-version-rows, with the parameters supplied in a JSON body. Use this operation when the parameters are too large for a URL.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvalTableVersionRowListParams

type EvalTableVersionRowListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `query:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvalTableVersionRowListParams) URLQuery

func (r EvalTableVersionRowListParams) URLQuery() (v url.Values)

URLQuery serializes EvalTableVersionRowListParams's query parameters as `url.Values`.

type EvalTableVersionRowListResponse

type EvalTableVersionRowListResponse struct {
	Rows       []EvalTableVersionRowListResponseRow `json:"rows"        api:"required"`
	NextCursor string                               `json:"next_cursor"`
	JSON       evalTableVersionRowListResponseJSON  `json:"-"`
}

func (*EvalTableVersionRowListResponse) UnmarshalJSON

func (r *EvalTableVersionRowListResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowListResponseRow

type EvalTableVersionRowListResponseRow struct {
	Attributes map[string]interface{}                     `json:"attributes"  api:"required"`
	CaseID     string                                     `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                     `json:"example_key" api:"required,nullable"`
	Input      interface{}                                `json:"input"       api:"required"`
	Output     interface{}                                `json:"output"      api:"required"`
	Scores     []EvalTableVersionRowListResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                               `json:"tags"    api:"required"`
	Variant string                                 `json:"variant" api:"required,nullable"`
	JSON    evalTableVersionRowListResponseRowJSON `json:"-"`
}

func (*EvalTableVersionRowListResponseRow) UnmarshalJSON

func (r *EvalTableVersionRowListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowListResponseRowsScore

type EvalTableVersionRowListResponseRowsScore struct {
	ID              string                                       `json:"id"                api:"required" format:"uuid"`
	ScorerID        string                                       `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                       `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                  `json:"value"             api:"required"`
	JSON            evalTableVersionRowListResponseRowsScoreJSON `json:"-"`
}

func (*EvalTableVersionRowListResponseRowsScore) UnmarshalJSON

func (r *EvalTableVersionRowListResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowSearchParams

type EvalTableVersionRowSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `json:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvalTableVersionRowSearchParams) MarshalJSON

func (r EvalTableVersionRowSearchParams) MarshalJSON() (data []byte, err error)

type EvalTableVersionRowSearchResponse

type EvalTableVersionRowSearchResponse struct {
	Rows       []EvalTableVersionRowSearchResponseRow `json:"rows"        api:"required"`
	NextCursor string                                 `json:"next_cursor"`
	JSON       evalTableVersionRowSearchResponseJSON  `json:"-"`
}

func (*EvalTableVersionRowSearchResponse) UnmarshalJSON

func (r *EvalTableVersionRowSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowSearchResponseRow

type EvalTableVersionRowSearchResponseRow struct {
	Attributes map[string]interface{}                       `json:"attributes"  api:"required"`
	CaseID     string                                       `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                       `json:"example_key" api:"required,nullable"`
	Input      interface{}                                  `json:"input"       api:"required"`
	Output     interface{}                                  `json:"output"      api:"required"`
	Scores     []EvalTableVersionRowSearchResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                 `json:"tags"    api:"required"`
	Variant string                                   `json:"variant" api:"required,nullable"`
	JSON    evalTableVersionRowSearchResponseRowJSON `json:"-"`
}

func (*EvalTableVersionRowSearchResponseRow) UnmarshalJSON

func (r *EvalTableVersionRowSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowSearchResponseRowsScore

type EvalTableVersionRowSearchResponseRowsScore struct {
	ID              string                                         `json:"id"                api:"required" format:"uuid"`
	ScorerID        string                                         `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                         `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                    `json:"value"             api:"required"`
	JSON            evalTableVersionRowSearchResponseRowsScoreJSON `json:"-"`
}

func (*EvalTableVersionRowSearchResponseRowsScore) UnmarshalJSON

func (r *EvalTableVersionRowSearchResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvalTableVersionRowService

type EvalTableVersionRowService struct {
	Options []option.RequestOption
	Compare *EvalTableVersionRowCompareService
}

EvalTableVersionRowService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableVersionRowService method instead.

func NewEvalTableVersionRowService

func NewEvalTableVersionRowService(opts ...option.RequestOption) (r *EvalTableVersionRowService)

NewEvalTableVersionRowService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableVersionRowService) List

Returns cases and their selected scores from the frozen evaluation version. Filtering and sorting happen before pagination.

Use these column names in `filter` and `order_by`:

  • `variant` or `example_key` for the row's model/checkpoint label or external example reference.
  • `i.<name>` for an input field.
  • `o.<name>` for an output field.
  • `s.<name>` for a score column.

`input`, `output`, and `score` are also accepted as the longer forms of `i`, `o`, and `s`.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/rows/search` operation.

func (*EvalTableVersionRowService) Search

Returns the same frozen rows as the GET rows operation, with the filter, sort order, and pagination parameters supplied in a JSON body.

Filtering and sorting happen before pagination. Use this operation when the parameters are too large for a URL.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvalTableVersionService

type EvalTableVersionService struct {
	Options []option.RequestOption
	Columns *EvalTableVersionColumnService
	Rows    *EvalTableVersionRowService
}

EvalTableVersionService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvalTableVersionService method instead.

func NewEvalTableVersionService

func NewEvalTableVersionService(opts ...option.RequestOption) (r *EvalTableVersionService)

NewEvalTableVersionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvalTableVersionService) New

Creates an immutable snapshot of the table's dataset and evaluation. Later row and score writes do not change this version.

Use the returned `evaluation_version_id` to read the frozen rows and columns. `dataset_version_id` identifies the associated dataset snapshot.

type EvaluationDeleteParams

type EvaluationDeleteParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationGetParams

type EvaluationGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationGetResponse

type EvaluationGetResponse struct {
	Attributes   map[string]interface{} `json:"attributes"    api:"required"`
	EvaluationID string                 `json:"evaluation_id" api:"required" format:"uuid"`
	Name         string                 `json:"name"          api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationGetResponseNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationGetResponsePrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                 `json:"scope_ref"           api:"required"`
	Source            EvaluationGetResponseSource            `json:"source"              api:"required"`
	JSON              evaluationGetResponseJSON              `json:"-"`
}

func (*EvaluationGetResponse) UnmarshalJSON

func (r *EvaluationGetResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationGetResponseNamespace

type EvaluationGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationGetResponseNamespaceWandb EvaluationGetResponseNamespace = "wandb"
)

func (EvaluationGetResponseNamespace) IsKnown

type EvaluationGetResponsePrimaryTargetKind

type EvaluationGetResponsePrimaryTargetKind string
const (
	EvaluationGetResponsePrimaryTargetKindCase       EvaluationGetResponsePrimaryTargetKind = "case"
	EvaluationGetResponsePrimaryTargetKindTrajectory EvaluationGetResponsePrimaryTargetKind = "trajectory"
)

func (EvaluationGetResponsePrimaryTargetKind) IsKnown

type EvaluationGetResponseSource

type EvaluationGetResponseSource struct {
	Kind             EvaluationGetResponseSourceKind `json:"kind"               api:"required"`
	DatasetID        string                          `json:"dataset_id"                        format:"uuid"`
	DatasetVersionID string                          `json:"dataset_version_id"                format:"uuid"`
	JSON             evaluationGetResponseSourceJSON `json:"-"`
	// contains filtered or unexported fields
}

func (EvaluationGetResponseSource) AsUnion

AsUnion returns a EvaluationGetResponseSourceUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are EvaluationGetResponseSourceFixedEvaluationSource, EvaluationGetResponseSourceLiveEvaluationSource.

func (*EvaluationGetResponseSource) UnmarshalJSON

func (r *EvaluationGetResponseSource) UnmarshalJSON(data []byte) (err error)

type EvaluationGetResponseSourceFixedEvaluationSource

type EvaluationGetResponseSourceFixedEvaluationSource struct {
	DatasetVersionID string                                               `json:"dataset_version_id" api:"required" format:"uuid"`
	Kind             EvaluationGetResponseSourceFixedEvaluationSourceKind `json:"kind"               api:"required"`
	JSON             evaluationGetResponseSourceFixedEvaluationSourceJSON `json:"-"`
}

func (*EvaluationGetResponseSourceFixedEvaluationSource) UnmarshalJSON

func (r *EvaluationGetResponseSourceFixedEvaluationSource) UnmarshalJSON(data []byte) (err error)

type EvaluationGetResponseSourceFixedEvaluationSourceKind

type EvaluationGetResponseSourceFixedEvaluationSourceKind string
const (
	EvaluationGetResponseSourceFixedEvaluationSourceKindFixed EvaluationGetResponseSourceFixedEvaluationSourceKind = "fixed"
)

func (EvaluationGetResponseSourceFixedEvaluationSourceKind) IsKnown

type EvaluationGetResponseSourceKind

type EvaluationGetResponseSourceKind string
const (
	EvaluationGetResponseSourceKindFixed EvaluationGetResponseSourceKind = "fixed"
	EvaluationGetResponseSourceKindLive  EvaluationGetResponseSourceKind = "live"
)

func (EvaluationGetResponseSourceKind) IsKnown

type EvaluationGetResponseSourceLiveEvaluationSource

type EvaluationGetResponseSourceLiveEvaluationSource struct {
	DatasetID string                                              `json:"dataset_id" api:"required" format:"uuid"`
	Kind      EvaluationGetResponseSourceLiveEvaluationSourceKind `json:"kind"       api:"required"`
	JSON      evaluationGetResponseSourceLiveEvaluationSourceJSON `json:"-"`
}

func (*EvaluationGetResponseSourceLiveEvaluationSource) UnmarshalJSON

func (r *EvaluationGetResponseSourceLiveEvaluationSource) UnmarshalJSON(data []byte) (err error)

type EvaluationGetResponseSourceLiveEvaluationSourceKind

type EvaluationGetResponseSourceLiveEvaluationSourceKind string
const (
	EvaluationGetResponseSourceLiveEvaluationSourceKindLive EvaluationGetResponseSourceLiveEvaluationSourceKind = "live"
)

func (EvaluationGetResponseSourceLiveEvaluationSourceKind) IsKnown

type EvaluationGetResponseSourceUnion

type EvaluationGetResponseSourceUnion interface {
	// contains filtered or unexported methods
}

Union satisfied by EvaluationGetResponseSourceFixedEvaluationSource or EvaluationGetResponseSourceLiveEvaluationSource.

type EvaluationListParams

type EvaluationListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Return only evaluations with exactly this name, including evaluation tables.
	// Omit to list all evaluations in the scope.
	Name param.Field[string] `query:"name"`
}

func (EvaluationListParams) URLQuery

func (r EvaluationListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationListParams's query parameters as `url.Values`.

type EvaluationListResponse

type EvaluationListResponse struct {
	Evaluations []EvaluationListResponseEvaluation `json:"evaluations" api:"required"`
	NextCursor  string                             `json:"next_cursor"`
	JSON        evaluationListResponseJSON         `json:"-"`
}

func (*EvaluationListResponse) UnmarshalJSON

func (r *EvaluationListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationListResponseEvaluation

type EvaluationListResponseEvaluation struct {
	Attributes   map[string]interface{} `json:"attributes"    api:"required"`
	EvaluationID string                 `json:"evaluation_id" api:"required" format:"uuid"`
	Name         string                 `json:"name"          api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationListResponseEvaluationsNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationListResponseEvaluationsPrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                             `json:"scope_ref"           api:"required"`
	Source            EvaluationListResponseEvaluationsSource            `json:"source"              api:"required"`
	JSON              evaluationListResponseEvaluationJSON               `json:"-"`
}

func (*EvaluationListResponseEvaluation) UnmarshalJSON

func (r *EvaluationListResponseEvaluation) UnmarshalJSON(data []byte) (err error)

type EvaluationListResponseEvaluationsNamespace

type EvaluationListResponseEvaluationsNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationListResponseEvaluationsNamespaceWandb EvaluationListResponseEvaluationsNamespace = "wandb"
)

func (EvaluationListResponseEvaluationsNamespace) IsKnown

type EvaluationListResponseEvaluationsPrimaryTargetKind

type EvaluationListResponseEvaluationsPrimaryTargetKind string
const (
	EvaluationListResponseEvaluationsPrimaryTargetKindCase       EvaluationListResponseEvaluationsPrimaryTargetKind = "case"
	EvaluationListResponseEvaluationsPrimaryTargetKindTrajectory EvaluationListResponseEvaluationsPrimaryTargetKind = "trajectory"
)

func (EvaluationListResponseEvaluationsPrimaryTargetKind) IsKnown

type EvaluationListResponseEvaluationsSource

type EvaluationListResponseEvaluationsSource struct {
	Kind             EvaluationListResponseEvaluationsSourceKind `json:"kind"               api:"required"`
	DatasetID        string                                      `json:"dataset_id"                        format:"uuid"`
	DatasetVersionID string                                      `json:"dataset_version_id"                format:"uuid"`
	JSON             evaluationListResponseEvaluationsSourceJSON `json:"-"`
	// contains filtered or unexported fields
}

func (EvaluationListResponseEvaluationsSource) AsUnion

AsUnion returns a EvaluationListResponseEvaluationsSourceUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are EvaluationListResponseEvaluationsSourceFixedEvaluationSource, EvaluationListResponseEvaluationsSourceLiveEvaluationSource.

func (*EvaluationListResponseEvaluationsSource) UnmarshalJSON

func (r *EvaluationListResponseEvaluationsSource) UnmarshalJSON(data []byte) (err error)

type EvaluationListResponseEvaluationsSourceFixedEvaluationSource

type EvaluationListResponseEvaluationsSourceFixedEvaluationSource struct {
	DatasetVersionID string                                                           `json:"dataset_version_id" api:"required" format:"uuid"`
	Kind             EvaluationListResponseEvaluationsSourceFixedEvaluationSourceKind `json:"kind"               api:"required"`
	JSON             evaluationListResponseEvaluationsSourceFixedEvaluationSourceJSON `json:"-"`
}

func (*EvaluationListResponseEvaluationsSourceFixedEvaluationSource) UnmarshalJSON

type EvaluationListResponseEvaluationsSourceFixedEvaluationSourceKind

type EvaluationListResponseEvaluationsSourceFixedEvaluationSourceKind string
const (
	EvaluationListResponseEvaluationsSourceFixedEvaluationSourceKindFixed EvaluationListResponseEvaluationsSourceFixedEvaluationSourceKind = "fixed"
)

func (EvaluationListResponseEvaluationsSourceFixedEvaluationSourceKind) IsKnown

type EvaluationListResponseEvaluationsSourceKind

type EvaluationListResponseEvaluationsSourceKind string
const (
	EvaluationListResponseEvaluationsSourceKindFixed EvaluationListResponseEvaluationsSourceKind = "fixed"
	EvaluationListResponseEvaluationsSourceKindLive  EvaluationListResponseEvaluationsSourceKind = "live"
)

func (EvaluationListResponseEvaluationsSourceKind) IsKnown

type EvaluationListResponseEvaluationsSourceLiveEvaluationSource

type EvaluationListResponseEvaluationsSourceLiveEvaluationSource struct {
	DatasetID string                                                          `json:"dataset_id" api:"required" format:"uuid"`
	Kind      EvaluationListResponseEvaluationsSourceLiveEvaluationSourceKind `json:"kind"       api:"required"`
	JSON      evaluationListResponseEvaluationsSourceLiveEvaluationSourceJSON `json:"-"`
}

func (*EvaluationListResponseEvaluationsSourceLiveEvaluationSource) UnmarshalJSON

type EvaluationListResponseEvaluationsSourceLiveEvaluationSourceKind

type EvaluationListResponseEvaluationsSourceLiveEvaluationSourceKind string
const (
	EvaluationListResponseEvaluationsSourceLiveEvaluationSourceKindLive EvaluationListResponseEvaluationsSourceLiveEvaluationSourceKind = "live"
)

func (EvaluationListResponseEvaluationsSourceLiveEvaluationSourceKind) IsKnown

type EvaluationListResponseEvaluationsSourceUnion

type EvaluationListResponseEvaluationsSourceUnion interface {
	// contains filtered or unexported methods
}

Union satisfied by EvaluationListResponseEvaluationsSourceFixedEvaluationSource or EvaluationListResponseEvaluationsSourceLiveEvaluationSource.

type EvaluationLogParams

type EvaluationLogParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string]                      `path:"scope_id" api:"required"`
	Results param.Field[[]EvaluationLogParamsResult] `                api:"required" json:"results"`
	// Model, agent, prompt, or checkpoint shared by these results. Leading and
	// trailing whitespace are not allowed.
	Variant param.Field[string] `json:"variant" api:"required"`
}

func (EvaluationLogParams) MarshalJSON

func (r EvaluationLogParams) MarshalJSON() (data []byte, err error)

type EvaluationLogParamsResult

type EvaluationLogParamsResult struct {
	// Reference to an example in external data. The service does not fetch it. The
	// same key and variant within the source Dataset reuse one Case. Leading and
	// trailing whitespace are not allowed.
	ExampleKey param.Field[string] `json:"example_key" api:"required"`
	// Scores keyed by Scorer name. Missing names are inferred and registered. Values
	// must be numbers, booleans, or strings and must match an existing Scorer's type.
	// Use an empty object when no scores are supplied. Earlier scores remain
	// unchanged.
	Scores param.Field[map[string]interface{}] `json:"scores" api:"required"`
}

func (EvaluationLogParamsResult) MarshalJSON

func (r EvaluationLogParamsResult) MarshalJSON() (data []byte, err error)

type EvaluationLogResponse

type EvaluationLogResponse struct {
	// One Case ID per result, in request order. Repeated example keys for the same
	// variant reuse the same ID.
	CaseIDs []string `json:"case_ids" api:"required" format:"uuid"`
	// All returned Cases and Scores are published at or before this commit.
	CommitID int64 `json:"commit_id" api:"required"`
	// Score IDs in result order, then lexicographic Scorer-name order within each
	// result.
	ScoreIDs []string                  `json:"score_ids" api:"required" format:"uuid"`
	JSON     evaluationLogResponseJSON `json:"-"`
}

func (*EvaluationLogResponse) UnmarshalJSON

func (r *EvaluationLogResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationMetricListParams

type EvaluationMetricListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationMetricListResponse

type EvaluationMetricListResponse struct {
	// Newest value per subject and name, ordered by subject and then name. Values
	// without a subject come first.
	Metrics []EvaluationMetricListResponseMetric `json:"metrics" api:"required"`
	// Publication cutoff used to select the returned metric values.
	PublishedCommitID int64                            `json:"published_commit_id" api:"required"`
	JSON              evaluationMetricListResponseJSON `json:"-"`
}

func (*EvaluationMetricListResponse) UnmarshalJSON

func (r *EvaluationMetricListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationMetricListResponseMetric

type EvaluationMetricListResponseMetric struct {
	CommitID  int64                                        `json:"commit_id"  api:"required"`
	Name      string                                       `json:"name"       api:"required"`
	Subject   string                                       `json:"subject"    api:"required,nullable"`
	Value     interface{}                                  `json:"value"      api:"required"`
	ValueType EvaluationMetricListResponseMetricsValueType `json:"value_type" api:"required"`
	JSON      evaluationMetricListResponseMetricJSON       `json:"-"`
}

func (*EvaluationMetricListResponseMetric) UnmarshalJSON

func (r *EvaluationMetricListResponseMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationMetricListResponseMetricsValueType

type EvaluationMetricListResponseMetricsValueType string
const (
	EvaluationMetricListResponseMetricsValueTypeBoolean EvaluationMetricListResponseMetricsValueType = "boolean"
	EvaluationMetricListResponseMetricsValueTypeNumber  EvaluationMetricListResponseMetricsValueType = "number"
	EvaluationMetricListResponseMetricsValueTypeString  EvaluationMetricListResponseMetricsValueType = "string"
	EvaluationMetricListResponseMetricsValueTypeJson    EvaluationMetricListResponseMetricsValueType = "json"
)

func (EvaluationMetricListResponseMetricsValueType) IsKnown

type EvaluationMetricReportParams

type EvaluationMetricReportParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string]                               `path:"scope_id" api:"required"`
	Metrics param.Field[[]EvaluationMetricReportParamsMetric] `                api:"required" json:"metrics"`
}

func (EvaluationMetricReportParams) MarshalJSON

func (r EvaluationMetricReportParams) MarshalJSON() (data []byte, err error)

type EvaluationMetricReportParamsMetric

type EvaluationMetricReportParamsMetric struct {
	Name param.Field[string] `json:"name" api:"required"`
	// Metric value calculated by your application, in any JSON type. Send JSON null to
	// remove this metric from this commit onward.
	Value param.Field[interface{}] `json:"value" api:"required"`
	// Model, checkpoint, or other entity the metric describes. Leading and trailing
	// whitespace are not allowed. Omit or send null for a metric describing the whole
	// evaluation.
	Subject param.Field[string] `json:"subject"`
}

func (EvaluationMetricReportParamsMetric) MarshalJSON

func (r EvaluationMetricReportParamsMetric) MarshalJSON() (data []byte, err error)

type EvaluationMetricReportResponse

type EvaluationMetricReportResponse struct {
	// Commit that recorded this report. An evaluation version includes these values if
	// its last_commit_id is at least this commit.
	CommitID     int64                              `json:"commit_id"     api:"required"`
	EvaluationID string                             `json:"evaluation_id" api:"required" format:"uuid"`
	JSON         evaluationMetricReportResponseJSON `json:"-"`
}

func (*EvaluationMetricReportResponse) UnmarshalJSON

func (r *EvaluationMetricReportResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationMetricService

type EvaluationMetricService struct {
	Options []option.RequestOption
}

EvaluationMetricService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationMetricService method instead.

func NewEvaluationMetricService

func NewEvaluationMetricService(opts ...option.RequestOption) (r *EvaluationMetricService)

NewEvaluationMetricService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationMetricService) List

Returns the newest reported value for each subject and metric name at the scope's latest published commit. The next evaluation version freezes these values.

For metrics calculated by aggregating individual scores, use the saved query results operations instead.

func (*EvaluationMetricService) Report

Stores metrics calculated by your application, such as FID or corpus BLEU, that cannot be aggregated from individual scores. A metric describes the whole evaluation or one named subject.

**Updating values**

  • Reporting the same subject and name replaces the earlier value from the new commit onward. Send JSON `null` to remove it.
  • Frozen evaluation versions retain the values at their publication cutoff. A value carries into later versions until replaced or removed.
  • The service does not track which cases or scores you used to calculate the metric.

**Value types**

Types are inferred from JSON. All JSON numbers use `number`. Objects and arrays use `json`. A metric name keeps the type of its first value across all subjects. Reporting another type returns 400 with the conflict.

**Storage limits**

An evaluation can hold at most 10,000 metrics and 4 MiB of metric subjects, names, and values at once. A report that exceeds either limit is rejected. Replacing or removing values frees space.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationNewParams

type EvaluationNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	Name    param.Field[string] `                api:"required" json:"name"`
	// Which rows this evaluation lists. A case evaluation supports evaluation rows,
	// row comparisons, and eval tables. A trajectory evaluation supports trajectory
	// rows. Saved queries choose their own target_kind and run on either.
	PrimaryTargetKind param.Field[EvaluationNewParamsPrimaryTargetKind] `json:"primary_target_kind" api:"required"`
	Source            param.Field[EvaluationNewParamsSourceUnion]       `json:"source"              api:"required"`
	Attributes        param.Field[map[string]interface{}]               `json:"attributes"`
}

func (EvaluationNewParams) MarshalJSON

func (r EvaluationNewParams) MarshalJSON() (data []byte, err error)

type EvaluationNewParamsPrimaryTargetKind

type EvaluationNewParamsPrimaryTargetKind string

Which rows this evaluation lists. A case evaluation supports evaluation rows, row comparisons, and eval tables. A trajectory evaluation supports trajectory rows. Saved queries choose their own target_kind and run on either.

const (
	EvaluationNewParamsPrimaryTargetKindCase       EvaluationNewParamsPrimaryTargetKind = "case"
	EvaluationNewParamsPrimaryTargetKindTrajectory EvaluationNewParamsPrimaryTargetKind = "trajectory"
)

func (EvaluationNewParamsPrimaryTargetKind) IsKnown

type EvaluationNewParamsSource

type EvaluationNewParamsSource struct {
	Kind             param.Field[EvaluationNewParamsSourceKind] `json:"kind"               api:"required"`
	DatasetID        param.Field[string]                        `json:"dataset_id"                        format:"uuid"`
	DatasetVersionID param.Field[string]                        `json:"dataset_version_id"                format:"uuid"`
}

func (EvaluationNewParamsSource) MarshalJSON

func (r EvaluationNewParamsSource) MarshalJSON() (data []byte, err error)

type EvaluationNewParamsSourceFixedEvaluationSource

type EvaluationNewParamsSourceFixedEvaluationSource struct {
	DatasetVersionID param.Field[string]                                             `json:"dataset_version_id" api:"required" format:"uuid"`
	Kind             param.Field[EvaluationNewParamsSourceFixedEvaluationSourceKind] `json:"kind"               api:"required"`
}

func (EvaluationNewParamsSourceFixedEvaluationSource) MarshalJSON

func (r EvaluationNewParamsSourceFixedEvaluationSource) MarshalJSON() (data []byte, err error)

type EvaluationNewParamsSourceFixedEvaluationSourceKind

type EvaluationNewParamsSourceFixedEvaluationSourceKind string
const (
	EvaluationNewParamsSourceFixedEvaluationSourceKindFixed EvaluationNewParamsSourceFixedEvaluationSourceKind = "fixed"
)

func (EvaluationNewParamsSourceFixedEvaluationSourceKind) IsKnown

type EvaluationNewParamsSourceKind

type EvaluationNewParamsSourceKind string
const (
	EvaluationNewParamsSourceKindFixed EvaluationNewParamsSourceKind = "fixed"
	EvaluationNewParamsSourceKindLive  EvaluationNewParamsSourceKind = "live"
)

func (EvaluationNewParamsSourceKind) IsKnown

func (r EvaluationNewParamsSourceKind) IsKnown() bool

type EvaluationNewParamsSourceLiveEvaluationSource

type EvaluationNewParamsSourceLiveEvaluationSource struct {
	DatasetID param.Field[string]                                            `json:"dataset_id" api:"required" format:"uuid"`
	Kind      param.Field[EvaluationNewParamsSourceLiveEvaluationSourceKind] `json:"kind"       api:"required"`
}

func (EvaluationNewParamsSourceLiveEvaluationSource) MarshalJSON

func (r EvaluationNewParamsSourceLiveEvaluationSource) MarshalJSON() (data []byte, err error)

type EvaluationNewParamsSourceLiveEvaluationSourceKind

type EvaluationNewParamsSourceLiveEvaluationSourceKind string
const (
	EvaluationNewParamsSourceLiveEvaluationSourceKindLive EvaluationNewParamsSourceLiveEvaluationSourceKind = "live"
)

func (EvaluationNewParamsSourceLiveEvaluationSourceKind) IsKnown

type EvaluationNewParamsSourceUnion

type EvaluationNewParamsSourceUnion interface {
	// contains filtered or unexported methods
}

Satisfied by EvaluationNewParamsSourceFixedEvaluationSource, EvaluationNewParamsSourceLiveEvaluationSource, EvaluationNewParamsSource.

type EvaluationNewResponse

type EvaluationNewResponse struct {
	Attributes   map[string]interface{} `json:"attributes"    api:"required"`
	EvaluationID string                 `json:"evaluation_id" api:"required" format:"uuid"`
	Name         string                 `json:"name"          api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationNewResponseNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationNewResponsePrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                 `json:"scope_ref"           api:"required"`
	Source            EvaluationNewResponseSource            `json:"source"              api:"required"`
	JSON              evaluationNewResponseJSON              `json:"-"`
}

func (*EvaluationNewResponse) UnmarshalJSON

func (r *EvaluationNewResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationNewResponseNamespace

type EvaluationNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationNewResponseNamespaceWandb EvaluationNewResponseNamespace = "wandb"
)

func (EvaluationNewResponseNamespace) IsKnown

type EvaluationNewResponsePrimaryTargetKind

type EvaluationNewResponsePrimaryTargetKind string
const (
	EvaluationNewResponsePrimaryTargetKindCase       EvaluationNewResponsePrimaryTargetKind = "case"
	EvaluationNewResponsePrimaryTargetKindTrajectory EvaluationNewResponsePrimaryTargetKind = "trajectory"
)

func (EvaluationNewResponsePrimaryTargetKind) IsKnown

type EvaluationNewResponseSource

type EvaluationNewResponseSource struct {
	Kind             EvaluationNewResponseSourceKind `json:"kind"               api:"required"`
	DatasetID        string                          `json:"dataset_id"                        format:"uuid"`
	DatasetVersionID string                          `json:"dataset_version_id"                format:"uuid"`
	JSON             evaluationNewResponseSourceJSON `json:"-"`
	// contains filtered or unexported fields
}

func (EvaluationNewResponseSource) AsUnion

AsUnion returns a EvaluationNewResponseSourceUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are EvaluationNewResponseSourceFixedEvaluationSource, EvaluationNewResponseSourceLiveEvaluationSource.

func (*EvaluationNewResponseSource) UnmarshalJSON

func (r *EvaluationNewResponseSource) UnmarshalJSON(data []byte) (err error)

type EvaluationNewResponseSourceFixedEvaluationSource

type EvaluationNewResponseSourceFixedEvaluationSource struct {
	DatasetVersionID string                                               `json:"dataset_version_id" api:"required" format:"uuid"`
	Kind             EvaluationNewResponseSourceFixedEvaluationSourceKind `json:"kind"               api:"required"`
	JSON             evaluationNewResponseSourceFixedEvaluationSourceJSON `json:"-"`
}

func (*EvaluationNewResponseSourceFixedEvaluationSource) UnmarshalJSON

func (r *EvaluationNewResponseSourceFixedEvaluationSource) UnmarshalJSON(data []byte) (err error)

type EvaluationNewResponseSourceFixedEvaluationSourceKind

type EvaluationNewResponseSourceFixedEvaluationSourceKind string
const (
	EvaluationNewResponseSourceFixedEvaluationSourceKindFixed EvaluationNewResponseSourceFixedEvaluationSourceKind = "fixed"
)

func (EvaluationNewResponseSourceFixedEvaluationSourceKind) IsKnown

type EvaluationNewResponseSourceKind

type EvaluationNewResponseSourceKind string
const (
	EvaluationNewResponseSourceKindFixed EvaluationNewResponseSourceKind = "fixed"
	EvaluationNewResponseSourceKindLive  EvaluationNewResponseSourceKind = "live"
)

func (EvaluationNewResponseSourceKind) IsKnown

type EvaluationNewResponseSourceLiveEvaluationSource

type EvaluationNewResponseSourceLiveEvaluationSource struct {
	DatasetID string                                              `json:"dataset_id" api:"required" format:"uuid"`
	Kind      EvaluationNewResponseSourceLiveEvaluationSourceKind `json:"kind"       api:"required"`
	JSON      evaluationNewResponseSourceLiveEvaluationSourceJSON `json:"-"`
}

func (*EvaluationNewResponseSourceLiveEvaluationSource) UnmarshalJSON

func (r *EvaluationNewResponseSourceLiveEvaluationSource) UnmarshalJSON(data []byte) (err error)

type EvaluationNewResponseSourceLiveEvaluationSourceKind

type EvaluationNewResponseSourceLiveEvaluationSourceKind string
const (
	EvaluationNewResponseSourceLiveEvaluationSourceKindLive EvaluationNewResponseSourceLiveEvaluationSourceKind = "live"
)

func (EvaluationNewResponseSourceLiveEvaluationSourceKind) IsKnown

type EvaluationNewResponseSourceUnion

type EvaluationNewResponseSourceUnion interface {
	// contains filtered or unexported methods
}

Union satisfied by EvaluationNewResponseSourceFixedEvaluationSource or EvaluationNewResponseSourceLiveEvaluationSource.

type EvaluationQueryGetParams

type EvaluationQueryGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationQueryGetResponse

type EvaluationQueryGetResponse struct {
	Definition        EvaluationQueryGetResponseDefinition `json:"definition"          api:"required"`
	EvaluationID      string                               `json:"evaluation_id"       api:"required" format:"uuid"`
	EvaluationQueryID string                               `json:"evaluation_query_id" api:"required" format:"uuid"`
	Name              string                               `json:"name"                api:"required"`
	// Namespace that assigned the scope reference.
	Namespace EvaluationQueryGetResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                              `json:"scope_ref" api:"required"`
	JSON      evaluationQueryGetResponseJSON      `json:"-"`
}

func (*EvaluationQueryGetResponse) UnmarshalJSON

func (r *EvaluationQueryGetResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryGetResponseDefinition

type EvaluationQueryGetResponseDefinition struct {
	Metrics []EvaluationQueryGetResponseDefinitionMetric `json:"metrics" api:"required"`
	// Stored definition version. Always present in responses.
	V       int64                                         `json:"v"        api:"required"`
	GroupBy []EvaluationQueryGetResponseDefinitionGroupBy `json:"group_by"`
	// Absent for a query over cases.
	TargetKind EvaluationQueryGetResponseDefinitionTargetKind `json:"target_kind"`
	JSON       evaluationQueryGetResponseDefinitionJSON       `json:"-"`
}

func (*EvaluationQueryGetResponseDefinition) UnmarshalJSON

func (r *EvaluationQueryGetResponseDefinition) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryGetResponseDefinitionGroupBy

type EvaluationQueryGetResponseDefinitionGroupBy struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryGetResponseDefinitionGroupBySource `json:"source"`
	JSON   evaluationQueryGetResponseDefinitionGroupByJSON   `json:"-"`
	// contains filtered or unexported fields
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryGetResponseDefinitionGroupBy) UnmarshalJSON

func (r *EvaluationQueryGetResponseDefinitionGroupBy) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumn

type EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSource

type EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSourceInput  EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSourceOutput EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryGetResponseDefinitionGroupByDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumn

type EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnKindDepth EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryGetResponseDefinitionGroupByDepthEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByKind

type EvaluationQueryGetResponseDefinitionGroupByKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByKindVariant            EvaluationQueryGetResponseDefinitionGroupByKind = "variant"
	EvaluationQueryGetResponseDefinitionGroupByKindDatasetField       EvaluationQueryGetResponseDefinitionGroupByKind = "dataset_field"
	EvaluationQueryGetResponseDefinitionGroupByKindScore              EvaluationQueryGetResponseDefinitionGroupByKind = "score"
	EvaluationQueryGetResponseDefinitionGroupByKindDepth              EvaluationQueryGetResponseDefinitionGroupByKind = "depth"
	EvaluationQueryGetResponseDefinitionGroupByKindParentTrajectoryID EvaluationQueryGetResponseDefinitionGroupByKind = "parent_trajectory_id"
	EvaluationQueryGetResponseDefinitionGroupByKindTags               EvaluationQueryGetResponseDefinitionGroupByKind = "tags"
)

func (EvaluationQueryGetResponseDefinitionGroupByKind) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumn

type EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryGetResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumn

type EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                               `json:"name" api:"required"`
	JSON evaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnKindScore EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryGetResponseDefinitionGroupByScoreEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionGroupBySource

type EvaluationQueryGetResponseDefinitionGroupBySource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryGetResponseDefinitionGroupBySourceInput  EvaluationQueryGetResponseDefinitionGroupBySource = "input"
	EvaluationQueryGetResponseDefinitionGroupBySourceOutput EvaluationQueryGetResponseDefinitionGroupBySource = "output"
)

func (EvaluationQueryGetResponseDefinitionGroupBySource) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumn

type EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnKindTags EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryGetResponseDefinitionGroupByTagsEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumn

type EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnKindVariant EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryGetResponseDefinitionGroupByVariantEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetric

type EvaluationQueryGetResponseDefinitionMetric struct {
	// Calculation to apply to the latest visible score for each case, or for each
	// trajectory in a trajectory query.
	//
	//   - **mean**: Average of integer or number scores, or the fraction of true boolean
	//     scores.
	//   - **sum**: Sum of integer or number scores, or the number of true boolean
	//     scores.
	//   - **min / max**: Smallest or largest integer, number, boolean, or string score.
	//     Strings compare lexicographically.
	//   - **count**: Number of non-null integer, number, boolean, or string scores. Zero
	//     and false are counted.
	//   - **pass_at_k**: Estimated probability that at least one of k attempts at a task
	//     succeeds. Requires boolean scores, k, and per. It counts true scores as
	//     successes, so it rejects a scorer version whose higher_is_better is false,
	//     where true is the bad outcome.
	//
	// For pass_at_k, per identifies each task. A task with n attempts and c true
	// scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks.
	// The result is null when a task has fewer than k attempts.
	Aggregation EvaluationQueryGetResponseDefinitionMetricsAggregation `json:"aggregation" api:"required"`
	// Unique name for this metric within the query. Result cells use this name.
	Name string `json:"name" api:"required"`
	// Version of the scorer whose values this metric aggregates. It must be registered
	// on the evaluation.
	ScorerVersionID string `json:"scorer_version_id" api:"required" format:"uuid"`
	// Number of attempts per task for pass_at_k. Required for pass_at_k and rejected
	// for other aggregations.
	K int64 `json:"k"`
	// How to handle a target with no non-null latest visible score. A target is a
	// case, or a trajectory in a trajectory query.
	//
	//   - **skip**: Exclude the target. A mean divides by the number of scored targets,
	//     and pass_at_k does not count it as an attempt. This also applies when missing
	//     is omitted.
	//   - **zero**: Include the target as 0, or false for boolean scores. A mean divides
	//     by every target in the group, and pass_at_k counts it as a failed attempt.
	//
	// Only mean, sum, and pass_at_k support zero. min, max, and count accept only
	// skip.
	Missing EvaluationQueryGetResponseDefinitionMetricsMissing `json:"missing"`
	// Column that identifies the task for each case, or for each trajectory in a
	// trajectory query, such as an input task field.
	//
	//   - Required for pass_at_k and rejected for other aggregations.
	//   - Must not also appear in group_by, and must not be depth, parent_trajectory_id,
	//     or tags.
	//   - Targets with no value in this column form one task.
	//   - A page returns 400 if the number of groups multiplied by their tasks exceeds
	//     the result row limit.
	Per  EvaluationQueryGetResponseDefinitionMetricsPer `json:"per"`
	JSON evaluationQueryGetResponseDefinitionMetricJSON `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionMetric) UnmarshalJSON

func (r *EvaluationQueryGetResponseDefinitionMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryGetResponseDefinitionMetricsAggregation

type EvaluationQueryGetResponseDefinitionMetricsAggregation string

Calculation to apply to the latest visible score for each case, or for each trajectory in a trajectory query.

  • **mean**: Average of integer or number scores, or the fraction of true boolean scores.
  • **sum**: Sum of integer or number scores, or the number of true boolean scores.
  • **min / max**: Smallest or largest integer, number, boolean, or string score. Strings compare lexicographically.
  • **count**: Number of non-null integer, number, boolean, or string scores. Zero and false are counted.
  • **pass_at_k**: Estimated probability that at least one of k attempts at a task succeeds. Requires boolean scores, k, and per. It counts true scores as successes, so it rejects a scorer version whose higher_is_better is false, where true is the bad outcome.

For pass_at_k, per identifies each task. A task with n attempts and c true scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks. The result is null when a task has fewer than k attempts.

const (
	EvaluationQueryGetResponseDefinitionMetricsAggregationMean    EvaluationQueryGetResponseDefinitionMetricsAggregation = "mean"
	EvaluationQueryGetResponseDefinitionMetricsAggregationSum     EvaluationQueryGetResponseDefinitionMetricsAggregation = "sum"
	EvaluationQueryGetResponseDefinitionMetricsAggregationMin     EvaluationQueryGetResponseDefinitionMetricsAggregation = "min"
	EvaluationQueryGetResponseDefinitionMetricsAggregationMax     EvaluationQueryGetResponseDefinitionMetricsAggregation = "max"
	EvaluationQueryGetResponseDefinitionMetricsAggregationCount   EvaluationQueryGetResponseDefinitionMetricsAggregation = "count"
	EvaluationQueryGetResponseDefinitionMetricsAggregationPassAtK EvaluationQueryGetResponseDefinitionMetricsAggregation = "pass_at_k"
)

func (EvaluationQueryGetResponseDefinitionMetricsAggregation) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsMissing

type EvaluationQueryGetResponseDefinitionMetricsMissing string

How to handle a target with no non-null latest visible score. A target is a case, or a trajectory in a trajectory query.

  • **skip**: Exclude the target. A mean divides by the number of scored targets, and pass_at_k does not count it as an attempt. This also applies when missing is omitted.
  • **zero**: Include the target as 0, or false for boolean scores. A mean divides by every target in the group, and pass_at_k counts it as a failed attempt.

Only mean, sum, and pass_at_k support zero. min, max, and count accept only skip.

const (
	EvaluationQueryGetResponseDefinitionMetricsMissingSkip EvaluationQueryGetResponseDefinitionMetricsMissing = "skip"
	EvaluationQueryGetResponseDefinitionMetricsMissingZero EvaluationQueryGetResponseDefinitionMetricsMissing = "zero"
)

func (EvaluationQueryGetResponseDefinitionMetricsMissing) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPer

type EvaluationQueryGetResponseDefinitionMetricsPer struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryGetResponseDefinitionMetricsPerSource `json:"source"`
	JSON   evaluationQueryGetResponseDefinitionMetricsPerJSON   `json:"-"`
	// contains filtered or unexported fields
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

func (*EvaluationQueryGetResponseDefinitionMetricsPer) UnmarshalJSON

func (r *EvaluationQueryGetResponseDefinitionMetricsPer) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumn

type EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource

type EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSourceInput  EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSourceOutput EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumn

type EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnKindDepth EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerKind

type EvaluationQueryGetResponseDefinitionMetricsPerKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerKindVariant            EvaluationQueryGetResponseDefinitionMetricsPerKind = "variant"
	EvaluationQueryGetResponseDefinitionMetricsPerKindDatasetField       EvaluationQueryGetResponseDefinitionMetricsPerKind = "dataset_field"
	EvaluationQueryGetResponseDefinitionMetricsPerKindScore              EvaluationQueryGetResponseDefinitionMetricsPerKind = "score"
	EvaluationQueryGetResponseDefinitionMetricsPerKindDepth              EvaluationQueryGetResponseDefinitionMetricsPerKind = "depth"
	EvaluationQueryGetResponseDefinitionMetricsPerKindParentTrajectoryID EvaluationQueryGetResponseDefinitionMetricsPerKind = "parent_trajectory_id"
	EvaluationQueryGetResponseDefinitionMetricsPerKindTags               EvaluationQueryGetResponseDefinitionMetricsPerKind = "tags"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn

type EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumn

type EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                                  `json:"name" api:"required"`
	JSON evaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnKindScore EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerSource

type EvaluationQueryGetResponseDefinitionMetricsPerSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryGetResponseDefinitionMetricsPerSourceInput  EvaluationQueryGetResponseDefinitionMetricsPerSource = "input"
	EvaluationQueryGetResponseDefinitionMetricsPerSourceOutput EvaluationQueryGetResponseDefinitionMetricsPerSource = "output"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerSource) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumn

type EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnKindTags EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionMetricsPerUnion

type EvaluationQueryGetResponseDefinitionMetricsPerUnion interface {
	// contains filtered or unexported methods
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

Union satisfied by EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumn, EvaluationQueryGetResponseDefinitionMetricsPerDatasetFieldEvaluationColumn, EvaluationQueryGetResponseDefinitionMetricsPerScoreEvaluationColumn, EvaluationQueryGetResponseDefinitionMetricsPerDepthEvaluationColumn, EvaluationQueryGetResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn or EvaluationQueryGetResponseDefinitionMetricsPerTagsEvaluationColumn.

type EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumn

type EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumn struct {
	Kind EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnKind

type EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnKind string
const (
	EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnKindVariant EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryGetResponseDefinitionMetricsPerVariantEvaluationColumnKind) IsKnown

type EvaluationQueryGetResponseDefinitionTargetKind

type EvaluationQueryGetResponseDefinitionTargetKind string

Absent for a query over cases.

const (
	EvaluationQueryGetResponseDefinitionTargetKindTrajectory EvaluationQueryGetResponseDefinitionTargetKind = "trajectory"
)

func (EvaluationQueryGetResponseDefinitionTargetKind) IsKnown

type EvaluationQueryGetResponseNamespace

type EvaluationQueryGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationQueryGetResponseNamespaceWandb EvaluationQueryGetResponseNamespace = "wandb"
)

func (EvaluationQueryGetResponseNamespace) IsKnown

type EvaluationQueryListParams

type EvaluationQueryListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (EvaluationQueryListParams) URLQuery

func (r EvaluationQueryListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationQueryListParams's query parameters as `url.Values`.

type EvaluationQueryListResponse

type EvaluationQueryListResponse struct {
	EvaluationQueries []EvaluationQueryListResponseEvaluationQuery `json:"evaluation_queries" api:"required"`
	NextCursor        string                                       `json:"next_cursor"`
	JSON              evaluationQueryListResponseJSON              `json:"-"`
}

func (*EvaluationQueryListResponse) UnmarshalJSON

func (r *EvaluationQueryListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryListResponseEvaluationQueriesDefinition

type EvaluationQueryListResponseEvaluationQueriesDefinition struct {
	Metrics []EvaluationQueryListResponseEvaluationQueriesDefinitionMetric `json:"metrics" api:"required"`
	// Stored definition version. Always present in responses.
	V       int64                                                           `json:"v"        api:"required"`
	GroupBy []EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBy `json:"group_by"`
	// Absent for a query over cases.
	TargetKind EvaluationQueryListResponseEvaluationQueriesDefinitionTargetKind `json:"target_kind"`
	JSON       evaluationQueryListResponseEvaluationQueriesDefinitionJSON       `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinition) UnmarshalJSON

func (r *EvaluationQueryListResponseEvaluationQueriesDefinition) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBy

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBy struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySource `json:"source"`
	JSON   evaluationQueryListResponseEvaluationQueriesDefinitionGroupByJSON   `json:"-"`
	// contains filtered or unexported fields
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBy) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSource

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSourceInput  EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSourceOutput EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnKindDepth EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByDepthEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKindVariant            EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind = "variant"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKindDatasetField       EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind = "dataset_field"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKindScore              EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind = "score"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKindDepth              EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind = "depth"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKindParentTrajectoryID EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind = "parent_trajectory_id"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKindTags               EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind = "tags"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                                                 `json:"name" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnKindScore EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByScoreEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySource

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySourceInput  EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySource = "input"
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySourceOutput EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySource = "output"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupBySource) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnKindTags EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByTagsEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnKindVariant EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionGroupByVariantEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetric

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetric struct {
	// Calculation to apply to the latest visible score for each case, or for each
	// trajectory in a trajectory query.
	//
	//   - **mean**: Average of integer or number scores, or the fraction of true boolean
	//     scores.
	//   - **sum**: Sum of integer or number scores, or the number of true boolean
	//     scores.
	//   - **min / max**: Smallest or largest integer, number, boolean, or string score.
	//     Strings compare lexicographically.
	//   - **count**: Number of non-null integer, number, boolean, or string scores. Zero
	//     and false are counted.
	//   - **pass_at_k**: Estimated probability that at least one of k attempts at a task
	//     succeeds. Requires boolean scores, k, and per. It counts true scores as
	//     successes, so it rejects a scorer version whose higher_is_better is false,
	//     where true is the bad outcome.
	//
	// For pass_at_k, per identifies each task. A task with n attempts and c true
	// scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks.
	// The result is null when a task has fewer than k attempts.
	Aggregation EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation `json:"aggregation" api:"required"`
	// Unique name for this metric within the query. Result cells use this name.
	Name string `json:"name" api:"required"`
	// Version of the scorer whose values this metric aggregates. It must be registered
	// on the evaluation.
	ScorerVersionID string `json:"scorer_version_id" api:"required" format:"uuid"`
	// Number of attempts per task for pass_at_k. Required for pass_at_k and rejected
	// for other aggregations.
	K int64 `json:"k"`
	// How to handle a target with no non-null latest visible score. A target is a
	// case, or a trajectory in a trajectory query.
	//
	//   - **skip**: Exclude the target. A mean divides by the number of scored targets,
	//     and pass_at_k does not count it as an attempt. This also applies when missing
	//     is omitted.
	//   - **zero**: Include the target as 0, or false for boolean scores. A mean divides
	//     by every target in the group, and pass_at_k counts it as a failed attempt.
	//
	// Only mean, sum, and pass_at_k support zero. min, max, and count accept only
	// skip.
	Missing EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissing `json:"missing"`
	// Column that identifies the task for each case, or for each trajectory in a
	// trajectory query, such as an input task field.
	//
	//   - Required for pass_at_k and rejected for other aggregations.
	//   - Must not also appear in group_by, and must not be depth, parent_trajectory_id,
	//     or tags.
	//   - Targets with no value in this column form one task.
	//   - A page returns 400 if the number of groups multiplied by their tasks exceeds
	//     the result row limit.
	Per  EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPer `json:"per"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionMetricJSON `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetric) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation string

Calculation to apply to the latest visible score for each case, or for each trajectory in a trajectory query.

  • **mean**: Average of integer or number scores, or the fraction of true boolean scores.
  • **sum**: Sum of integer or number scores, or the number of true boolean scores.
  • **min / max**: Smallest or largest integer, number, boolean, or string score. Strings compare lexicographically.
  • **count**: Number of non-null integer, number, boolean, or string scores. Zero and false are counted.
  • **pass_at_k**: Estimated probability that at least one of k attempts at a task succeeds. Requires boolean scores, k, and per. It counts true scores as successes, so it rejects a scorer version whose higher_is_better is false, where true is the bad outcome.

For pass_at_k, per identifies each task. A task with n attempts and c true scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks. The result is null when a task has fewer than k attempts.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregationMean    EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation = "mean"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregationSum     EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation = "sum"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregationMin     EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation = "min"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregationMax     EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation = "max"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregationCount   EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation = "count"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregationPassAtK EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation = "pass_at_k"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsAggregation) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissing

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissing string

How to handle a target with no non-null latest visible score. A target is a case, or a trajectory in a trajectory query.

  • **skip**: Exclude the target. A mean divides by the number of scored targets, and pass_at_k does not count it as an attempt. This also applies when missing is omitted.
  • **zero**: Include the target as 0, or false for boolean scores. A mean divides by every target in the group, and pass_at_k counts it as a failed attempt.

Only mean, sum, and pass_at_k support zero. min, max, and count accept only skip.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissingSkip EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissing = "skip"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissingZero EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissing = "zero"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsMissing) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPer

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPer struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSource `json:"source"`
	JSON   evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerJSON   `json:"-"`
	// contains filtered or unexported fields
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPer) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSource

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSourceInput  EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSourceOutput EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnKindDepth EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKindVariant            EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind = "variant"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKindDatasetField       EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind = "dataset_field"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKindScore              EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind = "score"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKindDepth              EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind = "depth"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKindParentTrajectoryID EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind = "parent_trajectory_id"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKindTags               EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind = "tags"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                                                    `json:"name" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnKindScore EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSource

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSourceInput  EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSource = "input"
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSourceOutput EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSource = "output"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerSource) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnKindTags EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerUnion

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerUnion interface {
	// contains filtered or unexported methods
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

Union satisfied by EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumn, EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDatasetFieldEvaluationColumn, EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerScoreEvaluationColumn, EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerDepthEvaluationColumn, EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerParentTrajectoryIDEvaluationColumn or EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerTagsEvaluationColumn.

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumn

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumn struct {
	Kind EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnKind string
const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnKindVariant EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionMetricsPerVariantEvaluationColumnKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesDefinitionTargetKind

type EvaluationQueryListResponseEvaluationQueriesDefinitionTargetKind string

Absent for a query over cases.

const (
	EvaluationQueryListResponseEvaluationQueriesDefinitionTargetKindTrajectory EvaluationQueryListResponseEvaluationQueriesDefinitionTargetKind = "trajectory"
)

func (EvaluationQueryListResponseEvaluationQueriesDefinitionTargetKind) IsKnown

type EvaluationQueryListResponseEvaluationQueriesNamespace

type EvaluationQueryListResponseEvaluationQueriesNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationQueryListResponseEvaluationQueriesNamespaceWandb EvaluationQueryListResponseEvaluationQueriesNamespace = "wandb"
)

func (EvaluationQueryListResponseEvaluationQueriesNamespace) IsKnown

type EvaluationQueryListResponseEvaluationQuery

type EvaluationQueryListResponseEvaluationQuery struct {
	Definition        EvaluationQueryListResponseEvaluationQueriesDefinition `json:"definition"          api:"required"`
	EvaluationID      string                                                 `json:"evaluation_id"       api:"required" format:"uuid"`
	EvaluationQueryID string                                                 `json:"evaluation_query_id" api:"required" format:"uuid"`
	Name              string                                                 `json:"name"                api:"required"`
	// Namespace that assigned the scope reference.
	Namespace EvaluationQueryListResponseEvaluationQueriesNamespace `json:"namespace" api:"required"`
	ScopeRef  string                                                `json:"scope_ref" api:"required"`
	JSON      evaluationQueryListResponseEvaluationQueryJSON        `json:"-"`
}

func (*EvaluationQueryListResponseEvaluationQuery) UnmarshalJSON

func (r *EvaluationQueryListResponseEvaluationQuery) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryNewParams

type EvaluationQueryNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID    param.Field[string]                             `path:"scope_id" api:"required"`
	Definition param.Field[EvaluationQueryNewParamsDefinition] `                api:"required" json:"definition"`
	Name       param.Field[string]                             `                api:"required" json:"name"`
}

func (EvaluationQueryNewParams) MarshalJSON

func (r EvaluationQueryNewParams) MarshalJSON() (data []byte, err error)

type EvaluationQueryNewParamsDefinition

type EvaluationQueryNewParamsDefinition struct {
	// Calculations to run for each group. Metric names must be unique, and scorer
	// versions must be registered on the evaluation.
	Metrics param.Field[[]EvaluationQueryNewParamsDefinitionMetric] `json:"metrics" api:"required"`
	// Columns whose distinct value combinations form result groups. Choose variant,
	// dataset fields, or score columns. Result group values follow this column order.
	// Omit, send null, or use an empty list to calculate metrics across all targets. A
	// trajectory query reads dataset fields from each trajectory's root case and
	// scores from the trajectory, and can also group by the trajectory's depth and
	// parent_trajectory_id. A case query can also group by tags. Each tag name forms a
	// group, a case with several tags counts in each of them, and cases with no tags
	// form the null group.
	GroupBy param.Field[[]EvaluationQueryNewParamsDefinitionGroupByUnion] `json:"group_by"`
	// Targets whose scores the query aggregates. Omit or use case to aggregate the
	// dataset's cases. trajectory aggregates scores on the dataset's trajectories and
	// groups each trajectory by its root case's variant and fields. It does not have
	// to match the evaluation's primary_target_kind.
	TargetKind param.Field[EvaluationQueryNewParamsDefinitionTargetKind] `json:"target_kind"`
	// Definition version.
	V param.Field[int64] `json:"v"`
}

func (EvaluationQueryNewParamsDefinition) MarshalJSON

func (r EvaluationQueryNewParamsDefinition) MarshalJSON() (data []byte, err error)

type EvaluationQueryNewParamsDefinitionGroupBy

type EvaluationQueryNewParamsDefinitionGroupBy struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByKind] `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name param.Field[string] `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source param.Field[EvaluationQueryNewParamsDefinitionGroupBySource] `json:"source"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (EvaluationQueryNewParamsDefinitionGroupBy) MarshalJSON

func (r EvaluationQueryNewParamsDefinitionGroupBy) MarshalJSON() (data []byte, err error)

type EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumn

type EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnKind] `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name param.Field[string] `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source param.Field[EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSource] `json:"source" api:"required"`
}

func (EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSource

type EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSourceInput  EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSourceOutput EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryNewParamsDefinitionGroupByDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumn

type EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumnKind] `json:"kind" api:"required"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumnKindDepth EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryNewParamsDefinitionGroupByDepthEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByKind

type EvaluationQueryNewParamsDefinitionGroupByKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByKindVariant            EvaluationQueryNewParamsDefinitionGroupByKind = "variant"
	EvaluationQueryNewParamsDefinitionGroupByKindDatasetField       EvaluationQueryNewParamsDefinitionGroupByKind = "dataset_field"
	EvaluationQueryNewParamsDefinitionGroupByKindScore              EvaluationQueryNewParamsDefinitionGroupByKind = "score"
	EvaluationQueryNewParamsDefinitionGroupByKindDepth              EvaluationQueryNewParamsDefinitionGroupByKind = "depth"
	EvaluationQueryNewParamsDefinitionGroupByKindParentTrajectoryID EvaluationQueryNewParamsDefinitionGroupByKind = "parent_trajectory_id"
	EvaluationQueryNewParamsDefinitionGroupByKindTags               EvaluationQueryNewParamsDefinitionGroupByKind = "tags"
)

func (EvaluationQueryNewParamsDefinitionGroupByKind) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumn

type EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumnKind] `json:"kind" api:"required"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryNewParamsDefinitionGroupByParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumn

type EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumnKind] `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name param.Field[string] `json:"name" api:"required"`
}

func (EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumnKindScore EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryNewParamsDefinitionGroupByScoreEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionGroupBySource

type EvaluationQueryNewParamsDefinitionGroupBySource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewParamsDefinitionGroupBySourceInput  EvaluationQueryNewParamsDefinitionGroupBySource = "input"
	EvaluationQueryNewParamsDefinitionGroupBySourceOutput EvaluationQueryNewParamsDefinitionGroupBySource = "output"
)

func (EvaluationQueryNewParamsDefinitionGroupBySource) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumn

type EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumnKind] `json:"kind" api:"required"`
}

Case queries only. Groups by tag name.

func (EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumnKindTags EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryNewParamsDefinitionGroupByTagsEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumn

type EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumnKind] `json:"kind" api:"required"`
}

func (EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumnKindVariant EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryNewParamsDefinitionGroupByVariantEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetric

type EvaluationQueryNewParamsDefinitionMetric struct {
	// Calculation to apply to the latest visible score for each case, or for each
	// trajectory in a trajectory query.
	//
	//   - **mean**: Average of integer or number scores, or the fraction of true boolean
	//     scores.
	//   - **sum**: Sum of integer or number scores, or the number of true boolean
	//     scores.
	//   - **min / max**: Smallest or largest integer, number, boolean, or string score.
	//     Strings compare lexicographically.
	//   - **count**: Number of non-null integer, number, boolean, or string scores. Zero
	//     and false are counted.
	//   - **pass_at_k**: Estimated probability that at least one of k attempts at a task
	//     succeeds. Requires boolean scores, k, and per. It counts true scores as
	//     successes, so it rejects a scorer version whose higher_is_better is false,
	//     where true is the bad outcome.
	//
	// For pass_at_k, per identifies each task. A task with n attempts and c true
	// scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks.
	// The result is null when a task has fewer than k attempts.
	Aggregation param.Field[EvaluationQueryNewParamsDefinitionMetricsAggregation] `json:"aggregation" api:"required"`
	// Unique name for this metric within the query. Result cells use this name.
	Name param.Field[string] `json:"name" api:"required"`
	// Version of the scorer whose values this metric aggregates. It must be registered
	// on the evaluation.
	ScorerVersionID param.Field[string] `json:"scorer_version_id" api:"required" format:"uuid"`
	// Number of attempts per task for pass_at_k. Required for pass_at_k and rejected
	// for other aggregations.
	K param.Field[int64] `json:"k"`
	// How to handle a target with no non-null latest visible score. A target is a
	// case, or a trajectory in a trajectory query.
	//
	//   - **skip**: Exclude the target. A mean divides by the number of scored targets,
	//     and pass_at_k does not count it as an attempt. This also applies when missing
	//     is omitted.
	//   - **zero**: Include the target as 0, or false for boolean scores. A mean divides
	//     by every target in the group, and pass_at_k counts it as a failed attempt.
	//
	// Only mean, sum, and pass_at_k support zero. min, max, and count accept only
	// skip.
	Missing param.Field[EvaluationQueryNewParamsDefinitionMetricsMissing] `json:"missing"`
	// Column that identifies the task for each case, or for each trajectory in a
	// trajectory query, such as an input task field.
	//
	//   - Required for pass_at_k and rejected for other aggregations.
	//   - Must not also appear in group_by, and must not be depth, parent_trajectory_id,
	//     or tags.
	//   - Targets with no value in this column form one task.
	//   - A page returns 400 if the number of groups multiplied by their tasks exceeds
	//     the result row limit.
	Per param.Field[EvaluationQueryNewParamsDefinitionMetricsPerUnion] `json:"per"`
}

func (EvaluationQueryNewParamsDefinitionMetric) MarshalJSON

func (r EvaluationQueryNewParamsDefinitionMetric) MarshalJSON() (data []byte, err error)

type EvaluationQueryNewParamsDefinitionMetricsAggregation

type EvaluationQueryNewParamsDefinitionMetricsAggregation string

Calculation to apply to the latest visible score for each case, or for each trajectory in a trajectory query.

  • **mean**: Average of integer or number scores, or the fraction of true boolean scores.
  • **sum**: Sum of integer or number scores, or the number of true boolean scores.
  • **min / max**: Smallest or largest integer, number, boolean, or string score. Strings compare lexicographically.
  • **count**: Number of non-null integer, number, boolean, or string scores. Zero and false are counted.
  • **pass_at_k**: Estimated probability that at least one of k attempts at a task succeeds. Requires boolean scores, k, and per. It counts true scores as successes, so it rejects a scorer version whose higher_is_better is false, where true is the bad outcome.

For pass_at_k, per identifies each task. A task with n attempts and c true scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks. The result is null when a task has fewer than k attempts.

const (
	EvaluationQueryNewParamsDefinitionMetricsAggregationMean    EvaluationQueryNewParamsDefinitionMetricsAggregation = "mean"
	EvaluationQueryNewParamsDefinitionMetricsAggregationSum     EvaluationQueryNewParamsDefinitionMetricsAggregation = "sum"
	EvaluationQueryNewParamsDefinitionMetricsAggregationMin     EvaluationQueryNewParamsDefinitionMetricsAggregation = "min"
	EvaluationQueryNewParamsDefinitionMetricsAggregationMax     EvaluationQueryNewParamsDefinitionMetricsAggregation = "max"
	EvaluationQueryNewParamsDefinitionMetricsAggregationCount   EvaluationQueryNewParamsDefinitionMetricsAggregation = "count"
	EvaluationQueryNewParamsDefinitionMetricsAggregationPassAtK EvaluationQueryNewParamsDefinitionMetricsAggregation = "pass_at_k"
)

func (EvaluationQueryNewParamsDefinitionMetricsAggregation) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsMissing

type EvaluationQueryNewParamsDefinitionMetricsMissing string

How to handle a target with no non-null latest visible score. A target is a case, or a trajectory in a trajectory query.

  • **skip**: Exclude the target. A mean divides by the number of scored targets, and pass_at_k does not count it as an attempt. This also applies when missing is omitted.
  • **zero**: Include the target as 0, or false for boolean scores. A mean divides by every target in the group, and pass_at_k counts it as a failed attempt.

Only mean, sum, and pass_at_k support zero. min, max, and count accept only skip.

const (
	EvaluationQueryNewParamsDefinitionMetricsMissingSkip EvaluationQueryNewParamsDefinitionMetricsMissing = "skip"
	EvaluationQueryNewParamsDefinitionMetricsMissingZero EvaluationQueryNewParamsDefinitionMetricsMissing = "zero"
)

func (EvaluationQueryNewParamsDefinitionMetricsMissing) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPer

type EvaluationQueryNewParamsDefinitionMetricsPer struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerKind] `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name param.Field[string] `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source param.Field[EvaluationQueryNewParamsDefinitionMetricsPerSource] `json:"source"`
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

func (EvaluationQueryNewParamsDefinitionMetricsPer) MarshalJSON

func (r EvaluationQueryNewParamsDefinitionMetricsPer) MarshalJSON() (data []byte, err error)

type EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumn

type EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnKind] `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name param.Field[string] `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source param.Field[EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSource] `json:"source" api:"required"`
}

func (EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSource

type EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSourceInput  EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSourceOutput EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumn

type EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumnKind] `json:"kind" api:"required"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumnKindDepth EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerKind

type EvaluationQueryNewParamsDefinitionMetricsPerKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerKindVariant            EvaluationQueryNewParamsDefinitionMetricsPerKind = "variant"
	EvaluationQueryNewParamsDefinitionMetricsPerKindDatasetField       EvaluationQueryNewParamsDefinitionMetricsPerKind = "dataset_field"
	EvaluationQueryNewParamsDefinitionMetricsPerKindScore              EvaluationQueryNewParamsDefinitionMetricsPerKind = "score"
	EvaluationQueryNewParamsDefinitionMetricsPerKindDepth              EvaluationQueryNewParamsDefinitionMetricsPerKind = "depth"
	EvaluationQueryNewParamsDefinitionMetricsPerKindParentTrajectoryID EvaluationQueryNewParamsDefinitionMetricsPerKind = "parent_trajectory_id"
	EvaluationQueryNewParamsDefinitionMetricsPerKindTags               EvaluationQueryNewParamsDefinitionMetricsPerKind = "tags"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumn

type EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind] `json:"kind" api:"required"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumn

type EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumnKind] `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name param.Field[string] `json:"name" api:"required"`
}

func (EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumnKindScore EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerSource

type EvaluationQueryNewParamsDefinitionMetricsPerSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewParamsDefinitionMetricsPerSourceInput  EvaluationQueryNewParamsDefinitionMetricsPerSource = "input"
	EvaluationQueryNewParamsDefinitionMetricsPerSourceOutput EvaluationQueryNewParamsDefinitionMetricsPerSource = "output"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerSource) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumn

type EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumnKind] `json:"kind" api:"required"`
}

Case queries only. Groups by tag name.

func (EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumnKindTags EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionMetricsPerUnion

type EvaluationQueryNewParamsDefinitionMetricsPerUnion interface {
	// contains filtered or unexported methods
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

Satisfied by EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumn, EvaluationQueryNewParamsDefinitionMetricsPerDatasetFieldEvaluationColumn, EvaluationQueryNewParamsDefinitionMetricsPerScoreEvaluationColumn, EvaluationQueryNewParamsDefinitionMetricsPerDepthEvaluationColumn, EvaluationQueryNewParamsDefinitionMetricsPerParentTrajectoryIDEvaluationColumn, EvaluationQueryNewParamsDefinitionMetricsPerTagsEvaluationColumn, EvaluationQueryNewParamsDefinitionMetricsPer.

type EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumn

type EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumn struct {
	Kind param.Field[EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumnKind] `json:"kind" api:"required"`
}

func (EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumn) MarshalJSON

type EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumnKind

type EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumnKind string
const (
	EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumnKindVariant EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryNewParamsDefinitionMetricsPerVariantEvaluationColumnKind) IsKnown

type EvaluationQueryNewParamsDefinitionTargetKind

type EvaluationQueryNewParamsDefinitionTargetKind string

Targets whose scores the query aggregates. Omit or use case to aggregate the dataset's cases. trajectory aggregates scores on the dataset's trajectories and groups each trajectory by its root case's variant and fields. It does not have to match the evaluation's primary_target_kind.

const (
	EvaluationQueryNewParamsDefinitionTargetKindCase       EvaluationQueryNewParamsDefinitionTargetKind = "case"
	EvaluationQueryNewParamsDefinitionTargetKindTrajectory EvaluationQueryNewParamsDefinitionTargetKind = "trajectory"
)

func (EvaluationQueryNewParamsDefinitionTargetKind) IsKnown

type EvaluationQueryNewResponse

type EvaluationQueryNewResponse struct {
	Definition        EvaluationQueryNewResponseDefinition `json:"definition"          api:"required"`
	EvaluationID      string                               `json:"evaluation_id"       api:"required" format:"uuid"`
	EvaluationQueryID string                               `json:"evaluation_query_id" api:"required" format:"uuid"`
	Name              string                               `json:"name"                api:"required"`
	// Namespace that assigned the scope reference.
	Namespace EvaluationQueryNewResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                              `json:"scope_ref" api:"required"`
	JSON      evaluationQueryNewResponseJSON      `json:"-"`
}

func (*EvaluationQueryNewResponse) UnmarshalJSON

func (r *EvaluationQueryNewResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryNewResponseDefinition

type EvaluationQueryNewResponseDefinition struct {
	Metrics []EvaluationQueryNewResponseDefinitionMetric `json:"metrics" api:"required"`
	// Stored definition version. Always present in responses.
	V       int64                                         `json:"v"        api:"required"`
	GroupBy []EvaluationQueryNewResponseDefinitionGroupBy `json:"group_by"`
	// Absent for a query over cases.
	TargetKind EvaluationQueryNewResponseDefinitionTargetKind `json:"target_kind"`
	JSON       evaluationQueryNewResponseDefinitionJSON       `json:"-"`
}

func (*EvaluationQueryNewResponseDefinition) UnmarshalJSON

func (r *EvaluationQueryNewResponseDefinition) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryNewResponseDefinitionGroupBy

type EvaluationQueryNewResponseDefinitionGroupBy struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryNewResponseDefinitionGroupBySource `json:"source"`
	JSON   evaluationQueryNewResponseDefinitionGroupByJSON   `json:"-"`
	// contains filtered or unexported fields
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryNewResponseDefinitionGroupBy) UnmarshalJSON

func (r *EvaluationQueryNewResponseDefinitionGroupBy) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumn

type EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSource

type EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSourceInput  EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSourceOutput EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryNewResponseDefinitionGroupByDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumn

type EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnKindDepth EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryNewResponseDefinitionGroupByDepthEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByKind

type EvaluationQueryNewResponseDefinitionGroupByKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByKindVariant            EvaluationQueryNewResponseDefinitionGroupByKind = "variant"
	EvaluationQueryNewResponseDefinitionGroupByKindDatasetField       EvaluationQueryNewResponseDefinitionGroupByKind = "dataset_field"
	EvaluationQueryNewResponseDefinitionGroupByKindScore              EvaluationQueryNewResponseDefinitionGroupByKind = "score"
	EvaluationQueryNewResponseDefinitionGroupByKindDepth              EvaluationQueryNewResponseDefinitionGroupByKind = "depth"
	EvaluationQueryNewResponseDefinitionGroupByKindParentTrajectoryID EvaluationQueryNewResponseDefinitionGroupByKind = "parent_trajectory_id"
	EvaluationQueryNewResponseDefinitionGroupByKindTags               EvaluationQueryNewResponseDefinitionGroupByKind = "tags"
)

func (EvaluationQueryNewResponseDefinitionGroupByKind) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumn

type EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryNewResponseDefinitionGroupByParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumn

type EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                               `json:"name" api:"required"`
	JSON evaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnKindScore EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryNewResponseDefinitionGroupByScoreEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionGroupBySource

type EvaluationQueryNewResponseDefinitionGroupBySource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewResponseDefinitionGroupBySourceInput  EvaluationQueryNewResponseDefinitionGroupBySource = "input"
	EvaluationQueryNewResponseDefinitionGroupBySourceOutput EvaluationQueryNewResponseDefinitionGroupBySource = "output"
)

func (EvaluationQueryNewResponseDefinitionGroupBySource) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumn

type EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnKindTags EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryNewResponseDefinitionGroupByTagsEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumn

type EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnKindVariant EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryNewResponseDefinitionGroupByVariantEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetric

type EvaluationQueryNewResponseDefinitionMetric struct {
	// Calculation to apply to the latest visible score for each case, or for each
	// trajectory in a trajectory query.
	//
	//   - **mean**: Average of integer or number scores, or the fraction of true boolean
	//     scores.
	//   - **sum**: Sum of integer or number scores, or the number of true boolean
	//     scores.
	//   - **min / max**: Smallest or largest integer, number, boolean, or string score.
	//     Strings compare lexicographically.
	//   - **count**: Number of non-null integer, number, boolean, or string scores. Zero
	//     and false are counted.
	//   - **pass_at_k**: Estimated probability that at least one of k attempts at a task
	//     succeeds. Requires boolean scores, k, and per. It counts true scores as
	//     successes, so it rejects a scorer version whose higher_is_better is false,
	//     where true is the bad outcome.
	//
	// For pass_at_k, per identifies each task. A task with n attempts and c true
	// scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks.
	// The result is null when a task has fewer than k attempts.
	Aggregation EvaluationQueryNewResponseDefinitionMetricsAggregation `json:"aggregation" api:"required"`
	// Unique name for this metric within the query. Result cells use this name.
	Name string `json:"name" api:"required"`
	// Version of the scorer whose values this metric aggregates. It must be registered
	// on the evaluation.
	ScorerVersionID string `json:"scorer_version_id" api:"required" format:"uuid"`
	// Number of attempts per task for pass_at_k. Required for pass_at_k and rejected
	// for other aggregations.
	K int64 `json:"k"`
	// How to handle a target with no non-null latest visible score. A target is a
	// case, or a trajectory in a trajectory query.
	//
	//   - **skip**: Exclude the target. A mean divides by the number of scored targets,
	//     and pass_at_k does not count it as an attempt. This also applies when missing
	//     is omitted.
	//   - **zero**: Include the target as 0, or false for boolean scores. A mean divides
	//     by every target in the group, and pass_at_k counts it as a failed attempt.
	//
	// Only mean, sum, and pass_at_k support zero. min, max, and count accept only
	// skip.
	Missing EvaluationQueryNewResponseDefinitionMetricsMissing `json:"missing"`
	// Column that identifies the task for each case, or for each trajectory in a
	// trajectory query, such as an input task field.
	//
	//   - Required for pass_at_k and rejected for other aggregations.
	//   - Must not also appear in group_by, and must not be depth, parent_trajectory_id,
	//     or tags.
	//   - Targets with no value in this column form one task.
	//   - A page returns 400 if the number of groups multiplied by their tasks exceeds
	//     the result row limit.
	Per  EvaluationQueryNewResponseDefinitionMetricsPer `json:"per"`
	JSON evaluationQueryNewResponseDefinitionMetricJSON `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionMetric) UnmarshalJSON

func (r *EvaluationQueryNewResponseDefinitionMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryNewResponseDefinitionMetricsAggregation

type EvaluationQueryNewResponseDefinitionMetricsAggregation string

Calculation to apply to the latest visible score for each case, or for each trajectory in a trajectory query.

  • **mean**: Average of integer or number scores, or the fraction of true boolean scores.
  • **sum**: Sum of integer or number scores, or the number of true boolean scores.
  • **min / max**: Smallest or largest integer, number, boolean, or string score. Strings compare lexicographically.
  • **count**: Number of non-null integer, number, boolean, or string scores. Zero and false are counted.
  • **pass_at_k**: Estimated probability that at least one of k attempts at a task succeeds. Requires boolean scores, k, and per. It counts true scores as successes, so it rejects a scorer version whose higher_is_better is false, where true is the bad outcome.

For pass_at_k, per identifies each task. A task with n attempts and c true scores contributes 1 - C(n-c, k) / C(n, k), and the result averages the tasks. The result is null when a task has fewer than k attempts.

const (
	EvaluationQueryNewResponseDefinitionMetricsAggregationMean    EvaluationQueryNewResponseDefinitionMetricsAggregation = "mean"
	EvaluationQueryNewResponseDefinitionMetricsAggregationSum     EvaluationQueryNewResponseDefinitionMetricsAggregation = "sum"
	EvaluationQueryNewResponseDefinitionMetricsAggregationMin     EvaluationQueryNewResponseDefinitionMetricsAggregation = "min"
	EvaluationQueryNewResponseDefinitionMetricsAggregationMax     EvaluationQueryNewResponseDefinitionMetricsAggregation = "max"
	EvaluationQueryNewResponseDefinitionMetricsAggregationCount   EvaluationQueryNewResponseDefinitionMetricsAggregation = "count"
	EvaluationQueryNewResponseDefinitionMetricsAggregationPassAtK EvaluationQueryNewResponseDefinitionMetricsAggregation = "pass_at_k"
)

func (EvaluationQueryNewResponseDefinitionMetricsAggregation) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsMissing

type EvaluationQueryNewResponseDefinitionMetricsMissing string

How to handle a target with no non-null latest visible score. A target is a case, or a trajectory in a trajectory query.

  • **skip**: Exclude the target. A mean divides by the number of scored targets, and pass_at_k does not count it as an attempt. This also applies when missing is omitted.
  • **zero**: Include the target as 0, or false for boolean scores. A mean divides by every target in the group, and pass_at_k counts it as a failed attempt.

Only mean, sum, and pass_at_k support zero. min, max, and count accept only skip.

const (
	EvaluationQueryNewResponseDefinitionMetricsMissingSkip EvaluationQueryNewResponseDefinitionMetricsMissing = "skip"
	EvaluationQueryNewResponseDefinitionMetricsMissingZero EvaluationQueryNewResponseDefinitionMetricsMissing = "zero"
)

func (EvaluationQueryNewResponseDefinitionMetricsMissing) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPer

type EvaluationQueryNewResponseDefinitionMetricsPer struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryNewResponseDefinitionMetricsPerSource `json:"source"`
	JSON   evaluationQueryNewResponseDefinitionMetricsPerJSON   `json:"-"`
	// contains filtered or unexported fields
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

func (*EvaluationQueryNewResponseDefinitionMetricsPer) UnmarshalJSON

func (r *EvaluationQueryNewResponseDefinitionMetricsPer) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumn

type EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource

type EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSourceInput  EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSourceOutput EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumn

type EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnKindDepth EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerKind

type EvaluationQueryNewResponseDefinitionMetricsPerKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerKindVariant            EvaluationQueryNewResponseDefinitionMetricsPerKind = "variant"
	EvaluationQueryNewResponseDefinitionMetricsPerKindDatasetField       EvaluationQueryNewResponseDefinitionMetricsPerKind = "dataset_field"
	EvaluationQueryNewResponseDefinitionMetricsPerKindScore              EvaluationQueryNewResponseDefinitionMetricsPerKind = "score"
	EvaluationQueryNewResponseDefinitionMetricsPerKindDepth              EvaluationQueryNewResponseDefinitionMetricsPerKind = "depth"
	EvaluationQueryNewResponseDefinitionMetricsPerKindParentTrajectoryID EvaluationQueryNewResponseDefinitionMetricsPerKind = "parent_trajectory_id"
	EvaluationQueryNewResponseDefinitionMetricsPerKindTags               EvaluationQueryNewResponseDefinitionMetricsPerKind = "tags"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn

type EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumn

type EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                                  `json:"name" api:"required"`
	JSON evaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnKindScore EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerSource

type EvaluationQueryNewResponseDefinitionMetricsPerSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryNewResponseDefinitionMetricsPerSourceInput  EvaluationQueryNewResponseDefinitionMetricsPerSource = "input"
	EvaluationQueryNewResponseDefinitionMetricsPerSourceOutput EvaluationQueryNewResponseDefinitionMetricsPerSource = "output"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerSource) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumn

type EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnKindTags EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionMetricsPerUnion

type EvaluationQueryNewResponseDefinitionMetricsPerUnion interface {
	// contains filtered or unexported methods
}

Column that identifies the task for each case, or for each trajectory in a trajectory query, such as an input task field.

  • Required for pass_at_k and rejected for other aggregations.
  • Must not also appear in group_by, and must not be depth, parent_trajectory_id, or tags.
  • Targets with no value in this column form one task.
  • A page returns 400 if the number of groups multiplied by their tasks exceeds the result row limit.

Union satisfied by EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumn, EvaluationQueryNewResponseDefinitionMetricsPerDatasetFieldEvaluationColumn, EvaluationQueryNewResponseDefinitionMetricsPerScoreEvaluationColumn, EvaluationQueryNewResponseDefinitionMetricsPerDepthEvaluationColumn, EvaluationQueryNewResponseDefinitionMetricsPerParentTrajectoryIDEvaluationColumn or EvaluationQueryNewResponseDefinitionMetricsPerTagsEvaluationColumn.

type EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumn

type EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumn struct {
	Kind EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnKind

type EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnKind string
const (
	EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnKindVariant EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryNewResponseDefinitionMetricsPerVariantEvaluationColumnKind) IsKnown

type EvaluationQueryNewResponseDefinitionTargetKind

type EvaluationQueryNewResponseDefinitionTargetKind string

Absent for a query over cases.

const (
	EvaluationQueryNewResponseDefinitionTargetKindTrajectory EvaluationQueryNewResponseDefinitionTargetKind = "trajectory"
)

func (EvaluationQueryNewResponseDefinitionTargetKind) IsKnown

type EvaluationQueryNewResponseNamespace

type EvaluationQueryNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationQueryNewResponseNamespaceWandb EvaluationQueryNewResponseNamespace = "wandb"
)

func (EvaluationQueryNewResponseNamespace) IsKnown

type EvaluationQueryResultListParams

type EvaluationQueryResultListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (EvaluationQueryResultListParams) URLQuery

func (r EvaluationQueryResultListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationQueryResultListParams's query parameters as `url.Values`.

type EvaluationQueryResultListResponse

type EvaluationQueryResultListResponse struct {
	// Dataset version supplying the cases or trajectories. For a live evaluation
	// queried on latest data, this is the dataset head selected for the first page.
	DatasetVersionID  string                                     `json:"dataset_version_id"  api:"required" format:"uuid"`
	EvaluationID      string                                     `json:"evaluation_id"       api:"required" format:"uuid"`
	EvaluationQueryID string                                     `json:"evaluation_query_id" api:"required" format:"uuid"`
	GroupBy           []EvaluationQueryResultListResponseGroupBy `json:"group_by"            api:"required"`
	Metrics           []EvaluationQueryResultListResponseMetric  `json:"metrics"             api:"required"`
	// Namespace that assigned the scope reference.
	Namespace EvaluationQueryResultListResponseNamespace `json:"namespace" api:"required"`
	// Publication cutoff shared by every page of these results. Scores published later
	// are excluded. For a live evaluation's latest data, cases and trajectories
	// published later are also excluded.
	PublishedCommitID int64                                  `json:"published_commit_id" api:"required"`
	Rows              []EvaluationQueryResultListResponseRow `json:"rows"                api:"required"`
	ScopeRef          string                                 `json:"scope_ref"           api:"required"`
	// Kind of target that each row's targets field counts.
	TargetKind EvaluationQueryResultListResponseTargetKind `json:"target_kind" api:"required"`
	// Frozen evaluation version supplying the data. Omitted when querying the
	// evaluation's latest data.
	EvaluationVersionID string `json:"evaluation_version_id" format:"uuid"`
	// Cursor for the next page. Absent on the last page.
	NextCursor string                                `json:"next_cursor"`
	JSON       evaluationQueryResultListResponseJSON `json:"-"`
}

func (*EvaluationQueryResultListResponse) UnmarshalJSON

func (r *EvaluationQueryResultListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryResultListResponseGroupBy

type EvaluationQueryResultListResponseGroupBy struct {
	Kind      EvaluationQueryResultListResponseGroupByKind      `json:"kind"       api:"required"`
	ValueType EvaluationQueryResultListResponseGroupByValueType `json:"value_type" api:"required"`
	Name      string                                            `json:"name"`
	Source    EvaluationQueryResultListResponseGroupBySource    `json:"source"`
	JSON      evaluationQueryResultListResponseGroupByJSON      `json:"-"`
}

func (*EvaluationQueryResultListResponseGroupBy) UnmarshalJSON

func (r *EvaluationQueryResultListResponseGroupBy) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryResultListResponseGroupByKind

type EvaluationQueryResultListResponseGroupByKind string
const (
	EvaluationQueryResultListResponseGroupByKindVariant            EvaluationQueryResultListResponseGroupByKind = "variant"
	EvaluationQueryResultListResponseGroupByKindDatasetField       EvaluationQueryResultListResponseGroupByKind = "dataset_field"
	EvaluationQueryResultListResponseGroupByKindScore              EvaluationQueryResultListResponseGroupByKind = "score"
	EvaluationQueryResultListResponseGroupByKindDepth              EvaluationQueryResultListResponseGroupByKind = "depth"
	EvaluationQueryResultListResponseGroupByKindParentTrajectoryID EvaluationQueryResultListResponseGroupByKind = "parent_trajectory_id"
	EvaluationQueryResultListResponseGroupByKindTags               EvaluationQueryResultListResponseGroupByKind = "tags"
)

func (EvaluationQueryResultListResponseGroupByKind) IsKnown

type EvaluationQueryResultListResponseGroupBySource

type EvaluationQueryResultListResponseGroupBySource string
const (
	EvaluationQueryResultListResponseGroupBySourceInput  EvaluationQueryResultListResponseGroupBySource = "input"
	EvaluationQueryResultListResponseGroupBySourceOutput EvaluationQueryResultListResponseGroupBySource = "output"
)

func (EvaluationQueryResultListResponseGroupBySource) IsKnown

type EvaluationQueryResultListResponseGroupByValueType

type EvaluationQueryResultListResponseGroupByValueType string
const (
	EvaluationQueryResultListResponseGroupByValueTypeBoolean EvaluationQueryResultListResponseGroupByValueType = "boolean"
	EvaluationQueryResultListResponseGroupByValueTypeInteger EvaluationQueryResultListResponseGroupByValueType = "integer"
	EvaluationQueryResultListResponseGroupByValueTypeNumber  EvaluationQueryResultListResponseGroupByValueType = "number"
	EvaluationQueryResultListResponseGroupByValueTypeString  EvaluationQueryResultListResponseGroupByValueType = "string"
)

func (EvaluationQueryResultListResponseGroupByValueType) IsKnown

type EvaluationQueryResultListResponseMetric

type EvaluationQueryResultListResponseMetric struct {
	Aggregation     EvaluationQueryResultListResponseMetricsAggregation `json:"aggregation"       api:"required"`
	Name            string                                              `json:"name"              api:"required"`
	ScorerID        string                                              `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                              `json:"scorer_version_id" api:"required" format:"uuid"`
	// Aggregation output type: number for mean and pass_at_k, integer for count and
	// boolean sum, and the scorer's type otherwise.
	ValueType EvaluationQueryResultListResponseMetricsValueType `json:"value_type" api:"required"`
	K         int64                                             `json:"k"`
	Missing   EvaluationQueryResultListResponseMetricsMissing   `json:"missing"`
	// Trajectory queries only. Groups by depth, an integer that is 0 for a top-level
	// trajectory.
	Per  EvaluationQueryResultListResponseMetricsPer `json:"per"`
	JSON evaluationQueryResultListResponseMetricJSON `json:"-"`
}

func (*EvaluationQueryResultListResponseMetric) UnmarshalJSON

func (r *EvaluationQueryResultListResponseMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryResultListResponseMetricsAggregation

type EvaluationQueryResultListResponseMetricsAggregation string
const (
	EvaluationQueryResultListResponseMetricsAggregationMean    EvaluationQueryResultListResponseMetricsAggregation = "mean"
	EvaluationQueryResultListResponseMetricsAggregationSum     EvaluationQueryResultListResponseMetricsAggregation = "sum"
	EvaluationQueryResultListResponseMetricsAggregationMin     EvaluationQueryResultListResponseMetricsAggregation = "min"
	EvaluationQueryResultListResponseMetricsAggregationMax     EvaluationQueryResultListResponseMetricsAggregation = "max"
	EvaluationQueryResultListResponseMetricsAggregationCount   EvaluationQueryResultListResponseMetricsAggregation = "count"
	EvaluationQueryResultListResponseMetricsAggregationPassAtK EvaluationQueryResultListResponseMetricsAggregation = "pass_at_k"
)

func (EvaluationQueryResultListResponseMetricsAggregation) IsKnown

type EvaluationQueryResultListResponseMetricsMissing

type EvaluationQueryResultListResponseMetricsMissing string
const (
	EvaluationQueryResultListResponseMetricsMissingSkip EvaluationQueryResultListResponseMetricsMissing = "skip"
	EvaluationQueryResultListResponseMetricsMissingZero EvaluationQueryResultListResponseMetricsMissing = "zero"
)

func (EvaluationQueryResultListResponseMetricsMissing) IsKnown

type EvaluationQueryResultListResponseMetricsPer

type EvaluationQueryResultListResponseMetricsPer struct {
	Kind EvaluationQueryResultListResponseMetricsPerKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryResultListResponseMetricsPerSource `json:"source"`
	JSON   evaluationQueryResultListResponseMetricsPerJSON   `json:"-"`
	// contains filtered or unexported fields
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryResultListResponseMetricsPer) UnmarshalJSON

func (r *EvaluationQueryResultListResponseMetricsPer) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumn

type EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumn struct {
	Kind EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind

type EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind string
const (
	EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKindDatasetField EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource

type EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSourceInput  EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource = "input"
	EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSourceOutput EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumn

type EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumn struct {
	Kind EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryResultListResponseMetricsPerDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumn) UnmarshalJSON

type EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumnKind

type EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumnKind string
const (
	EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumnKindDepth EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumnKind = "depth"
)

func (EvaluationQueryResultListResponseMetricsPerDepthEvaluationColumnKind) IsKnown

type EvaluationQueryResultListResponseMetricsPerKind

type EvaluationQueryResultListResponseMetricsPerKind string
const (
	EvaluationQueryResultListResponseMetricsPerKindVariant            EvaluationQueryResultListResponseMetricsPerKind = "variant"
	EvaluationQueryResultListResponseMetricsPerKindDatasetField       EvaluationQueryResultListResponseMetricsPerKind = "dataset_field"
	EvaluationQueryResultListResponseMetricsPerKindScore              EvaluationQueryResultListResponseMetricsPerKind = "score"
	EvaluationQueryResultListResponseMetricsPerKindDepth              EvaluationQueryResultListResponseMetricsPerKind = "depth"
	EvaluationQueryResultListResponseMetricsPerKindParentTrajectoryID EvaluationQueryResultListResponseMetricsPerKind = "parent_trajectory_id"
	EvaluationQueryResultListResponseMetricsPerKindTags               EvaluationQueryResultListResponseMetricsPerKind = "tags"
)

func (EvaluationQueryResultListResponseMetricsPerKind) IsKnown

type EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumn

type EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind

type EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumn

type EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumn struct {
	Kind EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                               `json:"name" api:"required"`
	JSON evaluationQueryResultListResponseMetricsPerScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumn) UnmarshalJSON

type EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumnKind

type EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumnKind string
const (
	EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumnKindScore EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumnKind = "score"
)

func (EvaluationQueryResultListResponseMetricsPerScoreEvaluationColumnKind) IsKnown

type EvaluationQueryResultListResponseMetricsPerSource

type EvaluationQueryResultListResponseMetricsPerSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationQueryResultListResponseMetricsPerSourceInput  EvaluationQueryResultListResponseMetricsPerSource = "input"
	EvaluationQueryResultListResponseMetricsPerSourceOutput EvaluationQueryResultListResponseMetricsPerSource = "output"
)

func (EvaluationQueryResultListResponseMetricsPerSource) IsKnown

type EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumn

type EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumn struct {
	Kind EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryResultListResponseMetricsPerTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumn) UnmarshalJSON

type EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumnKind

type EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumnKind string
const (
	EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumnKindTags EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumnKind = "tags"
)

func (EvaluationQueryResultListResponseMetricsPerTagsEvaluationColumnKind) IsKnown

type EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumn

type EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumn struct {
	Kind EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationQueryResultListResponseMetricsPerVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumn) UnmarshalJSON

type EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumnKind

type EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumnKind string
const (
	EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumnKindVariant EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumnKind = "variant"
)

func (EvaluationQueryResultListResponseMetricsPerVariantEvaluationColumnKind) IsKnown

type EvaluationQueryResultListResponseMetricsValueType

type EvaluationQueryResultListResponseMetricsValueType string

Aggregation output type: number for mean and pass_at_k, integer for count and boolean sum, and the scorer's type otherwise.

const (
	EvaluationQueryResultListResponseMetricsValueTypeBoolean EvaluationQueryResultListResponseMetricsValueType = "boolean"
	EvaluationQueryResultListResponseMetricsValueTypeInteger EvaluationQueryResultListResponseMetricsValueType = "integer"
	EvaluationQueryResultListResponseMetricsValueTypeNumber  EvaluationQueryResultListResponseMetricsValueType = "number"
	EvaluationQueryResultListResponseMetricsValueTypeString  EvaluationQueryResultListResponseMetricsValueType = "string"
)

func (EvaluationQueryResultListResponseMetricsValueType) IsKnown

type EvaluationQueryResultListResponseNamespace

type EvaluationQueryResultListResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationQueryResultListResponseNamespaceWandb EvaluationQueryResultListResponseNamespace = "wandb"
)

func (EvaluationQueryResultListResponseNamespace) IsKnown

type EvaluationQueryResultListResponseRow

type EvaluationQueryResultListResponseRow struct {
	// Values in group_by order, with null for missing or null fields. Empty for an
	// ungrouped query.
	Group   []EvaluationQueryResultListResponseRowsGroupUnion `json:"group"   api:"required"`
	Metrics []EvaluationQueryResultListResponseRowsMetric     `json:"metrics" api:"required"`
	// Number of targets in this group: cases, or trajectories in a trajectory query.
	Targets int64                                    `json:"targets" api:"required"`
	JSON    evaluationQueryResultListResponseRowJSON `json:"-"`
}

func (*EvaluationQueryResultListResponseRow) UnmarshalJSON

func (r *EvaluationQueryResultListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryResultListResponseRowsGroupUnion

type EvaluationQueryResultListResponseRowsGroupUnion interface {
	ImplementsEvaluationQueryResultListResponseRowsGroupUnion()
}

A JSON scalar (boolean, integer, number, or string) or null.

Union satisfied by shared.UnionBool, shared.UnionInt, shared.UnionFloat or shared.UnionString.

type EvaluationQueryResultListResponseRowsMetric

type EvaluationQueryResultListResponseRowsMetric struct {
	Name string `json:"name" api:"required"`
	// Calculated metric value. If no target has a non-null latest visible score, count
	// returns 0 and other aggregations return null.
	Value EvaluationQueryResultListResponseRowsMetricsValueUnion `json:"value" api:"required"`
	JSON  evaluationQueryResultListResponseRowsMetricJSON        `json:"-"`
}

func (*EvaluationQueryResultListResponseRowsMetric) UnmarshalJSON

func (r *EvaluationQueryResultListResponseRowsMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationQueryResultListResponseRowsMetricsValueUnion

type EvaluationQueryResultListResponseRowsMetricsValueUnion interface {
	ImplementsEvaluationQueryResultListResponseRowsMetricsValueUnion()
}

Calculated metric value. If no target has a non-null latest visible score, count returns 0 and other aggregations return null.

Union satisfied by shared.UnionBool, shared.UnionInt, shared.UnionFloat or shared.UnionString.

type EvaluationQueryResultListResponseTargetKind

type EvaluationQueryResultListResponseTargetKind string

Kind of target that each row's targets field counts.

const (
	EvaluationQueryResultListResponseTargetKindCase       EvaluationQueryResultListResponseTargetKind = "case"
	EvaluationQueryResultListResponseTargetKindTrajectory EvaluationQueryResultListResponseTargetKind = "trajectory"
)

func (EvaluationQueryResultListResponseTargetKind) IsKnown

type EvaluationQueryResultService

type EvaluationQueryResultService struct {
	Options []option.RequestOption
}

EvaluationQueryResultService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationQueryResultService method instead.

func NewEvaluationQueryResultService

func NewEvaluationQueryResultService(opts ...option.RequestOption) (r *EvaluationQueryResultService)

NewEvaluationQueryResultService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationQueryResultService) List

func (r *EvaluationQueryResultService) List(
	ctx context.Context,
	evaluationID string,
	evaluationQueryID string,
	params EvaluationQueryResultListParams,
	opts ...option.RequestOption,
) (res *EvaluationQueryResultListResponse, err error)

Runs a saved aggregation query against the evaluation's latest published data.

**Data included**

  • A fixed evaluation reads the cases, or the trajectories in a trajectory query, in its configured dataset version.
  • A live evaluation reads the cases, or the trajectories in a trajectory query, published to its dataset head.
  • Scores come from all writes published so far for the evaluation's registered scorers.
  • Later pages keep the first page's targets and scores, even if new data arrives.

**Grouping and ordering**

  • Rows sort by the `group_by` columns in order, ascending, with nulls last.
  • A missing grouping value and an explicit null belong to the same group.
  • Without grouping, the response has one row with an empty `group` array, even for an empty dataset.
  • With grouping, an empty dataset returns no rows.

type EvaluationQueryService

type EvaluationQueryService struct {
	Options []option.RequestOption
	Results *EvaluationQueryResultService
}

EvaluationQueryService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationQueryService method instead.

func NewEvaluationQueryService

func NewEvaluationQueryService(opts ...option.RequestOption) (r *EvaluationQueryService)

NewEvaluationQueryService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationQueryService) Get

func (r *EvaluationQueryService) Get(
	ctx context.Context,
	evaluationID string,
	evaluationQueryID string,
	query EvaluationQueryGetParams,
	opts ...option.RequestOption,
) (res *EvaluationQueryGetResponse, err error)

Returns the saved query definition without running it. A query belonging to another evaluation or scope returns 404.

func (*EvaluationQueryService) List

Returns an evaluation's saved query definitions in query ID order. This operation does not run the queries.

func (*EvaluationQueryService) New

Saves a query definition that groups cases or trajectories and aggregates their scores. For example, you can group by model variant and calculate a mean score for each variant.

The definition must match the evaluation's latest data. Every scorer the query reads, in a metric, a group_by column, or a pass_at_k per column, must allow the query's target_kind, or the request returns 400. Saving the query does not calculate results. Use the query's results operation to run it.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationRowListParams

type EvaluationRowListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `query:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvaluationRowListParams) URLQuery

func (r EvaluationRowListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationRowListParams's query parameters as `url.Values`.

type EvaluationRowListResponse

type EvaluationRowListResponse struct {
	Rows       []EvaluationRowListResponseRow `json:"rows"        api:"required"`
	NextCursor string                         `json:"next_cursor"`
	JSON       evaluationRowListResponseJSON  `json:"-"`
}

func (*EvaluationRowListResponse) UnmarshalJSON

func (r *EvaluationRowListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationRowListResponseRow

type EvaluationRowListResponseRow struct {
	Attributes map[string]interface{}               `json:"attributes"  api:"required"`
	CaseID     string                               `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                               `json:"example_key" api:"required,nullable"`
	Input      interface{}                          `json:"input"       api:"required"`
	Output     interface{}                          `json:"output"      api:"required"`
	Scores     []EvaluationRowListResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                         `json:"tags"    api:"required"`
	Variant string                           `json:"variant" api:"required,nullable"`
	JSON    evaluationRowListResponseRowJSON `json:"-"`
}

func (*EvaluationRowListResponseRow) UnmarshalJSON

func (r *EvaluationRowListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationRowListResponseRowsScore

type EvaluationRowListResponseRowsScore struct {
	ScoreID         string                                 `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                 `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                 `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                            `json:"value"             api:"required"`
	JSON            evaluationRowListResponseRowsScoreJSON `json:"-"`
}

func (*EvaluationRowListResponseRowsScore) UnmarshalJSON

func (r *EvaluationRowListResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationRowSearchParams

type EvaluationRowSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `json:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvaluationRowSearchParams) MarshalJSON

func (r EvaluationRowSearchParams) MarshalJSON() (data []byte, err error)

type EvaluationRowSearchResponse

type EvaluationRowSearchResponse struct {
	Rows       []EvaluationRowSearchResponseRow `json:"rows"        api:"required"`
	NextCursor string                           `json:"next_cursor"`
	JSON       evaluationRowSearchResponseJSON  `json:"-"`
}

func (*EvaluationRowSearchResponse) UnmarshalJSON

func (r *EvaluationRowSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationRowSearchResponseRow

type EvaluationRowSearchResponseRow struct {
	Attributes map[string]interface{}                 `json:"attributes"  api:"required"`
	CaseID     string                                 `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                 `json:"example_key" api:"required,nullable"`
	Input      interface{}                            `json:"input"       api:"required"`
	Output     interface{}                            `json:"output"      api:"required"`
	Scores     []EvaluationRowSearchResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                           `json:"tags"    api:"required"`
	Variant string                             `json:"variant" api:"required,nullable"`
	JSON    evaluationRowSearchResponseRowJSON `json:"-"`
}

func (*EvaluationRowSearchResponseRow) UnmarshalJSON

func (r *EvaluationRowSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationRowSearchResponseRowsScore

type EvaluationRowSearchResponseRowsScore struct {
	ScoreID         string                                   `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                   `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                   `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                              `json:"value"             api:"required"`
	JSON            evaluationRowSearchResponseRowsScoreJSON `json:"-"`
}

func (*EvaluationRowSearchResponseRowsScore) UnmarshalJSON

func (r *EvaluationRowSearchResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationRowService

type EvaluationRowService struct {
	Options []option.RequestOption
}

EvaluationRowService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationRowService method instead.

func NewEvaluationRowService

func NewEvaluationRowService(opts ...option.RequestOption) (r *EvaluationRowService)

NewEvaluationRowService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationRowService) List

func (r *EvaluationRowService) List(
	ctx context.Context,
	evaluationID string,
	params EvaluationRowListParams,
	opts ...option.RequestOption,
) (res *EvaluationRowListResponse, err error)

Reads the Evaluation's latest data without cutting an EvaluationVersion: the registered Scorers and every Score published so far, over the fixed DatasetVersion's Cases or every Case published to a live Evaluation's Dataset head. The first page pins that data, and later pages read the same Cases and Scores. If the Evaluation's Scorer selection changes between pages, such as when a new Score column appears, a continuation returns 400 and the read must start again without a cursor. `filter` and `order_by` use the same syntax as list-evaluation-version-rows.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/rows/search` operation.

func (*EvaluationRowService) Search

func (r *EvaluationRowService) Search(
	ctx context.Context,
	evaluationID string,
	params EvaluationRowSearchParams,
	opts ...option.RequestOption,
) (res *EvaluationRowSearchResponse, err error)

Reads the same latest data as list-evaluation-rows. `filter` and `order_by` use the same AIP-style syntax as the GET route. Filtering and ordering apply before pagination.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationScorerAddParams

type EvaluationScorerAddParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Scorer versions to add. Each Scorer ID must be unique. An already registered
	// Scorer changes to the supplied version, which must keep its registered name and
	// value type.
	Scorers param.Field[[]EvaluationScorerAddParamsScorer] `json:"scorers" api:"required"`
}

func (EvaluationScorerAddParams) MarshalJSON

func (r EvaluationScorerAddParams) MarshalJSON() (data []byte, err error)

type EvaluationScorerAddParamsScorer

type EvaluationScorerAddParamsScorer struct {
	ScorerID  param.Field[string] `json:"scorer_id"  api:"required" format:"uuid"`
	VersionID param.Field[string] `json:"version_id" api:"required" format:"uuid"`
}

func (EvaluationScorerAddParamsScorer) MarshalJSON

func (r EvaluationScorerAddParamsScorer) MarshalJSON() (data []byte, err error)

type EvaluationScorerAddResponse

type EvaluationScorerAddResponse struct {
	// The ScorerVersions the next EvaluationVersion selects, in order.
	Scorers []EvaluationScorerAddResponseScorer `json:"scorers" api:"required"`
	JSON    evaluationScorerAddResponseJSON     `json:"-"`
}

func (*EvaluationScorerAddResponse) UnmarshalJSON

func (r *EvaluationScorerAddResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationScorerAddResponseScorer

type EvaluationScorerAddResponseScorer struct {
	ScorerID  string                                `json:"scorer_id"  api:"required" format:"uuid"`
	VersionID string                                `json:"version_id" api:"required" format:"uuid"`
	JSON      evaluationScorerAddResponseScorerJSON `json:"-"`
}

func (*EvaluationScorerAddResponseScorer) UnmarshalJSON

func (r *EvaluationScorerAddResponseScorer) UnmarshalJSON(data []byte) (err error)

type EvaluationScorerService

type EvaluationScorerService struct {
	Options []option.RequestOption
}

EvaluationScorerService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationScorerService method instead.

func NewEvaluationScorerService

func NewEvaluationScorerService(opts ...option.RequestOption) (r *EvaluationScorerService)

NewEvaluationScorerService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationScorerService) Add

Atomically adds Scorers to the Evaluation's pending head or selects another version of an already registered Scorer. Published EvaluationVersions keep their selections. The Evaluation's latest data reads the selected versions' Scores. Saved EvaluationQueries name ScorerVersions, so create a new query when replacing a version used by an existing query. Every version must score cases or trajectories. A version that cannot score the targets of a saved query that groups by its scorer, or uses it as a pass_at_k task, returns 400. A missing Scorer or version returns 404, and a name already registered to another Scorer returns 409. Repeating the same selections changes nothing. If any item is invalid, no selections change.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationService

type EvaluationService struct {
	Options        []option.RequestOption
	Metrics        *EvaluationMetricService
	Rows           *EvaluationRowService
	TrajectoryRows *EvaluationTrajectoryRowService
	Scorers        *EvaluationScorerService
	Queries        *EvaluationQueryService
	Versions       *EvaluationVersionService
}

EvaluationService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationService method instead.

func NewEvaluationService

func NewEvaluationService(opts ...option.RequestOption) (r *EvaluationService)

NewEvaluationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationService) Delete

func (r *EvaluationService) Delete(
	ctx context.Context,
	evaluationID string,
	body EvaluationDeleteParams,
	opts ...option.RequestOption,
) (err error)

Soft-deletes the Evaluation. It, its EvaluationVersions, saved queries, query results, and metrics then return 404, and writes to them are rejected with 404. Its source Dataset and its Scores are unchanged. An absent or already deleted Evaluation returns 404. A retry with the same Idempotency-Key replays the first response.

func (*EvaluationService) Get

func (r *EvaluationService) Get(
	ctx context.Context,
	evaluationID string,
	query EvaluationGetParams,
	opts ...option.RequestOption,
) (res *EvaluationGetResponse, err error)

Returns the immutable evaluation definition in the same form as the create response. An evaluation that does not exist or is outside the requested scope returns 404.

func (*EvaluationService) List

Returns evaluations in creation order, including evaluations created through the evaluation table API. A scope with no evaluations returns an empty page.

func (*EvaluationService) Log

func (r *EvaluationService) Log(
	ctx context.Context,
	evaluationID string,
	params EvaluationLogParams,
	opts ...option.RequestOption,
) (res *EvaluationLogResponse, err error)

Logs results for one variant to a live Case Evaluation using canonical Dataset membership, Cases, Scorers, and Scores. It does not calculate scores. No Dataset or Case IDs are required.

Until the keyed Case schema is installed, returns 501 not_implemented with Cache-Control: no-store before making durable writes. The same request and Idempotency-Key can be retried after schema installation.

Results with the same variant and example key reuse one canonical Case within the source Dataset, including across requests and Evaluations. Supplied scores merge with earlier scores. Missing scores leave earlier values unchanged. A repeated score uses the latest published value, with later result order winning within one request. Scorer names select the Evaluation's immutable Scorer versions. New names infer number, boolean, or string types on first use. Existing definitions are never changed by logging.

A request is limited to 10000 results, 10000 total scores, and 1000 distinct Scorer names.

An exact retry with the same Idempotency-Key returns the same IDs. A changed payload with that key returns 409. Writes are resumable, not atomic across the batch: after an interrupted request, some canonical resources may already be visible. Retry the unchanged request with the same key to finish it without duplicate examples. If another request is still creating an example, retry after publication_pending. A new key adds Scores to the same examples. Current and frozen Evaluation rows use the existing read APIs.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

func (*EvaluationService) New

Defines which data and target kind an evaluation uses. This operation stores a definition. It does not run a model or calculate scores.

Choose one source:

  • **Fixed:** Set `source.kind` to `fixed` and provide `source.dataset_version_id` to evaluate a specific dataset version.
  • **Live:** Set `source.kind` to `live` and provide `source.dataset_id` to follow a dataset's current head.

Provide only the ID for the selected source kind. A source outside the requested scope returns 404. Attributes are stored as canonical JSON. An exact retry with the same idempotency key returns the original response.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

func (*EvaluationService) Update

func (r *EvaluationService) Update(
	ctx context.Context,
	evaluationID string,
	params EvaluationUpdateParams,
	opts ...option.RequestOption,
) (res *EvaluationUpdateResponse, err error)

Replaces the Evaluation's name, attributes, or both. Omitted fields keep their values, and attributes are replaced as a whole object. A body without either field is rejected. The source, primary target kind, EvaluationVersions, saved queries, and metrics are unchanged. Concurrent updates are last-writer-wins. A retry with the same Idempotency-Key replays the first response.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationTrajectoryRowGetParams

type EvaluationTrajectoryRowGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationTrajectoryRowGetResponse

type EvaluationTrajectoryRowGetResponse struct {
	// The case the trajectory starts from.
	RootCase EvaluationTrajectoryRowGetResponseRootCase `json:"root_case" api:"required"`
	// The newest score of each scorer the evaluation selects, in selection order. A
	// scorer with no score on this trajectory is left out.
	Scores     []EvaluationTrajectoryRowGetResponseScore    `json:"scores"     api:"required"`
	Trajectory EvaluationTrajectoryRowGetResponseTrajectory `json:"trajectory" api:"required"`
	JSON       evaluationTrajectoryRowGetResponseJSON       `json:"-"`
}

func (*EvaluationTrajectoryRowGetResponse) UnmarshalJSON

func (r *EvaluationTrajectoryRowGetResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowGetResponseRootCase

type EvaluationTrajectoryRowGetResponseRootCase struct {
	Attributes map[string]interface{} `json:"attributes"  api:"required"`
	CaseID     string                 `json:"case_id"     api:"required"          format:"uuid"`
	CommitID   int64                  `json:"commit_id"   api:"required"`
	ExampleKey string                 `json:"example_key" api:"required,nullable"`
	Input      interface{}            `json:"input"       api:"required"`
	Output     interface{}            `json:"output"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                       `json:"tags"    api:"required"`
	Variant string                                         `json:"variant" api:"required,nullable"`
	JSON    evaluationTrajectoryRowGetResponseRootCaseJSON `json:"-"`
}

The case the trajectory starts from.

func (*EvaluationTrajectoryRowGetResponseRootCase) UnmarshalJSON

func (r *EvaluationTrajectoryRowGetResponseRootCase) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowGetResponseScore

type EvaluationTrajectoryRowGetResponseScore struct {
	ScoreID         string                                      `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                      `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                      `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                 `json:"value"             api:"required"`
	JSON            evaluationTrajectoryRowGetResponseScoreJSON `json:"-"`
}

func (*EvaluationTrajectoryRowGetResponseScore) UnmarshalJSON

func (r *EvaluationTrajectoryRowGetResponseScore) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowGetResponseTrajectory

type EvaluationTrajectoryRowGetResponseTrajectory struct {
	CommitID  int64  `json:"commit_id"  api:"required"`
	DatasetID string `json:"dataset_id" api:"required" format:"uuid"`
	// 0 for a top-level trajectory, otherwise one more than its parent's.
	Depth int64  `json:"depth" api:"required"`
	Name  string `json:"name"  api:"required"`
	// Null for a top-level trajectory.
	ParentTrajectoryID string                                           `json:"parent_trajectory_id" api:"required,nullable" format:"uuid"`
	RootCaseID         string                                           `json:"root_case_id"         api:"required"          format:"uuid"`
	TrajectoryID       string                                           `json:"trajectory_id"        api:"required"          format:"uuid"`
	JSON               evaluationTrajectoryRowGetResponseTrajectoryJSON `json:"-"`
}

func (*EvaluationTrajectoryRowGetResponseTrajectory) UnmarshalJSON

func (r *EvaluationTrajectoryRowGetResponseTrajectory) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowListParams

type EvaluationTrajectoryRowListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvaluationTrajectoryRowListParams) URLQuery

func (r EvaluationTrajectoryRowListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationTrajectoryRowListParams's query parameters as `url.Values`.

type EvaluationTrajectoryRowListResponse

type EvaluationTrajectoryRowListResponse struct {
	Rows       []EvaluationTrajectoryRowListResponseRow `json:"rows"        api:"required"`
	NextCursor string                                   `json:"next_cursor"`
	JSON       evaluationTrajectoryRowListResponseJSON  `json:"-"`
}

func (*EvaluationTrajectoryRowListResponse) UnmarshalJSON

func (r *EvaluationTrajectoryRowListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowListResponseRow

type EvaluationTrajectoryRowListResponseRow struct {
	// The case the trajectory starts from.
	RootCase EvaluationTrajectoryRowListResponseRowsRootCase `json:"root_case" api:"required"`
	// The newest score of each scorer the evaluation selects, in selection order. A
	// scorer with no score on this trajectory is left out.
	Scores     []EvaluationTrajectoryRowListResponseRowsScore    `json:"scores"     api:"required"`
	Trajectory EvaluationTrajectoryRowListResponseRowsTrajectory `json:"trajectory" api:"required"`
	JSON       evaluationTrajectoryRowListResponseRowJSON        `json:"-"`
}

func (*EvaluationTrajectoryRowListResponseRow) UnmarshalJSON

func (r *EvaluationTrajectoryRowListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowListResponseRowsRootCase

type EvaluationTrajectoryRowListResponseRowsRootCase struct {
	Attributes map[string]interface{} `json:"attributes"  api:"required"`
	CaseID     string                 `json:"case_id"     api:"required"          format:"uuid"`
	CommitID   int64                  `json:"commit_id"   api:"required"`
	ExampleKey string                 `json:"example_key" api:"required,nullable"`
	Input      interface{}            `json:"input"       api:"required"`
	Output     interface{}            `json:"output"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                            `json:"tags"    api:"required"`
	Variant string                                              `json:"variant" api:"required,nullable"`
	JSON    evaluationTrajectoryRowListResponseRowsRootCaseJSON `json:"-"`
}

The case the trajectory starts from.

func (*EvaluationTrajectoryRowListResponseRowsRootCase) UnmarshalJSON

func (r *EvaluationTrajectoryRowListResponseRowsRootCase) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowListResponseRowsScore

type EvaluationTrajectoryRowListResponseRowsScore struct {
	ScoreID         string                                           `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                           `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                           `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                      `json:"value"             api:"required"`
	JSON            evaluationTrajectoryRowListResponseRowsScoreJSON `json:"-"`
}

func (*EvaluationTrajectoryRowListResponseRowsScore) UnmarshalJSON

func (r *EvaluationTrajectoryRowListResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowListResponseRowsTrajectory

type EvaluationTrajectoryRowListResponseRowsTrajectory struct {
	CommitID  int64  `json:"commit_id"  api:"required"`
	DatasetID string `json:"dataset_id" api:"required" format:"uuid"`
	// 0 for a top-level trajectory, otherwise one more than its parent's.
	Depth int64  `json:"depth" api:"required"`
	Name  string `json:"name"  api:"required"`
	// Null for a top-level trajectory.
	ParentTrajectoryID string                                                `json:"parent_trajectory_id" api:"required,nullable" format:"uuid"`
	RootCaseID         string                                                `json:"root_case_id"         api:"required"          format:"uuid"`
	TrajectoryID       string                                                `json:"trajectory_id"        api:"required"          format:"uuid"`
	JSON               evaluationTrajectoryRowListResponseRowsTrajectoryJSON `json:"-"`
}

func (*EvaluationTrajectoryRowListResponseRowsTrajectory) UnmarshalJSON

func (r *EvaluationTrajectoryRowListResponseRowsTrajectory) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowSearchParams

type EvaluationTrajectoryRowSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvaluationTrajectoryRowSearchParams) MarshalJSON

func (r EvaluationTrajectoryRowSearchParams) MarshalJSON() (data []byte, err error)

type EvaluationTrajectoryRowSearchResponse

type EvaluationTrajectoryRowSearchResponse struct {
	Rows       []EvaluationTrajectoryRowSearchResponseRow `json:"rows"        api:"required"`
	NextCursor string                                     `json:"next_cursor"`
	JSON       evaluationTrajectoryRowSearchResponseJSON  `json:"-"`
}

func (*EvaluationTrajectoryRowSearchResponse) UnmarshalJSON

func (r *EvaluationTrajectoryRowSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowSearchResponseRow

type EvaluationTrajectoryRowSearchResponseRow struct {
	// The case the trajectory starts from.
	RootCase EvaluationTrajectoryRowSearchResponseRowsRootCase `json:"root_case" api:"required"`
	// The newest score of each scorer the evaluation selects, in selection order. A
	// scorer with no score on this trajectory is left out.
	Scores     []EvaluationTrajectoryRowSearchResponseRowsScore    `json:"scores"     api:"required"`
	Trajectory EvaluationTrajectoryRowSearchResponseRowsTrajectory `json:"trajectory" api:"required"`
	JSON       evaluationTrajectoryRowSearchResponseRowJSON        `json:"-"`
}

func (*EvaluationTrajectoryRowSearchResponseRow) UnmarshalJSON

func (r *EvaluationTrajectoryRowSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowSearchResponseRowsRootCase

type EvaluationTrajectoryRowSearchResponseRowsRootCase struct {
	Attributes map[string]interface{} `json:"attributes"  api:"required"`
	CaseID     string                 `json:"case_id"     api:"required"          format:"uuid"`
	CommitID   int64                  `json:"commit_id"   api:"required"`
	ExampleKey string                 `json:"example_key" api:"required,nullable"`
	Input      interface{}            `json:"input"       api:"required"`
	Output     interface{}            `json:"output"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                              `json:"tags"    api:"required"`
	Variant string                                                `json:"variant" api:"required,nullable"`
	JSON    evaluationTrajectoryRowSearchResponseRowsRootCaseJSON `json:"-"`
}

The case the trajectory starts from.

func (*EvaluationTrajectoryRowSearchResponseRowsRootCase) UnmarshalJSON

func (r *EvaluationTrajectoryRowSearchResponseRowsRootCase) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowSearchResponseRowsScore

type EvaluationTrajectoryRowSearchResponseRowsScore struct {
	ScoreID         string                                             `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                             `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                             `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                        `json:"value"             api:"required"`
	JSON            evaluationTrajectoryRowSearchResponseRowsScoreJSON `json:"-"`
}

func (*EvaluationTrajectoryRowSearchResponseRowsScore) UnmarshalJSON

func (r *EvaluationTrajectoryRowSearchResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowSearchResponseRowsTrajectory

type EvaluationTrajectoryRowSearchResponseRowsTrajectory struct {
	CommitID  int64  `json:"commit_id"  api:"required"`
	DatasetID string `json:"dataset_id" api:"required" format:"uuid"`
	// 0 for a top-level trajectory, otherwise one more than its parent's.
	Depth int64  `json:"depth" api:"required"`
	Name  string `json:"name"  api:"required"`
	// Null for a top-level trajectory.
	ParentTrajectoryID string                                                  `json:"parent_trajectory_id" api:"required,nullable" format:"uuid"`
	RootCaseID         string                                                  `json:"root_case_id"         api:"required"          format:"uuid"`
	TrajectoryID       string                                                  `json:"trajectory_id"        api:"required"          format:"uuid"`
	JSON               evaluationTrajectoryRowSearchResponseRowsTrajectoryJSON `json:"-"`
}

func (*EvaluationTrajectoryRowSearchResponseRowsTrajectory) UnmarshalJSON

func (r *EvaluationTrajectoryRowSearchResponseRowsTrajectory) UnmarshalJSON(data []byte) (err error)

type EvaluationTrajectoryRowService

type EvaluationTrajectoryRowService struct {
	Options []option.RequestOption
}

EvaluationTrajectoryRowService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationTrajectoryRowService method instead.

func NewEvaluationTrajectoryRowService

func NewEvaluationTrajectoryRowService(opts ...option.RequestOption) (r *EvaluationTrajectoryRowService)

NewEvaluationTrajectoryRowService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationTrajectoryRowService) Get

Returns the trajectory's row as a new list-trajectory-rows read returns it. Each read sees the scores published by then, so two reads can differ. The trajectory must be in the evaluation's dataset: published to a live evaluation's dataset head, or in a fixed evaluation's dataset version. Child trajectories are rows too. Any other trajectory returns 404. The evaluation's `primary_target_kind` must be `trajectory`.

func (*EvaluationTrajectoryRowService) List

Reads the evaluation's latest data without cutting an evaluation version. The rows are the trajectories published to a live evaluation's dataset head, or in a fixed evaluation's dataset version, that match `filter`, in `order_by` order or else in the order the trajectories were created. Child trajectories are rows too. Each row holds the trajectory, its root case, and the newest published score of each scorer the evaluation selects. The evaluation's `primary_target_kind` must be `trajectory`.

Use these column names in `filter` and `order_by`:

  • `name`, `depth`, or `parent_trajectory_id` for the trajectory's own fields. `parent_trajectory_id` is null for a top-level trajectory. Compare it with a whole trajectory ID in either letter case. Any other string, including a wildcard pattern, returns 400.
  • `variant`, `i.<name>`, or `o.<name>` for the root case's variant or one of its input or output fields.
  • `s.<name>` for the trajectory's score from a selected scorer.

`input`, `output`, and `score` are also accepted as the longer forms of `i`, `o`, and `s`. Filtering and sorting happen before pagination.

Pass the returned `next_cursor` as `cursor`, with the same `filter` and `order_by`, to read the next page. The last page has no `next_cursor`. The first page pins that data, and later pages read the same trajectories and scores. If the evaluation's scorer selection changes between pages, a continuation returns 400 and the read must start again without a cursor.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/trajectory-rows/search` operation.

func (*EvaluationTrajectoryRowService) Search

Reads the same latest trajectory rows as list-trajectory-rows, with `filter`, `order_by`, `limit`, and `cursor` in a JSON body. `filter` and `order_by` take the same columns, and a `next_cursor` from either operation continues on the other with the same `filter` and `order_by`. Filtering and sorting happen before pagination.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationUpdateParams

type EvaluationUpdateParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Replaces the attributes as a whole object. Omit to keep them.
	Attributes param.Field[map[string]interface{}] `json:"attributes"`
	// Replaces the name. Omit to keep it.
	Name param.Field[string] `json:"name"`
}

func (EvaluationUpdateParams) MarshalJSON

func (r EvaluationUpdateParams) MarshalJSON() (data []byte, err error)

type EvaluationUpdateResponse

type EvaluationUpdateResponse struct {
	Attributes   map[string]interface{} `json:"attributes"    api:"required"`
	EvaluationID string                 `json:"evaluation_id" api:"required" format:"uuid"`
	Name         string                 `json:"name"          api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationUpdateResponseNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationUpdateResponsePrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                    `json:"scope_ref"           api:"required"`
	Source            EvaluationUpdateResponseSource            `json:"source"              api:"required"`
	JSON              evaluationUpdateResponseJSON              `json:"-"`
}

func (*EvaluationUpdateResponse) UnmarshalJSON

func (r *EvaluationUpdateResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationUpdateResponseNamespace

type EvaluationUpdateResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationUpdateResponseNamespaceWandb EvaluationUpdateResponseNamespace = "wandb"
)

func (EvaluationUpdateResponseNamespace) IsKnown

type EvaluationUpdateResponsePrimaryTargetKind

type EvaluationUpdateResponsePrimaryTargetKind string
const (
	EvaluationUpdateResponsePrimaryTargetKindCase       EvaluationUpdateResponsePrimaryTargetKind = "case"
	EvaluationUpdateResponsePrimaryTargetKindTrajectory EvaluationUpdateResponsePrimaryTargetKind = "trajectory"
)

func (EvaluationUpdateResponsePrimaryTargetKind) IsKnown

type EvaluationUpdateResponseSource

type EvaluationUpdateResponseSource struct {
	Kind             EvaluationUpdateResponseSourceKind `json:"kind"               api:"required"`
	DatasetID        string                             `json:"dataset_id"                        format:"uuid"`
	DatasetVersionID string                             `json:"dataset_version_id"                format:"uuid"`
	JSON             evaluationUpdateResponseSourceJSON `json:"-"`
	// contains filtered or unexported fields
}

func (EvaluationUpdateResponseSource) AsUnion

AsUnion returns a EvaluationUpdateResponseSourceUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are EvaluationUpdateResponseSourceFixedEvaluationSource, EvaluationUpdateResponseSourceLiveEvaluationSource.

func (*EvaluationUpdateResponseSource) UnmarshalJSON

func (r *EvaluationUpdateResponseSource) UnmarshalJSON(data []byte) (err error)

type EvaluationUpdateResponseSourceFixedEvaluationSource

type EvaluationUpdateResponseSourceFixedEvaluationSource struct {
	DatasetVersionID string                                                  `json:"dataset_version_id" api:"required" format:"uuid"`
	Kind             EvaluationUpdateResponseSourceFixedEvaluationSourceKind `json:"kind"               api:"required"`
	JSON             evaluationUpdateResponseSourceFixedEvaluationSourceJSON `json:"-"`
}

func (*EvaluationUpdateResponseSourceFixedEvaluationSource) UnmarshalJSON

func (r *EvaluationUpdateResponseSourceFixedEvaluationSource) UnmarshalJSON(data []byte) (err error)

type EvaluationUpdateResponseSourceFixedEvaluationSourceKind

type EvaluationUpdateResponseSourceFixedEvaluationSourceKind string
const (
	EvaluationUpdateResponseSourceFixedEvaluationSourceKindFixed EvaluationUpdateResponseSourceFixedEvaluationSourceKind = "fixed"
)

func (EvaluationUpdateResponseSourceFixedEvaluationSourceKind) IsKnown

type EvaluationUpdateResponseSourceKind

type EvaluationUpdateResponseSourceKind string
const (
	EvaluationUpdateResponseSourceKindFixed EvaluationUpdateResponseSourceKind = "fixed"
	EvaluationUpdateResponseSourceKindLive  EvaluationUpdateResponseSourceKind = "live"
)

func (EvaluationUpdateResponseSourceKind) IsKnown

type EvaluationUpdateResponseSourceLiveEvaluationSource

type EvaluationUpdateResponseSourceLiveEvaluationSource struct {
	DatasetID string                                                 `json:"dataset_id" api:"required" format:"uuid"`
	Kind      EvaluationUpdateResponseSourceLiveEvaluationSourceKind `json:"kind"       api:"required"`
	JSON      evaluationUpdateResponseSourceLiveEvaluationSourceJSON `json:"-"`
}

func (*EvaluationUpdateResponseSourceLiveEvaluationSource) UnmarshalJSON

func (r *EvaluationUpdateResponseSourceLiveEvaluationSource) UnmarshalJSON(data []byte) (err error)

type EvaluationUpdateResponseSourceLiveEvaluationSourceKind

type EvaluationUpdateResponseSourceLiveEvaluationSourceKind string
const (
	EvaluationUpdateResponseSourceLiveEvaluationSourceKindLive EvaluationUpdateResponseSourceLiveEvaluationSourceKind = "live"
)

func (EvaluationUpdateResponseSourceLiveEvaluationSourceKind) IsKnown

type EvaluationUpdateResponseSourceUnion

type EvaluationUpdateResponseSourceUnion interface {
	// contains filtered or unexported methods
}

Union satisfied by EvaluationUpdateResponseSourceFixedEvaluationSource or EvaluationUpdateResponseSourceLiveEvaluationSource.

type EvaluationVersionGetParams

type EvaluationVersionGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationVersionGetResponse

type EvaluationVersionGetResponse struct {
	DatasetID           string `json:"dataset_id"            api:"required" format:"uuid"`
	DatasetVersionID    string `json:"dataset_version_id"    api:"required" format:"uuid"`
	EvaluationID        string `json:"evaluation_id"         api:"required" format:"uuid"`
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Last published write visible to this snapshot. Scores and reported metrics
	// published later are excluded.
	LastCommitID int64 `json:"last_commit_id" api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationVersionGetResponseNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationVersionGetResponsePrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                        `json:"scope_ref"           api:"required"`
	// Scorer versions selected for this snapshot, in the order used by result
	// responses.
	Scorers []EvaluationVersionGetResponseScorer `json:"scorers" api:"required"`
	JSON    evaluationVersionGetResponseJSON     `json:"-"`
}

func (*EvaluationVersionGetResponse) UnmarshalJSON

func (r *EvaluationVersionGetResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionGetResponseNamespace

type EvaluationVersionGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationVersionGetResponseNamespaceWandb EvaluationVersionGetResponseNamespace = "wandb"
)

func (EvaluationVersionGetResponseNamespace) IsKnown

type EvaluationVersionGetResponsePrimaryTargetKind

type EvaluationVersionGetResponsePrimaryTargetKind string
const (
	EvaluationVersionGetResponsePrimaryTargetKindCase       EvaluationVersionGetResponsePrimaryTargetKind = "case"
	EvaluationVersionGetResponsePrimaryTargetKindTrajectory EvaluationVersionGetResponsePrimaryTargetKind = "trajectory"
)

func (EvaluationVersionGetResponsePrimaryTargetKind) IsKnown

type EvaluationVersionGetResponseScorer

type EvaluationVersionGetResponseScorer struct {
	ScorerID  string                                 `json:"scorer_id"  api:"required" format:"uuid"`
	VersionID string                                 `json:"version_id" api:"required" format:"uuid"`
	JSON      evaluationVersionGetResponseScorerJSON `json:"-"`
}

func (*EvaluationVersionGetResponseScorer) UnmarshalJSON

func (r *EvaluationVersionGetResponseScorer) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionListParams

type EvaluationVersionListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (EvaluationVersionListParams) URLQuery

func (r EvaluationVersionListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationVersionListParams's query parameters as `url.Values`.

type EvaluationVersionListResponse

type EvaluationVersionListResponse struct {
	Results    []EvaluationVersionListResponseResult `json:"results"     api:"required"`
	NextCursor string                                `json:"next_cursor"`
	JSON       evaluationVersionListResponseJSON     `json:"-"`
}

func (*EvaluationVersionListResponse) UnmarshalJSON

func (r *EvaluationVersionListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionListResponseResult

type EvaluationVersionListResponseResult struct {
	DatasetID           string `json:"dataset_id"            api:"required" format:"uuid"`
	DatasetVersionID    string `json:"dataset_version_id"    api:"required" format:"uuid"`
	EvaluationID        string `json:"evaluation_id"         api:"required" format:"uuid"`
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Last published write visible to this snapshot. Scores and reported metrics
	// published later are excluded.
	LastCommitID int64 `json:"last_commit_id" api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationVersionListResponseResultsNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationVersionListResponseResultsPrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                                `json:"scope_ref"           api:"required"`
	// Scorer versions selected for this snapshot, in the order used by result
	// responses.
	Scorers []EvaluationVersionListResponseResultsScorer `json:"scorers" api:"required"`
	JSON    evaluationVersionListResponseResultJSON      `json:"-"`
}

func (*EvaluationVersionListResponseResult) UnmarshalJSON

func (r *EvaluationVersionListResponseResult) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionListResponseResultsNamespace

type EvaluationVersionListResponseResultsNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationVersionListResponseResultsNamespaceWandb EvaluationVersionListResponseResultsNamespace = "wandb"
)

func (EvaluationVersionListResponseResultsNamespace) IsKnown

type EvaluationVersionListResponseResultsPrimaryTargetKind

type EvaluationVersionListResponseResultsPrimaryTargetKind string
const (
	EvaluationVersionListResponseResultsPrimaryTargetKindCase       EvaluationVersionListResponseResultsPrimaryTargetKind = "case"
	EvaluationVersionListResponseResultsPrimaryTargetKindTrajectory EvaluationVersionListResponseResultsPrimaryTargetKind = "trajectory"
)

func (EvaluationVersionListResponseResultsPrimaryTargetKind) IsKnown

type EvaluationVersionListResponseResultsScorer

type EvaluationVersionListResponseResultsScorer struct {
	ScorerID  string                                         `json:"scorer_id"  api:"required" format:"uuid"`
	VersionID string                                         `json:"version_id" api:"required" format:"uuid"`
	JSON      evaluationVersionListResponseResultsScorerJSON `json:"-"`
}

func (*EvaluationVersionListResponseResultsScorer) UnmarshalJSON

func (r *EvaluationVersionListResponseResultsScorer) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionMetricListParams

type EvaluationVersionMetricListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type EvaluationVersionMetricListResponse

type EvaluationVersionMetricListResponse struct {
	// Newest value per subject and name, ordered by subject and then name. Values
	// without a subject come first.
	Metrics []EvaluationVersionMetricListResponseMetric `json:"metrics" api:"required"`
	// Publication cutoff used to select the returned metric values.
	PublishedCommitID int64                                   `json:"published_commit_id" api:"required"`
	JSON              evaluationVersionMetricListResponseJSON `json:"-"`
}

func (*EvaluationVersionMetricListResponse) UnmarshalJSON

func (r *EvaluationVersionMetricListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionMetricListResponseMetric

type EvaluationVersionMetricListResponseMetric struct {
	CommitID  int64                                               `json:"commit_id"  api:"required"`
	Name      string                                              `json:"name"       api:"required"`
	Subject   string                                              `json:"subject"    api:"required,nullable"`
	Value     interface{}                                         `json:"value"      api:"required"`
	ValueType EvaluationVersionMetricListResponseMetricsValueType `json:"value_type" api:"required"`
	JSON      evaluationVersionMetricListResponseMetricJSON       `json:"-"`
}

func (*EvaluationVersionMetricListResponseMetric) UnmarshalJSON

func (r *EvaluationVersionMetricListResponseMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionMetricListResponseMetricsValueType

type EvaluationVersionMetricListResponseMetricsValueType string
const (
	EvaluationVersionMetricListResponseMetricsValueTypeBoolean EvaluationVersionMetricListResponseMetricsValueType = "boolean"
	EvaluationVersionMetricListResponseMetricsValueTypeNumber  EvaluationVersionMetricListResponseMetricsValueType = "number"
	EvaluationVersionMetricListResponseMetricsValueTypeString  EvaluationVersionMetricListResponseMetricsValueType = "string"
	EvaluationVersionMetricListResponseMetricsValueTypeJson    EvaluationVersionMetricListResponseMetricsValueType = "json"
)

func (EvaluationVersionMetricListResponseMetricsValueType) IsKnown

type EvaluationVersionMetricService

type EvaluationVersionMetricService struct {
	Options []option.RequestOption
}

EvaluationVersionMetricService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionMetricService method instead.

func NewEvaluationVersionMetricService

func NewEvaluationVersionMetricService(opts ...option.RequestOption) (r *EvaluationVersionMetricService)

NewEvaluationVersionMetricService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationVersionMetricService) List

Returns the newest reported value for each subject and metric name at this evaluation version's `last_commit_id`. The response exposes that cutoff as `published_commit_id`.

Values reported after the version was created are not included.

type EvaluationVersionNewParams

type EvaluationVersionNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Dataset version to freeze in the evaluation snapshot.
	//
	//   - For a fixed evaluation, omit this field or supply its configured dataset
	//     version ID.
	//   - For a live evaluation, supply a dataset version ID, or omit the field to
	//     publish the dataset's head and use it. Supplying the head's ID also publishes
	//     it.
	DatasetVersionID param.Field[string] `json:"dataset_version_id" format:"uuid"`
}

func (EvaluationVersionNewParams) MarshalJSON

func (r EvaluationVersionNewParams) MarshalJSON() (data []byte, err error)

type EvaluationVersionNewResponse

type EvaluationVersionNewResponse struct {
	DatasetID           string `json:"dataset_id"            api:"required" format:"uuid"`
	DatasetVersionID    string `json:"dataset_version_id"    api:"required" format:"uuid"`
	EvaluationID        string `json:"evaluation_id"         api:"required" format:"uuid"`
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Last published write visible to this snapshot. Scores and reported metrics
	// published later are excluded.
	LastCommitID int64 `json:"last_commit_id" api:"required"`
	// Namespace that assigned the scope reference.
	Namespace         EvaluationVersionNewResponseNamespace         `json:"namespace"           api:"required"`
	PrimaryTargetKind EvaluationVersionNewResponsePrimaryTargetKind `json:"primary_target_kind" api:"required"`
	ScopeRef          string                                        `json:"scope_ref"           api:"required"`
	// Scorer versions selected for this snapshot, in the order used by result
	// responses.
	Scorers []EvaluationVersionNewResponseScorer `json:"scorers" api:"required"`
	JSON    evaluationVersionNewResponseJSON     `json:"-"`
}

func (*EvaluationVersionNewResponse) UnmarshalJSON

func (r *EvaluationVersionNewResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionNewResponseNamespace

type EvaluationVersionNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationVersionNewResponseNamespaceWandb EvaluationVersionNewResponseNamespace = "wandb"
)

func (EvaluationVersionNewResponseNamespace) IsKnown

type EvaluationVersionNewResponsePrimaryTargetKind

type EvaluationVersionNewResponsePrimaryTargetKind string
const (
	EvaluationVersionNewResponsePrimaryTargetKindCase       EvaluationVersionNewResponsePrimaryTargetKind = "case"
	EvaluationVersionNewResponsePrimaryTargetKindTrajectory EvaluationVersionNewResponsePrimaryTargetKind = "trajectory"
)

func (EvaluationVersionNewResponsePrimaryTargetKind) IsKnown

type EvaluationVersionNewResponseScorer

type EvaluationVersionNewResponseScorer struct {
	ScorerID  string                                 `json:"scorer_id"  api:"required" format:"uuid"`
	VersionID string                                 `json:"version_id" api:"required" format:"uuid"`
	JSON      evaluationVersionNewResponseScorerJSON `json:"-"`
}

func (*EvaluationVersionNewResponseScorer) UnmarshalJSON

func (r *EvaluationVersionNewResponseScorer) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListParams

type EvaluationVersionQueryResultListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (EvaluationVersionQueryResultListParams) URLQuery

URLQuery serializes EvaluationVersionQueryResultListParams's query parameters as `url.Values`.

type EvaluationVersionQueryResultListResponse

type EvaluationVersionQueryResultListResponse struct {
	// Dataset version supplying the cases or trajectories. For a live evaluation
	// queried on latest data, this is the dataset head selected for the first page.
	DatasetVersionID  string                                            `json:"dataset_version_id"  api:"required" format:"uuid"`
	EvaluationID      string                                            `json:"evaluation_id"       api:"required" format:"uuid"`
	EvaluationQueryID string                                            `json:"evaluation_query_id" api:"required" format:"uuid"`
	GroupBy           []EvaluationVersionQueryResultListResponseGroupBy `json:"group_by"            api:"required"`
	Metrics           []EvaluationVersionQueryResultListResponseMetric  `json:"metrics"             api:"required"`
	// Namespace that assigned the scope reference.
	Namespace EvaluationVersionQueryResultListResponseNamespace `json:"namespace" api:"required"`
	// Publication cutoff shared by every page of these results. Scores published later
	// are excluded. For a live evaluation's latest data, cases and trajectories
	// published later are also excluded.
	PublishedCommitID int64                                         `json:"published_commit_id" api:"required"`
	Rows              []EvaluationVersionQueryResultListResponseRow `json:"rows"                api:"required"`
	ScopeRef          string                                        `json:"scope_ref"           api:"required"`
	// Kind of target that each row's targets field counts.
	TargetKind EvaluationVersionQueryResultListResponseTargetKind `json:"target_kind" api:"required"`
	// Frozen evaluation version supplying the data. Omitted when querying the
	// evaluation's latest data.
	EvaluationVersionID string `json:"evaluation_version_id" format:"uuid"`
	// Cursor for the next page. Absent on the last page.
	NextCursor string                                       `json:"next_cursor"`
	JSON       evaluationVersionQueryResultListResponseJSON `json:"-"`
}

func (*EvaluationVersionQueryResultListResponse) UnmarshalJSON

func (r *EvaluationVersionQueryResultListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListResponseGroupBy

type EvaluationVersionQueryResultListResponseGroupBy struct {
	Kind      EvaluationVersionQueryResultListResponseGroupByKind      `json:"kind"       api:"required"`
	ValueType EvaluationVersionQueryResultListResponseGroupByValueType `json:"value_type" api:"required"`
	Name      string                                                   `json:"name"`
	Source    EvaluationVersionQueryResultListResponseGroupBySource    `json:"source"`
	JSON      evaluationVersionQueryResultListResponseGroupByJSON      `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseGroupBy) UnmarshalJSON

func (r *EvaluationVersionQueryResultListResponseGroupBy) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListResponseGroupByKind

type EvaluationVersionQueryResultListResponseGroupByKind string
const (
	EvaluationVersionQueryResultListResponseGroupByKindVariant            EvaluationVersionQueryResultListResponseGroupByKind = "variant"
	EvaluationVersionQueryResultListResponseGroupByKindDatasetField       EvaluationVersionQueryResultListResponseGroupByKind = "dataset_field"
	EvaluationVersionQueryResultListResponseGroupByKindScore              EvaluationVersionQueryResultListResponseGroupByKind = "score"
	EvaluationVersionQueryResultListResponseGroupByKindDepth              EvaluationVersionQueryResultListResponseGroupByKind = "depth"
	EvaluationVersionQueryResultListResponseGroupByKindParentTrajectoryID EvaluationVersionQueryResultListResponseGroupByKind = "parent_trajectory_id"
	EvaluationVersionQueryResultListResponseGroupByKindTags               EvaluationVersionQueryResultListResponseGroupByKind = "tags"
)

func (EvaluationVersionQueryResultListResponseGroupByKind) IsKnown

type EvaluationVersionQueryResultListResponseGroupBySource

type EvaluationVersionQueryResultListResponseGroupBySource string
const (
	EvaluationVersionQueryResultListResponseGroupBySourceInput  EvaluationVersionQueryResultListResponseGroupBySource = "input"
	EvaluationVersionQueryResultListResponseGroupBySourceOutput EvaluationVersionQueryResultListResponseGroupBySource = "output"
)

func (EvaluationVersionQueryResultListResponseGroupBySource) IsKnown

type EvaluationVersionQueryResultListResponseGroupByValueType

type EvaluationVersionQueryResultListResponseGroupByValueType string
const (
	EvaluationVersionQueryResultListResponseGroupByValueTypeBoolean EvaluationVersionQueryResultListResponseGroupByValueType = "boolean"
	EvaluationVersionQueryResultListResponseGroupByValueTypeInteger EvaluationVersionQueryResultListResponseGroupByValueType = "integer"
	EvaluationVersionQueryResultListResponseGroupByValueTypeNumber  EvaluationVersionQueryResultListResponseGroupByValueType = "number"
	EvaluationVersionQueryResultListResponseGroupByValueTypeString  EvaluationVersionQueryResultListResponseGroupByValueType = "string"
)

func (EvaluationVersionQueryResultListResponseGroupByValueType) IsKnown

type EvaluationVersionQueryResultListResponseMetric

type EvaluationVersionQueryResultListResponseMetric struct {
	Aggregation     EvaluationVersionQueryResultListResponseMetricsAggregation `json:"aggregation"       api:"required"`
	Name            string                                                     `json:"name"              api:"required"`
	ScorerID        string                                                     `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                                     `json:"scorer_version_id" api:"required" format:"uuid"`
	// Aggregation output type: number for mean and pass_at_k, integer for count and
	// boolean sum, and the scorer's type otherwise.
	ValueType EvaluationVersionQueryResultListResponseMetricsValueType `json:"value_type" api:"required"`
	K         int64                                                    `json:"k"`
	Missing   EvaluationVersionQueryResultListResponseMetricsMissing   `json:"missing"`
	// Trajectory queries only. Groups by depth, an integer that is 0 for a top-level
	// trajectory.
	Per  EvaluationVersionQueryResultListResponseMetricsPer `json:"per"`
	JSON evaluationVersionQueryResultListResponseMetricJSON `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseMetric) UnmarshalJSON

func (r *EvaluationVersionQueryResultListResponseMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListResponseMetricsAggregation

type EvaluationVersionQueryResultListResponseMetricsAggregation string
const (
	EvaluationVersionQueryResultListResponseMetricsAggregationMean    EvaluationVersionQueryResultListResponseMetricsAggregation = "mean"
	EvaluationVersionQueryResultListResponseMetricsAggregationSum     EvaluationVersionQueryResultListResponseMetricsAggregation = "sum"
	EvaluationVersionQueryResultListResponseMetricsAggregationMin     EvaluationVersionQueryResultListResponseMetricsAggregation = "min"
	EvaluationVersionQueryResultListResponseMetricsAggregationMax     EvaluationVersionQueryResultListResponseMetricsAggregation = "max"
	EvaluationVersionQueryResultListResponseMetricsAggregationCount   EvaluationVersionQueryResultListResponseMetricsAggregation = "count"
	EvaluationVersionQueryResultListResponseMetricsAggregationPassAtK EvaluationVersionQueryResultListResponseMetricsAggregation = "pass_at_k"
)

func (EvaluationVersionQueryResultListResponseMetricsAggregation) IsKnown

type EvaluationVersionQueryResultListResponseMetricsMissing

type EvaluationVersionQueryResultListResponseMetricsMissing string
const (
	EvaluationVersionQueryResultListResponseMetricsMissingSkip EvaluationVersionQueryResultListResponseMetricsMissing = "skip"
	EvaluationVersionQueryResultListResponseMetricsMissingZero EvaluationVersionQueryResultListResponseMetricsMissing = "zero"
)

func (EvaluationVersionQueryResultListResponseMetricsMissing) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPer

type EvaluationVersionQueryResultListResponseMetricsPer struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationVersionQueryResultListResponseMetricsPerSource `json:"source"`
	JSON   evaluationVersionQueryResultListResponseMetricsPerJSON   `json:"-"`
	// contains filtered or unexported fields
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationVersionQueryResultListResponseMetricsPer) UnmarshalJSON

func (r *EvaluationVersionQueryResultListResponseMetricsPer) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumn

type EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumn struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the input or output field to use as a column.
	Name string `json:"name" api:"required"`
	// Whether the field belongs to the case's input or output.
	Source EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource `json:"source" api:"required"`
	JSON   evaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnJSON   `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumn) UnmarshalJSON

type EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind

type EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKindDatasetField EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind = "dataset_field"
)

func (EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource

type EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSourceInput  EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource = "input"
	EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSourceOutput EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource = "output"
)

func (EvaluationVersionQueryResultListResponseMetricsPerDatasetFieldEvaluationColumnSource) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumn

type EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumn struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by depth, an integer that is 0 for a top-level trajectory.

func (*EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumn) UnmarshalJSON

type EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnKind

type EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnKindDepth EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnKind = "depth"
)

func (EvaluationVersionQueryResultListResponseMetricsPerDepthEvaluationColumnKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerKind

type EvaluationVersionQueryResultListResponseMetricsPerKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerKindVariant            EvaluationVersionQueryResultListResponseMetricsPerKind = "variant"
	EvaluationVersionQueryResultListResponseMetricsPerKindDatasetField       EvaluationVersionQueryResultListResponseMetricsPerKind = "dataset_field"
	EvaluationVersionQueryResultListResponseMetricsPerKindScore              EvaluationVersionQueryResultListResponseMetricsPerKind = "score"
	EvaluationVersionQueryResultListResponseMetricsPerKindDepth              EvaluationVersionQueryResultListResponseMetricsPerKind = "depth"
	EvaluationVersionQueryResultListResponseMetricsPerKindParentTrajectoryID EvaluationVersionQueryResultListResponseMetricsPerKind = "parent_trajectory_id"
	EvaluationVersionQueryResultListResponseMetricsPerKindTags               EvaluationVersionQueryResultListResponseMetricsPerKind = "tags"
)

func (EvaluationVersionQueryResultListResponseMetricsPerKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumn

type EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumn struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnJSON `json:"-"`
}

Trajectory queries only. Groups by the parent trajectory's ID. Top-level trajectories form the null group.

func (*EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumn) UnmarshalJSON

type EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind

type EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKindParentTrajectoryID EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind = "parent_trajectory_id"
)

func (EvaluationVersionQueryResultListResponseMetricsPerParentTrajectoryIDEvaluationColumnKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumn

type EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumn struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnKind `json:"kind" api:"required"`
	// Name of the scorer whose score supplies this column.
	Name string                                                                      `json:"name" api:"required"`
	JSON evaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnJSON `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumn) UnmarshalJSON

type EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnKind

type EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnKindScore EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnKind = "score"
)

func (EvaluationVersionQueryResultListResponseMetricsPerScoreEvaluationColumnKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerSource

type EvaluationVersionQueryResultListResponseMetricsPerSource string

Whether the field belongs to the case's input or output.

const (
	EvaluationVersionQueryResultListResponseMetricsPerSourceInput  EvaluationVersionQueryResultListResponseMetricsPerSource = "input"
	EvaluationVersionQueryResultListResponseMetricsPerSourceOutput EvaluationVersionQueryResultListResponseMetricsPerSource = "output"
)

func (EvaluationVersionQueryResultListResponseMetricsPerSource) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumn

type EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumn struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnJSON `json:"-"`
}

Case queries only. Groups by tag name.

func (*EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumn) UnmarshalJSON

type EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnKind

type EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnKindTags EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnKind = "tags"
)

func (EvaluationVersionQueryResultListResponseMetricsPerTagsEvaluationColumnKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumn

type EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumn struct {
	Kind EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnKind `json:"kind" api:"required"`
	JSON evaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnJSON `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumn) UnmarshalJSON

type EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnKind

type EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnKind string
const (
	EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnKindVariant EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnKind = "variant"
)

func (EvaluationVersionQueryResultListResponseMetricsPerVariantEvaluationColumnKind) IsKnown

type EvaluationVersionQueryResultListResponseMetricsValueType

type EvaluationVersionQueryResultListResponseMetricsValueType string

Aggregation output type: number for mean and pass_at_k, integer for count and boolean sum, and the scorer's type otherwise.

const (
	EvaluationVersionQueryResultListResponseMetricsValueTypeBoolean EvaluationVersionQueryResultListResponseMetricsValueType = "boolean"
	EvaluationVersionQueryResultListResponseMetricsValueTypeInteger EvaluationVersionQueryResultListResponseMetricsValueType = "integer"
	EvaluationVersionQueryResultListResponseMetricsValueTypeNumber  EvaluationVersionQueryResultListResponseMetricsValueType = "number"
	EvaluationVersionQueryResultListResponseMetricsValueTypeString  EvaluationVersionQueryResultListResponseMetricsValueType = "string"
)

func (EvaluationVersionQueryResultListResponseMetricsValueType) IsKnown

type EvaluationVersionQueryResultListResponseNamespace

type EvaluationVersionQueryResultListResponseNamespace string

Namespace that assigned the scope reference.

const (
	EvaluationVersionQueryResultListResponseNamespaceWandb EvaluationVersionQueryResultListResponseNamespace = "wandb"
)

func (EvaluationVersionQueryResultListResponseNamespace) IsKnown

type EvaluationVersionQueryResultListResponseRow

type EvaluationVersionQueryResultListResponseRow struct {
	// Values in group_by order, with null for missing or null fields. Empty for an
	// ungrouped query.
	Group   []EvaluationVersionQueryResultListResponseRowsGroupUnion `json:"group"   api:"required"`
	Metrics []EvaluationVersionQueryResultListResponseRowsMetric     `json:"metrics" api:"required"`
	// Number of targets in this group: cases, or trajectories in a trajectory query.
	Targets int64                                           `json:"targets" api:"required"`
	JSON    evaluationVersionQueryResultListResponseRowJSON `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseRow) UnmarshalJSON

func (r *EvaluationVersionQueryResultListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListResponseRowsGroupUnion

type EvaluationVersionQueryResultListResponseRowsGroupUnion interface {
	ImplementsEvaluationVersionQueryResultListResponseRowsGroupUnion()
}

A JSON scalar (boolean, integer, number, or string) or null.

Union satisfied by shared.UnionBool, shared.UnionInt, shared.UnionFloat or shared.UnionString.

type EvaluationVersionQueryResultListResponseRowsMetric

type EvaluationVersionQueryResultListResponseRowsMetric struct {
	Name string `json:"name" api:"required"`
	// Calculated metric value. If no target has a non-null latest visible score, count
	// returns 0 and other aggregations return null.
	Value EvaluationVersionQueryResultListResponseRowsMetricsValueUnion `json:"value" api:"required"`
	JSON  evaluationVersionQueryResultListResponseRowsMetricJSON        `json:"-"`
}

func (*EvaluationVersionQueryResultListResponseRowsMetric) UnmarshalJSON

func (r *EvaluationVersionQueryResultListResponseRowsMetric) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionQueryResultListResponseRowsMetricsValueUnion

type EvaluationVersionQueryResultListResponseRowsMetricsValueUnion interface {
	ImplementsEvaluationVersionQueryResultListResponseRowsMetricsValueUnion()
}

Calculated metric value. If no target has a non-null latest visible score, count returns 0 and other aggregations return null.

Union satisfied by shared.UnionBool, shared.UnionInt, shared.UnionFloat or shared.UnionString.

type EvaluationVersionQueryResultListResponseTargetKind

type EvaluationVersionQueryResultListResponseTargetKind string

Kind of target that each row's targets field counts.

const (
	EvaluationVersionQueryResultListResponseTargetKindCase       EvaluationVersionQueryResultListResponseTargetKind = "case"
	EvaluationVersionQueryResultListResponseTargetKindTrajectory EvaluationVersionQueryResultListResponseTargetKind = "trajectory"
)

func (EvaluationVersionQueryResultListResponseTargetKind) IsKnown

type EvaluationVersionQueryResultService

type EvaluationVersionQueryResultService struct {
	Options []option.RequestOption
}

EvaluationVersionQueryResultService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionQueryResultService method instead.

func NewEvaluationVersionQueryResultService

func NewEvaluationVersionQueryResultService(opts ...option.RequestOption) (r *EvaluationVersionQueryResultService)

NewEvaluationVersionQueryResultService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationVersionQueryResultService) List

Runs one of the evaluation's saved aggregation queries against the data and scores captured in this evaluation version.

**Version compatibility**

Returns 400 if the dataset snapshot lacks a grouping field, or if the evaluation version does not select a scorer used by a metric or score grouping.

**Grouping and ordering**

  • Rows sort by the `group_by` columns in order, ascending, with nulls last.
  • A missing grouping value and an explicit null belong to the same group.
  • Without grouping, the response has one row with an empty `group` array, even for an empty dataset.
  • With grouping, an empty dataset returns no rows.

type EvaluationVersionQueryService

type EvaluationVersionQueryService struct {
	Options []option.RequestOption
	Results *EvaluationVersionQueryResultService
}

EvaluationVersionQueryService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionQueryService method instead.

func NewEvaluationVersionQueryService

func NewEvaluationVersionQueryService(opts ...option.RequestOption) (r *EvaluationVersionQueryService)

NewEvaluationVersionQueryService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type EvaluationVersionResultListParams

type EvaluationVersionResultListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (EvaluationVersionResultListParams) URLQuery

func (r EvaluationVersionResultListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationVersionResultListParams's query parameters as `url.Values`.

type EvaluationVersionResultListResponse

type EvaluationVersionResultListResponse struct {
	PublishedCommitID int64                                       `json:"published_commit_id" api:"required"`
	Targets           []EvaluationVersionResultListResponseTarget `json:"targets"             api:"required"`
	NextCursor        string                                      `json:"next_cursor"`
	JSON              evaluationVersionResultListResponseJSON     `json:"-"`
}

func (*EvaluationVersionResultListResponse) UnmarshalJSON

func (r *EvaluationVersionResultListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionResultListResponseTarget

type EvaluationVersionResultListResponseTarget struct {
	Scores []EvaluationVersionResultListResponseTargetsScore `json:"scores" api:"required"`
	Target EvaluationVersionResultListResponseTargetsTarget  `json:"target" api:"required"`
	JSON   evaluationVersionResultListResponseTargetJSON     `json:"-"`
}

func (*EvaluationVersionResultListResponseTarget) UnmarshalJSON

func (r *EvaluationVersionResultListResponseTarget) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionResultListResponseTargetsScore

type EvaluationVersionResultListResponseTargetsScore struct {
	CommitID        int64                                                     `json:"commit_id"         api:"required"`
	ScoreID         string                                                    `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                                    `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                                    `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                               `json:"value"             api:"required"`
	ValueType       EvaluationVersionResultListResponseTargetsScoresValueType `json:"value_type"        api:"required"`
	JSON            evaluationVersionResultListResponseTargetsScoreJSON       `json:"-"`
}

func (*EvaluationVersionResultListResponseTargetsScore) UnmarshalJSON

func (r *EvaluationVersionResultListResponseTargetsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionResultListResponseTargetsScoresValueType

type EvaluationVersionResultListResponseTargetsScoresValueType string
const (
	EvaluationVersionResultListResponseTargetsScoresValueTypeNull    EvaluationVersionResultListResponseTargetsScoresValueType = "null"
	EvaluationVersionResultListResponseTargetsScoresValueTypeBoolean EvaluationVersionResultListResponseTargetsScoresValueType = "boolean"
	EvaluationVersionResultListResponseTargetsScoresValueTypeInteger EvaluationVersionResultListResponseTargetsScoresValueType = "integer"
	EvaluationVersionResultListResponseTargetsScoresValueTypeNumber  EvaluationVersionResultListResponseTargetsScoresValueType = "number"
	EvaluationVersionResultListResponseTargetsScoresValueTypeString  EvaluationVersionResultListResponseTargetsScoresValueType = "string"
	EvaluationVersionResultListResponseTargetsScoresValueTypeJson    EvaluationVersionResultListResponseTargetsScoresValueType = "json"
)

func (EvaluationVersionResultListResponseTargetsScoresValueType) IsKnown

type EvaluationVersionResultListResponseTargetsTarget

type EvaluationVersionResultListResponseTargetsTarget struct {
	// ID of the published case, comparison, or trajectory selected by kind.
	ID string `json:"id" api:"required" format:"uuid"`
	// Kind of resource being scored.
	Kind EvaluationVersionResultListResponseTargetsTargetKind `json:"kind" api:"required"`
	JSON evaluationVersionResultListResponseTargetsTargetJSON `json:"-"`
}

func (*EvaluationVersionResultListResponseTargetsTarget) UnmarshalJSON

func (r *EvaluationVersionResultListResponseTargetsTarget) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionResultListResponseTargetsTargetKind

type EvaluationVersionResultListResponseTargetsTargetKind string

Kind of resource being scored.

const (
	EvaluationVersionResultListResponseTargetsTargetKindCase       EvaluationVersionResultListResponseTargetsTargetKind = "case"
	EvaluationVersionResultListResponseTargetsTargetKindComparison EvaluationVersionResultListResponseTargetsTargetKind = "comparison"
	EvaluationVersionResultListResponseTargetsTargetKindTrajectory EvaluationVersionResultListResponseTargetsTargetKind = "trajectory"
)

func (EvaluationVersionResultListResponseTargetsTargetKind) IsKnown

type EvaluationVersionResultService

type EvaluationVersionResultService struct {
	Options []option.RequestOption
}

EvaluationVersionResultService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionResultService method instead.

func NewEvaluationVersionResultService

func NewEvaluationVersionResultService(opts ...option.RequestOption) (r *EvaluationVersionResultService)

NewEvaluationVersionResultService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationVersionResultService) List

Returns the frozen version's targets and their scores in dataset position order. Cases added after the dataset snapshot never appear.

**Scores**

  • Each target includes the latest score visible at the version's frozen commit for each selected scorer version.
  • Scores follow the snapshot's scorer order. A target with no scores has an empty `scores` array.
  • `published_commit_id` identifies the frozen publication cutoff.

**Pagination**

The cursor tracks target position. The version fixes score visibility, so later pages use the same snapshot. The last page has no `next_cursor`.

**Trajectory targets:** The response is an empty page until the trajectory resource is implemented.

type EvaluationVersionRowCompareListParams

type EvaluationVersionRowCompareListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated EvaluationVersion IDs to compare with the reference, in result
	// order.
	CompareTo param.Field[[]string] `query:"compare_to" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvaluationVersionRowCompareListParams) URLQuery

URLQuery serializes EvaluationVersionRowCompareListParams's query parameters as `url.Values`.

type EvaluationVersionRowCompareListResponse

type EvaluationVersionRowCompareListResponse struct {
	Rows []EvaluationVersionRowCompareListResponseRow `json:"rows" api:"required"`
	// Matched rows across every page.
	TotalRows  int64                                       `json:"total_rows"  api:"required"`
	NextCursor string                                      `json:"next_cursor"`
	JSON       evaluationVersionRowCompareListResponseJSON `json:"-"`
}

func (*EvaluationVersionRowCompareListResponse) UnmarshalJSON

func (r *EvaluationVersionRowCompareListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowCompareListResponseRow

type EvaluationVersionRowCompareListResponseRow struct {
	// Identifies the matched row within this comparison: the hash of its example key
	// in hex, a colon, and its occurrence within each version, counted from 0. A row
	// written before the service hashed example keys has its Case ID, a colon, and its
	// version's index in evaluations instead.
	ID string `json:"id" api:"required"`
	// One entry per compared version, reference first.
	Evaluations []EvaluationVersionRowCompareListResponseRowsEvaluation `json:"evaluations" api:"required"`
	// The input of the first version with the row. Rows matched by a client example
	// key can differ in input.
	Input interface{}                                    `json:"input" api:"required"`
	JSON  evaluationVersionRowCompareListResponseRowJSON `json:"-"`
}

func (*EvaluationVersionRowCompareListResponseRow) UnmarshalJSON

func (r *EvaluationVersionRowCompareListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowCompareListResponseRowsEvaluation

type EvaluationVersionRowCompareListResponseRowsEvaluation struct {
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Absent when this version has no row with the example key.
	Row  EvaluationVersionRowCompareListResponseRowsEvaluationsRow `json:"row"`
	JSON evaluationVersionRowCompareListResponseRowsEvaluationJSON `json:"-"`
}

func (*EvaluationVersionRowCompareListResponseRowsEvaluation) UnmarshalJSON

func (r *EvaluationVersionRowCompareListResponseRowsEvaluation) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowCompareListResponseRowsEvaluationsRow

type EvaluationVersionRowCompareListResponseRowsEvaluationsRow struct {
	Attributes map[string]interface{}                                           `json:"attributes"  api:"required"`
	CaseID     string                                                           `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                                           `json:"example_key" api:"required,nullable"`
	Output     interface{}                                                      `json:"output"      api:"required"`
	Scores     []EvaluationVersionRowCompareListResponseRowsEvaluationsRowScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                                      `json:"tags"    api:"required"`
	Variant string                                                        `json:"variant" api:"required,nullable"`
	JSON    evaluationVersionRowCompareListResponseRowsEvaluationsRowJSON `json:"-"`
}

Absent when this version has no row with the example key.

func (*EvaluationVersionRowCompareListResponseRowsEvaluationsRow) UnmarshalJSON

type EvaluationVersionRowCompareListResponseRowsEvaluationsRowScore

type EvaluationVersionRowCompareListResponseRowsEvaluationsRowScore struct {
	ScoreID         string                                                             `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                                             `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                                             `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                                        `json:"value"             api:"required"`
	JSON            evaluationVersionRowCompareListResponseRowsEvaluationsRowScoreJSON `json:"-"`
}

func (*EvaluationVersionRowCompareListResponseRowsEvaluationsRowScore) UnmarshalJSON

type EvaluationVersionRowCompareSearchParams

type EvaluationVersionRowCompareSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// EvaluationVersion IDs to compare with the reference, in result order.
	CompareTo param.Field[[]string] `json:"compare_to" api:"required" format:"uuid"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvaluationVersionRowCompareSearchParams) MarshalJSON

func (r EvaluationVersionRowCompareSearchParams) MarshalJSON() (data []byte, err error)

type EvaluationVersionRowCompareSearchResponse

type EvaluationVersionRowCompareSearchResponse struct {
	Rows []EvaluationVersionRowCompareSearchResponseRow `json:"rows" api:"required"`
	// Matched rows across every page.
	TotalRows  int64                                         `json:"total_rows"  api:"required"`
	NextCursor string                                        `json:"next_cursor"`
	JSON       evaluationVersionRowCompareSearchResponseJSON `json:"-"`
}

func (*EvaluationVersionRowCompareSearchResponse) UnmarshalJSON

func (r *EvaluationVersionRowCompareSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowCompareSearchResponseRow

type EvaluationVersionRowCompareSearchResponseRow struct {
	// Identifies the matched row within this comparison: the hash of its example key
	// in hex, a colon, and its occurrence within each version, counted from 0. A row
	// written before the service hashed example keys has its Case ID, a colon, and its
	// version's index in evaluations instead.
	ID string `json:"id" api:"required"`
	// One entry per compared version, reference first.
	Evaluations []EvaluationVersionRowCompareSearchResponseRowsEvaluation `json:"evaluations" api:"required"`
	// The input of the first version with the row. Rows matched by a client example
	// key can differ in input.
	Input interface{}                                      `json:"input" api:"required"`
	JSON  evaluationVersionRowCompareSearchResponseRowJSON `json:"-"`
}

func (*EvaluationVersionRowCompareSearchResponseRow) UnmarshalJSON

func (r *EvaluationVersionRowCompareSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowCompareSearchResponseRowsEvaluation

type EvaluationVersionRowCompareSearchResponseRowsEvaluation struct {
	EvaluationVersionID string `json:"evaluation_version_id" api:"required" format:"uuid"`
	// Absent when this version has no row with the example key.
	Row  EvaluationVersionRowCompareSearchResponseRowsEvaluationsRow `json:"row"`
	JSON evaluationVersionRowCompareSearchResponseRowsEvaluationJSON `json:"-"`
}

func (*EvaluationVersionRowCompareSearchResponseRowsEvaluation) UnmarshalJSON

type EvaluationVersionRowCompareSearchResponseRowsEvaluationsRow

type EvaluationVersionRowCompareSearchResponseRowsEvaluationsRow struct {
	Attributes map[string]interface{}                                             `json:"attributes"  api:"required"`
	CaseID     string                                                             `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                                             `json:"example_key" api:"required,nullable"`
	Output     interface{}                                                        `json:"output"      api:"required"`
	Scores     []EvaluationVersionRowCompareSearchResponseRowsEvaluationsRowScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                                        `json:"tags"    api:"required"`
	Variant string                                                          `json:"variant" api:"required,nullable"`
	JSON    evaluationVersionRowCompareSearchResponseRowsEvaluationsRowJSON `json:"-"`
}

Absent when this version has no row with the example key.

func (*EvaluationVersionRowCompareSearchResponseRowsEvaluationsRow) UnmarshalJSON

type EvaluationVersionRowCompareSearchResponseRowsEvaluationsRowScore

type EvaluationVersionRowCompareSearchResponseRowsEvaluationsRowScore struct {
	ScoreID         string                                                               `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                                               `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                                               `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                                          `json:"value"             api:"required"`
	JSON            evaluationVersionRowCompareSearchResponseRowsEvaluationsRowScoreJSON `json:"-"`
}

func (*EvaluationVersionRowCompareSearchResponseRowsEvaluationsRowScore) UnmarshalJSON

type EvaluationVersionRowCompareService

type EvaluationVersionRowCompareService struct {
	Options []option.RequestOption
}

EvaluationVersionRowCompareService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionRowCompareService method instead.

func NewEvaluationVersionRowCompareService

func NewEvaluationVersionRowCompareService(opts ...option.RequestOption) (r *EvaluationVersionRowCompareService)

NewEvaluationVersionRowCompareService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationVersionRowCompareService) List

Matches the reference version's rows with each compared version's rows by example key, and pages through the union. A case logged without an example key but with an input matches by the key derived from that input when it was appended as an eval table row or written with `example_key_fields`. Any other case without an example key matches only itself, in versions that read its dataset. The k-th copy of an example key in one version matches the k-th copy in another. Each version reads its cases and selected scores at its own cutoff. A row written before the service hashed example keys matches no other row.

`filter` uses the rows operations' columns, without a version qualifier. Each version's row is tested on its own, and a row is kept, with every version's values, when any version's row passes. A version without a filter column reads as null in it.

`order_by` names one column of one compared version, as in `v."<evaluation_version_id>".s.accuracy desc` or `v."<evaluation_version_id>".example_key`. Rows without that version sort last. Without `order_by`, rows follow the reference's order, then each later version's rows that earlier versions lack. Filtering and ordering apply before pagination, and every page reports the total.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/rows/compare/search` operation.

func (*EvaluationVersionRowCompareService) Search

Returns the same comparison as compare-evaluation-version-rows, with the parameters supplied in a JSON body. Use this operation when the parameters are too large for a URL.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationVersionRowListParams

type EvaluationVersionRowListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `query:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `query:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `query:"order_by"`
}

func (EvaluationVersionRowListParams) URLQuery

func (r EvaluationVersionRowListParams) URLQuery() (v url.Values)

URLQuery serializes EvaluationVersionRowListParams's query parameters as `url.Values`.

type EvaluationVersionRowListResponse

type EvaluationVersionRowListResponse struct {
	Rows       []EvaluationVersionRowListResponseRow `json:"rows"        api:"required"`
	NextCursor string                                `json:"next_cursor"`
	JSON       evaluationVersionRowListResponseJSON  `json:"-"`
}

func (*EvaluationVersionRowListResponse) UnmarshalJSON

func (r *EvaluationVersionRowListResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowListResponseRow

type EvaluationVersionRowListResponseRow struct {
	Attributes map[string]interface{}                      `json:"attributes"  api:"required"`
	CaseID     string                                      `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                      `json:"example_key" api:"required,nullable"`
	Input      interface{}                                 `json:"input"       api:"required"`
	Output     interface{}                                 `json:"output"      api:"required"`
	Scores     []EvaluationVersionRowListResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                `json:"tags"    api:"required"`
	Variant string                                  `json:"variant" api:"required,nullable"`
	JSON    evaluationVersionRowListResponseRowJSON `json:"-"`
}

func (*EvaluationVersionRowListResponseRow) UnmarshalJSON

func (r *EvaluationVersionRowListResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowListResponseRowsScore

type EvaluationVersionRowListResponseRowsScore struct {
	ScoreID         string                                        `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                        `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                        `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                   `json:"value"             api:"required"`
	JSON            evaluationVersionRowListResponseRowsScoreJSON `json:"-"`
}

func (*EvaluationVersionRowListResponseRowsScore) UnmarshalJSON

func (r *EvaluationVersionRowListResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowSearchParams

type EvaluationVersionRowSearchParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Comma-separated i.<name>, o.<name>, or s.<name> selectors with
	// input/output/score aliases and JSON-quoted names, such as i."two words". Omit,
	// leave blank, or use _ for all dynamic columns. Use none for zero. Unknown names,
	// duplicate selectors after alias normalization, and lists combining selectors
	// with _ or none are rejected.
	Columns param.Field[string] `json:"columns"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `json:"cursor"`
	// Selects rows using column comparisons joined with AND, OR, and NOT. Parentheses
	// group expressions. NOT and - bind tighter than AND and OR, and mixing AND and OR
	// at one level needs parentheses. Parentheses nest at most 32 deep.
	//
	// For string comparisons with = or !=, use these patterns:
	//
	//   - matches zero or more characters
	//
	// - matches a literal asterisk \\ matches a literal backslash
	//
	// When rows are cases, the predicate tags:"<name>" matches a case that has that
	// tag.
	//
	// A filter can contain at most 100 predicates and 65,536 bytes of normalized JSON
	// literals in total.
	//
	// Example:
	//
	//	variant = "model-a" AND i.split = "test"
	Filter param.Field[string] `json:"filter"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `json:"limit"`
	// Column to sort by, optionally followed by desc for descending order. Without
	// desc, sorting is ascending. Rows cannot be sorted by tags. Omit to use the
	// operation's standard order.
	OrderBy param.Field[string] `json:"order_by"`
}

func (EvaluationVersionRowSearchParams) MarshalJSON

func (r EvaluationVersionRowSearchParams) MarshalJSON() (data []byte, err error)

type EvaluationVersionRowSearchResponse

type EvaluationVersionRowSearchResponse struct {
	Rows       []EvaluationVersionRowSearchResponseRow `json:"rows"        api:"required"`
	NextCursor string                                  `json:"next_cursor"`
	JSON       evaluationVersionRowSearchResponseJSON  `json:"-"`
}

func (*EvaluationVersionRowSearchResponse) UnmarshalJSON

func (r *EvaluationVersionRowSearchResponse) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowSearchResponseRow

type EvaluationVersionRowSearchResponseRow struct {
	Attributes map[string]interface{}                        `json:"attributes"  api:"required"`
	CaseID     string                                        `json:"case_id"     api:"required"          format:"uuid"`
	ExampleKey string                                        `json:"example_key" api:"required,nullable"`
	Input      interface{}                                   `json:"input"       api:"required"`
	Output     interface{}                                   `json:"output"      api:"required"`
	Scores     []EvaluationVersionRowSearchResponseRowsScore `json:"scores"      api:"required"`
	// Tag names on this case, sorted.
	Tags    []string                                  `json:"tags"    api:"required"`
	Variant string                                    `json:"variant" api:"required,nullable"`
	JSON    evaluationVersionRowSearchResponseRowJSON `json:"-"`
}

func (*EvaluationVersionRowSearchResponseRow) UnmarshalJSON

func (r *EvaluationVersionRowSearchResponseRow) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowSearchResponseRowsScore

type EvaluationVersionRowSearchResponseRowsScore struct {
	ScoreID         string                                          `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                                          `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                                          `json:"scorer_version_id" api:"required" format:"uuid"`
	Value           interface{}                                     `json:"value"             api:"required"`
	JSON            evaluationVersionRowSearchResponseRowsScoreJSON `json:"-"`
}

func (*EvaluationVersionRowSearchResponseRowsScore) UnmarshalJSON

func (r *EvaluationVersionRowSearchResponseRowsScore) UnmarshalJSON(data []byte) (err error)

type EvaluationVersionRowService

type EvaluationVersionRowService struct {
	Options []option.RequestOption
	Compare *EvaluationVersionRowCompareService
}

EvaluationVersionRowService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionRowService method instead.

func NewEvaluationVersionRowService

func NewEvaluationVersionRowService(opts ...option.RequestOption) (r *EvaluationVersionRowService)

NewEvaluationVersionRowService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationVersionRowService) List

Returns cases and their selected scores from the frozen evaluation version. Filtering and sorting happen before pagination.

Use these column names in `filter` and `order_by`:

  • `variant` or `example_key` for the row's model/checkpoint label or external example reference.
  • `i.<name>` for an input field.
  • `o.<name>` for an output field.
  • `s.<name>` for a score column.

`input`, `output`, and `score` are also accepted as the longer forms of `i`, `o`, and `s`. Quote field names that are not identifiers and escape them as JSON strings.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

The encoded request target (path and query string) must be at most 8000 bytes. Larger requests return 414 URI Too Long with error code `request_uri_too_long`. Retry the same parameters through the corresponding POST `/rows/search` operation.

func (*EvaluationVersionRowService) Search

Returns the same frozen rows as the GET rows operation, with the filter, sort order, and pagination parameters supplied in a JSON body.

Filtering and sorting happen before pagination. This operation does not create a saved query.

Column selection changes the response shape without changing which rows match or their order. Selected names resolve against the queried DatasetVersion and ScorerVersions, including JSON-valued columns. Fixed row fields and complete attributes remain present. Exact selections return empty input/output objects for unselected categories and non-object values, and an empty scores array when no Scores are selected. Missing fields and Scores are omitted. Explicit nulls remain present. Filters and sorting can use hidden columns. Cursors bind row membership and ordering independently of column selection, so callers can change columns while reading the same page or continuing a traversal.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type EvaluationVersionService

type EvaluationVersionService struct {
	Options []option.RequestOption
	Metrics *EvaluationVersionMetricService
	Results *EvaluationVersionResultService
	Queries *EvaluationVersionQueryService
	Rows    *EvaluationVersionRowService
}

EvaluationVersionService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewEvaluationVersionService method instead.

func NewEvaluationVersionService

func NewEvaluationVersionService(opts ...option.RequestOption) (r *EvaluationVersionService)

NewEvaluationVersionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*EvaluationVersionService) Get

Returns the frozen evaluation snapshot exactly as created, including its dataset version, selected scorer versions, and publication cutoff.

func (*EvaluationVersionService) List

Returns published evaluation versions in publication order, with the same fields as the get-version operation. An evaluation that does not exist or is outside the requested scope returns 404.

func (*EvaluationVersionService) New

Creates an immutable snapshot of one dataset version and the evaluation's currently registered scorer versions. The snapshot also records a publication cutoff for scores and reported metrics.

Later writes do not change the frozen results.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type ScoreGetParams

type ScoreGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type ScoreGetResponse

type ScoreGetResponse struct {
	Attributes map[string]interface{} `json:"attributes" api:"required"`
	CommitID   int64                  `json:"commit_id"  api:"required"`
	// Namespace that assigned the scope reference.
	Namespace       ScoreGetResponseNamespace `json:"namespace"         api:"required"`
	ScopeRef        string                    `json:"scope_ref"         api:"required"`
	ScoreID         string                    `json:"score_id"          api:"required" format:"uuid"`
	ScorerID        string                    `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID string                    `json:"scorer_version_id" api:"required" format:"uuid"`
	Target          ScoreGetResponseTarget    `json:"target"            api:"required"`
	Value           interface{}               `json:"value"             api:"required"`
	ValueType       ScoreGetResponseValueType `json:"value_type"        api:"required"`
	JSON            scoreGetResponseJSON      `json:"-"`
}

func (*ScoreGetResponse) UnmarshalJSON

func (r *ScoreGetResponse) UnmarshalJSON(data []byte) (err error)

type ScoreGetResponseNamespace

type ScoreGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	ScoreGetResponseNamespaceWandb ScoreGetResponseNamespace = "wandb"
)

func (ScoreGetResponseNamespace) IsKnown

func (r ScoreGetResponseNamespace) IsKnown() bool

type ScoreGetResponseTarget

type ScoreGetResponseTarget struct {
	// ID of the published case, comparison, or trajectory selected by kind.
	ID string `json:"id" api:"required" format:"uuid"`
	// Kind of resource being scored.
	Kind ScoreGetResponseTargetKind `json:"kind" api:"required"`
	JSON scoreGetResponseTargetJSON `json:"-"`
}

func (*ScoreGetResponseTarget) UnmarshalJSON

func (r *ScoreGetResponseTarget) UnmarshalJSON(data []byte) (err error)

type ScoreGetResponseTargetKind

type ScoreGetResponseTargetKind string

Kind of resource being scored.

const (
	ScoreGetResponseTargetKindCase       ScoreGetResponseTargetKind = "case"
	ScoreGetResponseTargetKindComparison ScoreGetResponseTargetKind = "comparison"
	ScoreGetResponseTargetKindTrajectory ScoreGetResponseTargetKind = "trajectory"
)

func (ScoreGetResponseTargetKind) IsKnown

func (r ScoreGetResponseTargetKind) IsKnown() bool

type ScoreGetResponseValueType

type ScoreGetResponseValueType string
const (
	ScoreGetResponseValueTypeNull    ScoreGetResponseValueType = "null"
	ScoreGetResponseValueTypeBoolean ScoreGetResponseValueType = "boolean"
	ScoreGetResponseValueTypeInteger ScoreGetResponseValueType = "integer"
	ScoreGetResponseValueTypeNumber  ScoreGetResponseValueType = "number"
	ScoreGetResponseValueTypeString  ScoreGetResponseValueType = "string"
	ScoreGetResponseValueTypeJson    ScoreGetResponseValueType = "json"
)

func (ScoreGetResponseValueType) IsKnown

func (r ScoreGetResponseValueType) IsKnown() bool

type ScoreNewParams

type ScoreNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string]                `path:"scope_id" api:"required"`
	Scores  param.Field[[]ScoreNewParamsScore] `                api:"required" json:"scores"`
}

func (ScoreNewParams) MarshalJSON

func (r ScoreNewParams) MarshalJSON() (data []byte, err error)

type ScoreNewParamsScore

type ScoreNewParamsScore struct {
	ScorerID        param.Field[string]                     `json:"scorer_id"         api:"required" format:"uuid"`
	ScorerVersionID param.Field[string]                     `json:"scorer_version_id" api:"required" format:"uuid"`
	Target          param.Field[ScoreNewParamsScoresTarget] `json:"target"            api:"required"`
	// Score calculated by your application. Its JSON type must match the referenced
	// scorer version's value_type.
	Value      param.Field[interface{}]            `json:"value"      api:"required"`
	Attributes param.Field[map[string]interface{}] `json:"attributes"`
}

func (ScoreNewParamsScore) MarshalJSON

func (r ScoreNewParamsScore) MarshalJSON() (data []byte, err error)

type ScoreNewParamsScoresTarget

type ScoreNewParamsScoresTarget struct {
	// ID of the published case, comparison, or trajectory selected by kind.
	ID param.Field[string] `json:"id" api:"required" format:"uuid"`
	// Kind of resource being scored.
	Kind param.Field[ScoreNewParamsScoresTargetKind] `json:"kind" api:"required"`
}

func (ScoreNewParamsScoresTarget) MarshalJSON

func (r ScoreNewParamsScoresTarget) MarshalJSON() (data []byte, err error)

type ScoreNewParamsScoresTargetKind

type ScoreNewParamsScoresTargetKind string

Kind of resource being scored.

const (
	ScoreNewParamsScoresTargetKindCase       ScoreNewParamsScoresTargetKind = "case"
	ScoreNewParamsScoresTargetKindComparison ScoreNewParamsScoresTargetKind = "comparison"
	ScoreNewParamsScoresTargetKindTrajectory ScoreNewParamsScoresTargetKind = "trajectory"
)

func (ScoreNewParamsScoresTargetKind) IsKnown

type ScoreNewResponse

type ScoreNewResponse struct {
	CommitID           int64                `json:"commit_id"            api:"required"`
	PublishOperationID string               `json:"publish_operation_id" api:"required" format:"uuid"`
	ScoreIDs           []string             `json:"score_ids"            api:"required" format:"uuid"`
	JSON               scoreNewResponseJSON `json:"-"`
}

func (*ScoreNewResponse) UnmarshalJSON

func (r *ScoreNewResponse) UnmarshalJSON(data []byte) (err error)

type ScoreService

type ScoreService struct {
	Options []option.RequestOption
}

ScoreService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewScoreService method instead.

func NewScoreService

func NewScoreService(opts ...option.RequestOption) (r *ScoreService)

NewScoreService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ScoreService) Get

func (r *ScoreService) Get(
	ctx context.Context,
	scoreID string,
	query ScoreGetParams,
	opts ...option.RequestOption,
) (res *ScoreGetResponse, err error)

Returns one score published in the requested scope. `value` contains the stored value as JSON. `value_type` distinguishes an integer score from a number score.

func (*ScoreService) New

func (r *ScoreService) New(
	ctx context.Context,
	params ScoreNewParams,
	opts ...option.RequestOption,
) (res *ScoreNewResponse, err error)

Stores score values that your application has calculated for existing targets.

  • Each value must match the referenced scorer version's `value_type`.
  • Each target must already be published and have a kind allowed by that scorer version.
  • The response includes `publish_operation_id`, `commit_id`, and `score_ids`. Score IDs follow request order.

Request bodies must be at most 16 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type ScorerDeleteParams

type ScorerDeleteParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type ScorerGetParams

type ScorerGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type ScorerGetResponse

type ScorerGetResponse struct {
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Namespace that assigned the scope reference.
	Namespace ScorerGetResponseNamespace `json:"namespace" api:"required"`
	ScopeRef  string                     `json:"scope_ref" api:"required"`
	ScorerID  string                     `json:"scorer_id" api:"required" format:"uuid"`
	JSON      scorerGetResponseJSON      `json:"-"`
}

func (*ScorerGetResponse) UnmarshalJSON

func (r *ScorerGetResponse) UnmarshalJSON(data []byte) (err error)

type ScorerGetResponseNamespace

type ScorerGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	ScorerGetResponseNamespaceWandb ScorerGetResponseNamespace = "wandb"
)

func (ScorerGetResponseNamespace) IsKnown

func (r ScorerGetResponseNamespace) IsKnown() bool

type ScorerListParams

type ScorerListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (ScorerListParams) URLQuery

func (r ScorerListParams) URLQuery() (v url.Values)

URLQuery serializes ScorerListParams's query parameters as `url.Values`.

type ScorerListResponse

type ScorerListResponse struct {
	Results    []ScorerListResponseResult `json:"results"     api:"required"`
	NextCursor string                     `json:"next_cursor"`
	JSON       scorerListResponseJSON     `json:"-"`
}

func (*ScorerListResponse) UnmarshalJSON

func (r *ScorerListResponse) UnmarshalJSON(data []byte) (err error)

type ScorerListResponseResult

type ScorerListResponseResult struct {
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Namespace that assigned the scope reference.
	Namespace ScorerListResponseResultsNamespace `json:"namespace" api:"required"`
	ScopeRef  string                             `json:"scope_ref" api:"required"`
	ScorerID  string                             `json:"scorer_id" api:"required" format:"uuid"`
	JSON      scorerListResponseResultJSON       `json:"-"`
}

func (*ScorerListResponseResult) UnmarshalJSON

func (r *ScorerListResponseResult) UnmarshalJSON(data []byte) (err error)

type ScorerListResponseResultsNamespace

type ScorerListResponseResultsNamespace string

Namespace that assigned the scope reference.

const (
	ScorerListResponseResultsNamespaceWandb ScorerListResponseResultsNamespace = "wandb"
)

func (ScorerListResponseResultsNamespace) IsKnown

type ScorerNewParams

type ScorerNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Kinds of resource this scorer version can score: individual cases, comparisons,
	// or trajectories.
	AllowedTargetKinds param.Field[[]ScorerNewParamsAllowedTargetKind] `json:"allowed_target_kinds" api:"required"`
	// Name of this scoring specification, such as accuracy or relevance. Leading and
	// trailing whitespace are not allowed.
	Name param.Field[string] `json:"name" api:"required"`
	// JSON type that every score recorded with this scorer version must use.
	ValueType param.Field[ScorerNewParamsValueType] `json:"value_type" api:"required"`
	// Human-readable explanation of what this scorer version measures.
	Description param.Field[string] `json:"description"`
	// Whether higher scores are better. Only boolean, integer, and number scorers
	// accept it. For a boolean scorer, true counts as higher than false.
	HigherIsBetter param.Field[bool] `json:"higher_is_better"`
}

func (ScorerNewParams) MarshalJSON

func (r ScorerNewParams) MarshalJSON() (data []byte, err error)

type ScorerNewParamsAllowedTargetKind

type ScorerNewParamsAllowedTargetKind string
const (
	ScorerNewParamsAllowedTargetKindCase       ScorerNewParamsAllowedTargetKind = "case"
	ScorerNewParamsAllowedTargetKindComparison ScorerNewParamsAllowedTargetKind = "comparison"
	ScorerNewParamsAllowedTargetKindTrajectory ScorerNewParamsAllowedTargetKind = "trajectory"
)

func (ScorerNewParamsAllowedTargetKind) IsKnown

type ScorerNewParamsValueType

type ScorerNewParamsValueType string

JSON type that every score recorded with this scorer version must use.

const (
	ScorerNewParamsValueTypeNull    ScorerNewParamsValueType = "null"
	ScorerNewParamsValueTypeBoolean ScorerNewParamsValueType = "boolean"
	ScorerNewParamsValueTypeInteger ScorerNewParamsValueType = "integer"
	ScorerNewParamsValueTypeNumber  ScorerNewParamsValueType = "number"
	ScorerNewParamsValueTypeString  ScorerNewParamsValueType = "string"
	ScorerNewParamsValueTypeJson    ScorerNewParamsValueType = "json"
)

func (ScorerNewParamsValueType) IsKnown

func (r ScorerNewParamsValueType) IsKnown() bool

type ScorerNewResponse

type ScorerNewResponse struct {
	AllowedTargetKinds []ScorerNewResponseAllowedTargetKind `json:"allowed_target_kinds" api:"required"`
	Description        string                               `json:"description"          api:"required,nullable"`
	// Whether higher scores are better. Null when the scorer version does not set it,
	// so its scores have no direction.
	HigherIsBetter bool   `json:"higher_is_better" api:"required,nullable"`
	Name           string `json:"name"             api:"required"`
	// Namespace that assigned the scope reference.
	Namespace ScorerNewResponseNamespace `json:"namespace"  api:"required"`
	ScopeRef  string                     `json:"scope_ref"  api:"required"`
	ScorerID  string                     `json:"scorer_id"  api:"required" format:"uuid"`
	ValueType ScorerNewResponseValueType `json:"value_type" api:"required"`
	VersionID string                     `json:"version_id" api:"required" format:"uuid"`
	JSON      scorerNewResponseJSON      `json:"-"`
}

func (*ScorerNewResponse) UnmarshalJSON

func (r *ScorerNewResponse) UnmarshalJSON(data []byte) (err error)

type ScorerNewResponseAllowedTargetKind

type ScorerNewResponseAllowedTargetKind string
const (
	ScorerNewResponseAllowedTargetKindCase       ScorerNewResponseAllowedTargetKind = "case"
	ScorerNewResponseAllowedTargetKindComparison ScorerNewResponseAllowedTargetKind = "comparison"
	ScorerNewResponseAllowedTargetKindTrajectory ScorerNewResponseAllowedTargetKind = "trajectory"
)

func (ScorerNewResponseAllowedTargetKind) IsKnown

type ScorerNewResponseNamespace

type ScorerNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	ScorerNewResponseNamespaceWandb ScorerNewResponseNamespace = "wandb"
)

func (ScorerNewResponseNamespace) IsKnown

func (r ScorerNewResponseNamespace) IsKnown() bool

type ScorerNewResponseValueType

type ScorerNewResponseValueType string
const (
	ScorerNewResponseValueTypeNull    ScorerNewResponseValueType = "null"
	ScorerNewResponseValueTypeBoolean ScorerNewResponseValueType = "boolean"
	ScorerNewResponseValueTypeInteger ScorerNewResponseValueType = "integer"
	ScorerNewResponseValueTypeNumber  ScorerNewResponseValueType = "number"
	ScorerNewResponseValueTypeString  ScorerNewResponseValueType = "string"
	ScorerNewResponseValueTypeJson    ScorerNewResponseValueType = "json"
)

func (ScorerNewResponseValueType) IsKnown

func (r ScorerNewResponseValueType) IsKnown() bool

type ScorerService

type ScorerService struct {
	Options  []option.RequestOption
	Versions *ScorerVersionService
}

ScorerService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewScorerService method instead.

func NewScorerService

func NewScorerService(opts ...option.RequestOption) (r *ScorerService)

NewScorerService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ScorerService) Delete

func (r *ScorerService) Delete(
	ctx context.Context,
	scorerID string,
	body ScorerDeleteParams,
	opts ...option.RequestOption,
) (err error)

Soft-deletes the Scorer. It and its ScorerVersions then return 404 and leave list-scorers, and new versions and Scores for it are rejected with 404. A Scorer that an Evaluation's unpublished head still selects returns 409 resource_in_use. Delete that Evaluation first. Published EvaluationVersions that selected it, and Scores already written, are unchanged. An absent or already deleted Scorer returns 404. A retry with the same Idempotency-Key replays the first response.

func (*ScorerService) Get

func (r *ScorerService) Get(
	ctx context.Context,
	scorerID string,
	query ScorerGetParams,
	opts ...option.RequestOption,
) (res *ScorerGetResponse, err error)

Returns the scorer's stable ID and creation time. To read its name, score type, and allowed targets, get a specific scorer version.

func (*ScorerService) List

func (r *ScorerService) List(
	ctx context.Context,
	params ScorerListParams,
	opts ...option.RequestOption,
) (res *ScorerListResponse, err error)

Returns one page of the scope's Scorers.

func (*ScorerService) New

func (r *ScorerService) New(
	ctx context.Context,
	params ScorerNewParams,
	opts ...option.RequestOption,
) (res *ScorerNewResponse, err error)

Creates a stable scorer identity and its first immutable version. The version defines the scorer name, score value type, and allowed target kinds.

This operation records the scorer's specification. Your application calculates score values and submits them through the scores API.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type ScorerVersionGetParams

type ScorerVersionGetParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type ScorerVersionGetResponse

type ScorerVersionGetResponse struct {
	AllowedTargetKinds []ScorerVersionGetResponseAllowedTargetKind `json:"allowed_target_kinds" api:"required"`
	Description        string                                      `json:"description"          api:"required,nullable"`
	// Whether higher scores are better. Null when the scorer version does not set it,
	// so its scores have no direction.
	HigherIsBetter bool   `json:"higher_is_better" api:"required,nullable"`
	Name           string `json:"name"             api:"required"`
	// Namespace that assigned the scope reference.
	Namespace ScorerVersionGetResponseNamespace `json:"namespace"  api:"required"`
	ScopeRef  string                            `json:"scope_ref"  api:"required"`
	ScorerID  string                            `json:"scorer_id"  api:"required" format:"uuid"`
	ValueType ScorerVersionGetResponseValueType `json:"value_type" api:"required"`
	VersionID string                            `json:"version_id" api:"required" format:"uuid"`
	JSON      scorerVersionGetResponseJSON      `json:"-"`
}

func (*ScorerVersionGetResponse) UnmarshalJSON

func (r *ScorerVersionGetResponse) UnmarshalJSON(data []byte) (err error)

type ScorerVersionGetResponseAllowedTargetKind

type ScorerVersionGetResponseAllowedTargetKind string
const (
	ScorerVersionGetResponseAllowedTargetKindCase       ScorerVersionGetResponseAllowedTargetKind = "case"
	ScorerVersionGetResponseAllowedTargetKindComparison ScorerVersionGetResponseAllowedTargetKind = "comparison"
	ScorerVersionGetResponseAllowedTargetKindTrajectory ScorerVersionGetResponseAllowedTargetKind = "trajectory"
)

func (ScorerVersionGetResponseAllowedTargetKind) IsKnown

type ScorerVersionGetResponseNamespace

type ScorerVersionGetResponseNamespace string

Namespace that assigned the scope reference.

const (
	ScorerVersionGetResponseNamespaceWandb ScorerVersionGetResponseNamespace = "wandb"
)

func (ScorerVersionGetResponseNamespace) IsKnown

type ScorerVersionGetResponseValueType

type ScorerVersionGetResponseValueType string
const (
	ScorerVersionGetResponseValueTypeNull    ScorerVersionGetResponseValueType = "null"
	ScorerVersionGetResponseValueTypeBoolean ScorerVersionGetResponseValueType = "boolean"
	ScorerVersionGetResponseValueTypeInteger ScorerVersionGetResponseValueType = "integer"
	ScorerVersionGetResponseValueTypeNumber  ScorerVersionGetResponseValueType = "number"
	ScorerVersionGetResponseValueTypeString  ScorerVersionGetResponseValueType = "string"
	ScorerVersionGetResponseValueTypeJson    ScorerVersionGetResponseValueType = "json"
)

func (ScorerVersionGetResponseValueType) IsKnown

type ScorerVersionListParams

type ScorerVersionListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// The previous response's next_cursor value. Omit for the first page.
	Cursor param.Field[string] `query:"cursor"`
	// Maximum number of results to return in one page.
	Limit param.Field[int64] `query:"limit"`
}

func (ScorerVersionListParams) URLQuery

func (r ScorerVersionListParams) URLQuery() (v url.Values)

URLQuery serializes ScorerVersionListParams's query parameters as `url.Values`.

type ScorerVersionListResponse

type ScorerVersionListResponse struct {
	Results    []ScorerVersionListResponseResult `json:"results"     api:"required"`
	NextCursor string                            `json:"next_cursor"`
	JSON       scorerVersionListResponseJSON     `json:"-"`
}

func (*ScorerVersionListResponse) UnmarshalJSON

func (r *ScorerVersionListResponse) UnmarshalJSON(data []byte) (err error)

type ScorerVersionListResponseResult

type ScorerVersionListResponseResult struct {
	AllowedTargetKinds []ScorerVersionListResponseResultsAllowedTargetKind `json:"allowed_target_kinds" api:"required"`
	Description        string                                              `json:"description"          api:"required,nullable"`
	// Whether higher scores are better. Null when the scorer version does not set it,
	// so its scores have no direction.
	HigherIsBetter bool   `json:"higher_is_better" api:"required,nullable"`
	Name           string `json:"name"             api:"required"`
	// Namespace that assigned the scope reference.
	Namespace ScorerVersionListResponseResultsNamespace `json:"namespace"  api:"required"`
	ScopeRef  string                                    `json:"scope_ref"  api:"required"`
	ScorerID  string                                    `json:"scorer_id"  api:"required" format:"uuid"`
	ValueType ScorerVersionListResponseResultsValueType `json:"value_type" api:"required"`
	VersionID string                                    `json:"version_id" api:"required" format:"uuid"`
	JSON      scorerVersionListResponseResultJSON       `json:"-"`
}

func (*ScorerVersionListResponseResult) UnmarshalJSON

func (r *ScorerVersionListResponseResult) UnmarshalJSON(data []byte) (err error)

type ScorerVersionListResponseResultsAllowedTargetKind

type ScorerVersionListResponseResultsAllowedTargetKind string
const (
	ScorerVersionListResponseResultsAllowedTargetKindCase       ScorerVersionListResponseResultsAllowedTargetKind = "case"
	ScorerVersionListResponseResultsAllowedTargetKindComparison ScorerVersionListResponseResultsAllowedTargetKind = "comparison"
	ScorerVersionListResponseResultsAllowedTargetKindTrajectory ScorerVersionListResponseResultsAllowedTargetKind = "trajectory"
)

func (ScorerVersionListResponseResultsAllowedTargetKind) IsKnown

type ScorerVersionListResponseResultsNamespace

type ScorerVersionListResponseResultsNamespace string

Namespace that assigned the scope reference.

const (
	ScorerVersionListResponseResultsNamespaceWandb ScorerVersionListResponseResultsNamespace = "wandb"
)

func (ScorerVersionListResponseResultsNamespace) IsKnown

type ScorerVersionListResponseResultsValueType

type ScorerVersionListResponseResultsValueType string
const (
	ScorerVersionListResponseResultsValueTypeNull    ScorerVersionListResponseResultsValueType = "null"
	ScorerVersionListResponseResultsValueTypeBoolean ScorerVersionListResponseResultsValueType = "boolean"
	ScorerVersionListResponseResultsValueTypeInteger ScorerVersionListResponseResultsValueType = "integer"
	ScorerVersionListResponseResultsValueTypeNumber  ScorerVersionListResponseResultsValueType = "number"
	ScorerVersionListResponseResultsValueTypeString  ScorerVersionListResponseResultsValueType = "string"
	ScorerVersionListResponseResultsValueTypeJson    ScorerVersionListResponseResultsValueType = "json"
)

func (ScorerVersionListResponseResultsValueType) IsKnown

type ScorerVersionNewParams

type ScorerVersionNewParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
	// Kinds of resource this scorer version can score: individual cases, comparisons,
	// or trajectories.
	AllowedTargetKinds param.Field[[]ScorerVersionNewParamsAllowedTargetKind] `json:"allowed_target_kinds" api:"required"`
	// Name of this scoring specification, such as accuracy or relevance. Leading and
	// trailing whitespace are not allowed.
	Name param.Field[string] `json:"name" api:"required"`
	// JSON type that every score recorded with this scorer version must use.
	ValueType param.Field[ScorerVersionNewParamsValueType] `json:"value_type" api:"required"`
	// Human-readable explanation of what this scorer version measures.
	Description param.Field[string] `json:"description"`
	// Whether higher scores are better. Only boolean, integer, and number scorers
	// accept it. For a boolean scorer, true counts as higher than false.
	HigherIsBetter param.Field[bool] `json:"higher_is_better"`
}

func (ScorerVersionNewParams) MarshalJSON

func (r ScorerVersionNewParams) MarshalJSON() (data []byte, err error)

type ScorerVersionNewParamsAllowedTargetKind

type ScorerVersionNewParamsAllowedTargetKind string
const (
	ScorerVersionNewParamsAllowedTargetKindCase       ScorerVersionNewParamsAllowedTargetKind = "case"
	ScorerVersionNewParamsAllowedTargetKindComparison ScorerVersionNewParamsAllowedTargetKind = "comparison"
	ScorerVersionNewParamsAllowedTargetKindTrajectory ScorerVersionNewParamsAllowedTargetKind = "trajectory"
)

func (ScorerVersionNewParamsAllowedTargetKind) IsKnown

type ScorerVersionNewParamsValueType

type ScorerVersionNewParamsValueType string

JSON type that every score recorded with this scorer version must use.

const (
	ScorerVersionNewParamsValueTypeNull    ScorerVersionNewParamsValueType = "null"
	ScorerVersionNewParamsValueTypeBoolean ScorerVersionNewParamsValueType = "boolean"
	ScorerVersionNewParamsValueTypeInteger ScorerVersionNewParamsValueType = "integer"
	ScorerVersionNewParamsValueTypeNumber  ScorerVersionNewParamsValueType = "number"
	ScorerVersionNewParamsValueTypeString  ScorerVersionNewParamsValueType = "string"
	ScorerVersionNewParamsValueTypeJson    ScorerVersionNewParamsValueType = "json"
)

func (ScorerVersionNewParamsValueType) IsKnown

type ScorerVersionNewResponse

type ScorerVersionNewResponse struct {
	AllowedTargetKinds []ScorerVersionNewResponseAllowedTargetKind `json:"allowed_target_kinds" api:"required"`
	Description        string                                      `json:"description"          api:"required,nullable"`
	// Whether higher scores are better. Null when the scorer version does not set it,
	// so its scores have no direction.
	HigherIsBetter bool   `json:"higher_is_better" api:"required,nullable"`
	Name           string `json:"name"             api:"required"`
	// Namespace that assigned the scope reference.
	Namespace ScorerVersionNewResponseNamespace `json:"namespace"  api:"required"`
	ScopeRef  string                            `json:"scope_ref"  api:"required"`
	ScorerID  string                            `json:"scorer_id"  api:"required" format:"uuid"`
	ValueType ScorerVersionNewResponseValueType `json:"value_type" api:"required"`
	VersionID string                            `json:"version_id" api:"required" format:"uuid"`
	JSON      scorerVersionNewResponseJSON      `json:"-"`
}

func (*ScorerVersionNewResponse) UnmarshalJSON

func (r *ScorerVersionNewResponse) UnmarshalJSON(data []byte) (err error)

type ScorerVersionNewResponseAllowedTargetKind

type ScorerVersionNewResponseAllowedTargetKind string
const (
	ScorerVersionNewResponseAllowedTargetKindCase       ScorerVersionNewResponseAllowedTargetKind = "case"
	ScorerVersionNewResponseAllowedTargetKindComparison ScorerVersionNewResponseAllowedTargetKind = "comparison"
	ScorerVersionNewResponseAllowedTargetKindTrajectory ScorerVersionNewResponseAllowedTargetKind = "trajectory"
)

func (ScorerVersionNewResponseAllowedTargetKind) IsKnown

type ScorerVersionNewResponseNamespace

type ScorerVersionNewResponseNamespace string

Namespace that assigned the scope reference.

const (
	ScorerVersionNewResponseNamespaceWandb ScorerVersionNewResponseNamespace = "wandb"
)

func (ScorerVersionNewResponseNamespace) IsKnown

type ScorerVersionNewResponseValueType

type ScorerVersionNewResponseValueType string
const (
	ScorerVersionNewResponseValueTypeNull    ScorerVersionNewResponseValueType = "null"
	ScorerVersionNewResponseValueTypeBoolean ScorerVersionNewResponseValueType = "boolean"
	ScorerVersionNewResponseValueTypeInteger ScorerVersionNewResponseValueType = "integer"
	ScorerVersionNewResponseValueTypeNumber  ScorerVersionNewResponseValueType = "number"
	ScorerVersionNewResponseValueTypeString  ScorerVersionNewResponseValueType = "string"
	ScorerVersionNewResponseValueTypeJson    ScorerVersionNewResponseValueType = "json"
)

func (ScorerVersionNewResponseValueType) IsKnown

type ScorerVersionService

type ScorerVersionService struct {
	Options []option.RequestOption
}

ScorerVersionService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewScorerVersionService method instead.

func NewScorerVersionService

func NewScorerVersionService(opts ...option.RequestOption) (r *ScorerVersionService)

NewScorerVersionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ScorerVersionService) Get

func (r *ScorerVersionService) Get(
	ctx context.Context,
	scorerID string,
	scorerVersionID string,
	query ScorerVersionGetParams,
	opts ...option.RequestOption,
) (res *ScorerVersionGetResponse, err error)

Returns one immutable scorer specification, including its name, score value type, and allowed target kinds.

func (*ScorerVersionService) List

Returns one page of a Scorer's immutable versions.

func (*ScorerVersionService) New

Creates an immutable specification under an existing scorer, with its own name, score value type, allowed target kinds, and optional description. Existing versions and their scores remain unchanged.

Request bodies must be at most 1 MiB. Bodies larger than the limit are rejected with 413 Request Entity Too Large.

type ServiceGetResponse

type ServiceGetResponse struct {
	Message string                 `json:"message" api:"required"`
	JSON    serviceGetResponseJSON `json:"-"`
}

func (*ServiceGetResponse) UnmarshalJSON

func (r *ServiceGetResponse) UnmarshalJSON(data []byte) (err error)

type ServiceService

type ServiceService struct {
	Options []option.RequestOption
}

ServiceService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewServiceService method instead.

func NewServiceService

func NewServiceService(opts ...option.RequestOption) (r *ServiceService)

NewServiceService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ServiceService) Get

func (r *ServiceService) Get(ctx context.Context, opts ...option.RequestOption) (res *ServiceGetResponse, err error)

Get

type TagListParams

type TagListParams struct {
	// Namespace that assigned the scope reference.
	//
	// Defaults to "wandb" if not set.
	Namespace param.Field[string] `path:"namespace" api:"required"`
	// Project reference assigned by the namespace. For wandb, use the internal W&B
	// project ID, not the project name or entity/project path.
	//
	// Percent-encode reserved characters so the reference occupies one URL path
	// segment. Only printable ASCII is accepted. References are compared exactly,
	// without parsing.
	//
	// Use [option.WithScopeID] on the client to set a global default for this field.
	ScopeID param.Field[string] `path:"scope_id" api:"required"`
}

type TagListResponse

type TagListResponse struct {
	Tags []TagListResponseTag `json:"tags" api:"required"`
	JSON tagListResponseJSON  `json:"-"`
}

func (*TagListResponse) UnmarshalJSON

func (r *TagListResponse) UnmarshalJSON(data []byte) (err error)

type TagListResponseTag

type TagListResponseTag struct {
	Name string                 `json:"name" api:"required"`
	JSON tagListResponseTagJSON `json:"-"`
}

func (*TagListResponseTag) UnmarshalJSON

func (r *TagListResponseTag) UnmarshalJSON(data []byte) (err error)

type TagService

type TagService struct {
	Options []option.RequestOption
}

TagService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTagService method instead.

func NewTagService

func NewTagService(opts ...option.RequestOption) (r *TagService)

NewTagService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TagService) List

func (r *TagService) List(
	ctx context.Context,
	query TagListParams,
	opts ...option.RequestOption,
) (res *TagListResponse, err error)

Returns every tag name in the scope, sorted by name.

type VerificationGetResponse

type VerificationGetResponse struct {
	Message string                      `json:"message" api:"required"`
	JSON    verificationGetResponseJSON `json:"-"`
}

func (*VerificationGetResponse) UnmarshalJSON

func (r *VerificationGetResponse) UnmarshalJSON(data []byte) (err error)

type VerificationService

type VerificationService struct {
	Options []option.RequestOption
}

VerificationService contains methods and other services that help with interacting with the CoreWeave Evaluations API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewVerificationService method instead.

func NewVerificationService

func NewVerificationService(opts ...option.RequestOption) (r *VerificationService)

NewVerificationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*VerificationService) Get

Get test

type WandbAudioV1ExtensionType

type WandbAudioV1ExtensionType string
const (
	WandbAudioV1ExtensionTypeWandbAudio WandbAudioV1ExtensionType = "wandb-audio"
)

func (WandbAudioV1ExtensionType) IsKnown

func (r WandbAudioV1ExtensionType) IsKnown() bool

type WandbAudioV1Param

type WandbAudioV1Param struct {
	ExtensionType param.Field[WandbAudioV1ExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[WandbAudioV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                    `json:"sha256"         api:"required"`
	Size          param.Field[int64]                     `json:"size"           api:"required"`
	// Row comparison across EvaluationVersions ignores this property.
	Uri         param.Field[string]                  `json:"uri"           api:"required"`
	WbMediaType param.Field[WandbAudioV1WbMediaType] `json:"wb_media_type" api:"required"`
	Caption     param.Field[string]                  `json:"caption"`
	ExtraFields map[string]interface{}               `json:"-,extras"`
}

A V1 W&B audio value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbAudioV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbAudioV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbAudioV1Param) MarshalJSON

func (r WandbAudioV1Param) MarshalJSON() (data []byte, err error)

type WandbAudioV1SchemaVersion

type WandbAudioV1SchemaVersion int64
const (
	WandbAudioV1SchemaVersion1 WandbAudioV1SchemaVersion = 1
)

func (WandbAudioV1SchemaVersion) IsKnown

func (r WandbAudioV1SchemaVersion) IsKnown() bool

type WandbAudioV1WbMediaType

type WandbAudioV1WbMediaType string
const (
	WandbAudioV1WbMediaTypeAudioFile WandbAudioV1WbMediaType = "audio-file"
)

func (WandbAudioV1WbMediaType) IsKnown

func (r WandbAudioV1WbMediaType) IsKnown() bool

type WandbBokehV1ExtensionType

type WandbBokehV1ExtensionType string
const (
	WandbBokehV1ExtensionTypeWandbBokeh WandbBokehV1ExtensionType = "wandb-bokeh"
)

func (WandbBokehV1ExtensionType) IsKnown

func (r WandbBokehV1ExtensionType) IsKnown() bool

type WandbBokehV1Param

type WandbBokehV1Param struct {
	ExtensionType param.Field[WandbBokehV1ExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[WandbBokehV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                    `json:"sha256"         api:"required"`
	Size          param.Field[int64]                     `json:"size"           api:"required"`
	// W&B run-file or artifact reference only. Row comparison across
	// EvaluationVersions ignores this property.
	Uri         param.Field[string]                  `json:"uri"           api:"required" format:"uri"`
	WbMediaType param.Field[WandbBokehV1WbMediaType] `json:"wb_media_type" api:"required"`
	Caption     param.Field[string]                  `json:"caption"`
	ExtraFields map[string]interface{}               `json:"-,extras"`
}

A V1 W&B Bokeh value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbBokehV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbBokehV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbBokehV1Param) MarshalJSON

func (r WandbBokehV1Param) MarshalJSON() (data []byte, err error)

type WandbBokehV1SchemaVersion

type WandbBokehV1SchemaVersion int64
const (
	WandbBokehV1SchemaVersion1 WandbBokehV1SchemaVersion = 1
)

func (WandbBokehV1SchemaVersion) IsKnown

func (r WandbBokehV1SchemaVersion) IsKnown() bool

type WandbBokehV1WbMediaType

type WandbBokehV1WbMediaType string
const (
	WandbBokehV1WbMediaTypeBokehFile WandbBokehV1WbMediaType = "bokeh-file"
)

func (WandbBokehV1WbMediaType) IsKnown

func (r WandbBokehV1WbMediaType) IsKnown() bool

type WandbHTMLV1ExtensionType

type WandbHTMLV1ExtensionType string
const (
	WandbHTMLV1ExtensionTypeWandbHTML WandbHTMLV1ExtensionType = "wandb-html"
)

func (WandbHTMLV1ExtensionType) IsKnown

func (r WandbHTMLV1ExtensionType) IsKnown() bool

type WandbHTMLV1Param

type WandbHTMLV1Param struct {
	ExtensionType param.Field[WandbHTMLV1ExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[WandbHTMLV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                   `json:"sha256"         api:"required"`
	Size          param.Field[int64]                    `json:"size"           api:"required"`
	// W&B run-file or artifact reference only. Row comparison across
	// EvaluationVersions ignores this property.
	Uri         param.Field[string]                 `json:"uri"           api:"required" format:"uri"`
	WbMediaType param.Field[WandbHTMLV1WbMediaType] `json:"wb_media_type" api:"required"`
	Caption     param.Field[string]                 `json:"caption"`
	ExtraFields map[string]interface{}              `json:"-,extras"`
}

A V1 W&B HTML value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbHTMLV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbHTMLV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbHTMLV1Param) MarshalJSON

func (r WandbHTMLV1Param) MarshalJSON() (data []byte, err error)

type WandbHTMLV1SchemaVersion

type WandbHTMLV1SchemaVersion int64
const (
	WandbHTMLV1SchemaVersion1 WandbHTMLV1SchemaVersion = 1
)

func (WandbHTMLV1SchemaVersion) IsKnown

func (r WandbHTMLV1SchemaVersion) IsKnown() bool

type WandbHTMLV1WbMediaType

type WandbHTMLV1WbMediaType string
const (
	WandbHTMLV1WbMediaTypeHTMLFile WandbHTMLV1WbMediaType = "html-file"
)

func (WandbHTMLV1WbMediaType) IsKnown

func (r WandbHTMLV1WbMediaType) IsKnown() bool

type WandbImageBoxesV1Param

type WandbImageBoxesV1Param struct {
	Sha256 param.Field[string] `json:"sha256" api:"required"`
	Size   param.Field[int64]  `json:"size"   api:"required"`
	// Row comparison across EvaluationVersions ignores this property.
	Uri         param.Field[string]                 `json:"uri"      api:"required"`
	Type        param.Field[WandbImageBoxesV1_Type] `json:"_type"`
	ExtraFields map[string]interface{}              `json:"-,extras"`
}

A file of 2D bounding boxes drawn over a W&B image. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbImageBoxesV1Param) MarshalJSON

func (r WandbImageBoxesV1Param) MarshalJSON() (data []byte, err error)

type WandbImageBoxesV1_Type

type WandbImageBoxesV1_Type string
const (
	WandbImageBoxesV1_TypeBoxes2D WandbImageBoxesV1_Type = "boxes2D"
)

func (WandbImageBoxesV1_Type) IsKnown

func (r WandbImageBoxesV1_Type) IsKnown() bool

type WandbImageMaskV1Param

type WandbImageMaskV1Param struct {
	Sha256 param.Field[string] `json:"sha256" api:"required"`
	Size   param.Field[int64]  `json:"size"   api:"required"`
	// Row comparison across EvaluationVersions ignores this property.
	Uri         param.Field[string]                `json:"uri"      api:"required"`
	Type        param.Field[WandbImageMaskV1_Type] `json:"_type"`
	ExtraFields map[string]interface{}             `json:"-,extras"`
}

A segmentation mask file drawn over a W&B image. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbImageMaskV1Param) MarshalJSON

func (r WandbImageMaskV1Param) MarshalJSON() (data []byte, err error)

type WandbImageMaskV1_Type

type WandbImageMaskV1_Type string
const (
	WandbImageMaskV1_TypeMask WandbImageMaskV1_Type = "mask"
)

func (WandbImageMaskV1_Type) IsKnown

func (r WandbImageMaskV1_Type) IsKnown() bool

type WandbImageV1ExtensionType

type WandbImageV1ExtensionType string
const (
	WandbImageV1ExtensionTypeWandbImage WandbImageV1ExtensionType = "wandb-image"
)

func (WandbImageV1ExtensionType) IsKnown

func (r WandbImageV1ExtensionType) IsKnown() bool

type WandbImageV1Param

type WandbImageV1Param struct {
	ExtensionType param.Field[WandbImageV1ExtensionType] `json:"extension_type" api:"required"`
	Format        param.Field[string]                    `json:"format"         api:"required"`
	SchemaVersion param.Field[WandbImageV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                    `json:"sha256"         api:"required"`
	Size          param.Field[int64]                     `json:"size"           api:"required"`
	// Row comparison across EvaluationVersions ignores this property.
	Uri         param.Field[string]                            `json:"uri"           api:"required"`
	WbMediaType param.Field[WandbImageV1WbMediaType]           `json:"wb_media_type" api:"required"`
	Boxes       param.Field[map[string]WandbImageBoxesV1Param] `json:"boxes"`
	Caption     param.Field[string]                            `json:"caption"`
	Height      param.Field[int64]                             `json:"height"`
	Masks       param.Field[map[string]WandbImageMaskV1Param]  `json:"masks"`
	Width       param.Field[int64]                             `json:"width"`
	ExtraFields map[string]interface{}                         `json:"-,extras"`
}

A V1 W&B image value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbImageV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbImageV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbImageV1Param) MarshalJSON

func (r WandbImageV1Param) MarshalJSON() (data []byte, err error)

type WandbImageV1SchemaVersion

type WandbImageV1SchemaVersion int64
const (
	WandbImageV1SchemaVersion1 WandbImageV1SchemaVersion = 1
)

func (WandbImageV1SchemaVersion) IsKnown

func (r WandbImageV1SchemaVersion) IsKnown() bool

type WandbImageV1WbMediaType

type WandbImageV1WbMediaType string
const (
	WandbImageV1WbMediaTypeImageFile WandbImageV1WbMediaType = "image-file"
)

func (WandbImageV1WbMediaType) IsKnown

func (r WandbImageV1WbMediaType) IsKnown() bool

type WandbMoleculeV1ExtensionType

type WandbMoleculeV1ExtensionType string
const (
	WandbMoleculeV1ExtensionTypeWandbMolecule WandbMoleculeV1ExtensionType = "wandb-molecule"
)

func (WandbMoleculeV1ExtensionType) IsKnown

func (r WandbMoleculeV1ExtensionType) IsKnown() bool

type WandbMoleculeV1Param

type WandbMoleculeV1Param struct {
	ExtensionType param.Field[WandbMoleculeV1ExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[WandbMoleculeV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                       `json:"sha256"         api:"required"`
	Size          param.Field[int64]                        `json:"size"           api:"required"`
	// W&B run-file or artifact reference only. Row comparison across
	// EvaluationVersions ignores this property.
	Uri         param.Field[string]                     `json:"uri"           api:"required" format:"uri"`
	WbMediaType param.Field[WandbMoleculeV1WbMediaType] `json:"wb_media_type" api:"required"`
	Caption     param.Field[string]                     `json:"caption"`
	ExtraFields map[string]interface{}                  `json:"-,extras"`
}

A V1 W&B Molecule value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbMoleculeV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbMoleculeV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbMoleculeV1Param) MarshalJSON

func (r WandbMoleculeV1Param) MarshalJSON() (data []byte, err error)

type WandbMoleculeV1SchemaVersion

type WandbMoleculeV1SchemaVersion int64
const (
	WandbMoleculeV1SchemaVersion1 WandbMoleculeV1SchemaVersion = 1
)

func (WandbMoleculeV1SchemaVersion) IsKnown

func (r WandbMoleculeV1SchemaVersion) IsKnown() bool

type WandbMoleculeV1WbMediaType

type WandbMoleculeV1WbMediaType string
const (
	WandbMoleculeV1WbMediaTypeMoleculeFile WandbMoleculeV1WbMediaType = "molecule-file"
)

func (WandbMoleculeV1WbMediaType) IsKnown

func (r WandbMoleculeV1WbMediaType) IsKnown() bool

type WandbObject3dV1ExtensionType

type WandbObject3dV1ExtensionType string
const (
	WandbObject3dV1ExtensionTypeWandbObject3d WandbObject3dV1ExtensionType = "wandb-object3d"
)

func (WandbObject3dV1ExtensionType) IsKnown

func (r WandbObject3dV1ExtensionType) IsKnown() bool

type WandbObject3dV1Param

type WandbObject3dV1Param struct {
	ExtensionType param.Field[WandbObject3dV1ExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[WandbObject3dV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                       `json:"sha256"         api:"required"`
	Size          param.Field[int64]                        `json:"size"           api:"required"`
	// W&B run-file or artifact reference only. Row comparison across
	// EvaluationVersions ignores this property.
	Uri         param.Field[string]                     `json:"uri"           api:"required" format:"uri"`
	WbMediaType param.Field[WandbObject3dV1WbMediaType] `json:"wb_media_type" api:"required"`
	Caption     param.Field[string]                     `json:"caption"`
	ExtraFields map[string]interface{}                  `json:"-,extras"`
}

A V1 W&B Object3D value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbObject3dV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbObject3dV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbObject3dV1Param) MarshalJSON

func (r WandbObject3dV1Param) MarshalJSON() (data []byte, err error)

type WandbObject3dV1SchemaVersion

type WandbObject3dV1SchemaVersion int64
const (
	WandbObject3dV1SchemaVersion1 WandbObject3dV1SchemaVersion = 1
)

func (WandbObject3dV1SchemaVersion) IsKnown

func (r WandbObject3dV1SchemaVersion) IsKnown() bool

type WandbObject3dV1WbMediaType

type WandbObject3dV1WbMediaType string
const (
	WandbObject3dV1WbMediaTypeObject3DFile WandbObject3dV1WbMediaType = "object3D-file"
)

func (WandbObject3dV1WbMediaType) IsKnown

func (r WandbObject3dV1WbMediaType) IsKnown() bool

type WandbVideoV1ExtensionType

type WandbVideoV1ExtensionType string
const (
	WandbVideoV1ExtensionTypeWandbVideo WandbVideoV1ExtensionType = "wandb-video"
)

func (WandbVideoV1ExtensionType) IsKnown

func (r WandbVideoV1ExtensionType) IsKnown() bool

type WandbVideoV1Param

type WandbVideoV1Param struct {
	ExtensionType param.Field[WandbVideoV1ExtensionType] `json:"extension_type" api:"required"`
	SchemaVersion param.Field[WandbVideoV1SchemaVersion] `json:"schema_version" api:"required"`
	Sha256        param.Field[string]                    `json:"sha256"         api:"required"`
	Size          param.Field[int64]                     `json:"size"           api:"required"`
	// Row comparison across EvaluationVersions ignores this property.
	Uri         param.Field[string]                  `json:"uri"           api:"required"`
	WbMediaType param.Field[WandbVideoV1WbMediaType] `json:"wb_media_type" api:"required"`
	Caption     param.Field[string]                  `json:"caption"`
	Height      param.Field[int64]                   `json:"height"`
	Width       param.Field[int64]                   `json:"width"`
	ExtraFields map[string]interface{}               `json:"-,extras"`
}

A V1 W&B video value in an evaluation input or output field. Row comparison across EvaluationVersions matches this value by every property except `uri`. An empty optional property matches a missing one.

func (WandbVideoV1Param) ImplementsCaseFieldValueUnionParam

func (r WandbVideoV1Param) ImplementsCaseFieldValueUnionParam()

func (WandbVideoV1Param) MarshalJSON

func (r WandbVideoV1Param) MarshalJSON() (data []byte, err error)

type WandbVideoV1SchemaVersion

type WandbVideoV1SchemaVersion int64
const (
	WandbVideoV1SchemaVersion1 WandbVideoV1SchemaVersion = 1
)

func (WandbVideoV1SchemaVersion) IsKnown

func (r WandbVideoV1SchemaVersion) IsKnown() bool

type WandbVideoV1WbMediaType

type WandbVideoV1WbMediaType string
const (
	WandbVideoV1WbMediaTypeVideoFile WandbVideoV1WbMediaType = "video-file"
)

func (WandbVideoV1WbMediaType) IsKnown

func (r WandbVideoV1WbMediaType) IsKnown() bool

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL