> ## Documentation Index > Fetch the complete documentation index at: https://docs.domino.ai/llms.txt > Use this file to discover all available pages before exploring further. # Create and upload a Workflow definition > Create and register a workflow definition. ## OpenAPI ````yaml /api-specs/6.3/flyte-native-api.json post /api/v1/workflows openapi: 3.0.3 info: description: >- Reference for the upstream Flyte control plane API, which backs Domino Flows. title: Flyte native API version: version not set servers: - description: >- Replace 'mycluster.domino.tech' with your Domino cluster hostname. For Domino Cloud customers, that is `your-subdomain`.domino.tech (e.g., acme.domino.tech). For self-hosted deployments, it is the hostname you reach the Domino UI at. url: https://mycluster.domino.tech/flows security: [] tags: - name: Children - name: Data - name: Description entities - name: Domains - name: Events - name: Executions - name: Launch plans - name: Matchable attributes - name: Metrics - name: Named entities - name: Node executions - name: Project attributes - name: Project domain attributes - name: Projects - name: Task executions - name: Tasks - name: Version - name: Workflow attributes - name: Workflows paths: /api/v1/workflows: post: tags: - Workflows summary: Create and upload a Workflow definition description: Create and register a workflow definition. operationId: AdminService_CreateWorkflow requestBody: content: application/json: schema: $ref: '#/components/schemas/adminWorkflowCreateRequest' required: true responses: '200': content: application/json: schema: $ref: '#/components/schemas/adminWorkflowCreateResponse' description: A successful response. '400': content: application/json: schema: {} description: Returned for bad request that may have failed validation. '409': content: application/json: schema: {} description: >- Returned for a request that references an identical entity that has already been registered. default: content: application/json: schema: $ref: '#/components/schemas/googlerpcStatus' description: An unexpected error response. components: schemas: adminWorkflowCreateRequest: properties: id: $ref: '#/components/schemas/coreIdentifier' spec: $ref: '#/components/schemas/adminWorkflowSpec' title: |- Represents a request structure to create a revision of a workflow. See Workflow for more details type: object adminWorkflowCreateResponse: description: Purposefully empty, may be populated in the future. type: object googlerpcStatus: properties: code: format: int32 type: integer details: items: $ref: '#/components/schemas/protobufAny' type: array message: type: string type: object coreIdentifier: description: Encapsulation of fields that uniquely identifies a Flyte resource. properties: domain: description: |- Name of the domain the resource belongs to. A domain can be considered as a subset within a specific project. type: string name: description: User provided value for the resource. type: string org: description: Optional, org key applied to the resource. type: string project: description: Name of the project the resource belongs to. type: string resource_type: $ref: '#/components/schemas/coreResourceType' version: description: Specific version of the resource. type: string type: object adminWorkflowSpec: description: >- Represents a structure that encapsulates the specification of the workflow. properties: description: $ref: '#/components/schemas/adminDescriptionEntity' sub_workflows: description: >- Workflows that are embedded into other workflows need to be passed alongside the parent workflow to the propeller compiler (since the compiler doesn't have any knowledge of other workflows - ie, it doesn't reach out to Admin to see other registered workflows). In fact, subworkflows do not even need to be registered. items: $ref: '#/components/schemas/coreWorkflowTemplate' type: array template: $ref: '#/components/schemas/coreWorkflowTemplate' type: object protobufAny: additionalProperties: {} description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } // or ... if (any.isSameTypeAs(Foo.getDefaultInstance())) { foo = any.unpack(Foo.getDefaultInstance()); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } properties: '@type': description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. type: string type: object coreResourceType: default: UNSPECIFIED description: >- Indicates a resource type within Flyte. - DATASET: A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects. Eventually all Catalog objects should be modeled similar to Flyte Objects. The Dataset entities makes it possible for the UI and CLI to act on the objects in a similar manner to other Flyte objects enum: - UNSPECIFIED - TASK - WORKFLOW - LAUNCH_PLAN - DATASET type: string adminDescriptionEntity: description: >- DescriptionEntity contains detailed description for the task/workflow. Documentation could provide insight into the algorithms, business use case, etc. properties: id: $ref: '#/components/schemas/coreIdentifier' long_description: $ref: '#/components/schemas/adminDescription' short_description: description: One-liner overview of the entity. type: string source_code: $ref: '#/components/schemas/adminSourceCode' tags: description: >- User-specified tags. These are arbitrary and can be used for searching filtering and discovering tasks. items: type: string type: array type: object coreWorkflowTemplate: description: >- Flyte Workflow Structure that encapsulates task, branch and subworkflow nodes to form a statically analyzable, directed acyclic graph. properties: failure_node: $ref: '#/components/schemas/coreNode' id: $ref: '#/components/schemas/coreIdentifier' interface: $ref: '#/components/schemas/coreTypedInterface' metadata: $ref: '#/components/schemas/coreWorkflowMetadata' metadata_defaults: $ref: '#/components/schemas/coreWorkflowMetadataDefaults' nodes: description: >- A list of nodes. In addition, 'globals' is a special reserved node id that can be used to consume workflow inputs. items: $ref: '#/components/schemas/coreNode' type: array outputs: description: >- A list of output bindings that specify how to construct workflow outputs. Bindings can pull node outputs or specify literals. All workflow outputs specified in the interface field must be bound in order for the workflow to be validated. A workflow has an implicit dependency on all of its nodes to execute successfully in order to bind final outputs. Most of these outputs will be Binding's with a BindingData of type OutputReference. That is, your workflow can just have an output of some constant (`Output(5)`), but usually, the workflow will be pulling outputs from the output of a task. items: $ref: '#/components/schemas/coreBinding' type: array type: object adminDescription: description: |- Full user description with formatting preserved. This can be rendered by clients, such as the console or command line tools with in-tact formatting. properties: format: $ref: '#/components/schemas/adminDescriptionFormat' icon_link: title: Optional link to an icon for the entity type: string uri: title: >- if the description sizes exceed some threshold we can offload the entire description proto altogether to an external data store, like S3 rather than store inline in the db type: string value: title: long description - no more than 4KB type: string type: object adminSourceCode: properties: link: type: string title: Link to source code used to define this entity type: object coreNode: description: >- A Workflow graph Node. One unit of execution in the graph. Each node can be linked to a Task, a Workflow or a branch node. properties: array_node: $ref: '#/components/schemas/coreArrayNode' branch_node: $ref: '#/components/schemas/coreBranchNode' gate_node: $ref: '#/components/schemas/coreGateNode' id: description: >- A workflow-level unique identifier that identifies this node in the workflow. 'inputs' and 'outputs' are reserved node ids that cannot be used by other nodes. type: string inputs: description: >- Specifies how to bind the underlying interface's inputs. All required inputs specified in the underlying interface must be fulfilled. items: $ref: '#/components/schemas/coreBinding' type: array metadata: $ref: '#/components/schemas/coreNodeMetadata' output_aliases: description: >- +optional. A node can define aliases for a subset of its outputs. This is particularly useful if different nodes need to conform to the same interface (e.g. all branches in a branch node). Downstream nodes must refer to this nodes outputs using the alias if one's specified. items: $ref: '#/components/schemas/coreAlias' type: array task_node: $ref: '#/components/schemas/coreTaskNode' upstream_node_ids: description: >- +optional Specifies execution dependency for this node ensuring it will only get scheduled to run after all its upstream nodes have completed. This node will have an implicit dependency on any node that appears in inputs field. items: type: string type: array workflow_node: $ref: '#/components/schemas/coreWorkflowNode' type: object coreTypedInterface: description: Defines strongly typed inputs and outputs. properties: inputs: $ref: '#/components/schemas/coreVariableMap' outputs: $ref: '#/components/schemas/coreVariableMap' type: object coreWorkflowMetadata: description: >- This is workflow layer metadata. These settings are only applicable to the workflow as a whole, and do not percolate down to child entities (like tasks) launched by the workflow. properties: on_failure: $ref: '#/components/schemas/WorkflowMetadataOnFailurePolicy' quality_of_service: $ref: '#/components/schemas/coreQualityOfService' tags: additionalProperties: type: string title: >- Arbitrary tags that allow users and the platform to store small but arbitrary labels type: object type: object coreWorkflowMetadataDefaults: description: >- The difference between these settings and the WorkflowMetadata ones is that these are meant to be passed down to a workflow's underlying entities (like tasks). For instance, 'interruptible' has no meaning at the workflow layer, it is only relevant when a task executes. The settings here are the defaults that are passed to all nodes unless explicitly overridden at the node layer. If you are adding a setting that applies to both the Workflow itself, and everything underneath it, it should be added to both this object and the WorkflowMetadata object above. properties: interruptible: description: Whether child nodes of the workflow are interruptible. type: boolean type: object coreBinding: description: >- An input/output binding of a variable to either static value or a node output. properties: binding: $ref: '#/components/schemas/coreBindingData' var: description: Variable name must match an input/output variable of the node. type: string type: object adminDescriptionFormat: default: DESCRIPTION_FORMAT_UNKNOWN description: '- DESCRIPTION_FORMAT_RST: python default documentation - comments is rst' enum: - DESCRIPTION_FORMAT_UNKNOWN - DESCRIPTION_FORMAT_MARKDOWN - DESCRIPTION_FORMAT_HTML - DESCRIPTION_FORMAT_RST title: The format of the long description type: string coreArrayNode: description: >- ArrayNode is a Flyte node type that simplifies the execution of a sub-node over a list of input values. An ArrayNode can be executed with configurable parallelism (separate from the parent workflow) and can be configured to succeed when a certain number of sub-nodes succeed. properties: bound_inputs: description: >- +optional. Specifies input bindings that are not mapped over for the node. items: type: string type: array data_mode: $ref: '#/components/schemas/ArrayNodeDataMode' execution_mode: $ref: '#/components/schemas/coreArrayNodeExecutionMode' is_original_sub_node_interface: title: Indicates whether the sub node's original interface was altered type: boolean min_success_ratio: description: >- If the array job size is not known beforehand, the min_success_ratio can instead be used to determine when an ArrayNode can be marked successful. format: float type: number min_successes: description: >- min_successes is an absolute number of the minimum number of successful completions of sub-nodes. As soon as this criteria is met, the ArrayNode will be marked as successful and outputs will be computed. This has to be a non-negative number if assigned. Default value is size (if specified). format: int64 type: integer node: $ref: '#/components/schemas/coreNode' parallelism: description: >- parallelism defines the minimum number of instances to bring up concurrently at any given point. Note that this is an optimistic restriction and that, due to network partitioning or other failures, the actual number of currently running instances might be more. This has to be a positive number if assigned. Default value is size. format: int64 type: integer run_all_sub_nodes: description: >- +optional. If set to true, the ArrayNode will continue to run all sub-nodes even after the failure threshold has been met (i.e. it is no longer possible to meet min_successes or min_success_ratio). This is useful when you want to ensure all sub-nodes complete execution even if the overall array node will fail. type: boolean type: object coreBranchNode: description: >- BranchNode is a special node that alter the flow of the workflow graph. It allows the control flow to branch at runtime based on a series of conditions that get evaluated on various parameters (e.g. inputs, primitives). properties: if_else: $ref: '#/components/schemas/coreIfElseBlock' type: object coreGateNode: description: >- GateNode refers to the condition that is required for the gate to successfully complete. properties: approve: $ref: '#/components/schemas/coreApproveCondition' signal: $ref: '#/components/schemas/coreSignalCondition' sleep: $ref: '#/components/schemas/coreSleepCondition' type: object coreNodeMetadata: description: Defines extra information about the Node. properties: cache_serializable: type: boolean cache_version: type: string cacheable: type: boolean config: additionalProperties: type: string description: >- Config is a bag of properties that can be used to instruct propeller on how to execute the node. type: object interruptible: type: boolean name: title: A friendly name for the Node type: string retries: $ref: '#/components/schemas/coreRetryStrategy' timeout: description: The overall timeout of a task. type: string type: object coreAlias: description: Links a variable to an alias. properties: alias: description: >- A workflow-level unique alias that downstream nodes can refer to in their input. type: string var: description: Must match one of the output variable names on a node. type: string type: object coreTaskNode: description: Refers to the task that the Node is to execute. properties: overrides: $ref: '#/components/schemas/coreTaskNodeOverrides' reference_id: $ref: '#/components/schemas/coreIdentifier' type: object coreWorkflowNode: description: Refers to a the workflow the node is to execute. properties: launchplan_ref: $ref: '#/components/schemas/coreIdentifier' sub_workflow_ref: $ref: '#/components/schemas/coreIdentifier' type: object coreVariableMap: properties: variables: additionalProperties: $ref: '#/components/schemas/coreVariable' description: Defines a map of variable names to variables. type: object title: A map of Variables type: object WorkflowMetadataOnFailurePolicy: default: FAIL_IMMEDIATELY description: >- - FAIL_IMMEDIATELY: FAIL_IMMEDIATELY instructs the system to fail as soon as a node fails in the workflow. It'll automatically abort all currently running nodes and clean up resources before finally marking the workflow executions as failed. - FAIL_AFTER_EXECUTABLE_NODES_COMPLETE: FAIL_AFTER_EXECUTABLE_NODES_COMPLETE instructs the system to make as much progress as it can. The system will not alter the dependencies of the execution graph so any node that depend on the failed node will not be run. Other nodes that will be executed to completion before cleaning up resources and marking the workflow execution as failed. enum: - FAIL_IMMEDIATELY - FAIL_AFTER_EXECUTABLE_NODES_COMPLETE title: Failure Handling Strategy type: string coreQualityOfService: description: Indicates the priority of an execution. properties: spec: $ref: '#/components/schemas/coreQualityOfServiceSpec' tier: $ref: '#/components/schemas/QualityOfServiceTier' type: object coreBindingData: description: Specifies either a simple value or a reference to another output. properties: collection: $ref: '#/components/schemas/coreBindingDataCollection' map: $ref: '#/components/schemas/coreBindingDataMap' offloaded_metadata: $ref: '#/components/schemas/coreLiteralOffloadedMetadata' promise: $ref: '#/components/schemas/coreOutputReference' scalar: $ref: '#/components/schemas/coreScalar' union: $ref: '#/components/schemas/coreUnionInfo' type: object ArrayNodeDataMode: default: SINGLE_INPUT_FILE description: >2- - SINGLE_INPUT_FILE: Indicates the ArrayNode's input is a list of input values that map to subNode executions. The file path set for the subNode will be the ArrayNode's input file, but the in-memory value utilized in propeller will be the individual value for each subNode execution. SubNode executions need to be able to read in and parse the individual value to execute correctly. - INDIVIDUAL_INPUT_FILES: Indicates the ArrayNode's input is a list of input values that map to subNode executions. Propeller will create input files for each ArrayNode subNode by parsing the inputs and setting the InputBindings on each subNodeSpec. Both the file path and in-memory input values will be the individual value for each subNode execution. enum: - SINGLE_INPUT_FILE - INDIVIDUAL_INPUT_FILES type: string coreArrayNodeExecutionMode: default: MINIMAL_STATE description: |2- - MINIMAL_STATE: Indicates the ArrayNode will store minimal state for the sub-nodes. This is more efficient, but only supports a subset of Flyte entities. - FULL_STATE: Indicates the ArrayNode will store full state for the sub-nodes. This supports a wider range of Flyte entities. enum: - MINIMAL_STATE - FULL_STATE type: string coreIfElseBlock: description: >- Defines a series of if/else blocks. The first branch whose condition evaluates to true is the one to execute. If no conditions were satisfied, the else_node or the error will execute. properties: case: $ref: '#/components/schemas/coreIfBlock' else_node: $ref: '#/components/schemas/coreNode' error: $ref: '#/components/schemas/coreError' other: description: +optional. Additional branches to evaluate. items: $ref: '#/components/schemas/coreIfBlock' type: array type: object coreApproveCondition: description: >- ApproveCondition represents a dependency on an external approval. During execution, this will manifest as a boolean signal with the provided signal_id. properties: signal_id: description: A unique identifier for the requested boolean signal. type: string type: object coreSignalCondition: description: SignalCondition represents a dependency on an signal. properties: output_variable_name: description: The variable name for the signal value in this nodes outputs. type: string signal_id: description: A unique identifier for the requested signal. type: string type: $ref: '#/components/schemas/coreLiteralType' type: object coreSleepCondition: description: >- SleepCondition represents a dependency on waiting for the specified duration. properties: duration: description: The overall duration for this sleep. type: string type: object coreRetryStrategy: description: Retry strategy associated with an executable unit. properties: retries: description: >- Number of retries. Retries will be consumed when the job fails with a recoverable error. The number of retries must be less than or equals to 10. format: int64 type: integer type: object coreTaskNodeOverrides: description: >- Optional task node overrides that will be applied at task execution time. properties: container_image: description: Override for the image used by task pods. type: string extended_resources: $ref: '#/components/schemas/coreExtendedResources' pod_template: $ref: '#/components/schemas/coreK8sPod' resources: $ref: '#/components/schemas/coreResources' type: object coreVariable: description: Defines a strongly typed variable. properties: artifact_partial_id: $ref: '#/components/schemas/coreArtifactID' artifact_tag: $ref: '#/components/schemas/coreArtifactTag' description: title: +optional string describing input variable type: string type: $ref: '#/components/schemas/coreLiteralType' type: object coreQualityOfServiceSpec: description: Represents customized execution run-time attributes. properties: queueing_budget: description: Indicates how much queueing delay an execution can tolerate. type: string type: object QualityOfServiceTier: default: UNDEFINED description: ' - UNDEFINED: Default: no quality of service specified.' enum: - UNDEFINED - HIGH - MEDIUM - LOW type: string coreBindingDataCollection: description: A collection of BindingData items. properties: bindings: items: $ref: '#/components/schemas/coreBindingData' type: array type: object coreBindingDataMap: description: A map of BindingData items. properties: bindings: additionalProperties: $ref: '#/components/schemas/coreBindingData' type: object type: object coreLiteralOffloadedMetadata: description: A message that contains the metadata of the offloaded data. properties: inferred_type: $ref: '#/components/schemas/coreLiteralType' size_bytes: description: The size of the offloaded data. format: uint64 type: string uri: description: The location of the offloaded core.Literal. type: string type: object coreOutputReference: description: >- A reference to an output produced by a node. The type can be retrieved -and validated- from the underlying interface of the node. properties: attr_path: items: $ref: '#/components/schemas/corePromiseAttribute' type: array node_id: description: Node id must exist at the graph layer. type: string var: description: Variable name must refer to an output variable for the node. type: string type: object coreScalar: properties: binary: $ref: '#/components/schemas/coreBinary' blob: $ref: '#/components/schemas/coreBlob' error: $ref: '#/components/schemas/coreError' generic: type: object none_type: $ref: '#/components/schemas/coreVoid' primitive: $ref: '#/components/schemas/corePrimitive' schema: $ref: '#/components/schemas/flyteidlcoreSchema' structured_dataset: $ref: '#/components/schemas/coreStructuredDataset' union: $ref: '#/components/schemas/coreUnion' type: object coreUnionInfo: properties: targetType: $ref: '#/components/schemas/coreLiteralType' type: object coreIfBlock: description: >- Defines a condition and the execution unit that should be executed if the condition is satisfied. properties: condition: $ref: '#/components/schemas/coreBooleanExpression' then_node: $ref: '#/components/schemas/coreNode' type: object coreError: description: Represents an error thrown from a node. properties: failed_node_id: description: The node id that threw the error. type: string message: description: Error message thrown. type: string type: object coreLiteralType: description: Defines a strong type to allow type checking between interfaces. properties: annotation: $ref: '#/components/schemas/coreTypeAnnotation' blob: $ref: '#/components/schemas/coreBlobType' collection_type: $ref: '#/components/schemas/coreLiteralType' enum_type: $ref: '#/components/schemas/flyteidlcoreEnumType' map_value_type: $ref: '#/components/schemas/coreLiteralType' metadata: description: >- This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by consumers to identify special behavior or display extended information for the type. type: object schema: $ref: '#/components/schemas/coreSchemaType' simple: $ref: '#/components/schemas/coreSimpleType' structure: $ref: '#/components/schemas/coreTypeStructure' structured_dataset_type: $ref: '#/components/schemas/coreStructuredDatasetType' union_type: $ref: '#/components/schemas/coreUnionType' type: object coreExtendedResources: description: >- Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to allocate to a task. properties: gpu_accelerator: $ref: '#/components/schemas/coreGPUAccelerator' shared_memory: $ref: '#/components/schemas/coreSharedMemory' type: object coreK8sPod: description: >- Defines a pod spec and additional pod metadata that is created when a task is executed. properties: data_config: $ref: '#/components/schemas/coreDataLoadingConfig' metadata: $ref: '#/components/schemas/coreK8sObjectMetadata' pod_spec: title: >- Defines the primary pod spec created when a task is executed. This should be a JSON-marshalled pod spec, which can be defined in - go, using: https://github.com/kubernetes/api/blob/release-1.21/core/v1/types.go#L2936 - python: using https://github.com/kubernetes-client/python/blob/release-19.0/kubernetes/client/models/v1_pod_spec.py type: object primary_container_name: description: >- Defines the primary container name when pod template override is executed. type: string type: object coreResources: description: >- A customizable interface to convey resources requested for a container. This can be interpreted differently for different container engines. properties: limits: description: >- Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique within the list. items: $ref: '#/components/schemas/ResourcesResourceEntry' type: array requests: description: >- The desired set of resources requested. ResourceNames must be unique within the list. items: $ref: '#/components/schemas/ResourcesResourceEntry' type: array type: object coreArtifactID: properties: artifact_key: $ref: '#/components/schemas/coreArtifactKey' partitions: $ref: '#/components/schemas/corePartitions' time_partition: $ref: '#/components/schemas/coreTimePartition' version: type: string type: object coreArtifactTag: properties: artifact_key: $ref: '#/components/schemas/coreArtifactKey' value: $ref: '#/components/schemas/coreLabelValue' type: object corePromiseAttribute: properties: int_value: format: int32 type: integer string_value: type: string type: object coreBinary: description: >- A simple byte array with a tag to help different parts of the system communicate about what is in the byte array. It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data. properties: tag: description: >- The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization. type: string value: description: >- Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict. format: byte type: string type: object coreBlob: description: >- Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is. There are no restrictions on how the uri is formatted since it will depend on how to interact with the store. properties: metadata: $ref: '#/components/schemas/coreBlobMetadata' uri: type: string type: object coreVoid: description: >- Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally undefined since it can be assigned to a scalar of any LiteralType. type: object corePrimitive: properties: boolean: type: boolean datetime: format: date-time type: string duration: type: string float_value: format: double type: number integer: format: int64 type: string string_value: type: string title: Primitive Types type: object flyteidlcoreSchema: description: >- A strongly typed schema that defines the interface of data retrieved from the underlying storage medium. properties: type: $ref: '#/components/schemas/coreSchemaType' uri: type: string type: object coreStructuredDataset: properties: metadata: $ref: '#/components/schemas/coreStructuredDatasetMetadata' uri: title: >- String location uniquely identifying where the data is. Should start with the storage location (e.g. s3://, gs://, bq://, etc.) type: string type: object coreUnion: description: >- The runtime representation of a tagged union value. See `UnionType` for more details. properties: type: $ref: '#/components/schemas/coreLiteralType' value: $ref: '#/components/schemas/coreLiteral' type: object coreBooleanExpression: description: >- Defines a boolean expression tree. It can be a simple or a conjunction expression. Multiple expressions can be combined using a conjunction or a disjunction to result in a final boolean result. properties: comparison: $ref: '#/components/schemas/coreComparisonExpression' conjunction: $ref: '#/components/schemas/coreConjunctionExpression' type: object coreTypeAnnotation: description: >- TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs. properties: annotations: description: A arbitrary JSON payload to describe a type. type: object type: object coreBlobType: properties: dimensionality: $ref: '#/components/schemas/BlobTypeBlobDimensionality' format: title: |- Format can be a free form string understood by SDK/UI etc like csv, parquet etc type: string title: Defines type behavior for blob objects type: object flyteidlcoreEnumType: description: >- Enables declaring enum types, with predefined string values For len(values) > 0, the first value in the ordered list is regarded as the default value. If you wish To provide no defaults, make the first value as undefined. properties: values: description: Predefined set of enum values. items: type: string type: array type: object coreSchemaType: description: >- Defines schema columns and types to strongly type-validate schemas interoperability. properties: columns: description: A list of ordered columns this schema comprises of. items: $ref: '#/components/schemas/SchemaTypeSchemaColumn' type: array type: object coreSimpleType: default: NONE description: Define a set of simple types. enum: - NONE - INTEGER - FLOAT - STRING - BOOLEAN - DATETIME - DURATION - BINARY - ERROR - STRUCT type: string coreTypeStructure: description: |- Hints to improve type matching e.g. allows distinguishing output from custom type transformers even if the underlying IDL serialization matches. properties: dataclass_type: additionalProperties: $ref: '#/components/schemas/coreLiteralType' title: >- dataclass_type only exists for dataclasses. This is used to resolve the type of the fields of dataclass The key is the field name, and the value is the literal type of the field e.g. For dataclass Foo, with fields a, and a is a string Foo.a will be resolved as a literal type of string from dataclass_type type: object tag: title: Must exactly match for types to be castable type: string type: object coreStructuredDatasetType: properties: columns: description: A list of ordered columns this schema comprises of. items: $ref: '#/components/schemas/StructuredDatasetTypeDatasetColumn' type: array external_schema_bytes: description: |- The serialized bytes of a third-party schema library like Arrow. This is an optional field that will not be used for type checking. format: byte type: string external_schema_type: description: >- This is a string representing the type that the bytes in external_schema_bytes are formatted in. This is an optional field that will not be used for type checking. type: string format: description: >- This is the storage format, the format of the bits at rest parquet, feather, csv, etc. For two types to be compatible, the format will need to be an exact match. type: string type: object coreUnionType: description: >- Defines a tagged union type, also known as a variant (and formally as the sum type). A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by storing the varaint's tag with the literal value and can be examined in runtime. Type S is typically written as S := Apple A | Banana B | Cantaloupe C | ... Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value: Optional X := X | Null See also: https://en.wikipedia.org/wiki/Tagged_union properties: variants: description: Predefined set of variants in union. items: $ref: '#/components/schemas/coreLiteralType' type: array type: object coreGPUAccelerator: description: >- Metadata associated with the GPU accelerator to allocate to a task. Contains information about device type, and for multi-instance GPUs, the partition size to use. properties: device: description: >- This can be any arbitrary string, and should be informed by the labels or taints associated with the nodes in question. Default cloud provider labels typically use the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc. type: string partition_size: description: >- Like `device`, this can be any arbitrary string, and should be informed by the labels or taints associated with the nodes in question. Default cloud provider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc. type: string unpartitioned: type: boolean type: object coreSharedMemory: description: Metadata associated with configuring a shared memory volume for a task. properties: mount_name: title: Name for volume type: string mount_path: title: Mount path to place in container type: string size_limit: title: >- Size limit for shared memory. If not set, then the shared memory is equal to the allocated memory. +optional type: string type: object coreDataLoadingConfig: description: >- This configuration allows executing raw containers in Flyte using the Flyte CoPilot system. Flyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path Any outputs generated by the user container - within output_path are automatically uploaded. properties: enabled: title: >- Flag enables DataLoading Config. If this is not set, data loading will not be used! type: boolean format: $ref: '#/components/schemas/DataLoadingConfigLiteralMapFormat' input_path: title: >- File system path (start at root). This folder will contain all the inputs exploded to a separate file. Example, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like /var/flyte/inputs/inputs. .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations /var/flyte/inputs/x -> X is a file that contains the value of x (integer) in string format /var/flyte/inputs/y -> Y is a file in Binary format /var/flyte/inputs/z/... -> Note Z itself is a directory More information about the protocol - refer to docs #TODO reference docs here type: string io_strategy: $ref: '#/components/schemas/coreIOStrategy' output_path: title: >- File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file type: string type: object coreK8sObjectMetadata: description: Metadata for building a kubernetes object when a task is executed. properties: annotations: additionalProperties: type: string description: Optional annotations to add to the pod definition. type: object labels: additionalProperties: type: string description: Optional labels to add to the pod definition. type: object type: object ResourcesResourceEntry: description: Encapsulates a resource name and value. properties: name: $ref: '#/components/schemas/ResourcesResourceName' value: title: >- Value must be a valid k8s quantity. See https://github.com/kubernetes/apimachinery/blob/master/pkg/api/resource/quantity.go#L30-L80 type: string type: object coreArtifactKey: properties: domain: type: string name: type: string org: type: string project: description: >- Project and domain and suffix needs to be unique across a given artifact store. type: string type: object corePartitions: properties: value: additionalProperties: $ref: '#/components/schemas/coreLabelValue' type: object type: object coreTimePartition: properties: granularity: $ref: '#/components/schemas/coreGranularity' value: $ref: '#/components/schemas/coreLabelValue' type: object coreLabelValue: properties: input_binding: $ref: '#/components/schemas/coreInputBindingData' runtime_binding: $ref: '#/components/schemas/coreRuntimeBinding' static_value: title: The string static value is for use in the Partitions object type: string time_value: format: date-time title: The time value is for use in the TimePartition case type: string triggered_binding: $ref: '#/components/schemas/coreArtifactBindingData' type: object coreBlobMetadata: properties: type: $ref: '#/components/schemas/coreBlobType' type: object coreStructuredDatasetMetadata: properties: structured_dataset_type: $ref: '#/components/schemas/coreStructuredDatasetType' type: object coreLiteral: description: >- A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives. properties: collection: $ref: '#/components/schemas/coreLiteralCollection' hash: title: >- A hash representing this literal. This is used for caching purposes. For more details refer to RFC 1893 (https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md) type: string map: $ref: '#/components/schemas/coreLiteralMap' metadata: additionalProperties: type: string description: Additional metadata for literals. type: object offloaded_metadata: $ref: '#/components/schemas/coreLiteralOffloadedMetadata' scalar: $ref: '#/components/schemas/coreScalar' type: object coreComparisonExpression: description: >- Defines a 2-level tree where the root is a comparison operator and Operands are primitives or known variables. Each expression results in a boolean result. properties: left_value: $ref: '#/components/schemas/coreOperand' operator: $ref: '#/components/schemas/coreComparisonExpressionOperator' right_value: $ref: '#/components/schemas/coreOperand' type: object coreConjunctionExpression: description: Defines a conjunction expression of two boolean expressions. properties: left_expression: $ref: '#/components/schemas/coreBooleanExpression' operator: $ref: '#/components/schemas/ConjunctionExpressionLogicalOperator' right_expression: $ref: '#/components/schemas/coreBooleanExpression' type: object BlobTypeBlobDimensionality: default: SINGLE enum: - SINGLE - MULTIPART type: string SchemaTypeSchemaColumn: properties: name: title: A unique name -within the schema type- for the column type: string type: $ref: '#/components/schemas/SchemaColumnSchemaColumnType' type: object StructuredDatasetTypeDatasetColumn: properties: literal_type: $ref: '#/components/schemas/coreLiteralType' name: description: A unique name within the schema type for the column. type: string type: object DataLoadingConfigLiteralMapFormat: default: JSON description: >- - JSON: JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - https://www.json.org/json-en.html - PROTO: Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core enum: - JSON - YAML - PROTO title: >- LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers. If the user has access to the protocol buffer definitions, it is recommended to use the PROTO format. JSON and YAML do not need any protobuf definitions to read it All remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem) type: string coreIOStrategy: properties: download_mode: $ref: '#/components/schemas/IOStrategyDownloadMode' upload_mode: $ref: '#/components/schemas/IOStrategyUploadMode' title: >- Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets) type: object ResourcesResourceName: default: UNKNOWN description: |- Known resource names. - EPHEMERAL_STORAGE: For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs. enum: - UNKNOWN - CPU - GPU - MEMORY - STORAGE - EPHEMERAL_STORAGE type: string coreGranularity: default: UNSET enum: - UNSET - MINUTE - HOUR - DAY - MONTH title: '- DAY: default' type: string coreInputBindingData: properties: var: type: string type: object coreRuntimeBinding: type: object coreArtifactBindingData: properties: bind_to_time_partition: type: boolean partition_key: type: string time_transform: $ref: '#/components/schemas/coreTimeTransform' title: Only valid for triggers type: object coreLiteralCollection: description: >- A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. properties: literals: items: $ref: '#/components/schemas/coreLiteral' type: array type: object coreLiteralMap: description: >- A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. properties: literals: additionalProperties: $ref: '#/components/schemas/coreLiteral' type: object type: object coreOperand: description: Defines an operand to a comparison expression. properties: primitive: $ref: '#/components/schemas/corePrimitive' scalar: $ref: '#/components/schemas/coreScalar' var: title: Or one of this node's input variables type: string type: object coreComparisonExpressionOperator: default: EQ description: |- - GT: Greater Than - LT: Less Than enum: - EQ - NEQ - GT - GTE - LT - LTE title: Binary Operator for each expression type: string ConjunctionExpressionLogicalOperator: default: AND description: '- AND: Conjunction' enum: - AND - OR title: |- Nested conditions. They can be conjoined using AND / OR Order of evaluation is not important as the operators are Commutative type: string SchemaColumnSchemaColumnType: default: INTEGER enum: - INTEGER - FLOAT - STRING - BOOLEAN - DATETIME - DURATION type: string IOStrategyDownloadMode: default: DOWNLOAD_EAGER description: >- - DOWNLOAD_EAGER: All data will be downloaded before the main container is executed - DOWNLOAD_STREAM: Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details - DO_NOT_DOWNLOAD: Large objects (offloaded) will not be downloaded enum: - DOWNLOAD_EAGER - DOWNLOAD_STREAM - DO_NOT_DOWNLOAD title: Mode to use for downloading type: string IOStrategyUploadMode: default: UPLOAD_ON_EXIT description: >- - UPLOAD_ON_EXIT: All data will be uploaded after the main container exits - UPLOAD_EAGER: Data will be uploaded as it appears. Refer to protocol specification for details - DO_NOT_UPLOAD: Data will not be uploaded, only references will be written enum: - UPLOAD_ON_EXIT - UPLOAD_EAGER - DO_NOT_UPLOAD title: Mode to use for uploading type: string coreTimeTransform: properties: op: $ref: '#/components/schemas/flyteidlcoreOperator' transform: type: string type: object flyteidlcoreOperator: default: MINUS enum: - MINUS - PLUS type: string ```` ## Related topics - [Create and upload a Task definition](/6.3/api-reference/tasks/create-and-upload-a-task-definition.md) - [Create and upload a LaunchPlan definition](/6.3/api-reference/launch-plans/create-and-upload-a-launchplan-definition.md) - [Fetch a Workflow definition.](/6.3/api-reference/workflows/fetch-a-workflow-definition.md) - [Fetch a list of Workflow definitions.](/6.3/api-reference/workflows/fetch-a-list-of-workflow-definitions.md)