yellowdog_client.model – Models

yellowdog_client.model contains all the data structures required to use all of the yellowdog_client services.

class yellowdog_client.model.AccessDelegate(creator=None, subject=None, description=None, createdTime=None, requiredPermissions=None)

Represents a user or application delegate within the YellowDog Platform.

Parameters:
createdTime: datetime | None = None
creator: str | None = None
description: str | None = None
id: str | None = None
requiredPermissions: Set[Permission] | None = None
subject: str | None = None
class yellowdog_client.model.Account(name, features=None)

Represents a user account within the YellowDog Platform.

Parameters:
features: List[Feature] | None = None
id: str | None = None
name: str
class yellowdog_client.model.AccountAllowance(effectiveFrom, resetType, limitEnforcement, monitoredStatuses, description=None, effectiveUntil=None, allowedHours=0, boostHours=None, resetInterval=None, hardLimitGraceMinutes=None)
Parameters:
allowedHours: int = 0
boostHours: int | None = None
createdById: str | None = None
description: str | None = None
effectiveFrom: datetime
effectiveUntil: datetime | None = None
hardLimitGraceMinutes: int | None = None
id: str | None = None
limitEnforcement: AllowanceLimitEnforcement
monitoredStatuses: List[InstanceStatus]
remainingHours: float | None = None
resetInterval: int | None = None
resetType: AllowanceResetType
type: str = 'co.yellowdog.platform.model.AccountAllowance'
class yellowdog_client.model.AccountAuthenticationProperties(azure=None, okta=None)
Parameters:
azure: AzureAccountAuthenticationProperties | None = None
okta: OktaAccountAuthenticationProperties | None = None
class yellowdog_client.model.AccountPolicy(instanceTagSpecification=None)
Parameters:

instanceTagSpecification (Optional[Dict[str, Set[str]]])

instanceTagSpecification: Dict[str, Set[str]] | None = None
class yellowdog_client.model.AddApplicationRequest(name, description=None)
Parameters:
description: str | None = None
name: str
class yellowdog_client.model.AddApplicationResponse(apiKey=None, application=None)
Parameters:
apiKey: ApiKey | None = None
application: Application | None = None
class yellowdog_client.model.AddConfiguredWorkerPoolRequest(name, namespace=None, tokenTtl=None, properties=None)
Parameters:
name: str

The name used to uniquely identify the worker pool.

namespace: str | None = None

The namespace that this worker pool is constrained to.

properties: ConfiguredWorkerPoolProperties | None = None
tokenTtl: timedelta | None = None

The time-to-live of the worker pool token. Workers have this much time, from the creation of the worker token, to register. If not set, workers have an unlimited length of time to register.

class yellowdog_client.model.AddConfiguredWorkerPoolResponse(workerPool=None, token=None)
Parameters:
token: WorkerPoolToken | None = None
workerPool: ConfiguredWorkerPool | None = None
class yellowdog_client.model.AddGroupRequest(name, description=None)
Parameters:
description: str | None = None
name: str
class yellowdog_client.model.AddNodeActionsRequest(actionGroups, nodeIdFilterList=None)
Parameters:
actionGroups: List[NodeActionGroup]
nodeIdFilterList: List[str] | None = None
class yellowdog_client.model.AddUserRequest(username, name, email)
Parameters:
email: str
name: str
username: str
class yellowdog_client.model.AddUserResponse(user=None)
Parameters:

user (Optional[User])

user: User | None = None
class yellowdog_client.model.AlibabaComputeSource

Derives from ComputeSource to provide the interface for all Alibaba Cloud compute source model objects.

type: str = 'co.yellowdog.platform.model.AlibabaComputeSource'
class yellowdog_client.model.AlibabaCredential(name, accessKeyId, secretAccessKey, description=None)

Holds the Access Key ID and Secret Access Key which form a set of credentials for Alibaba Cloud.

Parameters:
accessKeyId: str

The Alibaba Cloud Access Key ID

description: str | None = None
name: str
secretAccessKey: str

The Alibaba Cloud Secret Access Key

type: str = 'co.yellowdog.platform.account.credentials.AlibabaCredential'
class yellowdog_client.model.AlibabaInstance(id=None, createdTime=None, provider=None, instanceType=None, region=None, subregion=None, imageId=None, hostname=None, privateIpAddress=None, publicIpAddress=None, spot=False, status=None, statusChangedTime=None)

Extends Instance to add fields specific to the Alibaba Cloud compute sources.

Parameters:
createdTime: datetime | None = None

The date and time when this instance was first created.

hostname: str | None = None

The hostname of this instance.

id: InstanceId | None = None

The unique identifier for this instance formed from the YellowDog Compute Source ID and the provider supplied instance ID

imageId: str | None = None

The machine image ID used for this instance.

instanceType: str | None = None

The machine type of this instance.

privateIpAddress: str | None = None

The private IP address of this instance.

provider: CloudProvider | None = None

The cloud provider that supplies this instance.

publicIpAddress: str | None = None

The public IP address of this instance.

region: str | None = None

The region where this instance is provisioned.

spot: bool = False

Indicates if this instance was provisioned via spot pricing vs on-demand.

status: InstanceStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed

subregion: str | None = None

The subregion where this instance is provisioned.

type: str = 'co.yellowdog.platform.model.AlibabaInstance'
class yellowdog_client.model.AlibabaInstanceChargeType(value)

An enumeration.

POST_PAID = 'POST_PAID'
PRE_PAID = 'PRE_PAID'
class yellowdog_client.model.AlibabaInstancesComputeSource(name, credential, region, vSwitchId, securityGroupId, instanceType, imageId, availabilityZone=None, userData=None, instanceTags=None, ramRoleName=None, keyName=None, instanceChargeType=None, assignPublicIp=False, spotStrategy=None, spotPriceLimit=None, limit=0, specifyMinimum=False)

Defines a source of compute composed of Alibaba Cloud ECS instances.

Parameters:
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

availabilityZone: str | None = None

The Alibaba Cloud availability zone within the region where instances will be provisioned.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
exhaustion: ComputeSourceExhaustion | None = None
id: str | None = None
imageId: str

The region-specific Alibaba Cloud ID for the image to use for the provisioned instances.

instanceChargeType: AlibabaInstanceChargeType | None = None

The Alibaba Cloud charge type to use for the provisioned instances.

instancePricing: InstancePricing | None = None
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
instanceType: str

The Alibaba Cloud instance type for the provisioned instances.

keyName: str | None = None

The name of the Alibaba Cloud key pair to use when logging into any instances provisioned from this source.

limit: int = 0
name: str

The name of the compute source. This must be unique within a compute requirement.

ramRoleName: str | None = None

The name of the RAM Role to use for the provisioned instances.

region: str

The Alibaba Cloud region where instances will be provisioned.

securityGroupId: str

The ID of the Alibaba Cloud Security Group for the provisioned instances.

specifyMinimum: bool = False

Indicates if YellowDog Compute should specify the minimum when requesting instances from Alibaba Cloud. If true, then no instances are provisioned unless all requested instances are available; otherwise, if false, YellowDog Compute will provision as many instances as possible up to the number requested from this compute source.

spotPriceLimit: float | None = None

The Alibaba Cloud spot price limit to use with SPOT_WITH_PRICE_LIMIT spot strategy.

spotStrategy: AlibabaSpotStrategy | None = None

The Alibaba Cloud spot strategy to use when provisioning instances.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.AlibabaInstancesComputeSource'
userData: str | None = None
vSwitchId: str

The ID of the virtual switch to use for the provisioned instances.

class yellowdog_client.model.AlibabaNamespaceStorageConfiguration(namespace, endpoint, bucketName, credential)
Parameters:

  • namespace (str)

  • endpoint (str)

  • bucketName (str)

  • credential (str)

bucketName: str
credential: str
endpoint: str
namespace: str
type: str = 'co.yellowdog.platform.model.AlibabaNamespaceStorageConfiguration'
class yellowdog_client.model.AlibabaSpotStrategy(value)

An enumeration.

NO_SPOT = 'NO_SPOT'
SPOT_AS_PRICE_GO = 'SPOT_AS_PRICE_GO'
SPOT_WITH_PRICE_LIMIT = 'SPOT_WITH_PRICE_LIMIT'
class yellowdog_client.model.Allowance
type: str = None
class yellowdog_client.model.AllowanceExhaustedNotification(allowanceId=None, allowanceDescription=None, exhaustedSourceIds=None)
Parameters:
allowanceDescription: str | None = None
allowanceId: str | None = None
exhaustedSourceIds: List[str] | None = None
class yellowdog_client.model.AllowanceLimitEnforcement(value)

Defines the limit enforcement options for an empty allowance

HARD = 'HARD'

Existing operations will be terminated, possibly after a grace period, and new operations will be disallowed

SOFT = 'SOFT'

Existing operations will not be terminated but new operations will be disallowed

class yellowdog_client.model.AllowanceResetType(value)

Defines when, or if, an allowance will reset the used amount back to zero

DAYS = 'DAYS'

The allowance resets after a configured number of days

MONTHS = 'MONTHS'

The allowance resets after a configured number of months

NONE = 'NONE'

The allowance does not reset

class yellowdog_client.model.AllowanceSearch(sortField=None, sortDirection=None, description=None, effectiveFrom=None, effectiveUntil=None, limitEnforcement=None, allowedHours=None)
Parameters:
allowedHours: IntegerRange | None = None
description: str | None = None
effectiveFrom: InstantRange | None = None
effectiveUntil: InstantRange | None = None
limitEnforcement: AllowanceLimitEnforcement | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.ApiKey(id=None, secret=None)
Parameters:
id: str | None = None
secret: str | None = None
class yellowdog_client.model.Application(name, createdByUserId, description=None, accessDelegates=None)

Represents a user application within the YellowDog Platform.

Parameters:
accessDelegates: List[AccessDelegate] | None = None
createdByUserId: str
description: str | None = None
id: str | None = None
name: str
class yellowdog_client.model.ApplicationSearch(sortField=None, sortDirection=None, name=None)
Parameters:
name: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.AttributeConstraint
type: str = None
class yellowdog_client.model.AttributeDefinition
type: str = None
class yellowdog_client.model.AttributePreference
type: str = None
class yellowdog_client.model.AttributeSource
class yellowdog_client.model.AttributeSourceType(value)

An enumeration.

EXTERNAL = 'EXTERNAL'
SOURCE = 'SOURCE'
USER = 'USER'
class yellowdog_client.model.AttributeValue
type: str = None
class yellowdog_client.model.AuthenticationProvider(value)

An enumeration.

AZURE = 'AZURE'
OKTA = 'OKTA'
YELLOWDOG = 'YELLOWDOG'
class yellowdog_client.model.AutoShutdown(enabled=None, timeout=None)
Parameters:
enabled: bool | None = None
timeout: timedelta | None = None
class yellowdog_client.model.AwsAccountRoleCredential(name, externalRoleArn, externalId, description=None)

Holds the Role ARN and External ID required to allow YellowDog Platform to assume an assigned role in an external AWS account.

Parameters:
description: str | None = None
externalId: str

The external ID required to assume the external role.

externalRoleArn: str

The ARN of the IAM role in the external account.

name: str
type: str = 'co.yellowdog.platform.account.credentials.AwsAccountRoleCredential'
class yellowdog_client.model.AwsCapacityReservation(preference, groupArn=None, id=None)
Parameters:
groupArn: str | None = None
id: str | None = None
preference: AwsCapacityReservationPreference
class yellowdog_client.model.AwsCapacityReservationPreference(value)

An enumeration.

CAPACITY_RESERVATIONS_ONLY = 'CAPACITY_RESERVATIONS_ONLY'
NONE = 'NONE'
OPEN = 'OPEN'
class yellowdog_client.model.AwsComputeSource

Derives from ComputeSource to provide the interface for all AWS compute source model objects.

type: str = 'co.yellowdog.platform.model.AwsComputeSource'
class yellowdog_client.model.AwsCredential(name, accessKeyId, secretAccessKey, description=None, sessionToken=None, expiryTime=None)

Holds the Access Key ID and Secret Access Key which form a set of credentials for Amazon Web Services (AWS).

Parameters:
accessKeyId: str

The AWS Access Key ID

description: str | None = None
expiryTime: datetime | None = None

The expiry time if this credential is temporary

name: str
secretAccessKey: str

The AWS Secret Access Key

sessionToken: str | None = None

The AWS Session Token if this credential is temporary

type: str = 'co.yellowdog.platform.account.credentials.AwsCredential'
class yellowdog_client.model.AwsFleetComputeSource(name, credential, region, securityGroupId, instanceType, imageId, purchaseOption, availabilityZone=None, subnetId=None, userData=None, instanceTags=None, iamInstanceProfileArn=None, keyName=None, enableDetailedMonitoring=None, enableInstanceMetadataTags=None, assignPublicIp=False, createClusterPlacementGroup=None, existingPlacementGroup=None, createElasticFabricAdapter=None, secondaryNetworkInterfaces=None, capacityReservation=None, limit=0, maintainCapacity=False, instanceOverrides=None, onDemandOptions=None, spotOptions=None)

Defines a source of compute provisioned using an AWS EC2 Fleet request.

Parameters:
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

availabilityZone: str | None = None

The AWS availability zone within the region where instances will be provisioned.

capacityReservation: AwsCapacityReservation | None = None

Specifies the capacity reservation to target for provisioned instances.

createClusterPlacementGroup: bool | None = None

Indicates if instances should be provisioned within a cluster placement group.

createElasticFabricAdapter: bool | None = None

Indicates if instances should be provisioned with an Elastic Fabric Adapter network interface.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
enableDetailedMonitoring: bool | None = None

Indicates if provisioned instances should have detailed CloudWatch monitoring enabled.

enableInstanceMetadataTags: bool | None = None

Indicates if provisioned instances should expose their tags via instance metadata.

exhaustion: ComputeSourceExhaustion | None = None
existingPlacementGroup: AwsPlacementGroup | None = None

Indicates an existing placement group within which instances should be provisioned.

fleetId: str | None = None

The ID of the AWS EC2 Fleet.

iamInstanceProfileArn: str | None = None

The ARN of the IAM Instance Profile to use for the provisioned instances.

id: str | None = None
imageId: str

The region-specific Amazon Machine Image (AMI) ID for the image to use for the provisioned instances.

instanceOverrides: List[AwsFleetInstanceOverride] | None = None

Extra instance provision options that can override the main parameters set in this source.

instancePricing: InstancePricing | None = None
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
instanceType: str

The EC2 instance type for the provisioned instances.

keyName: str | None = None

The name of the EC2 key pair to use when logging into any instances provisioned from this source.

limit: int = 0
maintainCapacity: bool = False

Indicates if AWS EC2 Fleet should maintain the instance count independently of YellowDog Compute, replacing the reprovision functionality.

name: str
onDemandOptions: AwsFleetOnDemandOptions | None = None

Options related to provisioning On-Demand instances.

purchaseOption: AwsFleetPurchaseOption

Determines which instance purchase options (On-Demand and/or Spot) are available to AWS EC2 Fleet.

region: str

The AWS region where instances will be provisioned.

secondaryNetworkInterfaces: List[AwsSecondaryNetworkInterface] | None = None

Secondary network interfaces to create on provisioned instances.

securityGroupId: str

The ID of the AWS Security Group for the provisioned instances.

spotOptions: AwsFleetSpotOptions | None = None

Options related to provisioning Spot instances.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetId: str | None = None

The ID of the subnet to use for the provisioned instances.

supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.AwsFleetComputeSource'
userData: str | None = None
class yellowdog_client.model.AwsFleetInstanceOverride(instanceType, availabilityZone=None, spotMaxPrice=None, subnetId=None)
Parameters:
availabilityZone: str | None = None

The AWS availability zone within the region where instances will be provisioned.

instanceType: str

The EC2 instance type for the provisioned instances.

spotMaxPrice: float | None = None

The maximum price that will be paid for spot instances.

subnetId: str | None = None

The ID of the subnet to use for the provisioned instances.

class yellowdog_client.model.AwsFleetOnDemandAllocationStrategy(value)

Specifies the order of the instance overrides that should be used in fulfilling On-Demand capacity.

LOWEST_PRICE = 'LOWEST_PRICE'

AWS EC2 Fleet will use price to determine the order, launching the lowest price first. This is the default strategy.

ORDER_PRIORITIZED = 'ORDER_PRIORITIZED'

AWS EC2 Fleet will use the priority that YellowDog Compute assigns based on the order of the instanceOverrides in the AwsFleetComputeSource, launching in the order specified.

class yellowdog_client.model.AwsFleetOnDemandOptions(allocationStrategy=None, useCapacityReservationsFirst=None, maxTotalPrice=None, minInstanceCount=None, singleAvailabilityZone=None, singleInstanceType=None)
Parameters:
allocationStrategy: AwsFleetOnDemandAllocationStrategy | None = None

Determines the order of the instance overrides to use in fulfilling On-Demand capacity.

maxTotalPrice: float | None = None

The maximum amount per hour for On-Demand instances.

minInstanceCount: int | None = None

The minimum number of On-Demand instances that must be provisioned in the fleet.

singleAvailabilityZone: bool | None = None

