API Classes

Apps

Kelvin API Client.

class kelvin.api.client.api.apps.Apps(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (BaseModel | None)

  • _name (str | None)

  • kwargs (object)

classmethod list_apps_context(sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List Apps Contexts

Permission Required: kelvin.permission.app.read.

listAppsContext: POST /api/v4/apps/context/list

Parameters:

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • data (Union[AppsContextList, Mapping[str, object], None]) – requests.AppsContextList, optional

  • **kwargs (object) –

    Extra parameters for requests.AppsContextList

    • list_apps_context: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[AppsResourceContext], AppsContextListPaginatedResponseCursor]

classmethod create_app_version(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create App Version

Permission Required: kelvin.permission.app.create.

createAppVersion: POST /api/v4/apps/create

Parameters:

  • data (Union[AppVersionCreate, Mapping[str, object], None]) – requests.AppVersionCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionCreate

    • create_app_version: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppVersionCreate

classmethod list_apps(app_names=None, app_types=None, resources=None, search=None, sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Applications based on the provided filters and sort options.

Permission Required: kelvin.permission.app.read.

listApps: GET /api/v4/apps/list

Parameters:

  • app_names (Optional[Sequence[str]]) – Sequence[str] Filter the results by the provided application names.

  • app_types (Optional[Sequence[str]]) – Sequence[str] Application type.

  • resources (Optional[Sequence[str]]) – Sequence[str] Filter based on Resource (KRN format) associated with the App. Supported KRNs: asset.

  • search (Optional[Sequence[str]]) – Sequence[str] Search the name or title of the application for the provided string.

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[AppShort], AppsListPaginatedResponseCursor]

classmethod delete_app(app_name, _dry_run=False, _client=None)[source]

Delete App

Permission Required: kelvin.permission.app.delete.

deleteApp: POST /api/v4/apps/{app_name}/delete

Parameters:

  • app_name (str) – str, optional

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_app(app_name, _dry_run=False, _client=None)[source]

Get details of an Application

Permission Required: kelvin.permission.app.read.

getApp: GET /api/v4/apps/{app_name}/get

Parameters:

  • app_name (str) – str, optional

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

AppGet

classmethod patch_app(app_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update details of an Application. Any parameters that are not provided will remain unchanged.

Permission Required: kelvin.permission.app.update.

patchApp: POST /api/v4/apps/{app_name}/patch

Parameters:

  • app_name (str) – str, optional

  • data (Union[AppPatch, Mapping[str, object], None]) – requests.AppPatch, optional

  • **kwargs (object) –

    Extra parameters for requests.AppPatch

    • patch_app: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppPatch

classmethod delete_app_resources(app_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Delete App Resources

Permission Required: kelvin.permission.app.update.

deleteAppResources: POST /api/v4/apps/{app_name}/resources/delete

Parameters:

  • app_name (str) – str, optional

  • data (Union[AppResourcesDelete, Mapping[str, object], None]) – requests.AppResourcesDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.AppResourcesDelete

    • delete_app_resources: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod disable_app_resources(app_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Disable App Resources

Permission Required: kelvin.permission.app.update.

disableAppResources: POST /api/v4/apps/{app_name}/resources/disable

Parameters:

  • app_name (str) – str, optional

  • data (Union[AppResourcesDisable, Mapping[str, object], None]) – requests.AppResourcesDisable, optional

  • **kwargs (object) –

    Extra parameters for requests.AppResourcesDisable

    • disable_app_resources: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod enable_app_resources(app_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Enable App Resources

Permission Required: kelvin.permission.app.update.

enableAppResources: POST /api/v4/apps/{app_name}/resources/enable

Parameters:

  • app_name (str) – str, optional

  • data (Union[AppResourcesEnable, Mapping[str, object], None]) – requests.AppResourcesEnable, optional

  • **kwargs (object) –

    Extra parameters for requests.AppResourcesEnable

    • enable_app_resources: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod list_app_resources(app_name, search=None, resources=None, app_versions=None, workload_names=None, enabled=None, sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, fetch=True, _dry_run=False, _client=None)[source]

List App Resources

Permission Required: kelvin.permission.app.read.

listAppResources: GET /api/v4/apps/{app_name}/resources/list

Parameters:

  • app_name (str) – str, optional

  • search (Optional[Sequence[str]]) – Sequence[str]

  • resources (Optional[Sequence[str]]) – Sequence[str]

  • app_versions (Optional[Sequence[str]]) – Sequence[str]

  • workload_names (Optional[Sequence[str]]) – Sequence[str]

  • enabled (Optional[bool]) – bool

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[AppResource], AppResourcesListPaginatedResponseCursor]

classmethod delete_app_version(app_name, app_version, _dry_run=False, _client=None)[source]

Delete App Version

Permission Required: kelvin.permission.app.delete.

deleteAppVersion: POST /api/v4/apps/{app_name}/v/{app_version}/delete

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod deploy_app_version(app_name, app_version, data=None, _dry_run=False, _client=None, **kwargs)[source]

Deploy App Version

Issues the deployment of workloads based on the specified instructions.

The deployment section defines the strategy to deploy the application to resources (i.e. assets) by creating the necessary workloads based on the maximum number of resources each instance can handle, as well as the target cluster where the workloads will be deployed.

Each resource (i.e. asset) is defined in the runtime section, which includes defining its parameters and data stream mappings.

The parameters section is optional. If provided, it will update all parameters for that resource with the provided values, otherwise, the current ones will be injected into the new workloads. If parameters is set and a parameter is not defined, the current value will be deleted, effectively setting it to the default value. This behaviour means that setting parameters to an empty object ({}) will reset all parameters of that resource to their default values.

Permission Required: kelvin.permission.app.deploy.

deployAppVersion: POST /api/v4/apps/{app_name}/v/{app_version}/deploy

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • data (Union[AppVersionDeploy, Mapping[str, object], None]) – requests.AppVersionDeploy, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionDeploy

    • deploy_app_version: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppVersionDeploy

classmethod get_app_version(app_name, app_version, _dry_run=False, _client=None)[source]

Get App Version

Permission Required: kelvin.permission.app.read.

getAppVersion: GET /api/v4/apps/{app_name}/v/{app_version}/get

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

AppVersionGet

classmethod patch_app_version(app_name, app_version, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update App Version

Partially update the default settings and schemas for an App Version. The following keys can be updated individually. If a key is not specified, its existing value will remain unchanged. If a key is specified, it will completely overwrite the current value for that key and its nested fields.

  • defaults.deployment.max_resources

  • defaults.deployment.deployment_type

  • defaults.deployment.target

  • defaults.app.configuration

  • defaults.app.io_datastream_mapping

  • defaults.system

  • schemas.parameters

  • schemas.configuration

  • schemas.io_configuration

Permission Required: kelvin.permission.app.update.

patchAppVersion: POST /api/v4/apps/{app_name}/v/{app_version}/patch

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • data (Union[AppVersionPatch, Mapping[str, object], None]) – requests.AppVersionPatch, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionPatch

    • patch_app_version: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppVersionPatch

classmethod update_app_version(app_name, app_version, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update App Version

Update the default settings and schemas for an App Version.

Permission Required: kelvin.permission.app.update.

updateAppVersion: POST /api/v4/apps/{app_name}/v/{app_version}/update

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • data (Union[AppVersionUpdate, Mapping[str, object], None]) – requests.AppVersionUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionUpdate

    • update_app_version: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppVersionUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

AppParameters

Kelvin API Client.

class kelvin.api.client.api.app_parameters.AppParameters(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod list_app_version_parameters_history(sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List App Version Parameters History

Permission Required: kelvin.permission.parameter.read.

listAppVersionParametersHistory: POST /api/v4/apps/parameters/history/list

Parameters:

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one or more enumerators.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • data (Union[AppVersionParametersHistoryList, Mapping[str, object], None]) – requests.AppVersionParametersHistoryList, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionParametersHistoryList

    • list_app_version_parameters_history: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[AppVersionParameter], AppVersionParametersHistoryListPaginatedResponseCursor]

classmethod list_app_parameters(sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List App Parameters

Permission Required: kelvin.permission.parameter.read.

listAppParameters: POST /api/v4/apps/parameters/list

Parameters:

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one or more enumerators.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • data (Union[AppParametersList, Mapping[str, object], None]) – requests.AppParametersList, optional

  • **kwargs (object) –

    Extra parameters for requests.AppParametersList

    • list_app_parameters: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[AppParameter], AppParametersListPaginatedResponseCursor]

classmethod create_parameters_schedule(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new schedule to apply parameters to an application.

Schedules are sets of application parameter values that are applied to a group of assets at a given time.

Optionally, those values can be reverted to the desired value. When doing so, parameter values are defined for each asset individually, and the assets and parameters must match the original schedule. For example, if 2 parameters were changed for 2 assets and a revert operation is requested, then the revert parameters must have 2 assets and 2 parameters for each asset.

The schedule must be created in the future and, if a revert operation is requested, the revert date must be after the scheduled date.

Upon creation, the current values of the parameters are stored in the original_resource_parameters field.

Permission Required: kelvin.permission.parameter.update.

createParametersSchedule: POST /api/v4/apps/parameters/schedules/create

Parameters:

  • data (Union[ParametersScheduleCreate, Mapping[str, object], None]) – requests.ParametersScheduleCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.ParametersScheduleCreate

    • create_parameters_schedule: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ParametersScheduleCreate

classmethod list_parameters_schedule(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Parameter Schedules and its parameters. The Parameter Schedules can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.parameter.read.

listParametersSchedule: POST /api/v4/apps/parameters/schedules/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one or more enumerators.

  • data (Union[ParametersScheduleList, Mapping[str, object], None]) – requests.ParametersScheduleList, optional

  • **kwargs (object) –

    Extra parameters for requests.ParametersScheduleList

    • list_parameters_schedule: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[ParametersScheduleGet], ParametersScheduleListPaginatedResponseCursor]

classmethod apply_parameters_schedule(schedule_id, data=None, _dry_run=False, _client=None, **kwargs)[source]

Apply the scheduled or reverted parameters of a specific schedule.

There are 2 types of the “apply” action:

  • schedule: Applies the scheduled parameters if the schedule is in the

scheduled state. - schedule-revert: Applies the revert parameters if the schedule is in the scheduled-revert state.

If the schedule is not in the supported state for the selected type, the API will return an error.

Errors encountered when calling this API will not affect the schedule state.

Permission Required: kelvin.permission.parameter.update.

applyParametersSchedule: POST /api/v4/apps/parameters/schedules/{schedule_id}/apply

Parameters:

  • schedule_id (str) – str, optional The parameter schedule key id to be applied immediately.

  • data (Union[ParametersScheduleApply, Mapping[str, object], None]) – requests.ParametersScheduleApply, optional

  • **kwargs (object) –

    Extra parameters for requests.ParametersScheduleApply

    • apply_parameters_schedule: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod delete_parameters_schedule(schedule_id, _dry_run=False, _client=None)[source]

Delete a specific schedule.

Permission Required: kelvin.permission.parameter.update.

deleteParametersSchedule: POST /api/v4/apps/parameters/schedules/{schedule_id}/delete

Parameters:

  • schedule_id (str) – str, optional The parameter schedule key id to be delete.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_parameters_schedule(schedule_id, _dry_run=False, _client=None)[source]

Get a specific schedule.

Permission Required: kelvin.permission.parameter.read.

getParametersSchedule: GET /api/v4/apps/parameters/schedules/{schedule_id}/get

Parameters:

  • schedule_id (str) – str, optional The parameter schedule key id to be retrieved.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

ParametersScheduleGet

classmethod get_app_version_parameters_unique_values(data=None, _dry_run=False, _client=None, **kwargs)[source]

Get App Version Parameters Unique Values

Permission Required: kelvin.permission.parameter.read.

getAppVersionParametersUniqueValues: POST /api/v4/apps/parameters/unique-values/get

Parameters:

  • data (Union[AppVersionParametersUniqueValuesGet, Mapping[str, object], None]) – requests.AppVersionParametersUniqueValuesGet, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionParametersUniqueValuesGet

    • get_app_version_parameters_unique_values: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppVersionParametersUniqueValuesGet

classmethod list_app_version_parameter_values(sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List App Version Parameter Values

Permission Required: kelvin.permission.parameter.read.

listAppVersionParameterValues: POST /api/v4/apps/parameters/values/list

Parameters:

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one or more enumerators.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • data (Union[AppVersionParameterValuesList, Mapping[str, object], None]) – requests.AppVersionParameterValuesList, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionParameterValuesList

    • list_app_version_parameter_values: str

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[AppVersionParameter], AppVersionParameterValuesListPaginatedResponseCursor]

classmethod update_app_version_parameters_defaults(app_name, app_version, patch=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update App Version Parameters Defaults

Permission Required: kelvin.permission.app.update.

updateAppVersionParametersDefaults: POST /api/v4/apps/{app_name}/v/{app_version}/parameters/defaults/update

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • patch (Optional[bool]) – bool If set to true, it only updates the parameters that are explicitly defined in the request.

  • data (Union[AppVersionParametersDefaultsUpdate, Mapping[str, object], None]) – requests.AppVersionParametersDefaultsUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionParametersDefaultsUpdate

    • update_app_version_parameters_defaults: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod get_app_version_parameters_fallback_values(app_name, app_version, data=None, _dry_run=False, _client=None, **kwargs)[source]

Get App Version Parameters Fallback Values

Permission Required: kelvin.permission.parameter.read.

getAppVersionParametersFallbackValues: POST /api/v4/apps/{app_name}/v/{app_version}/parameters/fallback-values/get

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • data (Union[AppVersionParametersFallbackValuesGet, Mapping[str, object], None]) – requests.AppVersionParametersFallbackValuesGet, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionParametersFallbackValuesGet

    • get_app_version_parameters_fallback_values: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AppVersionParametersFallbackValuesGet

classmethod update_app_version_parameters(app_name, app_version, patch=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update App Version Parameters

Permission Required: kelvin.permission.parameter.update.

updateAppVersionParameters: POST /api/v4/apps/{app_name}/v/{app_version}/parameters/values/update

Parameters:

  • app_name (str) – str, optional

  • app_version (str) – str, optional

  • patch (Optional[bool]) – bool If set to true, it only updates the parameters that are explicitly defined in the request.

  • data (Union[AppVersionParametersUpdate, Mapping[str, object], None]) – requests.AppVersionParametersUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.AppVersionParametersUpdate

    • update_app_version_parameters: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

AppWorkloads

Kelvin API Client.

class kelvin.api.client.api.app_workloads.AppWorkloads(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod apply_workloads(data=None, _dry_run=False, _client=None, **kwargs)[source]

Initiate final deploy action for the downloaded Workloads. Only valid for Workloads that were previously deployed with the keys staged set to true and instantly_apply set to false.

Permission Required: kelvin.permission.workload.update.

applyWorkloads: POST /api/v4/apps/workloads/apply

Parameters:

  • data (Union[WorkloadsApply, Mapping[str, object], None]) – requests.WorkloadsApply, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadsApply

    • apply_workloads: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod update_workloads_bulk(data=None, _dry_run=False, _client=None, **kwargs)[source]

Update Workloads Bulk

Permission Required: kelvin.permission.workload.update.

updateWorkloadsBulk: POST /api/v4/apps/workloads/bulk/update

Parameters:

  • data (Union[WorkloadsBulkUpdate, Mapping[str, object], None]) – requests.WorkloadsBulkUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadsBulkUpdate

    • update_workloads_bulk: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod create_workload(stopped=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Create Workload

Permission Required: kelvin.permission.workload.create.

createWorkload: POST /api/v4/apps/workloads/create

Parameters:

  • stopped (Optional[bool]) – bool If set to true, the workload created will be deployed in a stopped state.

  • data (Union[WorkloadCreate, Mapping[str, object], None]) – requests.WorkloadCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadCreate

    • create_workload: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

WorkloadCreate

classmethod delete_workloads(staged=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Delete Workload

Permission Required: kelvin.permission.workload.delete.

deleteWorkloads: POST /api/v4/apps/workloads/delete

Parameters:
Return type:

None

classmethod list_workloads(search=None, app_names=None, app_versions=None, app_types=None, cluster_names=None, node_names=None, workload_names=None, resources=None, staged=None, statuses=None, download_statuses=None, sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, fetch=True, _dry_run=False, _client=None)[source]

List Workloads

Permission Required: kelvin.permission.workload.read.

listWorkloads: GET /api/v4/apps/workloads/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the keys name, title (Display Name), app_name and cluster_name. All strings in the array are treated as _OR_. The search is case insensitive and will find partial matches as well.

  • app_names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key app_name. The filter is on the full name only.

  • app_versions (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key app_version. The filter is on the full value only.

  • app_types (Optional[Sequence[str]]) – Sequence[str] Filter Workloads by their application types.

  • cluster_names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key cluster_name. The filter is on the full name only.

  • node_names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key node_name. The filter is on the full name only.

  • workload_names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key name. The filter is on the full name only.

  • resources (Optional[str]) – str Filter based on Resource (KRN format) associated with the Workload. Supported KRNs: asset.

  • staged (Optional[bool]) – bool A filter on the key staged. Using true will only show staged workloads, false will show all workloads.

  • statuses (Optional[Sequence[str]]) – Sequence[str]

  • download_statuses (Optional[Sequence[str]]) – Sequence[str]

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[WorkloadSummary], WorkloadsListPaginatedResponseCursor]

classmethod start_workloads(data=None, _dry_run=False, _client=None, **kwargs)[source]

Permission Required: kelvin.permission.workload.update.

startWorkloads: POST /api/v4/apps/workloads/start

Parameters:

  • data (Union[WorkloadsStart, Mapping[str, object], None]) – requests.WorkloadsStart, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadsStart

    • start_workloads: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod stop_workloads(data=None, _dry_run=False, _client=None, **kwargs)[source]

Permission Required: kelvin.permission.workload.update.

stopWorkloads: POST /api/v4/apps/workloads/stop

Parameters:

  • data (Union[WorkloadsStop, Mapping[str, object], None]) – requests.WorkloadsStop, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadsStop

    • stop_workloads: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod download_workload(workload_name, address=None, _dry_run=False, _client=None)[source]

Download the Workload package file for offline installation on the Edge System. The system automatically generates the file for download if the package is not already available.

Permission Required: kelvin.permission.workload.read.

downloadWorkload: GET /api/v4/apps/workloads/{workload_name}/download

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • address (Optional[bool]) – bool If true, the endpoint will return a direct URL to the workload package file.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

str

classmethod get_workload(workload_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Workload.

Permission Required: kelvin.permission.workload.read.

getWorkload: GET /api/v4/apps/workloads/{workload_name}/get

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

WorkloadGet

classmethod get_workload_logs(workload_name, tail_lines=None, since_time=None, _dry_run=False, _client=None)[source]

Get Workload Logs

Permission Required: kelvin.permission.workload.read.

getWorkloadLogs: GET /api/v4/apps/workloads/{workload_name}/logs/get

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • tail_lines (Optional[int]) – int Specify the number of the most recent log lines to retrieve, counting backwards from the latest entry.

  • since_time (Optional[datetime]) – datetime UTC time of the starting point for log retrieval, formatted in RFC 3339.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

WorkloadLogsGet

classmethod update_workload(workload_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update Workload

Update the modifiable components of a Workload. The following keys can be updated individually. If a key is not specified, its existing value will remain unchanged. If a key is specified, it will completely overwrite the current value for that key and its nested fields.

  • app_version

  • cluster_name

  • node_name

  • workload_title

  • runtime.resources

  • runtime.configuration

  • system

Permission Required: kelvin.permission.workload.update.

updateWorkload: POST /api/v4/apps/workloads/{workload_name}/patch

Parameters:

  • workload_name (str) – str, optional

  • data (Union[WorkloadUpdate, Mapping[str, object], None]) – requests.WorkloadUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadUpdate

    • update_workload: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

WorkloadUpdate

classmethod add_workload_resources(workload_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Add WorkloadResources

Permission Required: kelvin.permission.workload.update.

addWorkloadResources: POST /api/v4/apps/workloads/{workload_name}/resources/add

Parameters:

  • workload_name (str) – str, optional

  • data (Union[WorkloadResourcesAdd, Mapping[str, object], None]) – requests.WorkloadResourcesAdd, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadResourcesAdd

    • add_workload_resources: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

WorkloadResourcesAdd

classmethod remove_workload_resources(workload_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Remove WorkloadResources

Permission Required: kelvin.permission.workload.update.

removeWorkloadResources: POST /api/v4/apps/workloads/{workload_name}/resources/remove

Parameters:

  • workload_name (str) – str, optional

  • data (Union[WorkloadResourcesRemove, Mapping[str, object], None]) – requests.WorkloadResourcesRemove, optional

  • **kwargs (object) –

    Extra parameters for requests.WorkloadResourcesRemove

    • remove_workload_resources: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Asset

Kelvin API Client.

class kelvin.api.client.api.asset.Asset(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_asset_bulk(dry_run=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Create new Assets.

Permission Required: kelvin.permission.asset.create.

createAssetBulk: POST /api/v4/assets/bulk/create

Parameters:

  • dry_run (Optional[bool]) – bool Executes a simulated run when set to true, providing feedback without altering server data.

  • data (Union[AssetBulkCreate, Mapping[str, object], None]) – requests.AssetBulkCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetBulkCreate

    • create_asset_bulk: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod delete_asset_bulk(data=None, _dry_run=False, _client=None, **kwargs)[source]

Delete a list of existing Assets.

Permanently delete a list of existing Kelvin Assets. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.asset.delete.

deleteAssetBulk: POST /api/v4/assets/bulk/delete

Parameters:

  • data (Union[AssetBulkDelete, Mapping[str, object], None]) – requests.AssetBulkDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetBulkDelete

    • delete_asset_bulk: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod create_asset(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Asset.

Permission Required: kelvin.permission.asset.create.

createAsset: POST /api/v4/assets/create

Parameters:

  • data (Union[AssetCreate, Mapping[str, object], None]) – requests.AssetCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetCreate

    • create_asset: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AssetCreate

classmethod list_assets(search=None, names=None, asset_type_name=None, status_state=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Assets and its parameters. The Assets can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.asset.read.

listAssets: GET /api/v4/assets/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the keys title (Display Name) or name. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • asset_type_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key asset_type_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • status_state (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key [‘status’][‘state’]. Multiple statuses can be given and will be filtered as OR. The allowed values are: online, offline, unknown.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[Asset], AssetsListPaginatedResponseCursor]

classmethod list_assets_advanced(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Assets and its parameters. The Assets can be filtered and sorted on the server before being returned. Advanced filter options available for more granular return list.

Permission Required: kelvin.permission.asset.read.

listAssetsAdvanced: POST /api/v4/assets/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[AssetsAdvancedList, Mapping[str, object], None]) – requests.AssetsAdvancedList, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetsAdvancedList

    • list_assets_advanced: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[Asset], AssetsAdvancedListPaginatedResponseCursor]

classmethod get_asset_status_count(_dry_run=False, _client=None)[source]

Retrieve the total count of Assets grouped by the parameter status.

Permission Required: kelvin.permission.asset.read.

getAssetStatusCount: GET /api/v4/assets/status/count/get

Return type:

AssetStatusCountGet

Parameters:

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

classmethod get_asset_status_current(_dry_run=False, _client=None)[source]

Returns a list of all Assets and their current status (state).

Permission Required: kelvin.permission.asset.read.

getAssetStatusCurrent: GET /api/v4/assets/status/current/get

Return type:

AssetStatusCurrentGet

Parameters:

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

classmethod create_asset_type(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Asset Type.

Permission Required: kelvin.permission.asset_type.create.

createAssetType: POST /api/v4/assets/types/create

Parameters:

  • data (Union[AssetTypeCreate, Mapping[str, object], None]) – requests.AssetTypeCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetTypeCreate

    • create_asset_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AssetTypeCreate

classmethod delete_asset_type_bulk(data=None, _dry_run=False, _client=None, **kwargs)[source]

Delete a list of existing Asset Types.

Permanently delete a list of existing Kelvin Asset Types. This cannot be undone once the API request has been submitted.

This command can not delete Kelvin Asset Types that are currently linked to any Kelvin Assets and will return an error 409.

Permission Required: kelvin.permission.asset_type.delete.

deleteAssetTypeBulk: POST /api/v4/assets/types/delete

Parameters:

  • data (Union[AssetTypeBulkDelete, Mapping[str, object], None]) – requests.AssetTypeBulkDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetTypeBulkDelete

    • delete_asset_type_bulk: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod list_asset_types(search=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Asset Types and its parameters. The Asset Types can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.asset_type.read.

listAssetTypes: GET /api/v4/assets/types/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the keys title (Display Name) or name. The search is case insensitive and will find partial matches as well.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[AssetType], AssetTypesListPaginatedResponseCursor]

classmethod list_asset_types_advanced(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Asset Types and its parameters. The Asset Types can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.asset_type.read.

listAssetTypesAdvanced: POST /api/v4/assets/types/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[AssetTypesAdvancedList, Mapping[str, object], None]) – requests.AssetTypesAdvancedList, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetTypesAdvancedList

    • list_asset_types_advanced: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[AssetType], AssetTypesAdvancedListPaginatedResponseCursor]

classmethod delete_asset_type(asset_type_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Asset Type. An error will be returned if there are any current links to an Asset. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.asset_type.delete.

deleteAssetType: POST /api/v4/assets/types/{asset_type_name}/delete

Parameters:

  • asset_type_name (str) – str, optional Asset Type key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_asset_type(asset_type_name, _dry_run=False, _client=None)[source]

Retrieves the parameters of an Asset Type. Permission Required: kelvin.permission.asset_type.read.

getAssetType: GET /api/v4/assets/types/{asset_type_name}/get

Parameters:

  • asset_type_name (str) – str, optional Asset Type key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

AssetTypeGet

classmethod update_asset_type(asset_type_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Asset Type with any new values passed through the body parameters. All body parameters are optional and if not provided will remain unchanged. Only the unique identifier name can not be changed.

Permission Required: kelvin.permission.asset_type.update.

updateAssetType: POST /api/v4/assets/types/{asset_type_name}/update

Parameters:

  • asset_type_name (str) – str, optional Asset Type key name to update. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[AssetTypeUpdate, Mapping[str, object], None]) – requests.AssetTypeUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetTypeUpdate

    • update_asset_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AssetTypeUpdate

classmethod delete_asset(asset_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Asset. This cannot be undone once the API request has been submitted.

The data in the Asset / Data Stream pairs is not deleted and can be recovered if you create the same Asset name again.

Permission Required: kelvin.permission.asset.delete.

deleteAsset: POST /api/v4/assets/{asset_name}/delete

Parameters:

  • asset_name (str) – str, optional Asset key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_asset(asset_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of an Asset.

Permission Required: kelvin.permission.asset.read.

getAsset: GET /api/v4/assets/{asset_name}/get

Parameters:

  • asset_name (str) – str, optional Asset key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

AssetGet

classmethod update_asset(asset_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Asset with any new values passed through the body parameters. The minimum required in the body parameters is title. If this body parameter does not need to be changed, it should still have the original Display Name (title`) given. Any other body parameters that are not required and not provided will remain unchanged.

Permission Required: kelvin.permission.asset.update.

updateAsset: POST /api/v4/assets/{asset_name}/update

Parameters:

  • asset_name (str) – str, optional Asset key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[AssetUpdate, Mapping[str, object], None]) – requests.AssetUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetUpdate

    • update_asset: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

AssetUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

AssetInsights

Kelvin API Client.

class kelvin.api.client.api.asset_insights.AssetInsights(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod get_asset_insights(page_size=10000, page=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Advanced Asset Insights collates Asset data and optional custom defined fields and returns a structured array of Asset related objects. Ideal for generating UI lists, it accommodates a range of search, filter, and optional data on Data Streams, Parameters, Control Changes, Recommendations, etc. related to the Asset.

Permission Required: kelvin.permission.asset_insights.read.

getAssetInsights: POST /api/v4/asset-insights/get

Parameters:

  • page_size (Optional[int]) – int Number of Asset objects to be returned.

  • page (Optional[int]) – int Return the list of Asset objects on requested page using the page_size as a page calculation reference.

  • data (Union[AssetInsightsGet, Mapping[str, object], None]) – requests.AssetInsightsGet, optional

  • **kwargs (object) –

    Extra parameters for requests.AssetInsightsGet

    • get_asset_insights: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[AssetInsightsItem], AssetInsightsGetPaginated]

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

ControlChange

Kelvin API Client.

class kelvin.api.client.api.control_change.ControlChange(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod get_control_change_clustering(data=None, _dry_run=False, _client=None, **kwargs)[source]

Retrieve the total count of Control Changes matching an array of resources and filter options between two dates grouped by the parameter time_bucket. Will also return a list of all the Control Change `id`s counted.

Permission Required: kelvin.permission.control_change.read.

getControlChangeClustering: POST /api/v4/control-changes/clustering/get

Parameters:

  • data (Union[ControlChangeClusteringGet, Mapping[str, object], None]) – requests.ControlChangeClusteringGet, optional

  • **kwargs (object) –

    Extra parameters for requests.ControlChangeClusteringGet

    • get_control_change_clustering: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

KList[ControlChangeClustering]

classmethod create_control_change(data=None, _dry_run=False, _client=None, **kwargs)[source]

Send a new value to be written to an Asset / Data Stream pair. The Control Change Manager will automatically find which Cluster and Bridge to communicate the change to.

Permission Required: kelvin.permission.control_change.create.

createControlChange: POST /api/v4/control-changes/create

Parameters:

  • data (Union[ControlChangeCreate, Mapping[str, object], None]) – requests.ControlChangeCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.ControlChangeCreate

    • create_control_change: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ControlChangeCreate

classmethod get_control_change_last(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a dictionary with a data property containing an array of latest Control Change objects. Only the latest Control Changes for each resource in the request filters will be returned.

Permission Required: kelvin.permission.control_change.read.

getControlChangeLast: POST /api/v4/control-changes/last/get

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[ControlChangeLastGet, Mapping[str, object], None]) – requests.ControlChangeLastGet, optional

  • **kwargs (object) –

    Extra parameters for requests.ControlChangeLastGet

    • get_control_change_last: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[ControlChangeGet], ControlChangeLastGetPaginatedResponseCursor]

classmethod list_control_changes(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Control Change objects for specific Asset / Data Stream pairs or Control Change IDs. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.control_change.read.

listControlChanges: POST /api/v4/control-changes/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[ControlChangesList, Mapping[str, object], None]) – requests.ControlChangesList, optional

  • **kwargs (object) –

    Extra parameters for requests.ControlChangesList

    • list_control_changes: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[ControlChangeGet], ControlChangesListPaginatedResponseCursor]

classmethod get_control_change_range(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a dictionary with a data property containing an array of Control Changes within a specified time range for all of the resources in the resources array that match the filter options.

Permission Required: kelvin.permission.control_change.read.

getControlChangeRange: POST /api/v4/control-changes/range/get

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[ControlChangeRangeGet, Mapping[str, object], None]) – requests.ControlChangeRangeGet, optional

  • **kwargs (object) –

    Extra parameters for requests.ControlChangeRangeGet

    • get_control_change_range: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[ControlChangeGet], ControlChangeRangeGetPaginatedResponseCursor]

classmethod delete_control_change(control_change_id, _dry_run=False, _client=None)[source]

Deletes a control change

Permission Required: kelvin.permission.control_change.delete.

deleteControlChange: POST /api/v4/control-changes/{control_change_id}/delete

Parameters:

  • control_change_id (str) – str, optional A unique randomly generated UUID as the key id for the Control Change.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_control_change(control_change_id, _dry_run=False, _client=None)[source]

Retrieves the properties, status and all associated logs of a Control Change.

Permission Required: kelvin.permission.control_change.read.

getControlChange: GET /api/v4/control-changes/{control_change_id}/get

Parameters:

  • control_change_id (str) – str, optional A unique randomly generated UUID as the key id for the Control Change.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

ControlChangeGet

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

CustomActions

Kelvin API Client.

class kelvin.api.client.api.custom_actions.CustomActions(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_custom_action(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create Custom Action

Permission Required: kelvin.permission.custom-actions.create.

createCustomAction: POST /api/v4/custom-actions/create

Parameters:

  • data (Union[CustomActionCreate, Mapping[str, object], None]) – requests.CustomActionCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.CustomActionCreate

    • create_custom_action: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

CustomActionCreate

classmethod list_custom_actions(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Custom Action objects. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.custom-actions.read.

listCustomActions: POST /api/v4/custom-actions/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[CustomActionsList, Mapping[str, object], None]) – requests.CustomActionsList, optional

  • **kwargs (object) –

    Extra parameters for requests.CustomActionsList

    • list_custom_actions: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[CustomAction], CustomActionsListPaginatedResponseCursor]

classmethod create_custom_actions_type(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Custom Action Type.

Permission Required: kelvin.permission.custom-actions.create.

createCustomActionsType: POST /api/v4/custom-actions/types/create

Parameters:

  • data (Union[CustomActionsTypeCreate, Mapping[str, object], None]) – requests.CustomActionsTypeCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.CustomActionsTypeCreate

    • create_custom_actions_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

CustomActionsTypeCreate

classmethod list_custom_actions_types(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, search=None, app_names=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Custom Action Type objects. The list can be optionally filtered and sorted on the server before being returned. Permission Required: kelvin.permission.custom-actions.read.

listCustomActionsTypes: GET /api/v4/custom-actions/types/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the key name and title. The search is case insensitive and will find partial matches as well.

  • app_names (Optional[Sequence[str]]) – Sequence[str] Filter the list of custom action types to include only those that are currently in use by the specified applications.

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[CustomActionType], CustomActionsTypesListPaginatedCursor]

classmethod delete_custom_action_type(name, _dry_run=False, _client=None)[source]

Permanently delete an existing Custom Action Type. An error will be returned if there are any current Custom Action linked to the Custom Action Type. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.custom-actions.delete.

deleteCustomActionType: POST /api/v4/custom-actions/types/{name}/delete

Parameters:

  • name (str) – str, optional Custom Action Type key name to delete. Case sensitive name.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_custom_actions_type(name, _dry_run=False, _client=None)[source]

Retrieves the parameters of a Custom Action Type.

Permission Required: kelvin.permission.custom-actions.read.

getCustomActionsType: GET /api/v4/custom-actions/types/{name}/get

Parameters:

  • name (str) – str, optional Custom Action Type key name to get. Case sensitive name.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

CustomActionsTypeGet

classmethod update_custom_actions_type(name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Custom Action Type with any new values passed through the body parameters. All body parameters are optional and if not provided will remain unchanged. Only the unique identifier name can not be changed.

Permission Required: kelvin.permission.custom-actions.update.

updateCustomActionsType: POST /api/v4/custom-actions/types/{name}/update

Parameters:

  • name (str) – str, optional Custom Action Type key name to update. Case sensitive name.

  • data (Union[CustomActionsTypeUpdate, Mapping[str, object], None]) – requests.CustomActionsTypeUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.CustomActionsTypeUpdate

    • update_custom_actions_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

CustomActionsTypeUpdate

classmethod delete_custom_action(action_id, _dry_run=False, _client=None)[source]

Permanently delete an existing Custom Action.

Permission Required: kelvin.permission.custom-actions.delete.

deleteCustomAction: POST /api/v4/custom-actions/{action_id}/delete

Parameters:

  • action_id (str) – str, optional

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_custom_action(action_id, _dry_run=False, _client=None)[source]

Get Custom Action

Permission Required: kelvin.permission.custom-actions.read.

getCustomAction: GET /api/v4/custom-actions/{action_id}/get

Parameters:

  • action_id (str) – str, optional

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

CustomActionGet

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

DataQuality

Kelvin API Client.

class kelvin.api.client.api.data_quality.DataQuality(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod delete_bulk_data_quality(data=None, _dry_run=False, _client=None, **kwargs)[source]

Deletes multiple data quality configurations.

Permission Required: kelvin.permission.data-quality.delete.

deleteBulkDataQuality: POST /api/v4/data-quality/configuration/bulk/delete

Parameters:

  • data (Union[BulkDataQualityDelete, Mapping[str, object], None]) – requests.BulkDataQualityDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkDataQualityDelete

    • delete_bulk_data_quality: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod upsert_bulk_data_quality(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create or update multiple data quality configurations at once.

Permission Required: kelvin.permission.data-quality.create.

upsertBulkDataQuality: POST /api/v4/data-quality/configuration/bulk/upsert

Parameters:

  • data (Union[BulkDataQualityUpsert, Mapping[str, object], None]) – requests.BulkDataQualityUpsert, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkDataQualityUpsert

    • upsert_bulk_data_quality: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod create_data_quality(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Data Quality Configuration.

A data Quality is a configuration that defines all the algorithms being used to monitor a resource data quality.

All configurations are optional. There are no validations done regarding each configuration content.

Permission Required: kelvin.permission.data-quality.create.

createDataQuality: POST /api/v4/data-quality/configuration/create

Parameters:

  • data (Union[DataQualityCreate, Mapping[str, object], None]) – requests.DataQualityCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityCreate

    • create_data_quality: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataQualityCreate

classmethod list_data_quality(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, search=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List data quality configurations based on the provided filters.

Permission Required: kelvin.permission.data-quality.read.

listDataQuality: POST /api/v4/data-quality/configuration/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • search (Optional[Sequence[str]]) – Sequence[str] Search for data qualities with resources matching the search term.

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[DataQualityList, Mapping[str, object], None]) – requests.DataQualityList, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityList

    • list_data_quality: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[DataQuality], DataQualityListPaginatedResponseCursor]

classmethod delete_data_quality(resource, _dry_run=False, _client=None)[source]

Delete a Data Quality configuration by resource.

Permission Required: kelvin.permission.data-quality.delete.

deleteDataQuality: POST /api/v4/data-quality/configuration/{resource}/delete

Parameters:

  • resource (str) – str, optional Asset Data Stream pair for deleting the associated DataQuality configurations. (example: krn:ad:asset1/setpoint).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_data_quality(resource, _dry_run=False, _client=None)[source]

Get a Data Quality configuration by resource.

Permission Required: kelvin.permission.data-quality.read.

getDataQuality: GET /api/v4/data-quality/configuration/{resource}/get

Parameters:

  • resource (str) – str, optional Asset/Data Stream pair to retrieve the associated DataQuality configurations. (example: krn:ad:asset1/setpoint).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataQualityGet

classmethod update_data_quality(resource, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a Data Quality by providing the new configuration. This request changes the whole Data Quality Configuration.

Permission Required: kelvin.permission.data-quality.update.

updateDataQuality: POST /api/v4/data-quality/configuration/{resource}/update

Parameters:

  • resource (str) – str, optional Asset Data Stream pair to update the associated Data Quality configurations. (example: krn:ad:asset1/setpoint).

  • data (Union[DataQualityUpdate, Mapping[str, object], None]) – requests.DataQualityUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityUpdate

    • update_data_quality: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataQualityUpdate

classmethod bulk_delete_data_quality_metrics(data=None, _dry_run=False, _client=None, **kwargs)[source]

Delete multiple Data Quality Metrics by their names in a single request.

Permission Required: kelvin.permission.data-quality.delete.

bulkDeleteDataQualityMetrics: POST /api/v4/data-quality/metric/bulk/delete

Parameters:

  • data (Union[DeleteDataQualityMetricsBulk, Mapping[str, object], None]) – requests.DeleteDataQualityMetricsBulk, optional

  • **kwargs (object) –

    Extra parameters for requests.DeleteDataQualityMetricsBulk

    • bulk_delete_data_quality_metrics: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod bulk_upsert_data_quality_metrics(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create or update multiple Data Quality Metrics in a single request.

Permission Required: kelvin.permission.data-quality.create and kelvin.permission.data-quality.update.

bulkUpsertDataQualityMetrics: POST /api/v4/data-quality/metric/bulk/upsert

Parameters:

  • data (Union[UpsertDataQualityMetricsBulk, Mapping[str, object], None]) – requests.UpsertDataQualityMetricsBulk, optional

  • **kwargs (object) –

    Extra parameters for requests.UpsertDataQualityMetricsBulk

    • bulk_upsert_data_quality_metrics: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod create_data_quality_metric(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Data Quality Metric.

Permission Required: kelvin.permission.data-quality.create.

createDataQualityMetric: POST /api/v4/data-quality/metric/create

Parameters:

  • data (Union[DataQualityMetricCreate, Mapping[str, object], None]) – requests.DataQualityMetricCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityMetricCreate

    • create_data_quality_metric: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataQualityMetricCreate

classmethod list_data_quality_metrics(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Data Quality Metrics and its parameters. The Data Quality Metrics can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.data-quality.read.

listDataQualityMetrics: POST /api/v4/data-quality/metric/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[DataQualityMetricsList, Mapping[str, object], None]) – requests.DataQualityMetricsList, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityMetricsList

    • list_data_quality_metrics: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[DataQualityMetric], DataQualityMetricsListPaginatedResponseCursor]

classmethod delete_data_quality_metric(metric_name, _dry_run=False, _client=None)[source]

Delete a Data Quality Metric by name.

Permission Required: kelvin.permission.data-quality.delete.

deleteDataQualityMetric: POST /api/v4/data-quality/metric/{metric_name}/delete

Parameters:

  • metric_name (str) – str, optional The unique identifier name of the Data Quality Metric to delete.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_data_quality_metric(metric_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Data Quality Metric.

Permission Required: kelvin.permission.data-quality.read.

getDataQualityMetric: GET /api/v4/data-quality/metric/{metric_name}/get

Parameters:

  • metric_name (str) – str, optional The unique identifier name of the Data Quality Metric to retrieve.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataQualityMetricGet

classmethod update_data_quality_metric(metric_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Data Quality Metric.

Permission Required: kelvin.permission.data-quality.update.

updateDataQualityMetric: POST /api/v4/data-quality/metric/{metric_name}/update

Parameters:

  • metric_name (str) – str, optional The unique identifier name of the Data Quality Metric to update.

  • data (Union[DataQualityMetricUpdate, Mapping[str, object], None]) – requests.DataQualityMetricUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityMetricUpdate

    • update_data_quality_metric: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataQualityMetricUpdate

classmethod data_quality_simulate(data=None, _dry_run=False, _client=None, **kwargs)[source]

Simulate the effect of data quality updates without making permanent changes.

Permission Required: kelvin.permission.data-quality.read.

DataQualitySimulate: POST /api/v4/data-quality/simulate

Parameters:

  • data (Union[DataQualitySimulate, Mapping[str, object], None]) – requests.DataQualitySimulate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualitySimulate

    • data_quality_simulate: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataQualitySimulate

classmethod data_quality_statistics(data=None, _dry_run=False, _client=None, **kwargs)[source]

Retrieve data quality statistics regarding the ‘kelvin_data_quality_score’ metric.

Permission Required: kelvin.permission.data-quality.read.

DataQualityStatistics: POST /api/v4/data-quality/statistics

Parameters:

  • data (Union[DataQualityStatistics, Mapping[str, object], None]) – requests.DataQualityStatistics, optional

  • **kwargs (object) –

    Extra parameters for requests.DataQualityStatistics

    • data_quality_statistics: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataQualityStatistics

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

DataTag

Kelvin API Client.

class kelvin.api.client.api.data_tag.DataTag(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_data_tag(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Data Tag event.

Permission Required: kelvin.permission.datatag.create.

createDataTag: POST /api/v4/datatags/create

Parameters:

  • data (Union[DataTagCreate, Mapping[str, object], None]) – requests.DataTagCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataTagCreate

    • create_data_tag: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataTagCreate

classmethod list_data_tag(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Data Tags. The Data Tags can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.datatag.read.

listDataTag: POST /api/v4/datatags/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[DataTagList, Mapping[str, object], None]) – requests.DataTagList, optional

  • **kwargs (object) –

    Extra parameters for requests.DataTagList

    • list_data_tag: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[DataTag], DataTagListPaginatedResponseCursor]

classmethod create_tag(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Tag.

Permission Required: kelvin.permission.datatag.create.

createTag: POST /api/v4/datatags/tags/create

Parameters:

  • data (Union[TagCreate, Mapping[str, object], None]) – requests.TagCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.TagCreate

    • create_tag: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

TagCreate

classmethod list_tag(search=None, names=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Tags. The Tags can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.datatag.read.

listTag: GET /api/v4/datatags/tags/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the key name (Tag Name). All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • names (Optional[Sequence[str]]) – Sequence[str] Filter on the list based on the key name (Tag Name). All values in array will be filtered as OR. The search is case insensitive and is on the full Tags name only.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[Tag], TagListPaginatedResponseCursor]

classmethod delete_tag(tag_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Tag. An error will be returned if there are any current links to a DataTag and the Tag will not be deleted. Permission Required: kelvin.permission.datatag.delete.

deleteTag: POST /api/v4/datatags/tags/{tag_name}/delete

Parameters:

  • tag_name (str) – str, optional Tag key name.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_tag(tag_name, _dry_run=False, _client=None)[source]

Retrieves a Tag.

Permission Required: kelvin.permission.datatag.read.

getTag: GET /api/v4/datatags/tags/{tag_name}/get

Parameters:

  • tag_name (str) – str, optional Tag key name.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

TagGet

classmethod update_tag(tag_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Tag. The Tag key name can not be updated.

Permission Required: kelvin.permission.datatag.update.

updateTag: POST /api/v4/datatags/tags/{tag_name}/update

Parameters:

  • tag_name (str) – str, optional Tag key name.

  • data (Union[TagUpdate, Mapping[str, object], None]) – requests.TagUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.TagUpdate

    • update_tag: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

TagUpdate

classmethod delete_data_tag(datatag_id, _dry_run=False, _client=None)[source]

Permanently delete an existing Data Tag. Permission Required: kelvin.permission.datatag.delete.

deleteDataTag: POST /api/v4/datatags/{datatag_id}/delete

Parameters:

  • datatag_id (str) – str, optional Data Tag key id. The string can only contain alphanumeric characters and - character.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_data_tag(datatag_id, _dry_run=False, _client=None)[source]

Retrieves a Data Tag.

Permission Required: kelvin.permission.datatag.read.

getDataTag: GET /api/v4/datatags/{datatag_id}/get

Parameters:

  • datatag_id (str) – str, optional Data Tag key id. The string can only contain alphanumeric characters and - character.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataTagGet

classmethod update_data_tag(datatag_id, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Data Tag. Any parameters that are not provided will remain unchanged.

Permission Required: kelvin.permission.datatag.update.

updateDataTag: POST /api/v4/datatags/{datatag_id}/update

Parameters:

  • datatag_id (str) – str, optional Data Tag key id. The string can only contain alphanumeric characters and - character.

  • data (Union[DataTagUpdate, Mapping[str, object], None]) – requests.DataTagUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataTagUpdate

    • update_data_tag: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataTagUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

DataStreams

Kelvin API Client.

class kelvin.api.client.api.datastreams.Datastreams(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_bulk_data_stream(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a list of new Data Streams.

Permission Required: kelvin.permission.datastreams.create.

createBulkDataStream: POST /api/v4/datastreams/bulk/create

Parameters:

  • data (Union[BulkDataStreamCreate, Mapping[str, object], None]) – requests.BulkDataStreamCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkDataStreamCreate

    • create_bulk_data_stream: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod delete_bulk_data_stream(data=None, _dry_run=False, _client=None, **kwargs)[source]

Delete a list of Data Streams.

Permission Required: kelvin.permission.datastreams.delete.

deleteBulkDataStream: POST /api/v4/datastreams/bulk/delete

Parameters:

  • data (Union[BulkDataStreamDelete, Mapping[str, object], None]) – requests.BulkDataStreamDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkDataStreamDelete

    • delete_bulk_data_stream: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod list_data_stream_contexts(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Data Streams, where each stream includes an array of its associated Assets and respective data sources. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.datastreams.read.

listDataStreamContexts: POST /api/v4/datastreams/context/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[DataStreamContextsList, Mapping[str, object], None]) – requests.DataStreamContextsList, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamContextsList

    • list_data_stream_contexts: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[DataStreamContext], DataStreamContextsListPaginatedResponseCursor]

classmethod create_data_stream(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Data Stream.

Permission Required: kelvin.permission.datastreams.create.

createDataStream: POST /api/v4/datastreams/create

Parameters:

  • data (Union[DataStreamCreate, Mapping[str, object], None]) – requests.DataStreamCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamCreate

    • create_data_stream: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataStreamCreate

classmethod list_data_streams_data_types(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, search=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Data Types and its parameters. The Data Types can be optionally filtered and sorted on the server before being returned.

Pagination Sortable Columns: name, title, created, updated

Permission Required: kelvin.permission.datastreams.read.

listDataStreamsDataTypes: GET /api/v4/datastreams/data-types/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • search (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[DataStreamDataType], DataStreamsDataTypesListPaginatedResponseCursor]

classmethod list_data_streams(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Data Streams and its parameters. The Data Streams can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.datastreams.read.

listDataStreams: POST /api/v4/datastreams/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[DataStreamsList, Mapping[str, object], None]) – requests.DataStreamsList, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamsList

    • list_data_streams: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[DataStream], DataStreamsListPaginatedResponseCursor]

classmethod create_data_stream_semantic_type(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Semantic Type.

Permission Required: kelvin.permission.datastreams.create.

createDataStreamSemanticType: POST /api/v4/datastreams/semantic-types/create

Parameters:

  • data (Union[DataStreamSemanticTypeCreate, Mapping[str, object], None]) – requests.DataStreamSemanticTypeCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamSemanticTypeCreate

    • create_data_stream_semantic_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataStreamSemanticTypeCreate

classmethod list_data_streams_semantic_types(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, search=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Semantic Types and its parameters. The Semantic Types can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.datastreams.read.

listDataStreamsSemanticTypes: GET /api/v4/datastreams/semantic-types/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • search (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[DataStreamSemanticType], DataStreamsSemanticTypesListPaginatedResponseCursor]

classmethod delete_data_stream_semantic_type(semantic_type_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Semantic Type. An error will be returned if there are any current links to a Semantic Type. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.datastreams.delete.

deleteDataStreamSemanticType: POST /api/v4/datastreams/semantic-types/{semantic_type_name}/delete

Parameters:

  • semantic_type_name (str) – str, optional Semantic Type key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_data_stream_semantic_type(semantic_type_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Semantic Type.

Permission Required: kelvin.permission.datastreams.read.

getDataStreamSemanticType: GET /api/v4/datastreams/semantic-types/{semantic_type_name}/get

Parameters:

  • semantic_type_name (str) – str, optional Semantic Type key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataStreamSemanticTypeGet

classmethod update_data_stream_semantic_type(semantic_type_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Semantic Type with any new values passed through the body parameters. All body parameters are optional and if not provided will remain unchanged.

Permission Required: kelvin.permission.datastreams.create.

updateDataStreamSemanticType: POST /api/v4/datastreams/semantic-types/{semantic_type_name}/update

Parameters:

  • semantic_type_name (str) – str, optional Semantic Type key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[DataStreamSemanticTypeUpdate, Mapping[str, object], None]) – requests.DataStreamSemanticTypeUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamSemanticTypeUpdate

    • update_data_stream_semantic_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataStreamSemanticTypeUpdate

classmethod create_bulk_data_stream_unit(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a list of new Units.

Permission Required: kelvin.permission.datastreams.create.

createBulkDataStreamUnit: POST /api/v4/datastreams/units/bulk/create

Parameters:

  • data (Union[BulkDataStreamUnitCreate, Mapping[str, object], None]) – requests.BulkDataStreamUnitCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkDataStreamUnitCreate

    • create_bulk_data_stream_unit: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod create_data_stream_unit(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Unit.

Permission Required: kelvin.permission.datastreams.create.

createDataStreamUnit: POST /api/v4/datastreams/units/create

Parameters:

  • data (Union[DataStreamUnitCreate, Mapping[str, object], None]) – requests.DataStreamUnitCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamUnitCreate

    • create_data_stream_unit: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataStreamUnitCreate

classmethod list_data_streams_units(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, search=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Units and its parameters. The Units can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.datastreams.read.

listDataStreamsUnits: GET /api/v4/datastreams/units/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • search (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[Unit], DataStreamsUnitsListPaginatedResponseCursor]

classmethod delete_data_stream_unit(unit_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Unit. An error will be returned if there are any current links to a Unit. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.datastreams.delete.

deleteDataStreamUnit: POST /api/v4/datastreams/units/{unit_name}/delete

Parameters:

  • unit_name (str) – str, optional Unit key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_data_stream_unit(unit_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Unit.

Permission Required: kelvin.permission.datastreams.read.

getDataStreamUnit: GET /api/v4/datastreams/units/{unit_name}/get

Parameters:

  • unit_name (str) – str, optional Unit parameter name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataStreamUnitGet

classmethod update_data_stream_unit(unit_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Unit with any new values passed through the body parameters. All body parameters are optional and if not provided will remain unchanged.

Permission Required: kelvin.permission.datastreams.update.

updateDataStreamUnit: POST /api/v4/datastreams/units/{unit_name}/update

Parameters:

  • unit_name (str) – str, optional Unit parameter name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[DataStreamUnitUpdate, Mapping[str, object], None]) – requests.DataStreamUnitUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamUnitUpdate

    • update_data_stream_unit: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataStreamUnitUpdate

classmethod get_data_stream_context(datastream_name, _dry_run=False, _client=None)[source]

Retrieve an array of Assets and respective data sources contextualized within a specific Data Stream.

Permission Required: kelvin.permission.datastreams.read.

getDataStreamContext: GET /api/v4/datastreams/{datastream_name}/context/get

Parameters:

  • datastream_name (str) – str, optional Data Stream key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataStreamContextGet

classmethod delete_data_stream(datastream_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Data Stream. You will no longer be able to access any data saved in Asset / Data Stream pairs. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.datastreams.delete.

deleteDataStream: POST /api/v4/datastreams/{datastream_name}/delete

Parameters:

  • datastream_name (str) – str, optional Data Stream key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_data_stream(datastream_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Data Stream.

Permission Required: kelvin.permission.datastreams.read.

getDataStream: GET /api/v4/datastreams/{datastream_name}/get

Parameters:

  • datastream_name (str) – str, optional Data Stream key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

DataStreamGet

classmethod update_data_stream(datastream_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Data Stream with a new ‘title’ and/or ‘description’ and/or ‘type’ and/or ‘semantic_type_name’ and/or ‘unit_name’. Any parameters that are not provided will remain unchanged.

Permission Required: kelvin.permission.datastreams.update.

updateDataStream: POST /api/v4/datastreams/{datastream_name}/update

Parameters:

  • datastream_name (str) – str, optional Data Stream key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[DataStreamUpdate, Mapping[str, object], None]) – requests.DataStreamUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.DataStreamUpdate

    • update_data_stream: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

DataStreamUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

FileStorage

Kelvin API Client.

class kelvin.api.client.api.filestorage.Filestorage(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod list_files(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List the files currently present in the filestorage

Permission Required: kelvin.permission.filestorage.read.

listFiles: POST /api/v4/filestorage/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • data (Union[FilesList, Mapping[str, object], None]) – requests.FilesList, optional

  • **kwargs (object) –

    Extra parameters for requests.FilesList

    • list_files: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[FileStorage], FilesListPaginatedCursor]

classmethod upload_file(file, metadata=None, _dry_run=False, _client=None)[source]

Upload a file

Permission Required: kelvin.permission.filestorage.upload.

uploadFile: POST /api/v4/filestorage/upload

Parameters:
Return type:

FileUpload

classmethod delete_file(file_id, _dry_run=False, _client=None)[source]

Deletes the requested file from filestorage

Permission Required: kelvin.permission.filestorage.delete.

deleteFile: POST /api/v4/filestorage/{file_id}/delete

Parameters:

  • file_id (str) – str, optional UUID of the desired file

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod download_file(file_id, _dry_run=False, _client=None)[source]

Downloads the requested file

Permission Required: kelvin.permission.filestorage.download.

downloadFile: GET /api/v4/filestorage/{file_id}/download

Parameters:

  • file_id (str) – str, optional UUID of the desired file

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Iterator[bytes]

classmethod get_file(file_id, _dry_run=False, _client=None)[source]

Fetches the information for a specific file

Permission Required: kelvin.permission.filestorage.read.

getFile: GET /api/v4/filestorage/{file_id}/get

Parameters:

  • file_id (str) – str, optional UUID of the desired file

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

FileGet

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Guardrails

Kelvin API Client.

class kelvin.api.client.api.guardrails.Guardrails(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_bulk_guardrails(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create multiple guardrails at once.

Permission Required: kelvin.permission.guardrails.create.

createBulkGuardrails: POST /api/v4/guardrails/bulk/create

Parameters:

  • data (Union[BulkGuardrailsCreate, Mapping[str, object], None]) – requests.BulkGuardrailsCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkGuardrailsCreate

    • create_bulk_guardrails: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

BulkGuardrailsCreate

classmethod delete_bulk_guardrails(data=None, _dry_run=False, _client=None, **kwargs)[source]

Deletes multiple guardrails.

Permission Required: kelvin.permission.guardrails.delete.

deleteBulkGuardrails: POST /api/v4/guardrails/bulk/delete

Parameters:

  • data (Union[BulkGuardrailsDelete, Mapping[str, object], None]) – requests.BulkGuardrailsDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.BulkGuardrailsDelete

    • delete_bulk_guardrails: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod create_guardrail(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Guardrail.

A Guardrail is a configuration that defines a range of values, absolute or relative, that a control change must stay within. If the control change is outside of the defined range, it will be blocked and marked as rejected.

All configurations are optional. There are no validations done regarding a min being higher than a max or vice versa.

Additionally, a Guardrail value may be set by a data stream.

Permission Required: kelvin.permission.guardrails.create.

createGuardrail: POST /api/v4/guardrails/create

Parameters:

  • data (Union[GuardrailCreate, Mapping[str, object], None]) – requests.GuardrailCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.GuardrailCreate

    • create_guardrail: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

GuardrailCreate

classmethod list_guardrails(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, search=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

List guardrails based on the provided filters.

Permission Required: kelvin.permission.guardrails.read.

listGuardrails: POST /api/v4/guardrails/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • search (Optional[Sequence[str]]) – Sequence[str] Search for guardrails with resources matching the search term.

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[GuardrailsList, Mapping[str, object], None]) – requests.GuardrailsList, optional

  • **kwargs (object) –

    Extra parameters for requests.GuardrailsList

    • list_guardrails: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[Guardrail], GuardrailsListPaginatedResponseCursor]

classmethod delete_guardrail(resource, _dry_run=False, _client=None)[source]

Delete a Guardrail by ID.

Permission Required: kelvin.permission.guardrails.delete.

deleteGuardrail: POST /api/v4/guardrails/{resource}/delete

Parameters:

  • resource (str) – str, optional Asset/Data Stream pair for deleting the associated Guardrail configurations. (example: krn:ad:asset1/setpoint).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_guardrail(resource, _dry_run=False, _client=None)[source]

Get a Guardrail by ID.

Permission Required: kelvin.permission.guardrails.read.

getGuardrail: GET /api/v4/guardrails/{resource}/get

Parameters:

  • resource (str) – str, optional Asset/Data Stream pair to retrieve the associated Guardrail configurations. (example: krn:ad:asset1/setpoint).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

GuardrailGet

classmethod update_guardrail(resource, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a Guardrail by providing the Guardrail ID and the fields to update. This request changes the whole Guardrail.

Permission Required: kelvin.permission.guardrails.update.

updateGuardrail: POST /api/v4/guardrails/{resource}/update

Parameters:

  • resource (str) – str, optional Asset/Data Stream pair to update the associated Guardrail configurations. (example: krn:ad:asset1/setpoint).

  • data (Union[GuardrailUpdate, Mapping[str, object], None]) – requests.GuardrailUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.GuardrailUpdate

    • update_guardrail: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

GuardrailUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Instance

Kelvin API Client.

class kelvin.api.client.api.instance.Instance(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod list_instance_audit_logs(action=None, user_id=None, namespace=None, identifier=None, username=None, request_id=None, search=None, from_date_time=None, to_date_time=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

List Audit Log Permission Required: kelvin.permission.audit_log.read.

listInstanceAuditLogs: GET /api/v4/instance/auditlog/list

Parameters:

  • action (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key action. The filter is on the full name only.

  • user_id (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key user_id. The filter is on the full name only.

  • namespace (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key namespace. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters. If set, it will override acp_name

  • identifier (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key identifier. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters. If set, it will override acp_name

  • username (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key username. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters. If set, it will override acp_name

  • request_id (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key request_id. The filter is on the full name only.

  • search (Optional[Sequence[str]]) – Sequence[str] Search Audit Logs by key action, username or namespace. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • from_date_time (Optional[datetime]) – datetime Filter actions that occurred at or after this UTC time, formatted in RFC 3339.

  • to_date_time (Optional[datetime]) – datetime Filter actions that occurred until or at this UTC time, formatted in RFC 3339.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[InstanceAuditLogGetItem], InstanceAuditLogsListPaginatedResponseCursor]

classmethod get_instance_audit_log(audit_logger_id, _dry_run=False, _client=None)[source]

Get Audit Log

Permission Required: kelvin.permission.audit_log.read.

getInstanceAuditLog: GET /api/v4/instance/auditlog/{audit_logger_id}/get

Parameters:

  • audit_logger_id (int) – int, optional Unique ID of the Audit Log entry to get.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

InstanceAuditLogGet

classmethod get_instance_settings_kelvin_cluster(_dry_run=False, _client=None)[source]

Retrieve the Cluster Instance Settings.

Permission Required: kelvin.permission.instance.read.

getInstanceSettingsKelvinCluster: GET /api/v4/instance/settings/kelvin-cluster/get

Return type:

InstanceSettingsKelvinClusterGet

Parameters:

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

classmethod update_instance_settings_kelvin_cluster(data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Kelvin Cluster Instance Settings with any new values passed through the body parameters. All body parameters are optional and if not provided will remain unchanged.

Permission Required: kelvin.permission.instance.update.

updateInstanceSettingsKelvinCluster: POST /api/v4/instance/settings/kelvin-cluster/update

Parameters:

  • data (Union[InstanceSettingsKelvinClusterUpdate, Mapping[str, object], None]) – requests.InstanceSettingsKelvinClusterUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.InstanceSettingsKelvinClusterUpdate

    • update_instance_settings_kelvin_cluster: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

InstanceSettingsKelvinClusterUpdate

classmethod list_instance_settings(names=None, search=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

List Instance Settings

Permission Required: kelvin.permission.instance.read.

listInstanceSettings: GET /api/v4/instance/settings/list

Parameters:

  • names (Optional[Sequence[str]]) – Sequence[str] Filter Instance Setting list based on the key name.

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the Instance Setting list based on the key name. The search is case sensitive but will find partial matches anywhere in the name.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[InstanceSettings], InstanceSettingsListPaginatedResponseCursor]

classmethod delete_instance_setting(setting_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Instance Setting. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.instance.delete.

deleteInstanceSetting: POST /api/v4/instance/settings/{setting_name}/delete

Parameters:

  • setting_name (str) – str, optional Unique identifier name of the Instance Setting to delete.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_instance_settings(setting_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of an Instance Setting.

Permission Required: kelvin.permission.instance.read.

getInstanceSettings: GET /api/v4/instance/settings/{setting_name}/get

Parameters:

  • setting_name (str) – str, optional Unique identifier name of the Instance Setting to get.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

InstanceSettingsGet

classmethod update_instance_settings(setting_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Instance Settings. Any parameters that are not provided will remain unchanged.

Permission Required: kelvin.permission.instance.update.

updateInstanceSettings: POST /api/v4/instance/settings/{setting_name}/update

Parameters:

  • setting_name (str) – str, optional Unique identifier name of the Instance Setting to update.

  • data (Union[InstanceSettingsUpdate, Mapping[str, object], None]) – requests.InstanceSettingsUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.InstanceSettingsUpdate

    • update_instance_settings: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

InstanceSettingsUpdate

classmethod get_instance_status(_dry_run=False, _client=None)[source]

Retrieve the Health Status of all services on the Instance

Permission Required: n/a.

getInstanceStatus: GET /api/v4/instance/status/get

Return type:

InstanceStatusGet

Parameters:

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Orchestration

Kelvin API Client.

class kelvin.api.client.api.orchestration.Orchestration(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_orchestration_clusters(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Cluster. This only creates the Cloud registration, the actual installation still needs to be manually performed on the server/kubernetes cluster. The provision script to run locally on the server for type registered as k3s or on an existing kubernetes cluster for type registered as kubernetes will be in the key `provision_script ` in the 201 response body.

Permission Required: kelvin.permission.cluster.create.

createOrchestrationClusters: POST /api/v4/orchestration/clusters/create

Parameters:

  • data (Union[OrchestrationClustersCreate, Mapping[str, object], None]) – requests.OrchestrationClustersCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.OrchestrationClustersCreate

    • create_orchestration_clusters: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

OrchestrationClustersCreate

classmethod list_orchestration_clusters(names=None, search=None, type=None, ready=None, status=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Cluster objects. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.cluster.read.

listOrchestrationClusters: GET /api/v4/orchestration/clusters/list

Parameters:

  • names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the Cluster key name. The filter is on the full name only. All strings in the array are treated as OR. Can only contain lowercase alphanumeric characters and ., _ or - characters.

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the Cluster keys title (Display Name) or name. The search is case insensitive and will find partial matches as well.

  • type (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the Cluster key type. The filter is on the full name only. All strings in the array are treated as OR. Options are k3s and kubernetes

  • ready (Optional[bool]) – bool A filter on the list based on the Cluster key ready. Options are true and false

  • status (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the Cluster key status. The filter is on the full name only. All strings in the array are treated as OR. Options are pending_provision, pending, online, unreachable and requires_attention

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one of the Cluster parameters. Only one parameter can be selected. Options: name, title, ready, type, status, last_seen, created, updated, kelvin_version, container_version.

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[OrchestrationClustersCreateItem], OrchestrationClustersListPaginatedResponseCursor]

classmethod download_orchestration_cluster_provision_binary(arch=None, type=None, _dry_run=False, _client=None)[source]

Download Cluster Provision Binary

Permission Required: kelvin.permission.cluster.read.

downloadOrchestrationClusterProvisionBinary: GET /api/v4/orchestration/clusters/provision/bin/download

Parameters:

  • arch (Optional[Literal['amd64', 'arm64', 'armv7']]) – Literal['amd64', 'arm64', 'armv7'] Architecture of the binary to download. Options are amd64, arm64, armv7 (default: amd64) (‘amd64’, ‘arm64’, ‘armv7’)

  • type (Optional[Literal['kubernetes', 'docker']]) – Literal['kubernetes', 'docker'] Type of the binary to download. Options are kubernetes, docker (default: kubernetes) (‘kubernetes’, ‘docker’)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Iterator[bytes]

classmethod delete_orchestration_clusters(cluster_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Cluster and its Nodes. This will also delete Workloads, Bridges and Services residing on the Cluster. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.cluster.delete.

deleteOrchestrationClusters: POST /api/v4/orchestration/clusters/{cluster_name}/delete

Parameters:

  • cluster_name (str) – str, optional Cluster key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod apply_orchestration_clusters_edge_apps_version(cluster_name, _dry_run=False, _client=None)[source]

Initiates available cluster upgrades; requires cluster to be online and ready.

Permission Required: kelvin.permission.cluster.update.

applyOrchestrationClustersEdgeAppsVersion: GET /api/v4/orchestration/clusters/{cluster_name}/edge-apps/version/apply

Parameters:

  • cluster_name (str) – str, optional Cluster key name to initiate upgrades. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod update_orchestration_clusters_edge_apps_version_force(cluster_name, persist=None, _dry_run=False, _client=None)[source]

Force available updates to Cluster even if update setting is disabled. Optionally keep a force update action on standby if the Cluster is offline. This ensures the update is applied once the Cluster returns online.

Permission Required: kelvin.permission.cluster.update.

updateOrchestrationClustersEdgeAppsVersionForce: POST /api/v4/orchestration/clusters/{cluster_name}/edge-apps/version/force-update

Parameters:

  • cluster_name (str) – str, optional Cluster key name to initiate upgrades. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • persist (Optional[bool]) – bool Optional setting to wait if the Cluster is currently unreachable and force the update when the Cluster is next online.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_orchestration_clusters(cluster_name, _dry_run=False, _client=None)[source]

Retrieve the parameters and status of a Cluster.

Permission Required: kelvin.permission.cluster.read.

getOrchestrationClusters: GET /api/v4/orchestration/clusters/{cluster_name}/get

Parameters:

  • cluster_name (str) – str, optional Cluster key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

OrchestrationClustersGet

classmethod get_orchestration_clusters_manifests(cluster_name, version, _dry_run=False, _client=None)[source]

Get Cluster Manifests

Permission Required: kelvin.permission.cluster.read.

getOrchestrationClustersManifests: GET /api/v4/orchestration/clusters/{cluster_name}/manifests/get

Parameters:

  • cluster_name (str) – str, optional Cluster key name to retrieve provision yaml file. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • version (str) – str, optional Current version of the key kelvin_version in version object of the Cluster parameters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

OrchestrationClustersManifestsGet

classmethod list_orchestration_clusters_node(cluster_name, search=None, status=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Node objects in a Cluster. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.cluster.read.

listOrchestrationClustersNode: GET /api/v4/orchestration/clusters/{cluster_name}/nodes/list

Parameters:

  • cluster_name (str) – str, optional Cluster key name containing the Nodes to list. The filter is on the full name only. Can only contain lowercase alphanumeric characters and ., _ or - characters.

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the Node name. The search is case insensitive and will find partial matches as well.

  • status (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the Node key status. The filter is on the full name only. All strings in the array are treated as OR. Options are online, unreachable and not_ready

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one of the Cluster parameters. Only one parameter can be selected. Options: id, name, status, last_seen, created and updated.

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[OrchestrationClustersNodesGetItem], OrchestrationClustersNodeListPaginatedResponseCursor]

classmethod get_orchestration_clusters_nodes(cluster_name, node_name, _dry_run=False, _client=None)[source]

Retrieve the parameters and status of a specific Node on a Cluster.

Permission Required: kelvin.permission.cluster.read.

getOrchestrationClustersNodes: GET /api/v4/orchestration/clusters/{cluster_name}/nodes/{node_name}/get

Parameters:

  • cluster_name (str) – str, optional Cluster key name to look for Node. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • node_name (str) – str, optional Node key name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

OrchestrationClustersNodesGet

classmethod get_orchestration_clusters_provision(cluster_name, _dry_run=False, _client=None)[source]

Get Clusters Provision YAML Specifications

Permission Required: kelvin.permission.cluster.read.

getOrchestrationClustersProvision: GET /api/v4/orchestration/clusters/{cluster_name}/provision/get

Parameters:

  • cluster_name (str) – str, optional Cluster key name to retrieve provision yaml file. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

str

classmethod list_orchestration_clusters_service(cluster_name, search=None, workload_name=None, service_type=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Service objects in a Cluster. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.cluster.read.

listOrchestrationClustersService: GET /api/v4/orchestration/clusters/{cluster_name}/services/list

Parameters:

  • cluster_name (str) – str, optional Cluster key name containing the Services to list. The filter is on the full name only. Can only contain lowercase alphanumeric characters and ., _ or - characters.

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on any of the Service keys name, workload_name, network_interface, address, and service_type. The search is case insensitive and will find partial matches as well. All strings in the array are treated as OR.

  • workload_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the Workload key name. The filter is on the full name only. All strings in the array are treated as OR.

  • service_type (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the Service Type key service_type. The filter is on the full name only. All strings in the array are treated as OR. Options are cluster_ip, node_port and host_port.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one of the Cluster parameters. Only one parameter can be selected. Options: name, workload_name, network_interface, service_type, address, created and updated.

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[ServiceItem], OrchestrationClustersServiceListPaginatedResponseCursor]

classmethod update_orchestration_clusters(cluster_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update the configuration settings of the Cluster. Only key/values provided in the request body will be updated, all other settings will remain unchanged.

Permission Required: kelvin.permission.cluster.update.

updateOrchestrationClusters: POST /api/v4/orchestration/clusters/{cluster_name}/update

Parameters:

  • cluster_name (str) – str, optional Cluster key name target for sending parameter updates. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[OrchestrationClustersUpdate, Mapping[str, object], None]) – requests.OrchestrationClustersUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.OrchestrationClustersUpdate

    • update_orchestration_clusters: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

OrchestrationClustersUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Properties

Kelvin API Client.

class kelvin.api.client.api.properties.Properties(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_property(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Property Definition

Permission Required: kelvin.permission.property.create.

createProperty: POST /api/v4/properties/create

Parameters:

  • data (Union[PropertyCreate, Mapping[str, object], None]) – requests.PropertyCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.PropertyCreate

    • create_property: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

PropertyCreate

classmethod list_properties(search=None, primitive_type=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Property Definitions. The Properties can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.property.read.

listProperties: GET /api/v4/properties/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the keys title (Display Name) or name. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • primitive_type (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key primitive_type. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[PropertyDefinition], PropertiesListPaginatedResponseCursor]

classmethod get_property_unique_values(data=None, _dry_run=False, _client=None, **kwargs)[source]

Fetch the unique values for each property.

Permission Required: kelvin.permission.property.read.

getPropertyUniqueValues: POST /api/v4/properties/unique/values/get

Parameters:

  • data (Union[PropertyUniqueValuesGet, Mapping[str, object], None]) – requests.PropertyUniqueValuesGet, optional

  • **kwargs (object) –

    Extra parameters for requests.PropertyUniqueValuesGet

    • get_property_unique_values: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

PropertyUniqueValuesGet

classmethod delete_property(property_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Property. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.property.delete.

deleteProperty: POST /api/v4/properties/{property_name}/delete

Parameters:

  • property_name (str) – str, optional Property name, also known as property_name, to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_property(property_name, _dry_run=False, _client=None)[source]

Retrieve a Property Definition.

Permission Required: kelvin.permission.property.read.

getProperty: GET /api/v4/properties/{property_name}/get

Parameters:

  • property_name (str) – str, optional Property Definition name to fetch. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

PropertyGet

classmethod delete_property_values(property_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Permanently delete existing property Values. This cannot be undone once the API request has been submitted. Permission Required: kelvin.permission.property.delete.

deletePropertyValues: POST /api/v4/properties/{property_name}/values/delete

Parameters:

  • property_name (str) – str, optional Property name for which the values are to be deleted. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[PropertyValuesDelete, Mapping[str, object], None]) – requests.PropertyValuesDelete, optional

  • **kwargs (object) –

    Extra parameters for requests.PropertyValuesDelete

    • delete_property_values: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod get_property_values(property_name, resource_type=None, _dry_run=False, _client=None)[source]

Fetch property values belonging to a particular property definition.

Permission Required: kelvin.permission.property.read.

getPropertyValues: GET /api/v4/properties/{property_name}/values/get

Parameters:

  • property_name (str) – str, optional Property name for which the values are to be fetched. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • resource_type (Optional[Sequence[str]]) – Sequence[str] Array of resource types to filter the list of Property values returned.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

PropertyValuesGet

classmethod property_range_get(property_name, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Fetch the value history for a property given a time range.

Permission Required: kelvin.permission.property.read.

propertyRangeGet: POST /api/v4/properties/{property_name}/values/range/get

Parameters:

  • property_name (str) – str, optional Property name for which the values are to be updated. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[RangeGetPropertyValues, Mapping[str, object], None]) – requests.RangeGetPropertyValues, optional

  • **kwargs (object) –

    Extra parameters for requests.RangeGetPropertyValues

    • property_range_get: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[PropertyValueHistory], RangeGetPropertyPaginatedResponseCursor]

classmethod update_property_values(property_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Create or update Property Values.

Permission Required: kelvin.permission.property.create.

updatePropertyValues: POST /api/v4/properties/{property_name}/values/update

Parameters:

  • property_name (str) – str, optional Property name for which the values are to be updated. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[PropertyValuesUpdate, Mapping[str, object], None]) – requests.PropertyValuesUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.PropertyValuesUpdate

    • update_property_values: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Recommendation

Kelvin API Client.

class kelvin.api.client.api.recommendation.Recommendation(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod get_recommendation_clustering(data=None, _dry_run=False, _client=None, **kwargs)[source]

Retrieve the total count of Recommendations matching an array of resources and filter options between two dates grouped by the parameter time_bucket. Will also return a list of all the Recommendation `id`s counted.

Permission Required: kelvin.permission.recommendation.read.

getRecommendationClustering: POST /api/v4/recommendations/clustering/get

Parameters:

  • data (Union[RecommendationClusteringGet, Mapping[str, object], None]) – requests.RecommendationClusteringGet, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationClusteringGet

    • get_recommendation_clustering: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

KList[RecommendationClustering]

classmethod create_recommendation(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Recommendation. The new recommendation will automatically inherit the state pending.

Permission Required: kelvin.permission.recommendation.create.

createRecommendation: POST /api/v4/recommendations/create

Parameters:

  • data (Union[RecommendationCreate, Mapping[str, object], None]) – requests.RecommendationCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationCreate

    • create_recommendation: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RecommendationCreate

classmethod get_recommendation_last(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a dictionary with a data property containing an array of latest Recommendations. Only the latest Recommendation for each resource in the request filters will be returned.

Permission Required: kelvin.permission.recommendation.read.

getRecommendationLast: POST /api/v4/recommendations/last/get

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[RecommendationLastGet, Mapping[str, object], None]) – requests.RecommendationLastGet, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationLastGet

    • get_recommendation_last: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[Recommendation], RecommendationLastGetPaginatedResponseCursor]

classmethod list_recommendations(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Recommendation objects. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.recommendation.read.

listRecommendations: POST /api/v4/recommendations/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[RecommendationsList, Mapping[str, object], None]) – requests.RecommendationsList, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationsList

    • list_recommendations: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[Recommendation], RecommendationsListPaginatedResponseCursor]

classmethod get_recommendation_range(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a dictionary with a data property containing an array of Recommendations within a specified time range for all of the resources in the resources array that match the filter options.

Permission Required: kelvin.permission.recommendation.read.

getRecommendationRange: POST /api/v4/recommendations/range/get

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[RecommendationRangeGet, Mapping[str, object], None]) – requests.RecommendationRangeGet, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationRangeGet

    • get_recommendation_range: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[Recommendation], RecommendationRangeGetPaginatedResponseCursor]

classmethod create_recommendation_type(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Recommendation Type.

Permission Required: kelvin.permission.recommendation.create.

createRecommendationType: POST /api/v4/recommendations/types/create

Parameters:

  • data (Union[RecommendationTypeCreate, Mapping[str, object], None]) – requests.RecommendationTypeCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationTypeCreate

    • create_recommendation_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RecommendationTypeCreate

classmethod list_recommendation_types(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, search=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Recommendation Type objects. The list can be optionally filtered and sorted on the server before being returned. Permission Required: kelvin.permission.recommendation.read.

listRecommendationTypes: GET /api/v4/recommendations/types/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the key name and title. The search is case insensitive and will find partial matches as well.

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[RecommendationType], RecommendationTypesListPaginatedCursor]

classmethod delete_recommendation_type(name, _dry_run=False, _client=None)[source]

Permanently delete an existing Recommendation Type. An error will be returned if there are any current Recommendations linked to the Recommendation Type. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.recommendation.delete.

deleteRecommendationType: POST /api/v4/recommendations/types/{name}/delete

Parameters:

  • name (str) – str, optional Recommendation Type key name to delete. Case sensitive name.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_recommendation_type(name, _dry_run=False, _client=None)[source]

Retrieves the parameters of a Recommendation Type.

Permission Required: kelvin.permission.recommendation.read.

getRecommendationType: GET /api/v4/recommendations/types/{name}/get

Parameters:

  • name (str) – str, optional Recommendation Type key name to get. Case sensitive name.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

RecommendationTypeGet

classmethod update_recommendation_type(name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Recommendation Type with any new values passed through the body parameters. All body parameters are optional and if not provided will remain unchanged. Only the unique identifier name can not be changed.

Permission Required: kelvin.permission.recommendation.update.

updateRecommendationType: POST /api/v4/recommendations/types/{name}/update

Parameters:

  • name (str) – str, optional Recommendation Type key name to update. Case sensitive name.

  • data (Union[RecommendationTypeUpdate, Mapping[str, object], None]) – requests.RecommendationTypeUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationTypeUpdate

    • update_recommendation_type: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RecommendationTypeUpdate

classmethod update_recommendation_accept(recommendation_id, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a Recommendation state to accepted. This will trigger all objects in the actions parameter to be initiated. You will need to continue to monitor each action individually (for example a Control Change) to ensure it is completed successfully.

Permission Required: kelvin.permission.recommendation.update.

updateRecommendationAccept: POST /api/v4/recommendations/{recommendation_id}/accept/update

Parameters:

  • recommendation_id (str) – str, optional Recommendation key id to accept. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[RecommendationAcceptUpdate, Mapping[str, object], None]) – requests.RecommendationAcceptUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationAcceptUpdate

    • update_recommendation_accept: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod delete_recommendation(recommendation_id, _dry_run=False, _client=None)[source]

Permanently delete an existing Recommendation. Recommendations with states tagged as accepted or auto_accepted can not be deleted. This action cannot be undone once the API request has been submitted. Permission Required: kelvin.permission.recommendation.delete.

deleteRecommendation: POST /api/v4/recommendations/{recommendation_id}/delete

Parameters:

  • recommendation_id (str) – str, optional Recommendation key id to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_recommendation(recommendation_id, _dry_run=False, _client=None)[source]

Retrieves the properties, status and all associated actions of a Recommendation.

Permission Required: kelvin.permission.recommendation.read.

getRecommendation: GET /api/v4/recommendations/{recommendation_id}/get

Parameters:

  • recommendation_id (str) – str, optional Recommendation key id of the Recommendation to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

RecommendationGet

classmethod update_recommendation_reject(recommendation_id, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a Recommendation state to rejected. All actions will only be archived and not implemented.

Permission Required: kelvin.permission.recommendation.update.

updateRecommendationReject: POST /api/v4/recommendations/{recommendation_id}/reject/update

Parameters:

  • recommendation_id (str) – str, optional Recommendation key id to reject. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[RecommendationRejectUpdate, Mapping[str, object], None]) – requests.RecommendationRejectUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.RecommendationRejectUpdate

    • update_recommendation_reject: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Secret

Kelvin API Client.

class kelvin.api.client.api.secret.Secret(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_secret(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new Secret.

Once this is created you can not change or see the value itself from Kelvin API. Retrieval of the value can only be done through an App.

Permission Required: kelvin.permission.secret.create.

createSecret: POST /api/v4/secrets/create

Parameters:

  • data (Union[SecretCreate, Mapping[str, object], None]) – requests.SecretCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.SecretCreate

    • create_secret: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

SecretCreate

classmethod list_secrets(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, search=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Secrets. The actual Secret itself can not be retrieved here and is only available from an App.

Permission Required: kelvin.permission.secret.read.

listSecrets: GET /api/v4/secrets/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • search (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[SecretItem], SecretsListPaginatedResponseCursor]

classmethod delete_secret(secret_name, _dry_run=False, _client=None)[source]

Permanently delete a Secret. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.secret.delete.

deleteSecret: POST /api/v4/secrets/{secret_name}/delete

Parameters:

  • secret_name (str) – str, optional Secret key name to delete. The string can only contain lowercase alphanumeric characters and - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod update_secret(secret_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing Secret with a new ‘value’. Any parameters that are not provided will remain unchanged.

Permission Required: kelvin.permission.secret.update.

updateSecret: POST /api/v4/secrets/{secret_name}/update

Parameters:

  • secret_name (str) – str, optional Secret key name to update. The string can only contain lowercase alphanumeric characters and - characters.

  • data (Union[SecretUpdate, Mapping[str, object], None]) – requests.SecretUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.SecretUpdate

    • update_secret: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

SecretUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Thread

Kelvin API Client.

class kelvin.api.client.api.thread.Thread(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_thread(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create Thread

Permission Required: kelvin.permission.threads.create.

createThread: POST /api/v4/threads/create

Parameters:

  • data (Union[ThreadCreate, Mapping[str, object], None]) – requests.ThreadCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.ThreadCreate

    • create_thread: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ThreadCreate

classmethod list_threads(type=None, related_to=None, user_id=None, _dry_run=False, _client=None)[source]

List Threads

Pagination Sortable Columns: thread.id

Permission Required: kelvin.permission.threads.read.

listThreads: GET /api/v4/threads/list

Parameters:
Return type:

ThreadsList

classmethod delete_thread(thread_id, _dry_run=False, _client=None)[source]

Delete Thread

Permission Required: kelvin.permission.threads.delete.

deleteThread: POST /api/v4/threads/{thread_id}/delete

Parameters:

  • thread_id (str) – str, optional Thread ID

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod update_thread_follow(thread_id, follow=None, _dry_run=False, _client=None)[source]

Update Thread Follow

Permission Required: kelvin.permission.threads.read.

updateThreadFollow: POST /api/v4/threads/{thread_id}/follow/update

Parameters:

  • thread_id (str) – str, optional Thread ID

  • follow (Optional[bool]) – bool Set user follow value to true or false

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

ThreadFollowUpdate

classmethod get_thread(thread_id, _dry_run=False, _client=None)[source]

Get Thread

Permission Required: kelvin.permission.threads.read.

getThread: GET /api/v4/threads/{thread_id}/get

Parameters:

  • thread_id (str) – str, optional Thread ID

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

ThreadGet

classmethod create_thread_reply(thread_id, reply_id=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Create Thread Reply

Permission Required: kelvin.permission.threads.create.

createThreadReply: POST /api/v4/threads/{thread_id}/replies/create

Parameters:

  • thread_id (str) – str, optional Thread ID

  • reply_id (Optional[str]) – str Reply ID

  • data (Union[ThreadReplyCreate, Mapping[str, object], None]) – requests.ThreadReplyCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.ThreadReplyCreate

    • create_thread_reply: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ThreadReplyCreate

classmethod delete_thread_reply(thread_id, reply_id, _dry_run=False, _client=None)[source]

Delete Thread Reply

Permission Required: kelvin.permission.threads.delete.

deleteThreadReply: POST /api/v4/threads/{thread_id}/replies/{reply_id}/delete

Parameters:

  • thread_id (str) – str, optional Thread ID

  • reply_id (str) – str, optional Reply ID

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

str

classmethod update_thread_reply(thread_id, reply_id, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update Thread Reply

Permission Required: kelvin.permission.threads.update.

updateThreadReply: POST /api/v4/threads/{thread_id}/replies/{reply_id}/update

Parameters:

  • thread_id (str) – str, optional Thread ID

  • reply_id (str) – str, optional Reply ID

  • data (Union[ThreadReplyUpdate, Mapping[str, object], None]) – requests.ThreadReplyUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.ThreadReplyUpdate

    • update_thread_reply: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ThreadReplyUpdate

classmethod update_thread_seen(thread_id, seen=None, _dry_run=False, _client=None)[source]

Update Thread Seen

Permission Required: kelvin.permission.threads.read.

updateThreadSeen: POST /api/v4/threads/{thread_id}/seen/update

Parameters:

  • thread_id (str) – str, optional Thread ID

  • seen (Optional[bool]) – bool Set user seen value to true or false

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

ThreadSeenUpdate

classmethod update_thread(thread_id, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update Thread

Permission Required: kelvin.permission.threads.update.

updateThread: POST /api/v4/threads/{thread_id}/update

Parameters:

  • thread_id (str) – str, optional Thread ID

  • data (Union[ThreadUpdate, Mapping[str, object], None]) – requests.ThreadUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.ThreadUpdate

    • update_thread: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ThreadUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Timeseries

Kelvin API Client.

class kelvin.api.client.api.timeseries.Timeseries(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_timeseries(publish=None, data=None, _dry_run=False, _client=None, **kwargs)[source]

Create Time Series Data individually or in bulk for one or more Asset / Data Stream resources.

<span style=”color: #ff0000;font-weight: bold;”>WARNING</span> : If a value already exists at the defined time, then it will be overwritten with the new payload value. The old value will be lost and is not recoverable !

Permission Required: kelvin.permission.storage.create.

createTimeseries: POST /api/v4/timeseries/create

Parameters:
Return type:

None

classmethod get_timeseries_last(data=None, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Time Series objects and its latest value. The list returned must be filtered by one or more resources and optionally on fields. This list is not pageable.

Permission Required: kelvin.permission.storage.read.

getTimeseriesLast: POST /api/v4/timeseries/last/get

Parameters:

  • data (Union[TimeseriesLastGet, Mapping[str, object], None]) – requests.TimeseriesLastGet, optional

  • **kwargs (object) –

    Extra parameters for requests.TimeseriesLastGet

    • get_timeseries_last: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

KList[TimeseriesLastGet]

classmethod list_timeseries(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Time Series objects and its latest value. The list returned can be optionally restricted to one or more resources and/or sources.

Permission Required: kelvin.permission.storage.read.

listTimeseries: POST /api/v4/timeseries/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • data (Union[TimeseriesList, Mapping[str, object], None]) – requests.TimeseriesList, optional

  • **kwargs (object) –

    Extra parameters for requests.TimeseriesList

    • list_timeseries: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[TimeseriesData], TimeseriesListPaginatedResponseCursor]

classmethod download_timeseries_range(data=None, _dry_run=False, _client=None, **kwargs)[source]

Returns a CSV file with Time Series data within the specified time range one or more resources (Asset /Data Stream pairs). Optional to preprocess and aggregate the data on the server using agg and time_bucket before downloading.

Permission Required: kelvin.permission.storage.read’.

downloadTimeseriesRange: POST /api/v4/timeseries/range/download

Parameters:

  • data (Union[TimeseriesRangeDownload, Mapping[str, object], None]) – requests.TimeseriesRangeDownload, optional

  • **kwargs (object) –

    Extra parameters for requests.TimeseriesRangeDownload

    • download_timeseries_range: str

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Iterator[None]

classmethod get_timeseries_range(data=None, _dry_run=False, _client=None, **kwargs)[source]

Returns an array with Time Series data within the specified time range for one or more resources (Asset /Data Stream pairs). Optional to preprocess and aggregate the data on the server using agg and time_bucket before downloading.

Permission Required: kelvin.permission.storage.read.

getTimeseriesRange: POST /api/v4/timeseries/range/get

Parameters:

  • data (Union[TimeseriesRangeGet, Mapping[str, object], None]) – requests.TimeseriesRangeGet, optional

  • **kwargs (object) –

    Extra parameters for requests.TimeseriesRangeGet

    • get_timeseries_range: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

KIterator[TimeseriesRangeGet]

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

User

Kelvin API Client.

class kelvin.api.client.api.user.User(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod list_users(username=None, email=None, name=None, search=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Users and its parameters. The list can be optionally filtered and sorted on the server before being returned. Permission Required: kelvin.permission.users.read.

listUsers: GET /api/v4/users/list

Parameters:

  • username (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key username. The filter is on the full name only. All values in array will be filtered as OR. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • email (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key email. The search is case insensitive and will find partial matches as well. All values in array will be filtered as OR.

  • name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the User’s first_name and last_name separated by a space. The filter is on exact matches only and is case sensitive. All values in array will be filtered as OR.

  • search (Optional[Sequence[str]]) – Sequence[str] Search Users by key first_name, last_name or email. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[UserItem], UsersListPaginatedResponseCursor]

classmethod get_user_me(_dry_run=False, _client=None)[source]

Get Current User

Permission Required: n/a.

getUserMe: GET /api/v4/users/me

Return type:

UserMeGet

Parameters:

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

classmethod list_user_settings(names=None, search=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of User Settings and its parameters. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.users.read.

listUserSettings: GET /api/v4/users/settings/list

Parameters:

  • names (Optional[Sequence[str]]) – Sequence[str] Filter User Setting list based on the key setting_name.

  • search (Optional[Sequence[str]]) – Sequence[str] Search User Setting by key setting_name. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[UserSetting], UserSettingsListPaginatedResponseCursor]

classmethod delete_user_settings(setting_name, _dry_run=False, _client=None)[source]

Permanently delete an existing User Setting. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.users.delete.

deleteUserSettings: POST /api/v4/users/settings/{setting_name}/delete

Parameters:

  • setting_name (str) – str, optional The User Setting key setting_name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_user_settings(setting_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a User Setting.

Permission Required: kelvin.permission.users.read.

getUserSettings: GET /api/v4/users/settings/{setting_name}/get

Parameters:

  • setting_name (str) – str, optional The User Setting key setting_name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

UserSettingsGet

classmethod update_user_settings(setting_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing User Setting payload with any new values.

Permission Required: kelvin.permission.users.update.

updateUserSettings: POST /api/v4/users/settings/{setting_name}/update

Parameters:

  • setting_name (str) – str, optional The User Setting key setting_name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[UserSettingsUpdate, Mapping[str, object], None]) – requests.UserSettingsUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.UserSettingsUpdate

    • update_user_settings: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

UserSettingsUpdate

classmethod list_shared_settings(names=None, search=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Shared Settings and its parameters. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.users.read.

listSharedSettings: GET /api/v4/users/shared/settings/list

Parameters:

  • names (Optional[Sequence[str]]) – Sequence[str] Filter Shared Setting list based on the key setting_name.

  • search (Optional[Sequence[str]]) – Sequence[str] Search Shared Setting by key setting_name. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[SharedSetting], SharedSettingsListPaginatedResponseCursor]

classmethod delete_shared_settings(setting_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Shared Setting. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.users.delete.

deleteSharedSettings: POST /api/v4/users/shared/settings/{setting_name}/delete

Parameters:

  • setting_name (str) – str, optional The Shared Setting key setting_name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_shared_settings(setting_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Shared Setting.

Permission Required: kelvin.permission.users.read.

getSharedSettings: GET /api/v4/users/shared/settings/{setting_name}/get

Parameters:

  • setting_name (str) – str, optional The Shared Setting key setting_name to get. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

SharedSettingsGet

classmethod update_shared_settings(setting_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Updates an existing Shared Setting payload with any new values.

Permission Required: kelvin.permission.users.update.

updateSharedSettings: POST /api/v4/users/shared/settings/{setting_name}/update

Parameters:

  • setting_name (str) – str, optional The Shared Setting key setting_name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[SharedSettingsUpdate, Mapping[str, object], None]) – requests.SharedSettingsUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.SharedSettingsUpdate

    • update_shared_settings: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

SharedSettingsUpdate

classmethod get_user(user_id, _dry_run=False, _client=None)[source]

Retrieve the parameters of a User.

Permission Required: kelvin.permission.users.read.

getUser: GET /api/v4/users/{user_id}/get

Parameters:

  • user_id (str) – str, optional The generated UUID for the User to get.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

UserGet

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

UserAuthorization

Kelvin API Client.

class kelvin.api.client.api.user_authorization.UserAuthorization(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_group(data=None, _dry_run=False, _client=None, **kwargs)[source]

Creates a group

Permission Required: kelvin.permission.authorization.create.

createGroup: POST /api/v4/authorization/groups/create

Parameters:

  • data (Union[GroupCreate, Mapping[str, object], None]) – requests.GroupCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.GroupCreate

    • create_group: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

GroupCreate

classmethod list_groups(search=None, names=None, role_names=None, sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Groups and its parameters. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.authorization.read.

listGroups: GET /api/v4/authorization/groups/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search groups by key name or title. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • names (Optional[Sequence[str]]) – Sequence[str] Filter Group list based on the key name.

  • role_names (Optional[Sequence[str]]) – Sequence[str] Filter Group list based on the key role_name.

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[GroupItem], GroupsListPaginatedResponseCursor]

classmethod delete_group(group_name, _dry_run=False, _client=None)[source]

Delete a group.

Permission Required: kelvin.permission.authorization.delete.

deleteGroup: POST /api/v4/authorization/groups/{group_name}/delete

Parameters:

  • group_name (str) – str, optional Fill the group name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_group(group_name, _dry_run=False, _client=None)[source]

Retrieve a Group.

Permission Required: kelvin.permission.authorization.read.

getGroup: GET /api/v4/authorization/groups/{group_name}/get

Parameters:

  • group_name (str) – str, optional Fill the group name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

GroupGet

classmethod update_group(group_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a group.

Permission Required: kelvin.permission.authorization.update.

updateGroup: POST /api/v4/authorization/groups/{group_name}/update

Parameters:

  • group_name (str) – str, optional Fill the group name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[GroupUpdate, Mapping[str, object], None]) – requests.GroupUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.GroupUpdate

    • update_group: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

GroupUpdate

classmethod create_role(data=None, _dry_run=False, _client=None, **kwargs)[source]

Creates a role

Permission Required: kelvin.permission.authorization.create.

createRole: POST /api/v4/authorization/roles/create

Parameters:

  • data (Union[RoleCreate, Mapping[str, object], None]) – requests.RoleCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.RoleCreate

    • create_role: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RoleCreate

classmethod list_roles(search=None, names=None, group_names=None, sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Roles. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.authorization.read.

listRoles: GET /api/v4/authorization/roles/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search roles by key name or title. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • names (Optional[Sequence[str]]) – Sequence[str] Filter Role list based on the key name.

  • group_names (Optional[Sequence[str]]) – Sequence[str] Filter Role list based on the key group_name.

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[RoleItem], RolesListPaginatedResponseCursor]

classmethod delete_role(role_name, _dry_run=False, _client=None)[source]

Delete a role.

Permission Required: kelvin.permission.authorization.delete.

deleteRole: POST /api/v4/authorization/roles/{role_name}/delete

Parameters:

  • role_name (str) – str, optional Fill the role name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_role(role_name, _dry_run=False, _client=None)[source]

Retrieve a Role.

Permission Required: kelvin.permission.authorization.read.

getRole: GET /api/v4/authorization/roles/{role_name}/get

Parameters:

  • role_name (str) – str, optional Fill the role name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

RoleGet

classmethod create_role_policy(role_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Creates a role policy

Permission Required: kelvin.permission.authorization.create.

createRolePolicy: POST /api/v4/authorization/roles/{role_name}/policies/create

Parameters:

  • role_name (str) – str, optional Fill the role name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[RolePolicyCreate, Mapping[str, object], None]) – requests.RolePolicyCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.RolePolicyCreate

    • create_role_policy: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RolePolicyCreate

classmethod list_role_policies(role_name, search=None, names=None, resource_types=None, sort_by=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of policies for a role. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.authorization.read.

listRolePolicies: GET /api/v4/authorization/roles/{role_name}/policies/list

Parameters:

  • role_name (str) – str, optional Fill the role name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • search (Optional[Sequence[str]]) – Sequence[str] Search policies by key name or title. All values in array will be filtered as OR. The search is case insensitive and will find partial matches as well.

  • names (Optional[Sequence[str]]) – Sequence[str] Filter policies list based on the key name.

  • resource_types (Optional[Sequence[str]]) – Sequence[str] Filter policies list based on the key resource_types.

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[RolePolicy], RolePoliciesListPaginatedResponseCursor]

classmethod delete_role_policy(role_name, policy_name, _dry_run=False, _client=None)[source]

Delete a role policy.

Permission Required: kelvin.permission.authorization.delete.

deleteRolePolicy: POST /api/v4/authorization/roles/{role_name}/policies/{policy_name}/delete

Parameters:

  • role_name (str) – str, optional Fill the role name related to the policy. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • policy_name (str) – str, optional Fill the policy name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_role_policy(role_name, policy_name, _dry_run=False, _client=None)[source]

Retrieve a Role Policy.

Permission Required: kelvin.permission.authorization.read.

getRolePolicy: GET /api/v4/authorization/roles/{role_name}/policies/{policy_name}/get

Parameters:

  • role_name (str) – str, optional Fill the role name related to the policy. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • policy_name (str) – str, optional Fill the policy name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

RolePolicyGet

classmethod update_role_policy(role_name, policy_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a role policy.

Permission Required: kelvin.permission.authorization.update.

updateRolePolicy: POST /api/v4/authorization/roles/{role_name}/policies/{policy_name}/update

Parameters:

  • role_name (str) – str, optional Fill the role name related to the policy. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • policy_name (str) – str, optional Fill the policy name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[RolePolicyUpdate, Mapping[str, object], None]) – requests.RolePolicyUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.RolePolicyUpdate

    • update_role_policy: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RolePolicyUpdate

classmethod update_role(role_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update a role.

Permission Required: kelvin.permission.authorization.update.

updateRole: POST /api/v4/authorization/roles/{role_name}/update

Parameters:

  • role_name (str) – str, optional Fill the role name. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[RoleUpdate, Mapping[str, object], None]) – requests.RoleUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.RoleUpdate

    • update_role: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

RoleUpdate

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Deprecated APIs

The following APIs are deprecated and will be removed in a future release.

AppRegistry (Deprecated)

Kelvin API Client.

class kelvin.api.client.api.deprecated_app_registry.DeprecatedAppRegistry(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod create_legacy_app(data=None, _dry_run=False, _client=None, **kwargs)[source]

Create a new App or App Version in the App Registry. A new version will be automatically appended if the App already exists.

Note : The Kelvin API request is not the recommended way to create an App and will not be documented. Check Kelvin’s documentation on the best methods to create Apps.

Because the Applications have migrated to new types, this endpoint converts the legacy type to the current one as shown in the following table:

Legacy Type | Current Type |

|-------------|————–| | kelvin | app | | bridge | importer | | `docker | docker |

Permission Required: kelvin.permission.app_registry.create.

createLegacyApp: POST /api/v4/appregistry/create

Parameters:

  • data (Union[LegacyAppCreate, Mapping[str, object], None]) – requests.LegacyAppCreate, optional

  • **kwargs (object) –

    Extra parameters for requests.LegacyAppCreate

    • create_legacy_app: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

LegacyAppCreate

classmethod list_legacy_app_registry_apps(type=None, search=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Apps in the App Registry and its parameters. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.app_registry.read.

listLegacyAppRegistryApps: GET /api/v4/appregistry/list

Parameters:

  • type (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key type. This type is the legacy type, mapped from the current App Types.

  • search (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[LegacyAppItem], LegacyAppRegistryAppsListPaginatedResponseCursor]

classmethod delete_legacy_app(app_name, _dry_run=False, _client=None)[source]

Permanently delete all versions of an App in the App Registry. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.app_registry.delete.

deleteLegacyApp: POST /api/v4/appregistry/{app_name}/delete

Parameters:

  • app_name (str) – str, optional App Registry App key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_legacy_app_registry_app(app_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of an App in the App Registry.

Because the Applications have migrated to new types, this endpoint converts the current type to the legacy one as shown in the following table:

Current Type | Legacy Type |

|--------------|————-| | app | kelvin | | importer | bridge | | exporter | bridge | | docker | docker |

Permission Required: kelvin.permission.app_registry.read.

getLegacyAppRegistryApp: GET /api/v4/appregistry/{app_name}/get

Parameters:

  • app_name (str) – str, optional App Registry App key name to retrieve. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

LegacyAppRegistryAppGet

classmethod update_legacy_app(app_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update an existing App with a new ‘title’ and/or ‘description’. Any parameters that are not provided will remain unchanged.

Permission Required: kelvin.permission.app_registry.update.

updateLegacyApp: POST /api/v4/appregistry/{app_name}/update

Parameters:

  • app_name (str) – str, optional App Registry App key name to retrieve. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • data (Union[LegacyAppUpdate, Mapping[str, object], None]) – requests.LegacyAppUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.LegacyAppUpdate

    • update_legacy_app: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

LegacyAppUpdate

classmethod delete_legacy_app_version(app_name, app_version, _dry_run=False, _client=None)[source]

Permanently one version of an App in the App Registry. All other versions of an App will remain unaffected. This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.app_registry.delete.

deleteLegacyAppVersion: POST /api/v4/appregistry/{app_name}/versions/{app_version}/delete

Parameters:

  • app_name (str) – str, optional App Registry App key name to delete. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • app_version (str) – str, optional Version number of the App in the App Registry to delete.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_legacy_app_version(app_name, app_version, _dry_run=False, _client=None)[source]

Retrieve the parameters of a specific version of an App in the App Registry.

Because the Applications have migrated to new types, this endpoint converts the current type to the legacy one as shown in the following table:

Current Type | Legacy Type |

|--------------|————-| | app | kelvin | | importer | bridge | | exporter | bridge | | docker | docker |

Permission Required: kelvin.permission.app_registry.read.

getLegacyAppVersion: GET /api/v4/appregistry/{app_name}/versions/{app_version}/get

Parameters:

  • app_name (str) – str, optional App Registry App key name to retrieve. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • app_version (str) – str, optional Version number of the App in the App Registry to retrieve.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

LegacyAppVersionGet

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Bridge (Deprecated)

Kelvin API Client.

class kelvin.api.client.api.deprecated_bridge.DeprecatedBridge(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod deploy_bridge(data=None, _dry_run=False, _client=None, **kwargs)[source]

Deploy a Bridge (Connection) from the App Registry as a Workload to a Cluster/Node.

Permission Required: kelvin.permission.bridge.create.

deployBridge: POST /api/v4/bridges/deploy

Parameters:

  • data (Union[BridgeDeploy, Mapping[str, object], None]) – requests.BridgeDeploy, optional

  • **kwargs (object) –

    Extra parameters for requests.BridgeDeploy

    • deploy_bridge: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

BridgeDeploy

classmethod list_bridges(names=None, search=None, cluster_name=None, workload_name=None, status_state=None, app_name=None, app_version=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Bridges (also known as Connections) and its parameters. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.bridge.read.

listBridges: GET /api/v4/bridges/list

Parameters:

  • names (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the keys name, title (Display Name), cluster_name, node_name and workload_name. All strings in the array are treated as OR. The search is case insensitive and will find partial matches as well.

  • cluster_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key cluster_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters. If set, it will override acp_name

  • workload_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key workload_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • status_state (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key state in the status object. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • app_name (Optional[Sequence[str]]) – Sequence[str] Unique identifier name of the App. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • app_version (Optional[Sequence[str]]) – Sequence[str] App version

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[BridgeItem], BridgesListPaginatedResponseCursor]

classmethod delete_bridge(bridge_name, _dry_run=False, _client=None)[source]

Permanently delete an existing Bridge (Connection). You will no longer receive Asset / Data Stream data from the assets associated with the Bridge (Connection). This cannot be undone once the API request has been submitted.

Permission Required: kelvin.permission.bridge.delete.

deleteBridge: POST /api/v4/bridges/{bridge_name}/delete

Parameters:

  • bridge_name (str) – str, optional Unique identifier name of the Bridge (Connection).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod get_bridge(bridge_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Bridge (Connection).

Permission Required: kelvin.permission.bridge.read.

getBridge: GET /api/v4/bridges/{bridge_name}/get

Parameters:

  • bridge_name (str) – str, optional Unique identifier name of the Bridge (Connection).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

BridgeGet

classmethod start_bridge(bridge_name, _dry_run=False, _client=None)[source]

Start running the Bridge (Connection).

Permission Required: kelvin.permission.bridge.update.

startBridge: GET /api/v4/bridges/{bridge_name}/start

Parameters:

  • bridge_name (str) – str, optional Unique identifier name of the Bridge (Connection).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod stop_bridge(bridge_name, _dry_run=False, _client=None)[source]

Stop running the Bridge (Connection). Permission Required: kelvin.permission.bridge.update.

stopBridge: GET /api/v4/bridges/{bridge_name}/stop

Parameters:

  • bridge_name (str) – str, optional Unique identifier name of the Bridge (Connection).

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Parameters (Deprecated)

Kelvin API Client.

class kelvin.api.client.api.deprecated_parameters.DeprecatedParameters(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod update_parameters_app_version(app_name, version, data=None, _dry_run=False, _client=None, **kwargs)[source]

Bulk update Parameters for multiple resources of a given App Version. Parameters belonging to the App Version but not specified in the payload will not be changed. Setting a value to null will cause the parameter to be unset. Additionally, it’s also possible to set a comment for each parameter change.

The source of the change will, by default, be the user making the API request. If the user making the request is a Service Account, it can, optionally, set its own source KRN.

updateParametersAppVersion: POST /api/v4/parameters/app/{app_name}/versions/{version}/update

Parameters:

  • app_name (str) – str, optional Application key name to associate with Assets (resources) to perform the required actions.

  • version (str) – str, optional Version of Application.

  • data (Union[ParametersAppVersionUpdate, Mapping[str, object], None]) – requests.ParametersAppVersionUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.ParametersAppVersionUpdate

    • update_parameters_app_version: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod list_parameters_definitions(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Parameters and its definition in each App. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.parameter.read.

listParametersDefinitions: POST /api/v4/parameters/definitions/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one or more enumerators.

  • data (Union[ParametersDefinitionsList, Mapping[str, object], None]) – requests.ParametersDefinitionsList, optional

  • **kwargs (object) –

    Extra parameters for requests.ParametersDefinitionsList

    • list_parameters_definitions: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[ParameterDefinitionItem], ParametersDefinitionsListPaginatedResponseCursor]

classmethod list_resource_parameters(pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, data=None, fetch=True, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of Parameters and all values for each Resource. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.parameter.read.

listResourceParameters: POST /api/v4/parameters/resources/list

Parameters:

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str] Sort the results by one or more enumerators.

  • data (Union[ResourceParametersList, Mapping[str, object], None]) – requests.ResourceParametersList, optional

  • **kwargs (object) –

    Extra parameters for requests.ResourceParametersList

    • list_resource_parameters: dict

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

Union[KList[ParameterValueHistorianItem], ResourceParametersListPaginatedResponseCursor]

classmethod get_parameters_values(data=None, _dry_run=False, _client=None, **kwargs)[source]

Returns a list of all unique values for each Parameter. Default values will not be shown. If the App is not specified, then the response will be grouped by App Name.

Permission Required: kelvin.permission.parameter.read.

getParametersValues: POST /api/v4/parameters/values/get

Parameters:

  • data (Union[ParametersValuesGet, Mapping[str, object], None]) – requests.ParametersValuesGet, optional

  • **kwargs (object) –

    Extra parameters for requests.ParametersValuesGet

    • get_parameters_values: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

ParametersValuesGet

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None

Workload (Deprecated)

Kelvin API Client.

class kelvin.api.client.api.deprecated_workload.DeprecatedWorkload(_owner=None, _name=None, **kwargs)[source]

Bases: ApiServiceModel

Parameters:

  • _owner (Optional['BaseModel'])

  • _name (Optional[str])

  • kwargs (object)

classmethod apply_legacy_workload(data=None, _dry_run=False, _client=None, **kwargs)[source]

Initiate final deploy action for the downloaded Workloads. Only valid for Workloads that were previously deployed with the keys staged set to true and instantly_apply set to false.

Permission Required: kelvin.permission.workload.update.

applyLegacyWorkload: POST /api/v4/workloads/apply

Parameters:

  • data (Union[LegacyWorkloadApply, Mapping[str, object], None]) – requests.LegacyWorkloadApply, optional

  • **kwargs (object) –

    Extra parameters for requests.LegacyWorkloadApply

    • apply_legacy_workload: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

None

classmethod deploy_legacy_workload(data=None, _dry_run=False, _client=None, **kwargs)[source]

Deploy an App from the App Registry as a Workload to a Cluster/Node.

Permission Required: kelvin.permission.workload.update.

deployLegacyWorkload: POST /api/v4/workloads/deploy

Parameters:

  • data (Union[LegacyWorkloadDeploy, Mapping[str, object], None]) – requests.LegacyWorkloadDeploy, optional

  • **kwargs (object) –

    Extra parameters for requests.LegacyWorkloadDeploy

    • deploy_legacy_workload: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

LegacyWorkloadDeploy

classmethod list_legacy_workloads(search=None, app_name=None, app_version=None, acp_name=None, cluster_name=None, node_name=None, workload_name=None, enabled=None, asset_name=None, staged=None, download_statuses=None, pagination_type=None, page_size=10000, page=None, next=None, previous=None, direction=None, sort_by=None, fetch=True, _dry_run=False, _client=None)[source]

Returns a list of Workload objects. The list can be optionally filtered and sorted on the server before being returned.

Permission Required: kelvin.permission.workload.read.

listLegacyWorkloads: GET /api/v4/workloads/list

Parameters:

  • search (Optional[Sequence[str]]) – Sequence[str] Search and filter on the list based on the keys name, title (Display Name), app_name, cluster_name and node_name. All strings in the array are treated as OR. The search is case insensitive and will find partial matches as well.

  • app_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key app_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • app_version (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key app_version. The filter is on the full value only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • acp_name (Optional[Sequence[str]]) – Sequence[str] [Deprecated] A filter on the list based on the key acp_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • cluster_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key cluster_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters. If set, it will override acp_name

  • node_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key node_name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • workload_name (Optional[Sequence[str]]) – Sequence[str] A filter on the list based on the key name. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • enabled (Optional[bool]) – bool A filter on the list based on the key status (start/stop function in Kelvin UI) of the Workloads.

  • asset_name (Optional[str]) – str A filter on the list based on Asset name associated with the Workload. The filter is on the full name only. The string can only contain lowercase alphanumeric characters and ., _ or - characters.

  • staged (Optional[bool]) – bool A filter on the key staged. Using true will only show staged workloads, false will show all workloads.

  • download_statuses (Optional[Sequence[str]]) – Sequence[str]

  • pagination_type (Optional[Literal['limits', 'cursor', 'stream']]) – Literal['limits', 'cursor', 'stream'] Method of pagination to use for return results where total_items is greater than page_size. cursor and limits will return one page of results, stream will return all results. (‘limits’, ‘cursor’, ‘stream’)

  • page_size (Optional[int]) – int Number of objects to be returned in each page. Page size can range between 1 and 10000 objects.

  • page (Optional[int]) – int An integer for the wanted page of results. Used only with pagination_type set as limits.

  • next (Optional[str]) – str An alphanumeric string bookmark to indicate where to start for the next page. Used only with pagination_type set as cursor.

  • previous (Optional[str]) – str An alphanumeric string bookmark to indicate where to end for the previous page. Used only with pagination_type set as cursor.

  • direction (Optional[Literal['asc', 'desc']]) – Literal['asc', 'desc'] Sorting order according to the sort_by parameter. (‘asc’, ‘desc’)

  • sort_by (Optional[Sequence[str]]) – Sequence[str]

  • fetch (bool)

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

Union[KList[LegacyWorkloadItem], LegacyWorkloadsListPaginatedResponseCursor]

classmethod get_legacy_workload_configuration(workload_name, _dry_run=False, _client=None)[source]

Retrieve the configuration of a Workload.

Permission Required: kelvin.permission.workload.read.

getLegacyWorkloadConfiguration: GET /api/v4/workloads/{workload_name}/configurations/get

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

LegacyWorkloadConfigurationGet

classmethod update_legacy_workload_configuration(workload_name, data=None, _dry_run=False, _client=None, **kwargs)[source]

Update the configuration of a Workload.

Permission Required: kelvin.permission.workload.update

`WARNING!!`: Sending an empty configuration object will remove all configurations.

updateLegacyWorkloadConfiguration: POST /api/v4/workloads/{workload_name}/configurations/update

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • data (Union[LegacyWorkloadConfigurationUpdate, Mapping[str, object], None]) – requests.LegacyWorkloadConfigurationUpdate, optional

  • **kwargs (object) –

    Extra parameters for requests.LegacyWorkloadConfigurationUpdate

    • update_legacy_workload_configuration: dict

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

  • **kwargs

Return type:

LegacyWorkloadConfigurationUpdate

classmethod download_legacy_workload(workload_name, address=None, _dry_run=False, _client=None)[source]

Download the Workload package file for offline installation on the Edge System. The system automatically generates the file for download if the package is not already available.

Permission Required: kelvin.permission.workload.read.

downloadLegacyWorkload: GET /api/v4/workloads/{workload_name}/download

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • address (Optional[bool]) – bool If true, the endpoint will return a direct URL to the workload package file.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

str

classmethod get_legacy_workload(workload_name, _dry_run=False, _client=None)[source]

Retrieve the parameters of a Workload.

Permission Required: kelvin.permission.workload.read.

getLegacyWorkload: GET /api/v4/workloads/{workload_name}/get

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

LegacyWorkloadGet

classmethod get_legacy_workload_logs(workload_name, tail_lines=None, since_time=None, _dry_run=False, _client=None)[source]

Get Workload Logs

Permission Required: kelvin.permission.workload.read.

getLegacyWorkloadLogs: GET /api/v4/workloads/{workload_name}/logs/get

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • tail_lines (Optional[int]) – int Specify the number of the most recent log lines to retrieve, counting backwards from the latest entry.

  • since_time (Optional[datetime]) – datetime UTC time of the starting point for log retrieval, formatted in RFC 3339.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

LegacyWorkloadLogsGet

classmethod start_workload(workload_name, _dry_run=False, _client=None)[source]

Start running the Workload.

Permission Required: kelvin.permission.workload.update.

startWorkload: GET /api/v4/workloads/{workload_name}/start

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod stop_workload(workload_name, _dry_run=False, _client=None)[source]

Stop running the Workload.

Permission Required: kelvin.permission.workload.update.

stopWorkload: GET /api/v4/workloads/{workload_name}/stop

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

classmethod undeploy_workload(workload_name, staged=None, _dry_run=False, _client=None)[source]

Undeploy Workload from the Edge System.

Permission Required: kelvin.permission.workload.delete.

undeployWorkload: POST /api/v4/workloads/{workload_name}/undeploy

Parameters:

  • workload_name (str) – str, optional Unique identifier name of the Workload.

  • staged (Optional[bool]) – bool If true, the endpoint only undeploys the staged workload, if any.

  • _dry_run (bool)

  • _client (SyncBaseClient | None)

Return type:

None

fields = None
model_config = {'extra': 'allow', 'use_enum_values': True, 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self (BaseModel) – The BaseModel instance.

  • context (Any) – The context.

Return type:

None

schema = None