mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
930 lines
32 KiB
Go
930 lines
32 KiB
Go
/*
|
|
Hanzo Cloud API
|
|
|
|
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
|
|
API version: v1
|
|
*/
|
|
|
|
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
|
|
|
package hanzoai
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// DatasetAPIService DatasetAPI service
|
|
type DatasetAPIService service
|
|
|
|
type DatasetAPIRiskCreateDatasetRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
datasetRiskDatasetSpec *DatasetRiskDatasetSpec
|
|
}
|
|
|
|
func (r DatasetAPIRiskCreateDatasetRequest) DatasetRiskDatasetSpec(datasetRiskDatasetSpec DatasetRiskDatasetSpec) DatasetAPIRiskCreateDatasetRequest {
|
|
r.datasetRiskDatasetSpec = &datasetRiskDatasetSpec
|
|
return r
|
|
}
|
|
|
|
func (r DatasetAPIRiskCreateDatasetRequest) Execute() (*DatasetRiskDataset, *http.Response, error) {
|
|
return r.ApiService.RiskCreateDatasetExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskCreateDataset Declare the next version of a dataset
|
|
|
|
Declares the next version of a dataset from a bound query over
|
|
this org's own feature surface.
|
|
|
|
It mints a VERSION and writes no rows: a version is declared, then materialised
|
|
once, then never rewritten. Version numbers are monotone and never reused, so
|
|
"version 3 of signups" means one thing forever — which is the whole reason a
|
|
model can cite one.
|
|
|
|
The window is bounded by the source's retention, the horizon by a year, the
|
|
rows by the plane's cap, and the number of datasets and versions per org by
|
|
their own limits. Every refusal names which bound it hit.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return DatasetAPIRiskCreateDatasetRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskCreateDataset(ctx context.Context) DatasetAPIRiskCreateDatasetRequest {
|
|
return DatasetAPIRiskCreateDatasetRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskDataset
|
|
func (a *DatasetAPIService) RiskCreateDatasetExecute(r DatasetAPIRiskCreateDatasetRequest) (*DatasetRiskDataset, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskDataset
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskCreateDataset")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.datasetRiskDatasetSpec == nil {
|
|
return localVarReturnValue, nil, reportError("datasetRiskDatasetSpec is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.datasetRiskDatasetSpec
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type DatasetAPIRiskDatasetRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
name string
|
|
}
|
|
|
|
func (r DatasetAPIRiskDatasetRequest) Execute() (*DatasetRiskDatasetVersions, *http.Response, error) {
|
|
return r.ApiService.RiskDatasetExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskDataset Describe every version of one dataset
|
|
|
|
Dataset describes every version of one dataset, newest first — the whole
|
|
history, because the point of a version is that the older ones are still there
|
|
and a model fitted last quarter cites one of them.
|
|
|
|
A name this org does not own answers 404, exactly as an unknown name does, so a
|
|
probe learns nothing about another tenant's datasets.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset, from the path.
|
|
@return DatasetAPIRiskDatasetRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskDataset(ctx context.Context, name string) DatasetAPIRiskDatasetRequest {
|
|
return DatasetAPIRiskDatasetRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskDatasetVersions
|
|
func (a *DatasetAPIService) RiskDatasetExecute(r DatasetAPIRiskDatasetRequest) (*DatasetRiskDatasetVersions, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskDatasetVersions
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskDataset")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type DatasetAPIRiskDatasetLineageRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
name string
|
|
version *int64
|
|
}
|
|
|
|
// Version is the version to trace. Zero takes the newest published one.
|
|
func (r DatasetAPIRiskDatasetLineageRequest) Version(version int64) DatasetAPIRiskDatasetLineageRequest {
|
|
r.version = &version
|
|
return r
|
|
}
|
|
|
|
func (r DatasetAPIRiskDatasetLineageRequest) Execute() (*DatasetRiskLineage, *http.Response, error) {
|
|
return r.ApiService.RiskDatasetLineageExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskDatasetLineage Show where a version's rows came from, and whether that can still be demonstrated
|
|
|
|
Shows where a version's rows came from and whether that can
|
|
still be demonstrated.
|
|
|
|
The answer is MEASURED, not recalled: the plane asks the source the same
|
|
bounded question again and compares it to the fingerprint taken when the
|
|
version was built. Anything but exact agreement is reported as drift — the
|
|
source is fed by a rollup that runs behind the events, so "it holds more now"
|
|
is the ordinary case and it means re-running the spec would not reproduce this
|
|
version. An admitted gap is actionable; an unfalsifiable claim is not.
|
|
|
|
IT IS A PRICED, BOUNDED READ, because it is the same statement a
|
|
materialisation is charged for: an exact distinct-count over up to 400 days of
|
|
this org's feature surface. It takes the org's ONE source-scan slot, so a
|
|
tenant looping it spends one scan and not a thousand; it counts against the
|
|
plane's ceiling, so the fleet's warehouse is bounded too; and it runs under
|
|
this plane's own deadline rather than the caller's patience.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset, from the path.
|
|
@return DatasetAPIRiskDatasetLineageRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskDatasetLineage(ctx context.Context, name string) DatasetAPIRiskDatasetLineageRequest {
|
|
return DatasetAPIRiskDatasetLineageRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskLineage
|
|
func (a *DatasetAPIService) RiskDatasetLineageExecute(r DatasetAPIRiskDatasetLineageRequest) (*DatasetRiskLineage, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskLineage
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskDatasetLineage")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset/{name}/lineage"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.version != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "version", r.version, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type DatasetAPIRiskDatasetsRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
}
|
|
|
|
func (r DatasetAPIRiskDatasetsRequest) Execute() (*DatasetRiskDatasetList, *http.Response, error) {
|
|
return r.ApiService.RiskDatasetsExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskDatasets List this org's datasets
|
|
|
|
Datasets lists this org's datasets, each with its newest version. An org that
|
|
has declared none gets an empty list; a store that cannot be reached gets a
|
|
refusal, never an empty list, because the two read identically and only one of
|
|
them is true.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return DatasetAPIRiskDatasetsRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskDatasets(ctx context.Context) DatasetAPIRiskDatasetsRequest {
|
|
return DatasetAPIRiskDatasetsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskDatasetList
|
|
func (a *DatasetAPIService) RiskDatasetsExecute(r DatasetAPIRiskDatasetsRequest) (*DatasetRiskDatasetList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskDatasetList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskDatasets")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type DatasetAPIRiskDeleteDatasetRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
name string
|
|
}
|
|
|
|
func (r DatasetAPIRiskDeleteDatasetRequest) Execute() (*DatasetRiskDatasetDisposal, *http.Response, error) {
|
|
return r.ApiService.RiskDeleteDatasetExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskDeleteDataset Dispose of one dataset and every version of it
|
|
|
|
Disposes of one dataset and every version of it: the rows are
|
|
dropped and the register is marked with what went.
|
|
|
|
This is the ONLY expiry in this plane. Neither table carries a TTL, deliberately:
|
|
a table TTL is a fleet-wide clock no tenant can hold longer or shorten, which is
|
|
the opposite of a retention decision belonging to the tenant whose records they
|
|
are. The drop is a partition drop on (org, dataset), so the tenant is the first
|
|
component of the thing being dropped and a disposal cannot be spelled across one.
|
|
|
|
The BYTES are what goes. The register keeps one `disposed` row per version — the
|
|
name, the number, the spec, the digest and who disposed of it when — for two
|
|
reasons: a retention obligation is answered by a record of the deletion, not by
|
|
silence; and version numbers must stay monotone, so that after `orders` is
|
|
disposed of and declared again the next version is 4 and not 1. A number that
|
|
could be reused would make every citation of `orders v3` ambiguous forever.
|
|
|
|
It is not reversible and there is no soft state in between. A version a model
|
|
cited has no rows once this returns, and every read of it says so.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset, from the path.
|
|
@return DatasetAPIRiskDeleteDatasetRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskDeleteDataset(ctx context.Context, name string) DatasetAPIRiskDeleteDatasetRequest {
|
|
return DatasetAPIRiskDeleteDatasetRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskDatasetDisposal
|
|
func (a *DatasetAPIService) RiskDeleteDatasetExecute(r DatasetAPIRiskDeleteDatasetRequest) (*DatasetRiskDatasetDisposal, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskDatasetDisposal
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskDeleteDataset")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type DatasetAPIRiskExportDatasetRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
name string
|
|
version *int64
|
|
split *string
|
|
offset *int64
|
|
limit *int64
|
|
}
|
|
|
|
// Version is the version to read. Zero takes the newest published one.
|
|
func (r DatasetAPIRiskExportDatasetRequest) Version(version int64) DatasetAPIRiskExportDatasetRequest {
|
|
r.version = &version
|
|
return r
|
|
}
|
|
|
|
// Split narrows to train, val or test. Empty reads every split.
|
|
func (r DatasetAPIRiskExportDatasetRequest) Split(split string) DatasetAPIRiskExportDatasetRequest {
|
|
r.split = &split
|
|
return r
|
|
}
|
|
|
|
// Offset is where the page starts, in the version's own row order (by id, which is derived from the row and therefore stable forever).
|
|
func (r DatasetAPIRiskExportDatasetRequest) Offset(offset int64) DatasetAPIRiskExportDatasetRequest {
|
|
r.offset = &offset
|
|
return r
|
|
}
|
|
|
|
// Limit is how many rows to return. Zero and anything above the plane's bound take the bound.
|
|
func (r DatasetAPIRiskExportDatasetRequest) Limit(limit int64) DatasetAPIRiskExportDatasetRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r DatasetAPIRiskExportDatasetRequest) Execute() (*DatasetRiskDatasetRows, *http.Response, error) {
|
|
return r.ApiService.RiskExportDatasetExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskExportDataset Read a version's rows back, one page at a time
|
|
|
|
Reads a published version's rows back, one bounded page at a
|
|
time, in the version's own stable row order.
|
|
|
|
Only a published version can be exported. Rows written by an attempt that never
|
|
completed are inert — no register row names them — and they are disposed of with
|
|
the dataset.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset, from the path.
|
|
@return DatasetAPIRiskExportDatasetRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskExportDataset(ctx context.Context, name string) DatasetAPIRiskExportDatasetRequest {
|
|
return DatasetAPIRiskExportDatasetRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskDatasetRows
|
|
func (a *DatasetAPIService) RiskExportDatasetExecute(r DatasetAPIRiskExportDatasetRequest) (*DatasetRiskDatasetRows, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskDatasetRows
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskExportDataset")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset/{name}/export"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.version != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "version", r.version, "form", "")
|
|
}
|
|
if r.split != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "split", r.split, "form", "")
|
|
}
|
|
if r.offset != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "offset", r.offset, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type DatasetAPIRiskMaterializeDatasetRequest struct {
|
|
ctx context.Context
|
|
ApiService *DatasetAPIService
|
|
name string
|
|
}
|
|
|
|
func (r DatasetAPIRiskMaterializeDatasetRequest) Execute() (*DatasetRiskDataset, *http.Response, error) {
|
|
return r.ApiService.RiskMaterializeDatasetExecute(r)
|
|
}
|
|
|
|
/*
|
|
RiskMaterializeDataset Materialise the declared version into immutable rows
|
|
|
|
Builds the declared version into immutable rows and answers
|
|
202 as soon as the attempt is on record.
|
|
|
|
It never holds the request open for the work: a materialisation is a bounded
|
|
warehouse scan, and letting an HTTP client's timeout be a data plane's timeout
|
|
is how one tenant's retry loop becomes everyone's outage. ONE materialisation
|
|
runs per org at a time; a second is refused rather than queued, because a queue
|
|
admits the same work later and the honest answer to "again" while one is
|
|
running is that one is running.
|
|
|
|
Only a DECLARED version is admitted. A published version is immutable, and a
|
|
version whose earlier attempt did not complete is never re-attempted — that
|
|
would union two runs' rows under one number and make the digest a lie. In both
|
|
cases the answer is to declare a new version, which is what a second run over a
|
|
moving source honestly is.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the dataset, from the path.
|
|
@return DatasetAPIRiskMaterializeDatasetRequest
|
|
*/
|
|
func (a *DatasetAPIService) RiskMaterializeDataset(ctx context.Context, name string) DatasetAPIRiskMaterializeDatasetRequest {
|
|
return DatasetAPIRiskMaterializeDatasetRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return DatasetRiskDataset
|
|
func (a *DatasetAPIService) RiskMaterializeDatasetExecute(r DatasetAPIRiskMaterializeDatasetRequest) (*DatasetRiskDataset, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *DatasetRiskDataset
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DatasetAPIService.RiskMaterializeDataset")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/dataset/{name}/materialize"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|