Indicates that AWS EC2 Fleet should provision all On-Demand instances into a single availability zone.

singleInstanceType: bool | None = None

Indicates that AWS EC2 Fleet should use a single instance type to provision all On-Demand instances.

useCapacityReservationsFirst: bool | None = None

Indicates if AWS EC2 Fleet should use unused Capacity Reservations to fulfill On-Demand capacity.

class yellowdog_client.model.AwsFleetPurchaseOption(value)

An enumeration.

CAPACITY_BLOCK = 'CAPACITY_BLOCK'

AWS EC2 Fleet will only use instances within a Capacity Block.

ON_DEMAND_ONLY = 'ON_DEMAND_ONLY'

AWS EC2 Fleet will only use On-Demand instances.

ON_DEMAND_THEN_SPOT = 'ON_DEMAND_THEN_SPOT'

AWS EC2 Fleet will use both On-Demand and Spot instances but prefer On-Demand instances.

SPOT_ONLY = 'SPOT_ONLY'

AWS EC2 Fleet will only use Spot instances.

SPOT_THEN_ON_DEMAND = 'SPOT_THEN_ON_DEMAND'

AWS EC2 Fleet will use both Spot and On-Demand instances but prefer Spot instances.

class yellowdog_client.model.AwsFleetSpotAllocationStrategy(value)

An enumeration.

CAPACITY_OPTIMIZED = 'CAPACITY_OPTIMIZED'

AWS EC2 Fleet will launch instances from Spot instance pools with optimal capacity for the number of instances that are launching.

CAPACITY_OPTIMIZED_ORDER_PRIORITIZED = 'CAPACITY_OPTIMIZED_ORDER_PRIORITIZED'

AWS EC2 Fleet will launch instances optimizing for capacity first, but honor priority based on the order of the instanceOverrides in the AwsFleetComputeSource on a best-effort basis.

DIVERSIFIED = 'DIVERSIFIED'

AWS EC2 Fleet will launch Spot instances distributed across all Spot capacity pools.

LOWEST_PRICE = 'LOWEST_PRICE'

AWS EC2 Fleet will launch instances from the Spot instance pools with the lowest price. This is the default strategy.

class yellowdog_client.model.AwsFleetSpotOptions(allocationStrategy=None, instancePoolsToUseCount=None, launchReplacementInstanceOnRebalance=None, maxTotalPrice=None, minInstanceCount=None, singleAvailabilityZone=None, singleInstanceType=None)
Parameters:
allocationStrategy: AwsFleetSpotAllocationStrategy | None = None

Determines the order of the instance overrides to use in fulfilling Spot capacity.

instancePoolsToUseCount: int | None = None

The number of Spot pools across which AWS EC2 Fleet should allocate Spot capacity when using LOWEST_PRICE Spot allocation strategy.

launchReplacementInstanceOnRebalance: bool | None = None

Allow AWS EC2 Fleet to launch a replacement Spot instance when an instance rebalance notification is emitted for an existing Spot instance.

maxTotalPrice: float | None = None

The maximum amount per hour for Spot instances.

minInstanceCount: int | None = None

The minimum number of Spot instances that must be provisioned in the fleet.

singleAvailabilityZone: bool | None = None

Indicates that AWS EC2 Fleet should provision all Spot instances into a single availability zone.

singleInstanceType: bool | None = None

Indicates that AWS EC2 Fleet should use a single instance type to provision all Spot instances.

class yellowdog_client.model.AwsInstance(instanceLifecycle=None, id=None, createdTime=None, provider=None, instanceType=None, region=None, subregion=None, imageId=None, hostname=None, privateIpAddress=None, publicIpAddress=None, spot=False, status=None, statusChangedTime=None)

Extends Instance to add fields specific to the AWS compute sources.

Parameters:
createdTime: datetime | None = None

The date and time when this instance was first created.

hostname: str | None = None

The hostname of this instance.

id: InstanceId | None = None

The unique identifier for this instance formed from the YellowDog Compute Source ID and the provider supplied instance ID

imageId: str | None = None

The machine image ID used for this instance.

instanceLifecycle: str | None = None

The AWS EC2 instance lifecycle value for this instance.

instanceType: str | None = None

The machine type of this instance.

privateIpAddress: str | None = None

The private IP address of this instance.

provider: CloudProvider | None = None

The cloud provider that supplies this instance.

publicIpAddress: str | None = None

The public IP address of this instance.

region: str | None = None

The region where this instance is provisioned.

spot: bool = False

Indicates if this instance was provisioned via spot pricing vs on-demand.

status: InstanceStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed

subregion: str | None = None

The subregion where this instance is provisioned.

type: str = 'co.yellowdog.platform.model.AwsInstance'
class yellowdog_client.model.AwsInstancesComputeSource(name, credential, region, securityGroupId, instanceType, imageId, availabilityZone=None, subnetId=None, userData=None, instanceTags=None, iamInstanceProfileArn=None, keyName=None, enableDetailedMonitoring=None, enableInstanceMetadataTags=None, useCapacityBlock=None, assignPublicIp=False, createClusterPlacementGroup=None, existingPlacementGroup=None, createElasticFabricAdapter=None, secondaryNetworkInterfaces=None, capacityReservation=None, limit=0, specifyMinimum=False, spot=False, spotMaxPrice=None)

Defines a source of compute composed of AWS EC2 instances using the RunInstances API.

Parameters:
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

availabilityZone: str | None = None

The AWS availability zone within the region where instances will be provisioned.

capacityReservation: AwsCapacityReservation | None = None

Specifies the capacity reservation to target for provisioned instances.

createClusterPlacementGroup: bool | None = None

Indicates if instances should be provisioned within a cluster placement group.

createElasticFabricAdapter: bool | None = None

Indicates if instances should be provisioned with an Elastic Fabric Adapter network interface.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
enableDetailedMonitoring: bool | None = None

Indicates if provisioned instances should have detailed CloudWatch monitoring enabled.

enableInstanceMetadataTags: bool | None = None

Indicates if provisioned instances should expose their tags via instance metadata.

exhaustion: ComputeSourceExhaustion | None = None
existingPlacementGroup: AwsPlacementGroup | None = None

Indicates an existing placement group within which instances should be provisioned.

iamInstanceProfileArn: str | None = None

The ARN of the IAM Instance Profile to use for the provisioned instances.

id: str | None = None
imageId: str

The region-specific Amazon Machine Image (AMI) ID for the image to use for the provisioned instances.

instancePricing: InstancePricing | None = None
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
instanceType: str

The EC2 instance type for the provisioned instances.

keyName: str | None = None

The name of the EC2 key pair to use when logging into any instances provisioned from this source.

limit: int = 0
name: str
region: str

The AWS region where instances will be provisioned.

secondaryNetworkInterfaces: List[AwsSecondaryNetworkInterface] | None = None

Secondary network interfaces to create on provisioned instances.

securityGroupId: str

The ID of the AWS Security Group for the provisioned instances.

specifyMinimum: bool = False

Indicates if YellowDog Compute should specify the minimum when requesting instances from AWS. If true, then no instances are provisioned unless all requested instances are available; otherwise, if false, YellowDog Compute will provision as many instances as possible up to the number requested from this compute source.

spot: bool = False

Indicates if spot instances should be requested rather than on-demand.

spotMaxPrice: float | None = None

The maximum price that will be paid for instances provisioned from this source.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetId: str | None = None

The ID of the subnet to use for the provisioned instances.

supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.AwsInstancesComputeSource'
useCapacityBlock: bool | None = None

Indicates if instances should be provisioned within a reserved capacity block.

userData: str | None = None
class yellowdog_client.model.AwsNetworkInterfaceType(value)

An enumeration.

EFA_ONLY = 'EFA_ONLY'
EFA_WITH_ENA = 'EFA_WITH_ENA'
ENI = 'ENI'
class yellowdog_client.model.AwsPlacementGroup(groupName=None, groupId=None)
Parameters:
groupId: str | None = None
groupName: str | None = None
class yellowdog_client.model.AwsSecondaryNetworkInterface(networkInterfaceType, subnetId=None, securityGroupId=None)
Parameters:
networkInterfaceType: AwsNetworkInterfaceType

Determines the type of the network interface.

securityGroupId: str | None = None

Optional securityGroupId for this network interface. If not specified the subnetId of the parent source is used.

subnetId: str | None = None

Optional subnetId for this network interface. If not specified the subnetId of the parent source is used.

class yellowdog_client.model.AzureAccountAuthenticationProperties(tenantId, clientId, enabled=False, clientSecret=None)
Parameters:
clientId: str
clientSecret: str | None = None
enabled: bool = False
tenantId: str
class yellowdog_client.model.AzureClientCredential(name, clientId, tenantId, subscriptionId, key, description=None)

Holds the properties that form a set of credentials for Microsoft Azure.

Parameters:
clientId: str

The Azure Client ID

description: str | None = None
key: str

The Azure Key

name: str
subscriptionId: str

The Azure Subscription ID

tenantId: str

The Azure Tenant ID

type: str = 'co.yellowdog.platform.account.credentials.AzureClientCredential'
class yellowdog_client.model.AzureComputeCredential
type: str = 'co.yellowdog.platform.account.credentials.AzureComputeCredential'
class yellowdog_client.model.AzureComputeSource

Derives from ComputeSource to provide the interface for all Azure compute source model objects.

type: str = 'co.yellowdog.platform.model.AzureComputeSource'
class yellowdog_client.model.AzureInstance(resourceId=None, id=None, createdTime=None, provider=None, instanceType=None, region=None, subregion=None, imageId=None, hostname=None, privateIpAddress=None, publicIpAddress=None, spot=False, status=None, statusChangedTime=None)

Extends Instance to add fields specific to the Azure compute source.

Parameters:
createdTime: datetime | None = None

The date and time when this instance was first created.

hostname: str | None = None

The hostname of this instance.

id: InstanceId | None = None

The unique identifier for this instance formed from the YellowDog Compute Source ID and the provider supplied instance ID

imageId: str | None = None

The machine image ID used for this instance.

instanceType: str | None = None

The machine type of this instance.

privateIpAddress: str | None = None

The private IP address of this instance.

provider: CloudProvider | None = None

The cloud provider that supplies this instance.

publicIpAddress: str | None = None

The public IP address of this instance.

region: str | None = None

The region where this instance is provisioned.

resourceId: str | None = None
spot: bool = False

Indicates if this instance was provisioned via spot pricing vs on-demand.

status: InstanceStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed

subregion: str | None = None

The subregion where this instance is provisioned.

type: str = 'co.yellowdog.platform.model.AzureInstance'
class yellowdog_client.model.AzureInstanceCredential(name, adminUsername, description=None, adminPassword=None)

Holds an admin user name and password to be used for created instances in Microsoft Azure.

Parameters:
adminPassword: str | None = None

The admin password

adminUsername: str

The admin username

description: str | None = None
name: str
type: str = 'co.yellowdog.platform.account.credentials.AzureInstanceCredential'
class yellowdog_client.model.AzureInstancesComputeSource(name, credential, region, networkResourceGroupName, networkName, subnetName, vmSize, imageId, availabilityZone=None, environment=None, userData=None, instanceTags=None, adminUserCredential=None, sshKey=None, assignPublicIp=False, createProximityPlacementGroup=None, useAcceleratedNetworking=None, useSpot=None, spotMaxPrice=None, limit=0)
Parameters:
adminUserCredential: str | None = None

Optionally specifies the name of an AzureInstanceCredential that provides the admin user name and password to use for root (Linux) or administrator (Windows). If not specified, then YellowDog Compute uses the default admin user name and a different randomly generated password for each instance.

assignPublicIp: bool = False
availabilityZone: str | None = None
createProximityPlacementGroup: bool | None = None

Indicates if instances should be provisioned within a proximity placement group.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
environment: str | None = None
exhaustion: ComputeSourceExhaustion | None = None
id: str | None = None
imageId: str

The YellowDog prefixed Azure image ID for the image to use for the provisioned instances.

instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
limit: int = 0
name: str
networkName: str
networkResourceGroupName: str
region: str

The Azure region where instances will be provisioned.

spotMaxPrice: float | None = None
sshKey: str | None = None

The public SSH key. If provided, instances will be accessible with the matching private key through SSH.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetName: str
supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.AzureInstancesComputeSource'
useAcceleratedNetworking: bool | None = None

Indicates if instances should be provisioned with a primary networking interface with accelerated networking.

useSpot: bool | None = None
userData: str | None = None
vmSize: str
class yellowdog_client.model.AzureNamespaceStorageConfiguration(namespace, containerName, credential)
Parameters:

  • namespace (str)

  • containerName (str)

  • credential (str)

containerName: str
credential: str
namespace: str
type: str = 'co.yellowdog.platform.model.AzureNamespaceStorageConfiguration'
class yellowdog_client.model.AzureScaleSetComputeSource(name, credential, region, networkResourceGroupName, networkName, subnetName, vmSize, imageId, availabilityZone=None, environment=None, userData=None, instanceTags=None, adminUserCredential=None, sshKey=None, assignPublicIp=False, createProximityPlacementGroup=None, useAcceleratedNetworking=None, useSpot=None, spotMaxPrice=None, limit=0)
Parameters:
adminUserCredential: str | None = None

Optionally specifies the name of an AzureInstanceCredential that provides the admin user name and password to use for root (Linux) or administrator (Windows). If not specified, then YellowDog Compute uses the default admin user name and a different randomly generated password for each instance.

assignPublicIp: bool = False
availabilityZone: str | None = None
createProximityPlacementGroup: bool | None = None

Indicates if instances should be provisioned within a proximity placement group.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
environment: str | None = None
exhaustion: ComputeSourceExhaustion | None = None
id: str | None = None
imageId: str

The YellowDog prefixed Azure image ID for the image to use for the provisioned instances.

instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
limit: int = 0
name: str
networkName: str
networkResourceGroupName: str
region: str

The Azure region where instances will be provisioned.

spotMaxPrice: float | None = None
sshKey: str | None = None

The public SSH key. If provided, instances will be accessible with the matching private key through SSH.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetName: str
supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.AzureScaleSetComputeSource'
useAcceleratedNetworking: bool | None = None

Indicates if instances should be provisioned with a primary networking interface with accelerated networking.

useSpot: bool | None = None
userData: str | None = None
vmSize: str
class yellowdog_client.model.AzureStorageCredential(name, accountName, accountKey, description=None)
Parameters:
accountKey: str

The Azure storage account key

accountName: str

The Azure storage account name

description: str | None = None
name: str
type: str = 'co.yellowdog.platform.account.credentials.AzureStorageCredential'
class yellowdog_client.model.BestComputeSourceReport(createdTime=None, requirementTemplateId=None, provisionedRequirementId=None, namespace=None, selectedSourceTemplateIds=None, rejectedSourceTemplateIds=None, sourcesConsidered=0, sourcesSelected=0, totalRanks=0, image=None, constraints=None, preferences=None, sources=None, requirementSupportedOperations=None)
Parameters:
constraints: Dict[str, BestComputeSourceReportConstraint] | None = None
createdTime: datetime | None = None
image: BestComputeSourceReportImage | None = None
namespace: str | None = None
preferences: Dict[str, BestComputeSourceReportPreference] | None = None
provisionedRequirementId: str | None = None
rejectedSourceTemplateIds: List[str] | None = None
requirementSupportedOperations: ComputeRequirementSupportedOperations | None = None
requirementTemplateId: str | None = None
selectedSourceTemplateIds: List[str] | None = None
sources: List[BestComputeSourceReportSource] | None = None
sourcesConsidered: int = 0
sourcesSelected: int = 0
totalRanks: int = 0
class yellowdog_client.model.BestComputeSourceReportConstraint
type: str = None
class yellowdog_client.model.BestComputeSourceReportImage(id=None, suppliedId=None, osType=None, availability=None)
Parameters:
availability: List[BestComputeSourceReportImageAvailability] | None = None
id: str | None = None
osType: ImageOsType | None = None
suppliedId: str | None = None
class yellowdog_client.model.BestComputeSourceReportImageAvailability(provider=None, region=None, supportedInstanceTypes=None)
Parameters:
provider: CloudProvider | None = None
region: List[str] | None = None
supportedInstanceTypes: List[str] | None = None
class yellowdog_client.model.BestComputeSourceReportNumericConstraint(min=None, max=None)
Parameters:
max: float | None = None
min: float | None = None
type: str = 'co.yellowdog.platform.model.BestComputeSourceReportNumericConstraint'
class yellowdog_client.model.BestComputeSourceReportPreference(weight=None, lowestValue=None, highestValue=None)
Parameters:
highestValue: Any | None = None
lowestValue: Any | None = None
weight: float | None = None
class yellowdog_client.model.BestComputeSourceReportSource(sourceTemplateId=None, provisionedSourceId=None, type=None, name=None, provider=None, region=None, instanceType=None, traits=None, totalScore=None, rank=None, attributes=None)
Parameters:
attributes: Dict[str, BestComputeSourceReportSourceAttribute] | None = None
instanceType: str | None = None
name: str | None = None
provider: CloudProvider | None = None
provisionedSourceId: str | None = None
rank: int | None = None
region: str | None = None
sourceTemplateId: str | None = None
totalScore: float | None = None
traits: ComputeSourceTraits | None = None
type: str | None = None
class yellowdog_client.model.BestComputeSourceReportSourceAttribute(value=None, score=None, percentile=None)
Parameters:
percentile: float | None = None
score: float | None = None
value: Any | None = None
class yellowdog_client.model.BestComputeSourceReportStringConstraint(anyOf=None, noneOf=None, pattern=None)
Parameters:
anyOf: Set[str] | None = None
noneOf: Set[str] | None = None
pattern: str | None = None
type: str = 'co.yellowdog.platform.model.BestComputeSourceReportStringConstraint'
class yellowdog_client.model.ChangePasswordRequest(oldPassword, newPassword)
Parameters:

  • oldPassword (str)

  • newPassword (str)

newPassword: str
oldPassword: str
class yellowdog_client.model.CheckCredentialsResult(availability=None, missing=None)

The result of checking if the requestor has access to credentials named in Compute Sources within a Compute Requirement.

Parameters:
availability: CredentialAvailability | None = None

A value summarizing the availability of credentials.

missing: Dict[str, List[str]] | None = None

A map of source ID to the credentials missing for that source.

class yellowdog_client.model.CloudProvider(value)

Enumerates Cloud Compute Providers.

ALIBABA = 'ALIBABA'

Alibaba Cloud

AWS = 'AWS'

Amazon Web Services (AWS)

AZURE = 'AZURE'

Microsoft Azure

GOOGLE = 'GOOGLE'

Google Cloud

OCI = 'OCI'

Oracle Cloud Infrastructure

ON_PREMISE = 'ON_PREMISE'

Indicates that the source of compute is not cloud-based, but is on-premise.

class yellowdog_client.model.ComputeNamespaceFilter(fromTime, untilTime, createdById=None)
Parameters:
createdById: str | None = None
fromTime: datetime
untilTime: datetime
class yellowdog_client.model.ComputeProvisionStrategy

The interface implemented by all compute provision strategy model objects.

A compute provision strategy determines the behaviour of YellowDog Compute when trying to acquire and release instances to meet the compute requirement.

type: str = None
class yellowdog_client.model.ComputeRequirement(namespace, name, provisionStrategy, tag=None, targetInstanceCount=0, expectedInstanceCount=0, maintainInstanceCount=False, nextStatus=None)

Defines the requirement for compute resource and chosen options for how to provision it.

This class is the main model object within the YellowDog Compute API. It is passed between the service and clients in order to request compute resource and to monitor the state of that resource.

Parameters:
createdById: str | None = None

The ID of the User or Application that first submitted this compute requirement.

createdFromId: str | None = None

Gets the ID of the requirement template if this requirement was created from a template.

createdTime: datetime | None = None

The date and time when this compute requirement was first submitted to YellowDog Compute.

expectedInstanceCount: int = 0

The number of alive instances expected based on existing instances and the most recent provision action.

id: str | None = None

The ID of this compute requirement that is generated by YellowDog Compute when the requirement is first submitted.

maintainInstanceCount: bool = False

Indicates if the Compute Service should automatically attempt to provision new instances if the number of RUNNING instances is below the specified targetInstanceCount

name: str

The user allocated name used to uniquely identify this compute requirement within its namespace.

namespace: str

The user allocated namespace used to group compute requirements and other objects together.

nextStatus: ComputeRequirementStatus | None = None

The next status of this compute requirement when a status transition is being requested.

provisionStrategy: ComputeProvisionStrategy

The compute provision strategy that YellowDog Compute must use when provisioning instances to meet this requirement.

status: ComputeRequirementStatus | None = None

The status of this compute requirement.

statusChangedTime: datetime | None = None

The date and time when the status or nextStatus last changed

supportedOperations: ComputeRequirementSupportedOperations | None = None
tag: str | None = None
targetInstanceCount: int = 0

The number of instances to be provisioned to meet this compute requirement.

class yellowdog_client.model.ComputeRequirementDynamicTemplate(name, strategyType, namespace=None, description=None, minimumSourceCount=None, maximumSourceCount=None, imagesId=None, userData=None, instanceTags=None, constraints=None, preferences=None, sourceTraits=None)
Parameters:
constraints: List[AttributeConstraint] | None = None
description: str | None = None
id: str | None = None
imagesId: str | None = None
instanceTags: Dict[str, str] | None = None
maximumSourceCount: int | None = None
minimumSourceCount: int | None = None
name: str
namespace: str | None = None
preferences: List[AttributePreference] | None = None
sourceTraits: ComputeSourceTraitsFilter | None = None
strategyType: str
type: str = 'co.yellowdog.platform.model.ComputeRequirementDynamicTemplate'
userData: str | None = None
class yellowdog_client.model.ComputeRequirementDynamicTemplateTestResult(computeRequirement=None, report=None)
Parameters:
computeRequirement: ComputeRequirement | None = None
report: BestComputeSourceReport | None = None
type: str = 'co.yellowdog.platform.interaction.compute.ComputeRequirementDynamicTemplateTestResult'
class yellowdog_client.model.ComputeRequirementSearch(name=None, namespace=None, tag=None, statuses=None, createdTime=None, sortField=None, sortDirection=None)
Parameters:
createdTime: InstantRange | None = None
name: str | None = None
namespace: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
statuses: List[ComputeRequirementStatus] | None = None
tag: str | None = None
class yellowdog_client.model.ComputeRequirementStaticTemplate(name, strategyType, sources, namespace=None, description=None, imagesId=None, userData=None, instanceTags=None)
Parameters:
description: str | None = None
id: str | None = None
imagesId: str | None = None
instanceTags: Dict[str, str] | None = None
name: str
namespace: str | None = None
sources: List[ComputeSourceUsage]
strategyType: str
type: str = 'co.yellowdog.platform.model.ComputeRequirementStaticTemplate'
userData: str | None = None
class yellowdog_client.model.ComputeRequirementStaticTemplateTestResult(computeRequirement=None)
Parameters:

computeRequirement (Optional[ComputeRequirement])

computeRequirement: ComputeRequirement | None = None
type: str = 'co.yellowdog.platform.interaction.compute.ComputeRequirementStaticTemplateTestResult'
class yellowdog_client.model.ComputeRequirementStatus(value)

Describes the status of a compute requirement.

The status of a compute requirement provides an aggregated view of the statuses of instances provisioned for that requirement.

NEW = 'NEW'

The compute requirement has been created and submitted to YellowDog Compute.

PROVISIONING = 'PROVISIONING'

YellowDog Compute is in the process of provisioning computer machine instances to meet the requirement. The requirement will remain in PROVISIONING state until all newly provisioned instances have transitioned to RUNNING or TERMINATED (in the case where a provider cancels provision).

RUNNING = 'RUNNING'

The instances provisioned for the requirement are running. Individual instances may be independently transitioned to other states but the requirement is still considered to be running.

STARTING = 'STARTING'

The instances provisioned for the requirement are being re-started after having been stopped. Some instances may already have started, however the requirement is still considered to be STARTING until all instances have started.

STOPPED = 'STOPPED'

The instances provisioned for the requirement have stopped.

STOPPING = 'STOPPING'

The instances provisioned for the requirement are being stopped. Some instances may already have stopped, however the requirement is still considered to be STOPPING until all instances have stopped.

TERMINATED = 'TERMINATED'

The instances provisioned for the requirement have been terminated. At this point the compute requirement may no longer be changed and is considered to be in a final state.

TERMINATING = 'TERMINATING'

The instances provisioned for the requirement are being terminated. Some instances may already be terminated, however the requirement is still considered to be TERMINATING until all instances have terminated.

class yellowdog_client.model.ComputeRequirementSummary(id=None, namespace=None, name=None, tag=None, targetInstanceCount=0, expectedInstanceCount=0, aliveInstanceCount=0, createdTime=None, status=None, healthy=False)

Provides a summary of a ComputeRequirement including the ID that can be used to retrieve the full object.

Parameters:
aliveInstanceCount: int = 0

The number of alive instances.

createdTime: datetime | None = None

The date and time when this compute requirement was first submitted to YellowDog Compute.

expectedInstanceCount: int = 0

The number of alive instances expected based on existing instances and the most recent provision action.

healthy: bool = False

Represents whether the compute requirement is healthy or not. A compute requirement is considered healthy if no sources have a status of ERRORED

id: str | None = None

The ID of this compute requirement that is generated by YellowDog Compute when the requirement is first submitted.

name: str | None = None

The user allocated name used to uniquely identify the compute requirement within its namespace.

namespace: str | None = None

The user allocated namespace used to group compute requirements and other objects together.

status: ComputeRequirementStatus | None = None

The status of this compute requirement.

tag: str | None = None
targetInstanceCount: int = 0

The number of instances to be provisioned to meet this compute requirement.

class yellowdog_client.model.ComputeRequirementSummarySearch(name=None, namespace=None, tag=None, statuses=None, createdTime=None, isHealthy=None, sortField=None, sortDirection=None)
Parameters:
createdTime: InstantRange | None = None
isHealthy: bool | None = None
name: str | None = None
namespace: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
statuses: List[ComputeRequirementStatus] | None = None
tag: str | None = None
class yellowdog_client.model.ComputeRequirementSupportedOperations(canStopStart=False, canScaleOut=False, canReprovision=False)

Describes operations supported by a Compute Requirement based the traits of its compute sources.

Parameters:

  • canStopStart (bool)

  • canScaleOut (bool)

  • canReprovision (bool)

canReprovision: bool = False
canScaleOut: bool = False
canStopStart: bool = False
class yellowdog_client.model.ComputeRequirementTemplate
type: str = None
class yellowdog_client.model.ComputeRequirementTemplateSummary(id=None, name=None, namespace=None, description=None, strategyType=None, type=None)
Parameters:
description: str | None = None
id: str | None = None
name: str | None = None
namespace: str | None = None
strategyType: str | None = None
type: str | None = None
class yellowdog_client.model.ComputeRequirementTemplateTestResult
type: str = None
class yellowdog_client.model.ComputeRequirementTemplateUsage(templateId, requirementName, requirementNamespace=None, requirementTag=None, targetInstanceCount=0, imagesId=None, userData=None, instanceTags=None, maintainInstanceCount=False)
Parameters:
imagesId: str | None = None
instanceTags: Dict[str, str] | None = None
maintainInstanceCount: bool = False
requirementName: str
requirementNamespace: str | None = None
requirementTag: str | None = None
targetInstanceCount: int = 0
templateId: str
userData: str | None = None
class yellowdog_client.model.ComputeRequirementUsage(computeRequirementId=None, name=None, namespace=None, tag=None, createdById=None, createdTime=None, terminatedTime=None)
Parameters:
computeRequirementId: str | None = None
createdById: str | None = None
createdTime: datetime | None = None
name: str | None = None
namespace: str | None = None
tag: str | None = None
terminatedTime: datetime | None = None
class yellowdog_client.model.ComputeRequirementUsageFilter(fromTime, untilTime, createdById=None, namespaces=None)
Parameters:
createdById: str | None = None
fromTime: datetime
namespaces: List[str] | None = None
untilTime: datetime
class yellowdog_client.model.ComputeRequirementsSummary(statusCounts=None, errors=False)
Parameters:
errors: bool = False
statusCounts: Dict[ComputeRequirementStatus, int] | None = None
class yellowdog_client.model.ComputeSource

The interface implemented by all compute source model objects.

A compute source describes a specific source for acquiring instances in order to meet the compute requirement.

type: str = None
class yellowdog_client.model.ComputeSourceExhaustion(status=None, expectedTermination=None)

Provides details for a compute source that is exhausted or nearing exhaustion.

Parameters:
expectedTermination: datetime | None = None

The expected termination time when an associated exhausted allowance’s hard limit grace period will expire.

status: ComputeSourceExhaustionStatus | None = None

If the source is associated with an exhausted allowance, gets the exhaustion status.

class yellowdog_client.model.ComputeSourceExhaustionStatus(value)

An enumeration.

LIMITED = 'LIMITED'
LIMITED_AWAITING_TERMINATION = 'LIMITED_AWAITING_TERMINATION'
TERMINATION = 'TERMINATION'
class yellowdog_client.model.ComputeSourceStatus(value)

Describes the status of a compute source.

The status of a compute source indicates if there are active instances from that source, or if the source is currently being changed or has errored.

ACTIVE = 'ACTIVE'

The compute source is providing at least one instance that is not terminated.

ERRORED = 'ERRORED'

The last requested action performed by YellowDog Compute with this compute source resulted in an error.

INACTIVE = 'INACTIVE'

The compute source is either not providing any instances or any that have been provided are now terminated.

NEW = 'NEW'

The compute source has been created and submitted to YellowDog Compute.

UPDATING = 'UPDATING'

YellowDog Compute is currently updating its usage of the compute source. This could be provisioning or deprovisioning instances, or transitioning instances (stopping, starting, restarting, terminating)

class yellowdog_client.model.ComputeSourceTemplate(source, namespace=None, description=None, attributes=None)
Parameters:
attributes: List[AttributeValue[Any]] | None = None
description: str | None = None
id: str | None = None
namespace: str | None = None
source: ComputeSource
class yellowdog_client.model.ComputeSourceTemplateSummary(id=None, name=None, namespace=None, description=None, sourceType=None, provider=None)
Parameters:
description: str | None = None
id: str | None = None
name: str | None = None
namespace: str | None = None
provider: CloudProvider | None = None
sourceType: str | None = None
class yellowdog_client.model.ComputeSourceTraits(canStopStart=False, canRestart=False, canScaleOut=False, isSelfMaintained=False)

Describes behavioural traits specific to a compute source.

Parameters:

  • canStopStart (bool)

  • canRestart (bool)

  • canScaleOut (bool)

  • isSelfMaintained (bool)

canRestart: bool = False
canScaleOut: bool = False
canStopStart: bool = False
isSelfMaintained: bool = False
class yellowdog_client.model.ComputeSourceTraitsFilter(canStopStart=None, canRestart=None, canScaleOut=None, isSelfMaintained=None)
Parameters:
canRestart: bool | None = None
canScaleOut: bool | None = None
canStopStart: bool | None = None
isSelfMaintained: bool | None = None
class yellowdog_client.model.ComputeSourceUsage(sourceTemplateId, instanceType=None, imageId=None)
Parameters:
imageId: str | None = None
instanceType: str | None = None
sourceTemplateId: str
class yellowdog_client.model.ConfiguredWorkerPool(id=None, name=None, namespace=None, createdTime=None, status=None, statusChangedTime=None, expectedNodeCount=0, awaitingNodes=False, workerSummary=None, nodeSummary=None, properties=None)
Parameters:
awaitingNodes: bool = False
createdTime: datetime | None = None
expectedNodeCount: int = 0
id: str | None = None
name: str | None = None
namespace: str | None = None
nodeSummary: NodeSummary | None = None
properties: ConfiguredWorkerPoolProperties | None = None
status: WorkerPoolStatus | None = None
statusChangedTime: datetime | None = None
type: str = 'co.yellowdog.platform.model.ConfiguredWorkerPool'
workerSummary: WorkerSummary | None = None
class yellowdog_client.model.ConfiguredWorkerPoolProperties(nodeConfiguration=None, targetNodeCount=None, workerTag=None, metricsEnabled=None)

Defines properties to determine the behaviour that the Scheduler service should use when managing a configured worker pool.

Parameters:
metricsEnabled: bool | None = None
nodeConfiguration: WorkerPoolNodeConfiguration | None = None
targetNodeCount: int | None = None

The number of nodes that will be configured to register with this worker pool.

workerTag: str | None = None
class yellowdog_client.model.Constants
class yellowdog_client.model.CreateKeyringRequest(name, description=None, creatorSecret=None)
Parameters:
creatorSecret: str | None = None
description: str | None = None
name: str
class yellowdog_client.model.CreateKeyringResponse(keyring=None, keyringPassword=None)
Parameters:
keyring: Keyring | None = None
keyringPassword: str | None = None
class yellowdog_client.model.Credential

Interface implemented by classes used to provide cloud provider-specific credentials to YellowDog Compute.

type: str = None
class yellowdog_client.model.CredentialAvailability(value)

Summarizes how many credentials are available for a Compute Requirement

ALL = 'ALL'

All credentials named in the sources in the Compute Requirement are available

NONE = 'NONE'

None of the credentials named in the sources in the Compute Requirement are available

PARTIAL = 'PARTIAL'

Some of the credentials named in the sources in the Compute Requirement are available

class yellowdog_client.model.Currency(value)

An enumeration.

AED = 'AED'

UAE Dirham

ARS = 'ARS'

Argentinian Peso

AUD = 'AUD'

Australian Dollar

BDT = 'BDT'

Bangladeshi Taka

BGN = 'BGN'

Bulgarian Lev

BHD = 'BHD'

Bahraini Dinar

BRL = 'BRL'

Brazilian Real

CAD = 'CAD'

Canadian Dollar

CHF = 'CHF'

Swiss Frank

CLP = 'CLP'

Chilean Peso

CNY = 'CNY'

Chinese Yuan

COP = 'COP'

Colombian Peso

CRC = 'CRC'

Costa Rican Colon

CZK = 'CZK'

Czech Koruna

DKK = 'DKK'

Danish Krone

EGP = 'EGP'

Egyptian Pound

EUR = 'EUR'

Euro

GBP = 'GBP'

British Pound

HKD = 'HKD'

Hong Kong Dollar

HRK = 'HRK'

Croatian Kuna

HUF = 'HUF'

Hungarian Forint

IDR = 'IDR'

Indonesian Rupiah

ILS = 'ILS'

Israeli New Shekel

INR = 'INR'

Indian Rupee

ISK = 'ISK'

Icelandic Krona

JPY = 'JPY'

Japanese Yen

KRW = 'KRW'

South Korean Won

KWD = 'KWD'

Kuwaiti Dinar

MXN = 'MXN'

Mexican Peso

MYR = 'MYR'

Malaysian Ringgit

NOK = 'NOK'

Norwegian Krone

NZD = 'NZD'

New Zealand Dollar

PEN = 'PEN'

Peruvian Sol

PHP = 'PHP'

Philippine Peso

PKR = 'PKR'

Pakistani Rupee

PLN = 'PLN'

Poland Zloty

QAR = 'QAR'

Qatari Rial

RON = 'RON'

Romanian Leu

RSD = 'RSD'

Serbian Dinar

RUB = 'RUB'

Russian Ruble

SAR = 'SAR'

Saudi Riyal

SEK = 'SEK'

Swedish Krone

SGD = 'SGD'

Singapore Dollar

THB = 'THB'

Thai Baht

TRY = 'TRY'

Turkish Lira

TWD = 'TWD'

Taiwan Dollar

USD = 'USD'

US Dollar

VND = 'VND'

Vietnamese Dong

ZAR = 'ZAR'

South African Rand

class yellowdog_client.model.DoubleRange(min=None, max=None)
Parameters:
max: float | None = None
min: float | None = None
class yellowdog_client.model.EmailChangeRequest(newEmail)
Parameters:

newEmail (str)

newEmail: str
class yellowdog_client.model.ErrorResponse(errorType, message=None, detail=None)
Parameters:
detail: List[str] | None = None
errorType: str
message: str | None = None
class yellowdog_client.model.ExistingPasswordRequest(password)
Parameters:

password (str)

password: str
class yellowdog_client.model.ExternalAttributeDefinition(inputs, definition)
Parameters:
definition: AttributeDefinition
inputs: List[str]
class yellowdog_client.model.ExternalAttributeProviderQuery(attributes=None, sources=None)
Parameters:
attributes: List[str] | None = None
sources: List[ExternalAttributeProviderQuerySource] | None = None
class yellowdog_client.model.ExternalAttributeProviderQuerySource(id=None, source=None, image=None)
Parameters:
id: str | None = None
image: Dict[str, Any] | None = None
source: Dict[str, Any] | None = None
class yellowdog_client.model.ExternalAttributeProviderRegistration(providerName=None, maxSourcesPerRequest=0, attributes=None)
Parameters:
attributes: List[ExternalAttributeDefinition] | None = None
maxSourcesPerRequest: int = 0
providerName: str | None = None
class yellowdog_client.model.ExternalAttributeProviderResults(sources=None, expires=None)
Parameters:
expires: datetime | None = None
sources: List[ExternalAttributeProviderResultsSource] | None = None
class yellowdog_client.model.ExternalAttributeProviderResultsSource(id, attributes=None)
Parameters:
attributes: Dict[str, Any] | None = None
id: str
class yellowdog_client.model.ExternalAttributeSource(name=None, healthy=False, attributes=None)
Parameters:
attributes: List[AttributeDefinition] | None = None
healthy: bool = False
name: str | None = None
sourceType: AttributeSourceType | None = None
class yellowdog_client.model.ExternalUser(name, email=None, eulaAccepted=False, accessDelegates=None, passwordSet=False)

Represents an external user within the YellowDog Platform.

Parameters:
accessDelegates: List[AccessDelegate] | None = None
authenticationProvider: AuthenticationProvider = None
email: str | None = None
eulaAccepted: bool = False
externalId: str = None
id: str | None = None
name: str
passwordSet: bool = False
type: str = 'co.yellowdog.platform.model.ExternalUser'
class yellowdog_client.model.Feature(value)

An enumeration.

INDEX = 'INDEX'
INDEX_PRO = 'INDEX_PRO'
PLATFORM = 'PLATFORM'
class yellowdog_client.model.FeatureDetail(name=None, title=None)
Parameters:
name: str | None = None
title: str | None = None
class yellowdog_client.model.Filter
class yellowdog_client.model.FlattenPath(value)

Indicates which path flattening strategy should be applied when downloading task inputs.

FILE_NAME_ONLY = 'FILE_NAME_ONLY'

Save the file to the working directory with just its file name.

REPLACE_PATH_SEPERATOR = 'REPLACE_PATH_SEPERATOR'

Save the file to the working directory including directories in the output file name, separated by an underscore.

class yellowdog_client.model.GceComputeSource

Derives from ComputeSource to provide the interface for all Google Compute Engine (GCE) compute source model objects.

type: str = 'co.yellowdog.platform.model.GceComputeSource'
class yellowdog_client.model.GceHostMaintenanceBehaviour(value)

The GCE instance behaviour to apply on a host maintenance event.

MIGRATE = 'MIGRATE'

Specifies that instances shall be live-migrated on a host maintenance event.

TERMINATE = 'TERMINATE'

Specifies that instances shall be stopped on a host maintenance event.

class yellowdog_client.model.GceInstance(preemptible=False, confidential=False, id=None, createdTime=None, provider=None, instanceType=None, region=None, subregion=None, imageId=None, hostname=None, privateIpAddress=None, publicIpAddress=None, spot=False, status=None, statusChangedTime=None)

Extends Instance to add fields specific to the Google Compute Engine (GCE) compute source.

Parameters:
confidential: bool = False
createdTime: datetime | None = None

The date and time when this instance was first created.

hostname: str | None = None

The hostname of this instance.

id: InstanceId | None = None

The unique identifier for this instance formed from the YellowDog Compute Source ID and the provider supplied instance ID

imageId: str | None = None

The machine image ID used for this instance.

instanceType: str | None = None

The machine type of this instance.

preemptible: bool = False
privateIpAddress: str | None = None

The private IP address of this instance.

provider: CloudProvider | None = None

The cloud provider that supplies this instance.

publicIpAddress: str | None = None

The public IP address of this instance.

region: str | None = None

The region where this instance is provisioned.

spot: bool = False

Indicates if this instance was provisioned via spot pricing vs on-demand.

status: InstanceStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed

subregion: str | None = None

The subregion where this instance is provisioned.

type: str = 'co.yellowdog.platform.model.GceInstance'
class yellowdog_client.model.GceInstanceGroupComputeSource(name, credential, project, region, machineType, image, limit=0, assignPublicIp=False, userData=None, instanceTags=None, sshKeys=None, zone=None, network=None, subnetwork=None, preemptible=False, spot=False, confidential=False, acceleratorType=None, acceleratorCount=0, hostMaintenanceBehaviour=None)

Defines a source of compute composed of Google Compute Engine (GCE) instances organised into an Instance Group.

Parameters:
acceleratorCount: int = 0
acceleratorType: str | None = None
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

confidential: bool = False
createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
exhaustion: ComputeSourceExhaustion | None = None
hostMaintenanceBehaviour: GceHostMaintenanceBehaviour | None = None
id: str | None = None
image: str
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
limit: int = 0
machineType: str
name: str
network: str | None = None
preemptible: bool = False
project: str
region: str
spot: bool = False
sshKeys: str | None = None

A list of public SSH keys. If provided, instances will be accessible with the matching private keys through SSH.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetwork: str | None = None
supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.GceInstanceGroupComputeSource'
userData: str | None = None
zone: str | None = None
class yellowdog_client.model.GceInstancesComputeSource(name, credential, project, region, machineType, image, limit=0, assignPublicIp=False, specifyMinimum=False, createCompactPlacementPolicy=None, userData=None, instanceTags=None, sshKeys=None, zone=None, network=None, subnetwork=None, preemptible=False, spot=False, confidential=False, acceleratorType=None, acceleratorCount=0, hostMaintenanceBehaviour=None)

Defines a source of compute composed of Google Compute Engine (GCE) instances individually provisioned.

Parameters:
acceleratorCount: int = 0
acceleratorType: str | None = None
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

confidential: bool = False
createCompactPlacementPolicy: bool | None = None

Indicates if instances should be provisioned using a compact placement policy.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
exhaustion: ComputeSourceExhaustion | None = None
hostMaintenanceBehaviour: GceHostMaintenanceBehaviour | None = None
id: str | None = None
image: str
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
limit: int = 0
machineType: str
name: str
network: str | None = None
preemptible: bool = False
project: str
region: str
specifyMinimum: bool = False

Indicates if YellowDog Compute should specify the minimum when requesting instances. NB: This can only be used with a limit set between 1..1000 If true, then no instances are provisioned unless all requested instances are available; otherwise, if false, YellowDog Compute will provision as many instances as possible up to the number requested from this compute source.

spot: bool = False
sshKeys: str | None = None

A list of public SSH keys. If provided, instances will be accessible with the matching private keys through SSH.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetwork: str | None = None
supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.GceInstancesComputeSource'
userData: str | None = None
zone: str | None = None
class yellowdog_client.model.GcsNamespaceStorageConfiguration(namespace, bucketName, credential)
Parameters:

  • namespace (str)

  • bucketName (str)

  • credential (str)

bucketName: str
credential: str
namespace: str
type: str = 'co.yellowdog.platform.model.GcsNamespaceStorageConfiguration'
class yellowdog_client.model.GoogleCloudCredential(name, serviceAccountKeyJson, description=None)
Parameters:
description: str | None = None
name: str
serviceAccountKeyJson: str

The Google Cloud service account key JSON text

type: str = 'co.yellowdog.platform.account.credentials.GoogleCloudCredential'
class yellowdog_client.model.GrantApplicationAccessRequest(applicationApiKey)
Parameters:

applicationApiKey (ApiKey)

applicationApiKey: ApiKey
class yellowdog_client.model.GrantUserAccessRequest(userPassword)
Parameters:

userPassword (str)

userPassword: str
class yellowdog_client.model.Group(name, description=None, roles=None, adminGroup=False)
Parameters:
adminGroup: bool = False
description: str | None = None
id: str | None = None
name: str
roles: List[GroupRole] | None = None
class yellowdog_client.model.GroupRole(role)
Parameters:

role (RoleSummary)

role: RoleSummary
class yellowdog_client.model.GroupSearch(sortField=None, sortDirection=None, name=None)
Parameters:
name: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.GroupSummary(id=None, name=None, description=None, adminGroup=False)
Parameters:
adminGroup: bool = False
description: str | None = None
id: str | None = None
name: str | None = None
class yellowdog_client.model.Identified

Interface implemented by all model types that have a system generated ID field for identification

class yellowdog_client.model.ImageAccess(value)

An enumeration.

PRIVATE = 'PRIVATE'
PUBLIC = 'PUBLIC'
class yellowdog_client.model.ImageOsType(value)

An enumeration.

LINUX = 'LINUX'
WINDOWS = 'WINDOWS'
class yellowdog_client.model.Instance

Describes an instance provisioned for a compute requirement.

This class provides common fields shared across all compute provisioners. It is generally specialised for each provisioner to add extra fields specific to that provisioner.

type: str = None
class yellowdog_client.model.InstanceId(sourceId, instanceId)

Represents the composite ID for an Instance

Parameters:

  • sourceId (str)

  • instanceId (str)

instanceId: str

The provider supplied ID for this instance.

sourceId: str

The ID of the compute source from which this instance was provisioned.

class yellowdog_client.model.InstancePricing(value)

An enumeration.

ON_DEMAND_ONLY = 'ON_DEMAND_ONLY'
SPOT_AND_ON_DEMAND = 'SPOT_AND_ON_DEMAND'
SPOT_ONLY = 'SPOT_ONLY'
class yellowdog_client.model.InstanceSearch(sortField=None, sortDirection=None, computeRequirementId=None, computeSourceId=None, providers=None, regions=None, statuses=None, imageIds=None, publicIpAddress=None, privateIpAddress=None, hostname=None)
Parameters:
computeRequirementId: str | None = None
computeSourceId: str | None = None
hostname: str | None = None
imageIds: List[str] | None = None
privateIpAddress: str | None = None
providers: List[CloudProvider] | None = None
publicIpAddress: str | None = None
regions: List[str] | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
statuses: List[InstanceStatus] | None = None
class yellowdog_client.model.InstanceStatus(value)

Describes the status of a instance.

PENDING = 'PENDING'

The instance is in the process of being provisioned, or rebooted.

RUNNING = 'RUNNING'

The instance is running.

STOPPED = 'STOPPED'

The instance has been stopped.

STOPPING = 'STOPPING'

The instance is in the process of being stopped.

TERMINATED = 'TERMINATED'

The instance has been terminated and can no longer be used.

TERMINATING = 'TERMINATING'

The instance is in the process of being terminated.

UNAVAILABLE = 'UNAVAILABLE'

The instance is unavailable due to a process external to YellowDog e.g. creating an image or repairing the instance.

UNKNOWN = 'UNKNOWN'

The status of the instance is unknown. The instance can be restarted to try to recover or terminated.

class yellowdog_client.model.InstanceSummary(statusCounts=None, requestedCount=0, expectedCount=0, expiredCount=0, totalCount=0, lastUpdatedTime=None)

Provides summary counts for instances provisioned from a compute source.

Parameters:
aliveCount: int | None = None
expectedCount: int = 0

The number of alive instances expected from this compute source, based on existing instances and the most recent provision action.

expiredCount: int = 0

The count of TERMINATED instances that have expired and can no longer be retrieved from the platform.

lastUpdatedTime: datetime | None = None
requestedCount: int = 0

The number of instances last requested from this compute source.

statusCounts: Dict[InstanceStatus, int] | None = None

A count of each status based on the non-expired instances that have been provisioned.

totalCount: int = 0

The total count of all instances provisioned from this compute source (including expired instances).

class yellowdog_client.model.InstanceType(provider=None, name=None, processorArchitecture=None, defaultVcpus=None, defaultGpus=None, ramInMib=None, regions=None)
Parameters:
defaultGpus: Dict[str, int] | None = None
defaultVcpus: float | None = None
name: str | None = None
processorArchitecture: ProcessorArchitecture | None = None
provider: CloudProvider | None = None
ramInMib: int | None = None
regions: List[InstanceTypeRegion] | None = None
class yellowdog_client.model.InstanceTypePrice(provider=None, region=None, subRegion=None, instanceType=None, usageType=None, operatingSystemLicence=None, price=None)
Parameters:
instanceType: str | None = None
operatingSystemLicence: OperatingSystemLicence | None = None
price: Price | None = None
provider: CloudProvider | None = None
region: str | None = None
subRegion: str | None = None
usageType: UsageType | None = None
class yellowdog_client.model.InstanceTypePriceSearch(providers=None, region=None, subRegion=None, instanceType=None, usageTypes=None, operatingSystemLicences=None, sortField=None, sortDirection=None)
Parameters:
instanceType: str | None = None
operatingSystemLicences: List[OperatingSystemLicence] | None = None
providers: List[CloudProvider] | None = None
region: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
subRegion: str | None = None
usageTypes: List[UsageType] | None = None
class yellowdog_client.model.InstanceTypeRegion(name=None, subRegions=None)
Parameters:
name: str | None = None
subRegions: List[str] | None = None
class yellowdog_client.model.InstanceTypeSearch(providers=None, name=None, processorArchitectures=None, defaultVcpus=None, ramInMib=None, region=None, subRegion=None, sortField=None, sortDirection=None)
Parameters:
defaultVcpus: DoubleRange | None = None
name: str | None = None
processorArchitectures: List[ProcessorArchitecture] | None = None
providers: List[CloudProvider] | None = None
ramInMib: DoubleRange | None = None
region: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
subRegion: str | None = None
class yellowdog_client.model.InstanceTypeWithPrices(instanceTypeName=None, processorArchitecture=None, defaultVcpus=None, ramInMib=None, offered=None, spotPrice=None, onDemandPrice=None)
Parameters:
defaultVcpus: float | None = None
instanceTypeName: str | None = None
offered: bool | None = None
onDemandPrice: Price | None = None
processorArchitecture: ProcessorArchitecture | None = None
ramInMib: int | None = None
spotPrice: Price | None = None
class yellowdog_client.model.InstanceTypeWithPricesSearch(provider, operatingSystemLicence, sortField=None, sortDirection=None, instanceTypeName=None, region=None, subRegion=None)
Parameters:
instanceTypeName: str | None = None
operatingSystemLicence: OperatingSystemLicence
provider: CloudProvider
region: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
subRegion: str | None = None
class yellowdog_client.model.InstanceUsage(provider=None, region=None, instanceType=None, sourceName=None, instanceCount=0, statusDurations=None)
Parameters:
instanceCount: int = 0
instanceType: str | None = None
provider: CloudProvider | None = None
region: str | None = None
sourceName: str | None = None
statusDurations: Dict[InstanceStatus, timedelta] | None = None
class yellowdog_client.model.InstanceUsageFilter(fromTime, untilTime, createdById=None, namespaces=None, requirements=None)
Parameters:
createdById: str | None = None
fromTime: datetime
namespaces: List[str] | None = None
requirements: List[str] | None = None
untilTime: datetime
class yellowdog_client.model.InstantRange(min=None, max=None)
Parameters:
max: datetime | None = None
min: datetime | None = None
class yellowdog_client.model.IntegerRange(min=None, max=None)
Parameters:
max: int | None = None
min: int | None = None
class yellowdog_client.model.InternalAttributeSource(sourceType=None, attributes=None)
Parameters:
attributes: List[AttributeDefinition] | None = None
sourceType: AttributeSourceType | None = None
class yellowdog_client.model.InternalUser(username, name, email=None, eulaAccepted=False, accessDelegates=None, passwordSet=False)

Represents an internal user within the YellowDog Platform.

Parameters:
accessDelegates: List[AccessDelegate] | None = None
email: str | None = None
eulaAccepted: bool = False
id: str | None = None
name: str
passwordSet: bool = False
type: str = 'co.yellowdog.platform.model.InternalUser'
username: str
class yellowdog_client.model.Keyring(id=None, name=None, description=None, credentials=None, accessors=None)
Parameters:
accessors: List[KeyringAccessor] | None = None
credentials: List[KeyringCredential] | None = None
description: str | None = None
id: str | None = None
name: str | None = None
class yellowdog_client.model.KeyringAccessSecrets(keyringPassword, accessorSecret)
Parameters:

  • keyringPassword (str)

  • accessorSecret (str)

accessorSecret: str
keyringPassword: str
class yellowdog_client.model.KeyringAccessor(accessorId=None, accessorType=None, accessorName=None)
Parameters:
accessorId: str | None = None
accessorName: str | None = None
accessorType: str | None = None
class yellowdog_client.model.KeyringCredential(name=None, description=None, type=None)
Parameters:
description: str | None = None
name: str | None = None
type: str | None = None
class yellowdog_client.model.KeyringSummary(id=None, name=None, description=None)
Parameters:
description: str | None = None
id: str | None = None
name: str | None = None
class yellowdog_client.model.LongRange(min=None, max=None)
Parameters:
max: int | None = None
min: int | None = None
class yellowdog_client.model.MachineImage(name, provider, providerImageId, osType, regions=None, supportedInstanceTypes=None, metadata=None)

Describes a machine software image, its capabilities and where it is available.

Parameters:
createdTime: datetime | None = None

The date and time when this machine image record was first created. NB: This may not be indicative of the time the actual image was created.

id: str | None = None
metadata: Dict[str, str] | None = None

A map of user-definable key-value pairs to hold extra metadata properties related to the machine image.

name: str

The machine image name

osType: ImageOsType

The image operating system type

provider: CloudProvider

The compute provider in whose system the image is registered.

providerImageId: str

The ID for the image in the compute provider’s system.

regions: List[str] | None = None

The regions in which the image is registered. If null or empty then the image is assumed to be available in all regions.

supportedInstanceTypes: List[str] | None = None

The instance types that can be used with the image in the cloud provider’s system. If null or empty then the image is assumed to compatible with any instance type.

class yellowdog_client.model.MachineImageFamily(namespace, name, osType, access=ImageAccess.PRIVATE, metadataSpecification=None, imageGroups=None)

Defines a family of versions of machine image groups.

Parameters:
access: ImageAccess = 'PRIVATE'

The access level for this machine image family and any contained groups and images.

createdTime: datetime | None = None

The date and time when this machine image family was first created.

id: str | None = None
imageGroups: List[MachineImageGroup] | None = None

A list of the related machine image groups.

metadataSpecification: Dict[str, str] | None = None

A map of user-definable key-value pairs used to specify metadata keys and, optionally, values required to be on all images within the machine image family.

name: str

The user allocated name used to uniquely identify this machine image family within its namespace.

namespace: str

The user allocated namespace used to group machine image families and other objects together.

osType: ImageOsType

The operating system type of all images within this machine image family.

class yellowdog_client.model.MachineImageFamilySearch(sortField=None, sortDirection=None, includePublic=False, namespace=None, familyName=None, groupName=None, osType=None, familyCreatedTime=None, groupCreatedTime=None, imageCreatedTime=None, providers=None, regions=None, supportedInstanceTypes=None, metadataFilters=None)
Parameters:
familyCreatedTime: InstantRange | None = None
familyName: str | None = None
groupCreatedTime: InstantRange | None = None
groupName: str | None = None
imageCreatedTime: InstantRange | None = None
includePublic: bool = False
metadataFilters: List[MetadataFilter] | None = None
namespace: str | None = None
osType: ImageOsType | None = None
providers: List[CloudProvider] | None = None
regions: List[str] | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
supportedInstanceTypes: List[str] | None = None
class yellowdog_client.model.MachineImageFamilySummary(id=None, namespace=None, name=None, createdTime=None, access=None, osType=None, owned=None)

Provides a summary of a Machine Image Family including the ID that can be used to retrieve the full object.

Parameters:
access: ImageAccess | None = None

The access level for this machine image family and any contained groups and images.

createdTime: datetime | None = None

The date and time when the machine image family was first created.

id: str | None = None
name: str | None = None

The user allocated name used to uniquely identify the machine image family within its namespace.

namespace: str | None = None

The user allocated namespace used to group machine image families and other objects together.

osType: ImageOsType | None = None

The operating system type of all images within this machine image family.

owned: bool | None = None

Indicates if the machine image family is owned by the authenticated account.

class yellowdog_client.model.MachineImageGroup(name, osType, metadataSpecification=None, images=None)

Defines a group of functionally equivalent machine images across different provider/region environments.

Parameters:
createdTime: datetime | None = None

The date and time when this machine image group was first created.

id: str | None = None
images: List[MachineImage] | None = None

A list of functionally equivalent machine images

metadataSpecification: Dict[str, str] | None = None

A map of user-definable key-value pairs used to specify metadata keys and, optionally, values required to be on all images within the machine image group.

name: str

The user allocated name used to uniquely identify this machine image group within its family.

osType: ImageOsType

The operating system type of all images within this machine image group.

class yellowdog_client.model.MeasurementAggregate(metric=None, timestamp=None, averageValue=None)
Parameters:
averageValue: float | None = None
metric: str | None = None
timestamp: datetime | None = None
class yellowdog_client.model.MeasurementSearch(metrics, timestamp)
Parameters:
metrics: Set[str]
timestamp: InstantRange
class yellowdog_client.model.MeasurementSearchValidator
class yellowdog_client.model.MetadataFilter(key, value=None)
Parameters:
key: str
value: str | None = None
class yellowdog_client.model.ModelException
class yellowdog_client.model.Named

Interface implemented by all model types that have a name field

class yellowdog_client.model.NamespaceAutoscalingCapacityResponse(namespace=None, capacityLimited=False, remainingCapacity=None)
Parameters:
capacityLimited: bool = False
namespace: str | None = None
remainingCapacity: int | None = None
class yellowdog_client.model.NamespaceObjectsResponse(namespace=None, objects=None)
Parameters:
namespace: str | None = None
objects: List[str] | None = None
class yellowdog_client.model.NamespacePolicy(namespace, autoscalingMaxNodes=None)
Parameters:
autoscalingMaxNodes: int | None = None
namespace: str
class yellowdog_client.model.NamespacePolicySearch(sortField=None, sortDirection=None, namespace=None)
Parameters:
namespace: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.NamespaceStorageConfiguration
type: str = None
class yellowdog_client.model.NewPasswordRequest(password)
Parameters:

password (str)

password: str
class yellowdog_client.model.Node(id=None, workerPoolId=None, details=None, status=None, statusChangedTime=None, registeredTime=None, workers=None, actionQueueStatus=None, agentVersion=None)

Describes an instance within a worker pool.

Parameters:
actionQueueStatus: NodeActionQueueStatus | None = None

The status of the action queue for the node.

agentVersion: str | None = None
details: NodeDetails | None = None

The details of the node.

id: str | None = None

The ID of the node.

registeredTime: datetime | None = None

The time when the node was registered.

status: NodeStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed.

workerPoolId: str | None = None

The ID of the worker pool containing the node.

workers: List[Worker] | None = None

The workers on this instance.

class yellowdog_client.model.NodeAction
action: str = None
class yellowdog_client.model.NodeActionGroup(actions)
Parameters:

actions (List[NodeAction])

actions: List[NodeAction]
class yellowdog_client.model.NodeActionQueueSnapshot(timestamp=None, status=None, waiting=None, executing=None, failed=None)
Parameters:
executing: List[NodeAction] | None = None
failed: NodeAction | None = None
status: NodeActionQueueStatus | None = None
timestamp: datetime | None = None
waiting: List[NodeAction] | None = None
class yellowdog_client.model.NodeActionQueueStatus(value)

The status of the action queue for a specific node.

EMPTY = 'EMPTY'

No actions are waiting for the node to execute.

EXECUTING = 'EXECUTING'

Actions are currently being executed by the node.

FAILED = 'FAILED'

The node has failed to execute an action and the queue is stopped.

WAITING = 'WAITING'

Actions are waiting for the node to retrieve and execute.

class yellowdog_client.model.NodeCreateWorkersAction(nodeWorkers=None, totalWorkers=None, nodeIdFilter=None, nodeTypes=None)
Parameters:
action: str = 'CREATE_WORKERS'
nodeIdFilter: NodeIdFilter | None = None
nodeTypes: List[str] | None = None
nodeWorkers: NodeWorkerTarget | None = None
totalWorkers: int | None = None
class yellowdog_client.model.NodeDetails(instanceId, provider=None, region=None, sourceName=None, sourceNumber=None, instanceType=None, hostname=None, privateIpAddress=None, publicIpAddress=None, vcpus=None, ram=None, supportedTaskTypes=None, workerTag=None, nodeType=None, nodeSlot=None)

Describes the details of a worker pool node.

Parameters:
hostname: str | None = None

The hostname of the instance.

instanceId: str

The ID of the node’s instance.

instanceType: str | None = None

The instance type of the instance.

nodeSlot: int | None = None

The slot number of this node within its node type if slot numbering has been configured.

nodeType: str | None = None

The node type of this node if node types have been configured.

privateIpAddress: str | None = None

The private IP address of the instance.

provider: CloudProvider | None = None

The provider of the node’s instance.

publicIpAddress: str | None = None

The public IP address of the instance.

ram: float | None = None

The amount of RAM in GB on the node’s instance.

region: str | None = None

The region in which the node’s instance is running.

sourceName: str | None = None

The name of the compute source from which the node’s instance was provisioned.

sourceNumber: int | None = None

The number of the compute source based on its order within the parent compute requirement.

supportedTaskTypes: List[str] | None = None

The task types supported by this node.

vcpus: float | None = None

The number of processors (threads) on the node’s instance.

workerTag: str | None = None

An optional tag value that can be used to constrain worker allocation.

class yellowdog_client.model.NodeEvent(value)

An enumeration.

NODES_ADDED = 'NODES_ADDED'

Nodes have registered (and been identified if node types are configured) after the STARTUP event has been raised.

NODES_REMOVED = 'NODES_REMOVED'

Nodes have been removed (unregistered or terminated) after the STARTUP event has been raised.

STARTUP_NODES_ADDED = 'STARTUP_NODES_ADDED'

The initial provision of worker pool nodes has completed and nodes have registered (and been identified if node types are configured)

class yellowdog_client.model.NodeIdFilter(value)

An enumeration.

EVENT = 'EVENT'
LIST = 'LIST'
class yellowdog_client.model.NodeRunCommandAction(path, arguments=None, environment=None, nodeIdFilter=None, nodeTypes=None)
Parameters:
action: str = 'RUN_COMMAND'
arguments: List[str] | None = None
environment: Dict[str, str] | None = None
nodeIdFilter: NodeIdFilter | None = None
nodeTypes: List[str] | None = None
path: str
class yellowdog_client.model.NodeSearch(workerPoolId=None, statuses=None, providers=None, instanceId=None, region=None, instanceType=None, ram=None, vcpus=None, workerClaimCount=None, workerRegisteredTime=None, workerTaskGroupId=None, workerTag=None, workerStatuses=None, sortField=None, sortDirection=None)
Parameters:
instanceId: str | None = None
instanceType: str | None = None
providers: List[CloudProvider] | None = None
ram: DoubleRange | None = None
region: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
statuses: List[NodeStatus] | None = None
vcpus: DoubleRange | None = None
workerClaimCount: LongRange | None = None
workerPoolId: str | None = None
workerRegisteredTime: InstantRange | None = None
workerStatuses: List[WorkerStatus] | None = None
workerTag: str | None = None
workerTaskGroupId: str | None = None
class yellowdog_client.model.NodeSlotNumbering(value)

An enumeration.

REUSABLE = 'REUSABLE'
class yellowdog_client.model.NodeStatus(value)

Indicates the status of a node.

DEREGISTERED = 'DEREGISTERED'

The node has been deregistered from the worker pool.

LATE = 'LATE'

The node’s heartbeat is late.

LOST = 'LOST'

The node’s heartbeat has not been received for long enough that it is considered lost.

RUNNING = 'RUNNING'

The node is running and its heartbeat is being received.

TERMINATED = 'TERMINATED'

The node has been terminated.

class yellowdog_client.model.NodeSummary(statusCounts=None, actionQueueStatuses=None, lastUpdatedTime=None)

A summary of a group of nodes.

Parameters:
actionQueueStatuses: Dict[NodeActionQueueStatus, int] | None = None

The number of nodes with each action queue status.

lastUpdatedTime: datetime | None = None

The last time this summary was updated.

statusCounts: Dict[NodeStatus, int] | None = None

The number of nodes in each status.

class yellowdog_client.model.NodeType(name, count=None, min=None, sourceNames=None, slotNumbering=None)
Parameters:
count: int | None = None
min: int | None = None
name: str
slotNumbering: NodeSlotNumbering | None = None
sourceNames: List[str] | None = None
class yellowdog_client.model.NodeWorkerTarget(targetCount, targetType)
Parameters:
static per_node(target_count)
Parameters:

target_count (int)

Return type:

NodeWorkerTarget

static per_vcpus(target_count)
Parameters:

target_count (float)

Return type:

NodeWorkerTarget

targetCount: float
targetType: NodeWorkerTargetType
class yellowdog_client.model.NodeWorkerTargetType(value)

An enumeration.

PER_NODE = 'PER_NODE'
PER_VCPU = 'PER_VCPU'
class yellowdog_client.model.NodeWriteFileAction(path, content=None, nodeIdFilter=None, nodeTypes=None)
Parameters:
action: str = 'WRITE_FILE'
content: str | None = None
nodeIdFilter: NodeIdFilter | None = None
nodeTypes: List[str] | None = None
path: str
class yellowdog_client.model.NumericAttributeConstraint(attribute, min=None, max=None)
Parameters:
attribute: str
max: float | None = None
min: float | None = None
type: str = 'co.yellowdog.platform.model.NumericAttributeConstraint'
class yellowdog_client.model.NumericAttributeDefinition(name, title, defaultRankOrder, description=None, units=None, range=None, options=None)
Parameters:
defaultRankOrder: NumericAttributeRankOrder
description: str | None = None
name: str
options: List[float] | None = None
range: NumericAttributeRange | None = None
title: str
type: str = 'co.yellowdog.platform.model.NumericAttributeDefinition'
units: str | None = None
class yellowdog_client.model.NumericAttributePreference(attribute, weight=1, rankOrder=None)
Parameters:
attribute: str
rankOrder: NumericAttributeRankOrder | None = None
type: str = 'co.yellowdog.platform.model.NumericAttributePreference'
weight: float = 1
class yellowdog_client.model.NumericAttributeRange(min=None, max=None)
Parameters:
max: float | None = None
min: float | None = None
class yellowdog_client.model.NumericAttributeRankOrder(value)

An enumeration.

PREFER_HIGHER = 'PREFER_HIGHER'
PREFER_LOWER = 'PREFER_LOWER'
class yellowdog_client.model.NumericAttributeValue(attribute, value)
Parameters:
attribute: str
type: str = 'co.yellowdog.platform.model.NumericAttributeValue'
value: float
class yellowdog_client.model.OAuth2AuthenticationProperties
class yellowdog_client.model.ObjectDetail(namespace=None, objectName=None, objectSize=None, lastModified=None)

Describes details about an object stored in the YellowDog Object Store service.

Parameters:
lastModified: datetime | None = None

When the object was last modified.

namespace: str | None = None

The user allocated namespace used to group objects together.

objectName: str | None = None

The object name which may contain path seperators ‘/’.

objectSize: int | None = None

The object size in bytes.

class yellowdog_client.model.ObjectDownloadRequest(objectName, chunkSize)
Parameters:

  • objectName (str)

  • chunkSize (int)

chunkSize: int
objectName: str
class yellowdog_client.model.ObjectDownloadResponse(sessionId=None, namespace=None, objectName=None, objectSize=None, chunkSize=None, chunkCount=None)
Parameters:
chunkCount: int | None = None
chunkSize: int | None = None
namespace: str | None = None
objectName: str | None = None
objectSize: int | None = None
sessionId: str | None = None
class yellowdog_client.model.ObjectPath(name, displayName=None, prefix=False)
Parameters:
displayName: str | None = None
name: str
prefix: bool = False
class yellowdog_client.model.ObjectPathsRequest(namespace=None, flat=False, prefix=None)
Parameters:
flat: bool = False
namespace: str | None = None
prefix: str | None = None
class yellowdog_client.model.ObjectPathsSliceRequest(namespace=None, flat=False, prefix=None, sliceReference=<factory>)
Parameters:
flat: bool = False
namespace: str | None = None
prefix: str | None = None
sliceReference: SliceReference
class yellowdog_client.model.ObjectUploadRequest(objectName, objectSize, chunkSize, chunkCount)
Parameters:

  • objectName (str)

  • objectSize (int)

  • chunkSize (int)

  • chunkCount (int)

chunkCount: int
chunkSize: int
objectName: str
objectSize: int
class yellowdog_client.model.OciComputeSource

Derives from ComputeSource to provide the interface for all AWS compute source model objects.

type: str = 'co.yellowdog.platform.model.OciComputeSource'
class yellowdog_client.model.OciCredential(name, userId, tenantId, fingerprint, privateKey, description=None, passphrase=None)

Holds the properties that form a set of credentials for Oracle Cloud Infrastructure (OCI).

Parameters:
description: str | None = None
fingerprint: str

The OCI public key fingerprint.

name: str
passphrase: str | None = None

The OCI private key passphrase.

privateKey: str

The OCI private key.

tenantId: str

The OCI tenant ID (ocid).

type: str = 'co.yellowdog.platform.account.credentials.OciCredential'
userId: str

The OCI User ID (ocid).

class yellowdog_client.model.OciInstance(compartmentId=None, flexOcpus=None, flexRam=None, id=None, createdTime=None, provider=None, instanceType=None, region=None, subregion=None, imageId=None, hostname=None, privateIpAddress=None, publicIpAddress=None, spot=False, status=None, statusChangedTime=None)

Extends Instance to add fields specific to the OCI compute sources.

Parameters:
compartmentId: str | None = None

The OCID of the compartment containing this instance.

createdTime: datetime | None = None

The date and time when this instance was first created.

flexOcpus: float | None = None

The number of OCPUs provisioned on this flex type instance.

flexRam: float | None = None

The amount of ram in GB provisioned on this flex type instance.

hostname: str | None = None

The hostname of this instance.

id: InstanceId | None = None

The unique identifier for this instance formed from the YellowDog Compute Source ID and the provider supplied instance ID

imageId: str | None = None

The machine image ID used for this instance.

instanceType: str | None = None

The machine type of this instance.

privateIpAddress: str | None = None

The private IP address of this instance.

provider: CloudProvider | None = None

The cloud provider that supplies this instance.

publicIpAddress: str | None = None

The public IP address of this instance.

region: str | None = None

The region where this instance is provisioned.

spot: bool = False

Indicates if this instance was provisioned via spot pricing vs on-demand.

status: InstanceStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed

subregion: str | None = None

The subregion where this instance is provisioned.

type: str = 'co.yellowdog.platform.model.OciInstance'
class yellowdog_client.model.OciInstancePoolComputeSource(name, credential, region, compartmentId, imageId, shape, subnetId, sshKey=None, availabilityDomain=None, flexOcpus=None, flexRam=None, limit=0, assignPublicIp=False, createClusterNetwork=None, userData=None, instanceTags=None)

Defines a source of compute composed of OCI instances provisioned using the OCI Instance Pool API.

Parameters:
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

availabilityDomain: str | None = None

The OCI availability domain where instances will be provisioned.

compartmentId: str

The OCI compartment ID (ocid) where instances will be provisioned.

createClusterNetwork: bool | None = None
createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
exhaustion: ComputeSourceExhaustion | None = None
flexOcpus: float | None = None
flexRam: float | None = None
id: str | None = None
imageId: str

The region-specific OCI Image ID (ocid) for the image to use for the provisioned instances.

instancePricing: InstancePricing | None = None
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
limit: int = 0
name: str
region: str

The OCI region where instances will be provisioned.

shape: str
sshKey: str | None = None

The public SSH key. If provided, instances will be accessible with the matching private key through SSH.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetId: str

The region-specific OCI Subnet ID (ocid) for the subnet to use for the provisioned instances.

supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.OciInstancePoolComputeSource'
userData: str | None = None
class yellowdog_client.model.OciInstancesComputeSource(name, credential, region, compartmentId, imageId, shape, subnetId, sshKey=None, availabilityDomain=None, flexOcpus=None, flexRam=None, preemptible=False, limit=0, assignPublicIp=False, userData=None, instanceTags=None)

Defines a source of compute composed of OCI instances provisioned individually.

Parameters:
assignPublicIp: bool = False

Indicates if provisioned instances should be assigned public IP addresses.

availabilityDomain: str | None = None

The OCI availability domain where instances will be provisioned.

compartmentId: str

The OCI compartment ID (ocid) where instances will be provisioned.

createdFromId: str | None = None
credential: str
credentials: Set[str] | None = None
exhaustion: ComputeSourceExhaustion | None = None
flexOcpus: float | None = None
flexRam: float | None = None
id: str | None = None
imageId: str

The region-specific OCI Image ID (ocid) for the image to use for the provisioned instances.

instancePricing: InstancePricing | None = None
instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
limit: int = 0
name: str
preemptible: bool = False
region: str

The OCI region where instances will be provisioned.

shape: str
sshKey: str | None = None

The public SSH key. If provided, instances will be accessible with the matching private key through SSH.

status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subnetId: str

The region-specific OCI Subnet ID (ocid) for the subnet to use for the provisioned instances.

supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.OciInstancesComputeSource'
userData: str | None = None
class yellowdog_client.model.OciNamespaceStorageConfiguration(namespace, ociNamespaceName, bucketName, region, credential)
Parameters:

  • namespace (str)

  • ociNamespaceName (str)

  • bucketName (str)

  • region (str)

  • credential (str)

bucketName: str
credential: str
namespace: str
ociNamespaceName: str
region: str
type: str = 'co.yellowdog.platform.model.OciNamespaceStorageConfiguration'
class yellowdog_client.model.OktaAccountAuthenticationProperties(domain, clientId, enabled=False, clientSecret=None)
Parameters:
clientId: str
clientSecret: str | None = None
domain: str
enabled: bool = False
class yellowdog_client.model.OperatingSystemLicence(value)

An enumeration.

NONE = 'NONE'
WINDOWS = 'WINDOWS'
class yellowdog_client.model.Permission(value)

An enumeration.

ACCOUNT_APPLICATION_READ = 'ACCOUNT_APPLICATION_READ'
ACCOUNT_APPLICATION_WRITE = 'ACCOUNT_APPLICATION_WRITE'
ACCOUNT_AUTH_PROPERTIES_READ = 'ACCOUNT_AUTH_PROPERTIES_READ'
ACCOUNT_AUTH_PROPERTIES_WRITE = 'ACCOUNT_AUTH_PROPERTIES_WRITE'
ACCOUNT_GROUP_READ = 'ACCOUNT_GROUP_READ'
ACCOUNT_GROUP_WRITE = 'ACCOUNT_GROUP_WRITE'
ACCOUNT_POLICY_READ = 'ACCOUNT_POLICY_READ'
ACCOUNT_POLICY_WRITE = 'ACCOUNT_POLICY_WRITE'
ACCOUNT_ROLE_READ = 'ACCOUNT_ROLE_READ'
ACCOUNT_ROLE_WRITE = 'ACCOUNT_ROLE_WRITE'
ACCOUNT_USER_READ = 'ACCOUNT_USER_READ'
ACCOUNT_USER_WRITE = 'ACCOUNT_USER_WRITE'
COMPUTE_ALLOWANCE_READ = 'COMPUTE_ALLOWANCE_READ'
COMPUTE_ALLOWANCE_WRITE = 'COMPUTE_ALLOWANCE_WRITE'
COMPUTE_READ = 'COMPUTE_READ'
COMPUTE_REQUIREMENT_TEMPLATE_WRITE = 'COMPUTE_REQUIREMENT_TEMPLATE_WRITE'
COMPUTE_REQUIREMENT_WRITE = 'COMPUTE_REQUIREMENT_WRITE'
COMPUTE_SOURCE_TEMPLATE_WRITE = 'COMPUTE_SOURCE_TEMPLATE_WRITE'
COMPUTE_USAGE_READ = 'COMPUTE_USAGE_READ'
COMPUTE_USER_ATTRIBUTE_WRITE = 'COMPUTE_USER_ATTRIBUTE_WRITE'
IMAGE_READ = 'IMAGE_READ'
IMAGE_WRITE = 'IMAGE_WRITE'
KEYRING_ACCESS_WRITE = 'KEYRING_ACCESS_WRITE'
KEYRING_READ = 'KEYRING_READ'
KEYRING_WRITE = 'KEYRING_WRITE'
LOG_READ = 'LOG_READ'
METRICS_READ = 'METRICS_READ'
METRICS_WRITE = 'METRICS_WRITE'
NAMESPACE_READ = 'NAMESPACE_READ'
NAMESPACE_WRITE = 'NAMESPACE_WRITE'
OBJECT_READ = 'OBJECT_READ'
OBJECT_STORAGE_CONFIGURATION_READ = 'OBJECT_STORAGE_CONFIGURATION_READ'
OBJECT_STORAGE_CONFIGURATION_WRITE = 'OBJECT_STORAGE_CONFIGURATION_WRITE'
OBJECT_WRITE = 'OBJECT_WRITE'
WORKER_POOL_READ = 'WORKER_POOL_READ'
WORKER_POOL_TOKEN_READ = 'WORKER_POOL_TOKEN_READ'
WORKER_POOL_TOKEN_WRITE = 'WORKER_POOL_TOKEN_WRITE'
WORKER_POOL_WRITE = 'WORKER_POOL_WRITE'
WORK_REQUIREMENT_READ = 'WORK_REQUIREMENT_READ'
WORK_REQUIREMENT_WRITE = 'WORK_REQUIREMENT_WRITE'
class yellowdog_client.model.PermissionDetail(name=None, title=None, includes=None)
Parameters:
includes: Set[str] | None = None
name: str | None = None
title: str | None = None
class yellowdog_client.model.Price(currency=None, value=None)
Parameters:
currency: Currency | None = None
value: float | None = None
class yellowdog_client.model.ProcessorArchitecture(value)

An enumeration.

ARM64 = 'ARM64'
X86_64 = 'X86_64'
class yellowdog_client.model.ProviderNodeSummary(provider=None, totalNodes=None, workingNodes=None)

A summary of a group of nodes.

Parameters:
provider: CloudProvider | None = None
totalNodes: int | None = None
workingNodes: int | None = None
class yellowdog_client.model.ProviderRegionNodeSummary(region=None, totalNodes=None, workingNodes=None)

A summary of a group of nodes.

Parameters:
region: str | None = None
totalNodes: int | None = None
workingNodes: int | None = None
class yellowdog_client.model.ProvisionTemplateWorkerPoolRequest(requirementTemplateUsage, provisionedProperties=None)
Parameters:
provisionedProperties: ProvisionedWorkerPoolProperties | None = None
requirementTemplateUsage: ComputeRequirementTemplateUsage
class yellowdog_client.model.ProvisionedWorkerPool(id=None, name=None, namespace=None, createdTime=None, status=None, statusChangedTime=None, expectedNodeCount=0, awaitingNodes=False, workerSummary=None, nodeSummary=None, properties=None, computeRequirementId=None)
Parameters:
awaitingNodes: bool = False
computeRequirementId: str | None = None

The ID of the compute requirement used to provision the compute resource.

createdTime: datetime | None = None
expectedNodeCount: int = 0
id: str | None = None
name: str | None = None
namespace: str | None = None
nodeSummary: NodeSummary | None = None
properties: ProvisionedWorkerPoolProperties | None = None
status: WorkerPoolStatus | None = None
statusChangedTime: datetime | None = None
type: str = 'co.yellowdog.platform.model.ProvisionedWorkerPool'
workerSummary: WorkerSummary | None = None
class yellowdog_client.model.ProvisionedWorkerPoolProperties(createNodeWorkers=None, minNodes=None, maxNodes=None, nodeBootTimeout=None, idleNodeShutdown=None, idlePoolShutdown=None, workerTag=None, nodeConfiguration=None, metricsEnabled=None)

Defines properties to determine the behaviour that the Scheduler service should use when managing a provisioned worker pool.

Parameters:
createNodeWorkers: NodeWorkerTarget | None = None

How many workers to create on each node.

idleNodeShutdown: AutoShutdown | None = None

Determines the auto shutdown behaviour applied for idle nodes.

idlePoolShutdown: AutoShutdown | None = None

Determines the auto shutdown behaviour applied for an idle pool.

maxNodes: int | None = None

The maximum number of nodes that the worker pool can be scaled up to.

metricsEnabled: bool | None = None
minNodes: int | None = None

The minimum number of nodes that the worker pool can be scaled down to.

nodeBootTimeout: timedelta | None = None

The time given for a node to be registered before it is considered to have failed.

nodeConfiguration: WorkerPoolNodeConfiguration | None = None
workerTag: str | None = None

An optional tag value that will be attached to all workers in this pool and used to constrain worker allocation.

class yellowdog_client.model.Range
class yellowdog_client.model.Region(provider=None, name=None)
Parameters:
name: str | None = None
provider: CloudProvider | None = None
class yellowdog_client.model.RegionSearch(providers=None, name=None, sortField=None, sortDirection=None)
Parameters:
name: str | None = None
providers: List[CloudProvider] | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.RequirementAllowance(requirementId, effectiveFrom, resetType, limitEnforcement, monitoredStatuses, description=None, effectiveUntil=None, allowedHours=0, boostHours=None, resetInterval=None, hardLimitGraceMinutes=None)
Parameters:
allowedHours: int = 0
boostHours: int | None = None
createdById: str | None = None
description: str | None = None
effectiveFrom: datetime
effectiveUntil: datetime | None = None
hardLimitGraceMinutes: int | None = None
id: str | None = None
limitEnforcement: AllowanceLimitEnforcement
monitoredStatuses: List[InstanceStatus]
remainingHours: float | None = None
requirementId: str
resetInterval: int | None = None
resetType: AllowanceResetType
type: str = 'co.yellowdog.platform.model.RequirementAllowance'
class yellowdog_client.model.RequirementsAllowance(effectiveFrom, resetType, limitEnforcement, monitoredStatuses, requirementCreatedFromId=None, requirementCreatedById=None, namespace=None, tag=None, description=None, effectiveUntil=None, allowedHours=0, boostHours=None, resetInterval=None, hardLimitGraceMinutes=None)
Parameters:
allowedHours: int = 0
boostHours: int | None = None
createdById: str | None = None
description: str | None = None
effectiveFrom: datetime
effectiveUntil: datetime | None = None
hardLimitGraceMinutes: int | None = None
id: str | None = None
limitEnforcement: AllowanceLimitEnforcement
monitoredStatuses: List[InstanceStatus]
namespace: str | None = None
remainingHours: float | None = None
requirementCreatedById: str | None = None
requirementCreatedFromId: str | None = None
resetInterval: int | None = None
resetType: AllowanceResetType
tag: str | None = None
type: str = 'co.yellowdog.platform.model.RequirementsAllowance'
class yellowdog_client.model.RetryProperties(maxAttempts=3, initialInterval=datetime.timedelta(seconds=5), maxInterval=datetime.timedelta(seconds=60))

Defines properties that control services client retry behaviour

Parameters:
initialInterval: timedelta = datetime.timedelta(seconds=5)

The initial interval before the first retry attempt.

maxAttempts: int = 3

Set the number of attempts before retries are exhausted. Includes the initial attempt before the retries begin.

maxInterval: timedelta = datetime.timedelta(seconds=60)

The maximum interval between retry attempts.

class yellowdog_client.model.Role(name, permissions, description=None)
Parameters:
description: str | None = None
id: str | None = None
name: str
permissions: Set[Permission]
class yellowdog_client.model.RoleSearch(sortField=None, sortDirection=None, name=None, permission=None)
Parameters:
name: str | None = None
permission: Permission | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.RoleSummary(id=None, name=None)
Parameters:
id: str | None = None
name: str | None = None
class yellowdog_client.model.RunSpecification(taskTypes, instanceTypes=None, vcpus=None, ram=None, minWorkers=None, maxWorkers=None, tasksPerWorker=None, exclusiveWorkers=None, maximumTaskRetries=0, taskTimeout=None, providers=None, regions=None, workerTags=None, namespaces=None)

Specifies the behaviours to be used by the YellowDog Scheduler when executing Tasks within the associated TaskGroup.

Parameters:
exclusiveWorkers: bool | None = None

If true, then do not allow claimed Workers to be shared with other task groups; otherwise, Workers can be shared.

instanceTypes: List[str] | None = None

The machine instance types that can be used to execute tasks

maxWorkers: int | None = None

The maximum number of Workers that can be claimed for the associated TaskGroup.

maximumTaskRetries: int = 0

The maximum number of times a task can be retried after it has failed.

minWorkers: int | None = None

The minimum number of Workers that the associated TaskGroup requires. This many workers must be claimed before the associated TaskGroup will start running.

namespaces: List[str] | None = None

Constrains the YellowDog Scheduler to only execute tasks from the associated TaskGroup on nodes from worker pools in the specified namespaces.

providers: List[CloudProvider] | None = None

Constrains the YellowDog Scheduler to only execute tasks from the associated TaskGroup on the specified providers.

ram: DoubleRange | None = None

Range constraint on GB of RAM that are required to execute tasks

regions: List[str] | None = None

Constrains the YellowDog Scheduler to only execute tasks from the associated TaskGroup in the specified regions.

taskTimeout: timedelta | None = None

The maximum time that a worker should attempt to execute a task for before failing it. NB: This value can be overridden on individual tasks when they are added.

taskTypes: List[str]

The task types that will be used in the associated TaskGroup.

tasksPerWorker: int | None = None

Determines the number of worker claims based on splitting the number of unfinished tasks across workers.

vcpus: DoubleRange | None = None

Range constraint on number of vCPUs that are required to execute tasks

workerTags: List[str] | None = None

Constrains the YellowDog Scheduler to only execute tasks from the associated TaskGroup on workers with a matching tag value.

class yellowdog_client.model.S3NamespaceStorageConfiguration(namespace, bucketName, region, credential)
Parameters:

  • namespace (str)

  • bucketName (str)

  • region (str)

  • credential (str)

bucketName: str
credential: str
namespace: str
region: str
type: str = 'co.yellowdog.platform.model.S3NamespaceStorageConfiguration'
class yellowdog_client.model.ServicesSchema(retry=<factory>, defaultUrl=None, accountServiceUrl=None, computeServiceUrl=None, logServiceUrl=None, imagesServiceUrl=None, objectStoreServiceUrl=None, schedulerServiceUrl=None, usageServiceUrl=None, cloudInfoServiceUrl=None, metricsServiceUrl=None)

Defines a set of URLs and request retry settings to be used to connect to YellowDog Platform Services.

Parameters:
accountServiceUrl: str | None = None

The base URL where the Account service is located. This is the YellowDog Cell URL rather than a service specific path.

cloudInfoServiceUrl: str | None = None

The base URL where the Cloud Info service is located. This is the YellowDog Cell URL rather than a service specific path.

computeServiceUrl: str | None = None

The base URL where the Compute service is located. This is the YellowDog Cell URL rather than a service specific path.

defaultUrl: str | None = None

The default base URL where services are located. This is the YellowDog Cell URL rather than a service specific path.

imagesServiceUrl: str | None = None

The base URL where the Images service is located. This is the YellowDog Cell URL rather than a service specific path.

logServiceUrl: str | None = None

The base URL where the Log service is located. This is the YellowDog Cell URL rather than a service specific path.

metricsServiceUrl: str | None = None

The base URL where the Metrics service is located. This is the YellowDog Cell URL rather than a service specific path.

objectStoreServiceUrl: str | None = None

The base URL where the Object Store service is located. This is the YellowDog Cell URL rather than a service specific path.

retry: RetryProperties
schedulerServiceUrl: str | None = None

The base URL where the Scheduler service is located. This is the YellowDog Cell URL rather than a service specific path.

usageServiceUrl: str | None = None

The base URL where the Usage service is located. This is the YellowDog Cell URL rather than a service specific path.

class yellowdog_client.model.SetPasswordRequest(accountName, username, password, token)
Parameters:

  • accountName (str)

  • username (str)

  • password (str)

  • token (str)

accountName: str
password: str
token: str
username: str
class yellowdog_client.model.SimulatorComputeSource(name, credential=None, region='sim-region', instanceType='sim-instance', imageId='sim-image', instanceTags=None, implicitCapacity=None, instanceStartupTimeSeconds=0, instanceStartupTimeVariance=0, instanceShutdownTimeSeconds=0, instanceShutdownTimeVariance=0, unexpectedInstanceTerminationProbability=0, failOnRequestAllInstances=False, failOnProvision=False, reportSupportingResourcesExist=False, limit=0)

Defines a simulated source of compute that can be used to test the YellowDog Compute system.

Parameters:

  • name (str)

  • credential (Optional[str])

  • region (str)

  • instanceType (str)

  • imageId (str)

  • instanceTags (Optional[Dict[str, str]])

  • implicitCapacity (Optional[int])

  • instanceStartupTimeSeconds (int)

  • instanceStartupTimeVariance (float)

  • instanceShutdownTimeSeconds (int)

  • instanceShutdownTimeVariance (float)

  • unexpectedInstanceTerminationProbability (float)

  • failOnRequestAllInstances (bool)

  • failOnProvision (bool)

  • reportSupportingResourcesExist (bool)

  • limit (int)

createdFromId: str | None = None
credential: str | None = None
credentials: Set[str] | None = None
exhaustion: ComputeSourceExhaustion | None = None
failOnProvision: bool = False
failOnRequestAllInstances: bool = False
id: str | None = None
imageId: str = 'sim-image'
implicitCapacity: int | None = None

The implicit capacity of this source that is not directly discoverable by the compute service, independent of limit.

instancePricing: InstancePricing | None = None
instanceShutdownTimeSeconds: int = 0

The simulated shutdown time for an instance.

instanceShutdownTimeVariance: float = 0

A variance multiplier (from 0 to 1) applied randomly to the instance shutdown time.

instanceStartupTimeSeconds: int = 0

The simulated startup time for an instance.

instanceStartupTimeVariance: float = 0

A variance multiplier (from 0 to 1) applied randomly to the instance startup time.

instanceSummary: InstanceSummary | None = None
instanceTags: Dict[str, str] | None = None
instanceType: str = 'sim-instance'
limit: int = 0
name: str
provider: CloudProvider | None = None
region: str = 'sim-region'
reportSupportingResourcesExist: bool = False
status: ComputeSourceStatus | None = None
statusMessage: str | None = None
subregion: str | None = None
supportingResourceCreated: bool | None = None
traits: ComputeSourceTraits | None = None
type: str = 'co.yellowdog.platform.model.SimulatorComputeSource'
unexpectedInstanceTerminationProbability: float = 0

The probability (from 0 to 1) that any instance will be unexpectedly terminated whenever it is refreshed.

userData: str | None = None
class yellowdog_client.model.SimulatorInstance(id=None, createdTime=None, provider=None, instanceType=None, region=None, subregion=None, imageId=None, hostname=None, privateIpAddress=None, publicIpAddress=None, spot=False, status=None, statusChangedTime=None)

Extends Instance to add fields specific to the Simulator compute source.

Parameters:
createdTime: datetime | None = None

The date and time when this instance was first created.

hostname: str | None = None

The hostname of this instance.

id: InstanceId | None = None

The unique identifier for this instance formed from the YellowDog Compute Source ID and the provider supplied instance ID

imageId: str | None = None

The machine image ID used for this instance.

instanceType: str | None = None

The machine type of this instance.

privateIpAddress: str | None = None

The private IP address of this instance.

provider: CloudProvider | None = None

The cloud provider that supplies this instance.

publicIpAddress: str | None = None

The public IP address of this instance.

region: str | None = None

The region where this instance is provisioned.

spot: bool = False

Indicates if this instance was provisioned via spot pricing vs on-demand.

status: InstanceStatus | None = None

The status of this instance.

statusChangedTime: datetime | None = None

The date and time when the status last changed

subregion: str | None = None

The subregion where this instance is provisioned.

type: str = 'co.yellowdog.platform.model.SimulatorInstance'
class yellowdog_client.model.SingleSourceProvisionStrategy(sources)

Instructs YellowDog Compute to use a single compute source for the compute requirement.

Parameters:

sources (List[ComputeSource])

credentials: Set[str] | None = None
sources: List[ComputeSource]

The compute sources to use for the compute requirement.

type: str = 'co.yellowdog.platform.model.SingleSourceProvisionStrategy'
class yellowdog_client.model.Slice(items=None, nextSliceId=None)
Parameters:
items: List[T] | None = None
nextSliceId: str | None = None
class yellowdog_client.model.SliceReference(sliceId=None, size=None)
Parameters:
size: int | None = None
sliceId: str | None = None
class yellowdog_client.model.SortDirection(value)

An enumeration.

ASCENDING = 'ASCENDING'
DESCENDING = 'DESCENDING'
class yellowdog_client.model.SourceAllowance(sourceId, effectiveFrom, resetType, limitEnforcement, monitoredStatuses, description=None, effectiveUntil=None, allowedHours=0, boostHours=None, resetInterval=None, hardLimitGraceMinutes=None)
Parameters:
allowedHours: int = 0
boostHours: int | None = None
createdById: str | None = None
description: str | None = None
effectiveFrom: datetime
effectiveUntil: datetime | None = None
hardLimitGraceMinutes: int | None = None
id: str | None = None
limitEnforcement: AllowanceLimitEnforcement
monitoredStatuses: List[InstanceStatus]
remainingHours: float | None = None
resetInterval: int | None = None
resetType: AllowanceResetType
sourceId: str
type: str = 'co.yellowdog.platform.model.SourceAllowance'
class yellowdog_client.model.SourcesAllowance(effectiveFrom, resetType, limitEnforcement, monitoredStatuses, sourceCreatedFromId=None, provider=None, regions=None, instanceTypes=None, credentialName=None, description=None, effectiveUntil=None, allowedHours=0, boostHours=None, resetInterval=None, hardLimitGraceMinutes=None)
Parameters:
allowedHours: int = 0
boostHours: int | None = None
createdById: str | None = None
credentialName: str | None = None
description: str | None = None
effectiveFrom: datetime
effectiveUntil: datetime | None = None
hardLimitGraceMinutes: int | None = None
id: str | None = None
instanceTypes: List[str] | None = None
limitEnforcement: AllowanceLimitEnforcement
monitoredStatuses: List[InstanceStatus]
provider: CloudProvider | None = None
regions: List[str] | None = None
remainingHours: float | None = None
resetInterval: int | None = None
resetType: AllowanceResetType
sourceCreatedFromId: str | None = None
type: str = 'co.yellowdog.platform.model.SourcesAllowance'
class yellowdog_client.model.SplitProvisionStrategy(sources)

Instructs YellowDog Compute to split the provision of instances as evenly as possible across the compute sources.

Parameters:

sources (List[ComputeSource])

credentials: Set[str] | None = None
sources: List[ComputeSource]

The compute sources to use for the compute requirement.

type: str = 'co.yellowdog.platform.model.SplitProvisionStrategy'
class yellowdog_client.model.StringAttributeConstraint(attribute, anyOf=None, noneOf=None, pattern=None)
Parameters:
anyOf: Set[str] | None = None
attribute: str
noneOf: Set[str] | None = None
pattern: str | None = None
type: str = 'co.yellowdog.platform.model.StringAttributeConstraint'
class yellowdog_client.model.StringAttributeDefinition(name, title, description=None, options=None)
Parameters:
description: str | None = None
name: str
options: List[str] | None = None
title: str
type: str = 'co.yellowdog.platform.model.StringAttributeDefinition'
class yellowdog_client.model.StringAttributePreference(attribute, weight=1, preferredValues=None, preferredPatterns=None)
Parameters:
attribute: str
preferredPatterns: List[str] | None = None
preferredValues: List[str] | None = None
type: str = 'co.yellowdog.platform.model.StringAttributePreference'
weight: float = 1
class yellowdog_client.model.StringAttributeValue(attribute, value=None)
Parameters:
attribute: str
type: str = 'co.yellowdog.platform.model.StringAttributeValue'
value: str | None = None
class yellowdog_client.model.SubRegion(provider=None, region=None, name=None)
Parameters:
name: str | None = None
provider: CloudProvider | None = None
region: str | None = None
class yellowdog_client.model.SubRegionSearch(providers=None, region=None, name=None, sortField=None, sortDirection=None)
Parameters:
name: str | None = None
providers: List[CloudProvider] | None = None
region: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.Tagged

Interface implemented by all model types that have a tag field for user defined information

class yellowdog_client.model.Task(taskType, name=None, tag=None, arguments=None, taskData=None, environment=None, startedTime=None, finishedTime=None, abortRequestedTime=None, inputs=None, flattenInputPaths=None, outputs=None, data=None, timeout=None)

Defines a task to be executed as part of a WorkRequirement.

Parameters:
abortRequestedTime: datetime | None = None

The time when task abort was requested.

arguments: List[str] | None = None

A list of arguments that will be passed to the task type run command when the task is executed.

data: TaskData | None = None

Task data requirement specifications.

environment: Dict[str, str] | None = None

A map containing environment variable values that will be added to the process environment when the task is executed.

errors: List[TaskError] | None = None
finishedTime: datetime | None = None

The time the task was finished.

flattenInputPaths: FlattenPath | None = None

Indicates if the input objects’ paths should be flattened when they are downloaded.

fullyQualifiedName: str | None = None

The system generated fully qualified name of the task in the form {namespace}/{workRequirementName}/{taskGroupName}/{taskName}. This is only generated if all ancestor entities are named.

id: str | None = None
inputs: List[TaskInput] | None = None

Input object specifications that determine objects to be downloaded prior to running the task.

name: str | None = None

The user allocated name used to uniquely identify the task within its task group.

outputs: List[TaskOutput] | None = None

Output object specifications that determine objects to be uploaded after running the task.

retryCount: int | None = None

How many times the task has failed and then been set back to WAITING to be retried.

startedTime: datetime | None = None

The time the task was last started by a Worker.

status: TaskStatus | None = None

The task status.

tag: str | None = None
taskData: str | None = None

The data to be passed to the Worker when the task is started.

taskGroupId: str | None = None
taskType: str

The type of the task, used to identify the program to use to execute the task.

timeout: timedelta | None = None

The maximum time that a worker should attempt to execute the task for before failing it.

workerId: str | None = None
class yellowdog_client.model.TaskData(inputs=None, outputs=None)
Parameters:
inputs: List[TaskDataInput] | None = None
outputs: List[TaskDataOutput] | None = None
class yellowdog_client.model.TaskDataInput(source, destination)
Parameters:

  • source (str)

  • destination (str)

destination: str
source: str
class yellowdog_client.model.TaskDataOutput(source, destination, alwaysUpload=False)
Parameters:

  • source (str)

  • destination (str)

  • alwaysUpload (bool)

alwaysUpload: bool = False
destination: str
source: str
class yellowdog_client.model.TaskError(timestamp=None, workerId=None, error=None)

Holds details of an error that occurred during execution of the task.

Parameters:
error: str | None = None

A description of the error.

timestamp: datetime | None = None

The time at which the error occurred.

workerId: str | None = None

The ID of the worker where the error occurred.

class yellowdog_client.model.TaskGroup(name, runSpecification, tag=None, priority=0, dependentOn=None, starved=False, waitingOnDependency=False, finishIfAllTasksFinished=True, finishIfAnyTaskFailed=False, completedTaskTtl=None)

Defines a group of tasks to be executed as part of a WorkRequirement.

Parameters:
completedTaskTtl: timedelta | None = None

The time to live for completed tasks. If set, tasks that have been completed for longer than this period will be deleted.

dependentOn: str | None = None

The name of another task group within the same WorkRequirement that must be successfully completed before the task group is started.

finishIfAllTasksFinished: bool = True

If true, the task group will finish automatically once all contained tasks are finished.

finishIfAnyTaskFailed: bool = False

If true, the task group will finish automatically if any contained tasks fail.

id: str | None = None
name: str

The user allocated name used to uniquely identify the task group within its work requirement.

priority: float = 0

The task group priority.

runSpecification: RunSpecification

The run specification which determines the YellowDog Scheduler behaviours when it is executing the tasks within the task group.

starved: bool = False

Indicates if the task group is unable to claim any workers.

status: TaskGroupStatus | None = None

The task group status.

statusChangedTime: datetime | None = None

The date and time when the status last changed

tag: str | None = None
taskSummary: TaskSummary | None = None
waitingOnDependency: bool = False

Indicates if the task group is waiting for a dependency task group to finish.

class yellowdog_client.model.TaskGroupStatus(value)

Describes the status of a task group.

The status of the task group provides an aggregated view of the statuses of tasks within the task group.

CANCELLED = 'CANCELLED'

The parent work requirement has been cancelled, no tasks are currently being executed or will be executed.

CANCELLING = 'CANCELLING'

The parent work requirement is in the process of being cancelled, no further tasks will be executed.

COMPLETED = 'COMPLETED'

All tasks within the task group have been completed.

FAILED = 'FAILED'

All tasks within the task group have been finished but at least one has failed.

FAILING = 'FAILING'

At least one task in the task group has failed and the task group is in the process of discarding any outstanding tasks.

HELD = 'HELD'

The task group parent work requirement has been held by the user such that no further tasks are executed. Resources (e.g. Workers) will be released. The task group will remain in HELD state until the user reactivates the parent work requirement.

PENDING = 'PENDING'

The task group is awaiting resources required to execute tasks.

RUNNING = 'RUNNING'

The task group has sufficient resources to execute tasks.

class yellowdog_client.model.TaskInput(source, objectNamePattern, namespace=None, verification=None)

Defines task inputs to be downloaded prior to worker execution of the task.

Parameters:
static from_namespace(namespace, object_name_pattern, verification=None)

Specifies that matching objects from the supplied namespace should be downloaded to the working directory prior to task execution.

Parameters:
Return type:

TaskInput

static from_task_namespace(object_name_pattern, verification=None)

Specifies that matching objects from the same namespace as the task should be downloaded to the working directory prior to task execution.

Parameters:
Return type:

TaskInput

namespace: str | None = None

The namespace containing matching objects; only if the source is set to TaskInputSource.OTHER_NAMESPACE.

objectNamePattern: str

An ant-style pattern to select objects by name.

source: TaskInputSource

The source context where the inputs can be found.

verification: TaskInputVerification | None = None

Indicates if and how the Scheduler should verify the existence of a task input prior to starting the task.

verificationStatus: TaskInputVerificationStatus | None = None

The task input verification status.

class yellowdog_client.model.TaskInputSource(value)

Defines the source contexts where task inputs can be found.

OTHER_NAMESPACE = 'OTHER_NAMESPACE'

Task inputs from any namespace defined by the owner of the work requirement containing the task.

TASK_NAMESPACE = 'TASK_NAMESPACE'

Task inputs from the same namespace as the task.

class yellowdog_client.model.TaskInputVerification(value)

Indicates if the Scheduler should verify the existence of a task input prior to starting the task.

VERIFY_AT_START = 'VERIFY_AT_START'

The task input must exist at the time when the task group is started, otherwise the task is FAILED.

VERIFY_WAIT = 'VERIFY_WAIT'

The task will remain in PENDING until the task input exists.

class yellowdog_client.model.TaskInputVerificationStatus(value)

Describes the status of a task input that requires verification.

FAILED = 'FAILED'

The task input does not exist.

VERIFIED = 'VERIFIED'

The task input has been verified and exists.

WAITING = 'WAITING'

The Scheduler is waiting for notification that the task input exists.

class yellowdog_client.model.TaskOutput(source, directoryName=None, filePattern=None, alwaysUpload=False, required=False)

Defines task outputs to be uploaded following worker execution of the

Parameters:
alwaysUpload: bool = False

Indicates that the outputs should still be uploaded even if the task execution failed or was aborted.

directoryName: str | None = None

The pre-configured directory name; only if the source is set to TaskOutputSource.OTHER_DIRECTORY.

filePattern: str | None = None

An ant-style pattern to select output files by path.

static from_directory(directory_name, file_pattern, required=False)

Specifies that matching files from the directory (defined in the agent configuration with the specified name) should be uploaded.

Parameters:

  • directory_name (str)

  • file_pattern (str)

  • required (bool)

Return type:

TaskOutput

static from_task_process()

Specifies that the text file containing the output from the task execution process should be uploaded.

Return type:

TaskOutput

static from_worker_directory(file_pattern, required=False)

Specifies that matching files from the working directory of the worker that executed the task should be uploaded.

Parameters:

  • file_pattern (str)

  • required (bool)

Return type:

TaskOutput

required: bool = False

Indicates that at least one output should be found otherwise the task execution is failed.

source: TaskOutputSource

The source context where the outputs can be found.

class yellowdog_client.model.TaskOutputSource(value)

Defines the source contexts where the task outputs can be found.

OTHER_DIRECTORY = 'OTHER_DIRECTORY'

Task outputs from a directory defined in the agent configuration.

PROCESS_OUTPUT = 'PROCESS_OUTPUT'

The file containing the output from the process executing the task.

WORKER_DIRECTORY = 'WORKER_DIRECTORY'

Task outputs from the working directory of the worker that executed the task.

class yellowdog_client.model.TaskSearch(workRequirementId=None, taskGroupId=None, name=None, startedTime=None, finishedTime=None, hasInputs=None, hasOutputs=None, hasErrors=None, tag=None, statuses=None, sortField=None, sortDirection=None)
Parameters:
finishedTime: InstantRange | None = None
hasErrors: bool | None = None
hasInputs: bool | None = None
hasOutputs: bool | None = None
name: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
startedTime: InstantRange | None = None
statuses: List[TaskStatus] | None = None
tag: str | None = None
taskGroupId: str | None = None
workRequirementId: str | None = None
class yellowdog_client.model.TaskStatus(value)

Describes the status of task.

ABORTED = 'ABORTED'

The task has been aborted whilst in progress.

ALLOCATED = 'ALLOCATED'

The task has been allocated to a worker to be executed.

CANCELLED = 'CANCELLED'

The task has been cancelled by the user.

COMPLETED = 'COMPLETED'

The task has been completed.

DISCARDED = 'DISCARDED'

The task will not be allocated as its task group has finished.

DOWNLOADING = 'DOWNLOADING'

The task inputs are being downloaded by its allocated worker.

EXECUTING = 'EXECUTING'

The task is being executed by its allocated worker.

FAILED = 'FAILED'

The task has failed.

PENDING = 'PENDING'

The task is waiting for resources to be verified.

READY = 'READY'

The task is ready to be allocated and executed.

UPLOADING = 'UPLOADING'

The task outputs are being uploaded by its allocated worker.

class yellowdog_client.model.TaskSummary(statusCounts=None, taskCount=0, lastUpdatedTime=None)
Parameters:
lastUpdatedTime: datetime | None = None
statusCounts: Dict[TaskStatus, int] | None = None
taskCount: int = 0
class yellowdog_client.model.Track(id=None, createdTime=None, tags=None)
Parameters:
createdTime: datetime | None = None
id: str | None = None
tags: Dict[str, str] | None = None
class yellowdog_client.model.TrackSearch(tags=None, sortField=None, sortDirection=None)
Parameters:
sortDirection: SortDirection | None = None
sortField: str | None = None
tags: Dict[str, str] | None = None
class yellowdog_client.model.TransferStatusResponse(namespace=None, objectName=None, objectSize=None, chunkSize=None, chunkCount=None, chunksReceived=None)
Parameters:
chunkCount: int | None = None
chunkSize: int | None = None
chunksReceived: List[int] | None = None
namespace: str | None = None
objectName: str | None = None
objectSize: int | None = None
class yellowdog_client.model.TransferSummaryResponse(sessionId=None, accountId=None, namespace=None, objectName=None, objectSize=None, chunkSize=None, chunkCount=None, transferredChunkCount=None)
Parameters:
accountId: str | None = None
chunkCount: int | None = None
chunkSize: int | None = None
namespace: str | None = None
objectName: str | None = None
objectSize: int | None = None
sessionId: str | None = None
transferredChunkCount: int | None = None
class yellowdog_client.model.UpdateApplicationRequest(name=None, description=None)
Parameters:
description: str | None = None
name: str | None = None
class yellowdog_client.model.UpdateGroupRequest(name, description=None)
Parameters:
description: str | None = None
name: str
class yellowdog_client.model.UpdateKeyringRequest(description=None)
Parameters:

description (Optional[str])

description: str | None = None
class yellowdog_client.model.UpdateUserRequest(name=None)
Parameters:

name (Optional[str])

name: str | None = None
class yellowdog_client.model.UsageType(value)

An enumeration.

ON_DEMAND = 'ON_DEMAND'
SPOT = 'SPOT'
class yellowdog_client.model.User

Represents a user within the YellowDog Platform.

type: str = None
class yellowdog_client.model.UserLoginRequest(accountName, username, password)
Parameters:

  • accountName (str)

  • username (str)

  • password (str)

accountName: str
password: str
username: str
class yellowdog_client.model.UserPortalContext(userType=None, accountId=None, accountName=None, id=None, name=None, email=None, eulaAccepted=False, passwordSet=False, features=None)
Parameters:
accountId: str | None = None
accountName: str | None = None
email: str | None = None
eulaAccepted: bool = False
features: List[Feature] | None = None
id: str | None = None
name: str | None = None
passwordSet: bool = False
userType: str | None = None
class yellowdog_client.model.UserSearch(sortField=None, sortDirection=None, name=None, email=None)
Parameters:
email: str | None = None
name: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
class yellowdog_client.model.WaterfallProvisionStrategy(sources)

Instructs YellowDog Compute to provision instances by acquiring the maximum available from each compute source in order, until the required number of instances is reached.

Parameters:

sources (List[ComputeSource])

credentials: Set[str] | None = None
sources: List[ComputeSource]

The compute sources to use for the compute requirement.

type: str = 'co.yellowdog.platform.model.WaterfallProvisionStrategy'
class yellowdog_client.model.WorkRequirement(namespace, name, taskGroups=None, tag=None, priority=0)

Defines the requirement for work to be done with specifications on how it should be executed.

This class is the main model object within the YellowDog Scheduler API. It is passed between the service and clients in order to request work to be done and to monitor the state of that work.

Parameters:
createdTime: datetime | None = None

The date and time when the work requirement was first submitted to YellowDog Scheduler.

id: str | None = None

The ID of the work requirement that is generated by YellowDog Scheduler when the requirement is first submitted.

name: str

The user allocated name used to uniquely identify the work requirement within its namespace.

namespace: str

The user allocated namespace used to group work requirements and other objects together.

priority: float = 0

The priority of the work requirement.

status: WorkRequirementStatus | None = None

The status of the work requirement.

statusChangedTime: datetime | None = None

The date and time when the status last changed

tag: str | None = None
taskGroups: List[TaskGroup] | None = None

The task groups containing tasks to be executed.

class yellowdog_client.model.WorkRequirementDashboardSummary(statusCounts=None, errors=False)
Parameters:
errors: bool = False
statusCounts: Dict[WorkRequirementStatus, int] | None = None
class yellowdog_client.model.WorkRequirementSearch(namespace=None, name=None, tag=None, statuses=None, isHealthy=None, createdTime=None, sortField=None, sortDirection=None)
Parameters:
createdTime: InstantRange | None = None
isHealthy: bool | None = None
name: str | None = None
namespace: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
statuses: List[WorkRequirementStatus] | None = None
tag: str | None = None
class yellowdog_client.model.WorkRequirementStatus(value)

Describes the status of a work requirement.

The status of a work requirement provides an aggregated view of the statuses of the task groups within that requirement.

CANCELLED = 'CANCELLED'

The work requirement has been explicitly cancelled by the user.

CANCELLING = 'CANCELLING'

The work requirement is in the process of cancelling, once no task groups are currently executing the status will become CANCELLED.

COMPLETED = 'COMPLETED'

All task groups in the work requirement have been completed.

FAILED = 'FAILED'

All task groups in the work requirement have been finished but at least one has failed.

HELD = 'HELD'

The work requirement has been held by the user and no further tasks will be executed until it is resumed. Task group resources (e.g. Workers) will be released.

RUNNING = 'RUNNING'

The work requirement is in progress and its tasks can be executed.

class yellowdog_client.model.WorkRequirementSummary(id=None, namespace=None, name=None, tag=None, createdTime=None, priority=0, completedTaskCount=0, totalTaskCount=0, status=None, healthy=False)

Provides a summary of a WorkRequirement including the ID that can be used to retrieve the full object.

Parameters:
completedTaskCount: int = 0

The count of successfully completed tasks in the work requirement.

createdTime: datetime | None = None

The date and time when the work requirement was first submitted to YellowDog Scheduler.

healthy: bool = False

Indicates if the work requirement is healthy. If false then tasks may have failed or task groups may be starved.

id: str | None = None
name: str | None = None

The user allocated name used to uniquely identify the work requirement within its namespace.

namespace: str | None = None

The user allocated namespace used to group work requirements and other objects together.

priority: float = 0

The priority of the work requirement.

status: WorkRequirementStatus | None = None

The status of the work requirement.

tag: str | None = None
totalTaskCount: int = 0

The total count of tasks in the work requirement.

class yellowdog_client.model.Worker(id=None, status=None, taskGroupIds=None, claimCount=0, exclusive=False, currentTaskId=None, registeredTime=None)

Describes a Worker managed by the YellowDog Scheduler service.

Parameters:
claimCount: int = 0

A count of the tasks groups which have claims on the worker. Always identical to the size of #taskGroupIds.

currentTaskId: str | None = None

The ID of the task currently allocated to the worker.

exclusive: bool = False

Indicates if the worker is exclusively claimed by a single task group.

id: str | None = None
registeredTime: datetime | None = None

The time at which the worker was registered.

status: WorkerStatus | None = None

The status of the worker.

taskGroupIds: List[str] | None = None

The IDs of the task groups which have claims on the worker.

class yellowdog_client.model.WorkerAction(value)

Indicates the type of action that a worker has been instructed to perform

DO_TASK = 'DO_TASK'

The worker has been instructed to execute a Task

SHUTDOWN = 'SHUTDOWN'

The worker has been instructed to shutdown

SLEEP = 'SLEEP'

The worker has been instructed to sleep for a specified period of time

STOP = 'STOP'

The worker has been instructed to stop

class yellowdog_client.model.WorkerPool

A pool of workers that are managed together.

type: str = None
class yellowdog_client.model.WorkerPoolDashboardSummary(statusCounts=None, errors=False)
Parameters:
errors: bool = False
statusCounts: Dict[WorkerPoolStatus, int] | None = None
class yellowdog_client.model.WorkerPoolNodeConfiguration(nodeTypes=None, nodeEvents=None)
Parameters:
nodeEvents: Dict[NodeEvent, List[NodeActionGroup]] | None = None
nodeTypes: List[NodeType] | None = None
class yellowdog_client.model.WorkerPoolProperties
class yellowdog_client.model.WorkerPoolSearch(namespace=None, name=None, type=None, statuses=None, createdTime=None, isHealthy=None, sortField=None, sortDirection=None)
Parameters:
createdTime: InstantRange | None = None
isHealthy: bool | None = None
name: str | None = None
namespace: str | None = None
sortDirection: SortDirection | None = None
sortField: str | None = None
statuses: List[WorkerPoolStatus] | None = None
type: str | None = None
class yellowdog_client.model.WorkerPoolStatus(value)

Indicates the status of a worker pool

CONFIGURING = 'CONFIGURING'

The nodes in the worker pool are being identified and their node types are being set.

EMPTY = 'EMPTY'

The worker pool has no registered workers.

IDLE = 'IDLE'

The worker pool has registered workers but none are currently claimed.

PENDING = 'PENDING'

The worker pool has been started but no workers have yet registered.

RUNNING = 'RUNNING'

One or more workers are claimed.

SHUTDOWN = 'SHUTDOWN'

The worker pool is shutdown and any workers are instructed to shutdown.

TERMINATED = 'TERMINATED'

The worker pool is terminated and the associated compute requirement is terminated (provisioned worker pool) or all nodes have shutdown (configured worker pool).

class yellowdog_client.model.WorkerPoolSummary(id=None, name=None, namespace=None, type=None, registeredNodeCount=0, registeredWorkerCount=0, claimedWorkerCount=0, workingWorkerCount=0, status=None, createdTime=None, healthy=False)

Provides a summary of a WorkerPool including the ID that can be used to retrieve the full object.

Parameters:
claimedWorkerCount: int = 0

The count of workers within the worker pool that have been claimed by one or more task groups.

createdTime: datetime | None = None

The date and time when the worker pool was first created.

healthy: bool = False

Indicates if the worker pool is healthy. If false then workers may be late or lost.

id: str | None = None
name: str | None = None

The name used to uniquely identify the worker pool.

namespace: str | None = None

The namespace that the worker pool is associated with

registeredNodeCount: int = 0

The count of nodes that have registered with the worker pool.

registeredWorkerCount: int = 0

The count of workers that have registered with the worker pool.

status: WorkerPoolStatus | None = None

The status of the worker pool.

type: str | None = None

The type of the worker pool.

workingWorkerCount: int = 0

The count of workers within the worker pool that are currently doing a task.

class yellowdog_client.model.WorkerPoolToken(secret=None, expiryTime=None)

Defines a secret token shared with an agent in advance of its registration.

Parameters:
expiryTime: datetime | None = None

The token expiry time.

secret: str | None = None

The token secret.

class yellowdog_client.model.WorkerStatus(value)

Describes the current status of a Worker.

DOING_TASK = 'DOING_TASK'

The Worker has been instructed to execute a task.

FOUND = 'FOUND'

The Worker was considered to be lost but its heartbeat has returned, however it has not yet requested instruction.

LATE = 'LATE'

The Worker’s heartbeat is late.

LOST = 'LOST'

The Worker’s heartbeat has not been received for long enough that the Worker is considered to have been lost.

SHUTDOWN = 'SHUTDOWN'

The Worker has been instructed to shut down.

SLEEPING = 'SLEEPING'

The Worker has been instructed to sleep for a specified period of time.

STARTING = 'STARTING'

The Agent has been instructed to start the Worker.

STOPPED = 'STOPPED'

The Worker has been instructed to stop.

class yellowdog_client.model.WorkerSummary(statusCounts=None, allWorkerClaimsCount=0, claimedWorkerCount=0, lastClaimedTime=None, lastReleasedTime=None, lastUpdatedTime=None)

A summary of a group of workers.

Parameters:
allWorkerClaimsCount: int = 0

The number of claims across all workers in this worker pool.

claimedWorkerCount: int = 0

The number of workers that are claimed.

lastClaimedTime: datetime | None = None

The last time one of these workers was claimed.

lastReleasedTime: datetime | None = None

The last time one of these workers was released.

lastUpdatedTime: datetime | None = None

The last time this summary was updated.

statusCounts: Dict[WorkerStatus, int] | None = None

The number of workers in each status.