cognite-toolkit 0.7.30__py3-none-any.whl → 0.7.32__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/build_v2/build_cmd.py

@@ -0,0 +1,241 @@
+from pathlib import Path
+from typing import Any, Literal, TypedDict
+
+from rich import print
+from rich.panel import Panel
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.commands.build_cmd import BuildCommand as OldBuildCommand
+from cognite_toolkit._cdf_tk.commands.build_v2.build_input import BuildInput
+from cognite_toolkit._cdf_tk.commands.build_v2.build_issues import BuildIssue, BuildIssueList
+from cognite_toolkit._cdf_tk.data_classes import (
+    BuildConfigYAML,
+    BuildVariables,
+    BuiltModuleList,
+    ModuleDirectories,
+)
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.hints import verify_module_directory
+from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning, WarningList
+from cognite_toolkit._cdf_tk.utils.file import safe_rmtree
+from cognite_toolkit._cdf_tk.validation import validate_module_selection, validate_modules_variables
+from cognite_toolkit._version import __version__
+
+
+class BuildWarnings(TypedDict):
+    warning: ToolkitWarning
+    location: list[Path]
+
+
+class BuildCommand(ToolkitCommand):
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.issues = BuildIssueList()
+
+    def execute(
+        self,
+        verbose: bool,
+        organization_dir: Path,
+        build_dir: Path,
+        selected: list[str | Path] | None,
+        build_env_name: str | None,
+        no_clean: bool,
+        client: ToolkitClient | None = None,
+        on_error: Literal["continue", "raise"] = "continue",
+    ) -> BuiltModuleList:
+        """
+        Build the resources into deployable artifacts in the build directory.
+        """
+
+        self.verbose = verbose
+        self.on_error = on_error
+
+        # Tracking the project and cluster for the build.
+        if client:
+            self._additional_tracking_info.project = client.config.project
+            self._additional_tracking_info.cluster = client.config.cdf_cluster
+
+        # Setting the parameters for the build.
+        input = BuildInput.load(organization_dir, build_dir, build_env_name, client, selected)
+
+        # Print the build input.
+        if self.verbose:
+            self._print_build_input(input)
+
+        # Capture warnings from module structure integrity
+        if module_selection_issues := self._validate_modules(input):
+            self.issues.extend(module_selection_issues)
+
+        # Logistics: clean and create build directory
+        if prepare_issues := self._prepare_target_directory(input, not no_clean):
+            self.issues.extend(prepare_issues)
+
+        # Compile the configuration and variables,
+        # check syntax on module and resource level
+        # for any "compilation errors and warnings"
+        built_modules, build_integrity_issues = self._build_configuration(input)
+        if build_integrity_issues:
+            self.issues.extend(build_integrity_issues)
+
+        # This is where we would add any recommendations for the user to improve the build.
+        if build_quality_issues := self._verify_build_quality(built_modules):
+            self.issues.extend(build_quality_issues)
+
+        # Finally, print warnings grouped by category/code and location.
+        self._print_or_log_warnings_by_category(self.issues)
+
+        return built_modules
+
+    def _print_build_input(self, input: BuildInput) -> None:
+        print(
+            Panel(
+                f"Building {input.organization_dir!s}:\n  - Toolkit Version '{__version__!s}'\n"
+                f"  - Environment name {input.build_env_name!r}, validation-type {input.config.environment.validation_type!r}.\n"
+                f"  - Config '{input.config.filepath!s}'",
+                expand=False,
+            )
+        )
+
+    def _prepare_target_directory(self, input: BuildInput, clean: bool = False) -> BuildIssueList:
+        """
+        Directory logistics
+        """
+        issues = BuildIssueList()
+        if input.build_dir.exists() and any(input.build_dir.iterdir()):
+            if not clean:
+                raise ToolkitError("Build directory is not empty. Run without --no-clean to remove existing files.")
+
+            if self.verbose:
+                issues.append(BuildIssue(description=f"Build directory {input.build_dir!s} is not empty. Clearing."))
+            safe_rmtree(input.build_dir)
+        input.build_dir.mkdir(parents=True, exist_ok=True)
+        return issues
+
+    def _validate_modules(self, input: BuildInput) -> BuildIssueList:
+        issues = BuildIssueList()
+        # Verify that the modules exists, are not duplicates,
+        # and at least one is selected
+        verify_module_directory(input.organization_dir, input.build_env_name)
+
+        # Validate module selection
+        user_selected_modules = input.config.environment.get_selected_modules({})
+        module_warnings = validate_module_selection(
+            modules=input.modules,
+            config=input.config,
+            packages={},
+            selected_modules=user_selected_modules,
+            organization_dir=input.organization_dir,
+        )
+        if module_warnings:
+            issues.extend(BuildIssueList.from_warning_list(module_warnings))
+
+        # Validate variables. Note: this looks for non-replaced template
+        # variables <.*?> and can be improved in the future.
+        # Keeping for reference.
+        variables_warnings = validate_modules_variables(input.variables, input.config.filepath)
+        if variables_warnings:
+            issues.extend(BuildIssueList.from_warning_list(variables_warnings))
+
+        # Track LOC of managed configuration
+        # Note: _track is not implemented yet, so we skip it for now
+        # self._track(input)
+
+        return issues
+
+    def _build_configuration(self, input: BuildInput) -> tuple[BuiltModuleList, BuildIssueList]:
+        issues = BuildIssueList()
+        # Use input.modules.selected directly (it's already a ModuleDirectories)
+        if not input.modules.selected:
+            return BuiltModuleList(), issues
+
+        # first collect variables into practical lookup
+        # TODO: parallelism is not implemented yet. I'm sure there are optimizations to be had here, but we'll focus on process parallelism since we believe loading yaml and file i/O are the biggest bottlenecks.
+
+        old_build_command = OldBuildCommand(print_warning=False, skip_tracking=False)
+        built_modules = old_build_command.build_config(
+            build_dir=input.build_dir,
+            organization_dir=input.organization_dir,
+            config=input.config,
+            packages={},
+            clean=False,
+            verbose=self.verbose,
+            client=input.client,
+            progress_bar=False,
+            on_error=self.on_error,
+        )
+        # Copy tracking info from old command to self
+        self._additional_tracking_info.package_ids.update(old_build_command._additional_tracking_info.package_ids)
+        self._additional_tracking_info.module_ids.update(old_build_command._additional_tracking_info.module_ids)
+
+        # Collect warnings from the old build command and convert to issues
+        # Always convert warnings to issues, even if the list appears empty
+        # (WarningList might have custom __bool__ behavior)
+        if old_build_command.warning_list:
+            converted_issues = BuildIssueList.from_warning_list(old_build_command.warning_list)
+            issues.extend(converted_issues)
+        return built_modules, issues
+
+    def _verify_build_quality(self, built_modules: BuiltModuleList) -> BuildIssueList:
+        issues = BuildIssueList()
+        return issues
+
+    def _write(self, input: BuildInput) -> None:
+        # Write the build to the build directory.
+        # Track lines of code built.
+        raise NotImplementedError()
+
+    def _track(self, input: BuildInput) -> None:
+        raise NotImplementedError()
+
+    def _print_or_log_warnings_by_category(self, issues: BuildIssueList) -> None:
+        pass
+
+    # Delegate to old BuildCommand for backward compatibility with tests
+    def build_modules(
+        self,
+        modules: ModuleDirectories,
+        build_dir: Path,
+        variables: BuildVariables,
+        verbose: bool = False,
+        progress_bar: bool = False,
+        on_error: Literal["continue", "raise"] = "continue",
+    ) -> BuiltModuleList:
+        """Delegate to old BuildCommand for backward compatibility."""
+        old_cmd = OldBuildCommand()
+
+        built_modules = old_cmd.build_modules(modules, build_dir, variables, verbose, progress_bar, on_error)
+        self._additional_tracking_info.package_ids.update(old_cmd._additional_tracking_info.package_ids)
+        self._additional_tracking_info.module_ids.update(old_cmd._additional_tracking_info.module_ids)
+        self.issues.extend(BuildIssueList.from_warning_list(old_cmd.warning_list or WarningList[ToolkitWarning]()))
+        return built_modules
+
+    def build_config(
+        self,
+        build_dir: Path,
+        organization_dir: Path,
+        config: BuildConfigYAML,
+        packages: dict[str, list[str]],
+        clean: bool = False,
+        verbose: bool = False,
+        client: ToolkitClient | None = None,
+        progress_bar: bool = False,
+        on_error: Literal["continue", "raise"] = "continue",
+    ) -> BuiltModuleList:
+        """Delegate to old BuildCommand for backward compatibility."""
+        old_cmd = OldBuildCommand()
+        return old_cmd.build_config(
+            build_dir, organization_dir, config, packages, clean, verbose, client, progress_bar, on_error
+        )
+
+    def _replace_variables(
+        self,
+        resource_files: list[Path],
+        variables: BuildVariables,
+        resource_name: str,
+        module_dir: Path,
+        verbose: bool = False,
+    ) -> list[Any]:
+        """Delegate to old BuildCommand for backward compatibility."""
+        old_cmd = OldBuildCommand()
+        return old_cmd._replace_variables(resource_files, variables, resource_name, module_dir, verbose)

cognite_toolkit/_cdf_tk/commands/build_v2/build_input.py

@@ -0,0 +1,85 @@
+import sys
+from functools import cached_property
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from pydantic import BaseModel, ConfigDict
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.constants import DEFAULT_ENV
+from cognite_toolkit._cdf_tk.data_classes import (
+    BuildConfigYAML,
+    BuildVariables,
+    ModuleDirectories,
+)
+from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning, WarningList
+from cognite_toolkit._cdf_tk.utils.modules import parse_user_selected_modules
+
+
+class BuildInput(BaseModel):
+    """Input to the build process."""
+
+    # need this until we turn BuildConfigYaml and ToolkitClient into Pydantic models
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+
+    organization_dir: Path
+    build_dir: Path
+    build_env_name: str
+    config: BuildConfigYAML
+    client: ToolkitClient | None = None
+    selected: list[str | Path] | None = None
+    warnings: WarningList[ToolkitWarning] | None = None
+
+    @classmethod
+    def load(
+        cls,
+        organization_dir: Path,
+        build_dir: Path,
+        build_env_name: str | None,
+        client: ToolkitClient | None,
+        selected: list[str | Path] | None = None,
+    ) -> Self:
+        resolved_org_dir = Path.cwd() if organization_dir in {Path("."), Path("./")} else organization_dir
+        resolved_env = build_env_name or DEFAULT_ENV
+        config, warnings = cls._load_config(resolved_org_dir, resolved_env, selected)
+        return cls(
+            organization_dir=resolved_org_dir,
+            build_dir=build_dir,
+            build_env_name=resolved_env,
+            config=config,
+            client=client,
+            selected=selected,
+            warnings=warnings,
+        )
+
+    @classmethod
+    def _load_config(
+        cls, organization_dir: Path, build_env_name: str, selected: list[str | Path] | None
+    ) -> tuple[BuildConfigYAML, WarningList[ToolkitWarning]]:
+        warnings: WarningList[ToolkitWarning] = WarningList[ToolkitWarning]()
+        if (organization_dir / BuildConfigYAML.get_filename(build_env_name or DEFAULT_ENV)).exists():
+            config = BuildConfigYAML.load_from_directory(organization_dir, build_env_name or DEFAULT_ENV)
+        else:
+            # Loads the default environment
+            config = BuildConfigYAML.load_default(organization_dir)
+        if selected:
+            config.environment.selected = parse_user_selected_modules(selected, organization_dir)
+        config.set_environment_variables()
+        if environment_warning := config.validate_environment():
+            warnings.append(environment_warning)
+        return config, warnings
+
+    @cached_property
+    def modules(self) -> ModuleDirectories:
+        user_selected_modules = self.config.environment.get_selected_modules({})
+        return ModuleDirectories.load(self.organization_dir, user_selected_modules)
+
+    @cached_property
+    def variables(self) -> BuildVariables:
+        return BuildVariables.load_raw(
+            self.config.variables, self.modules.available_paths, self.modules.selected.available_paths
+        )

cognite_toolkit/_cdf_tk/commands/build_v2/build_issues.py

@@ -0,0 +1,27 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from collections import UserList
+
+from pydantic import BaseModel
+
+from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning, WarningList
+
+
+class BuildIssue(BaseModel):
+    """Issue with the build. Can have a recommendation for the user to improve the build."""
+
+    description: str
+
+
+class BuildIssueList(UserList[BuildIssue]):
+    """List of build issues."""
+
+    @classmethod
+    def from_warning_list(cls, warning_list: WarningList[ToolkitWarning]) -> Self:
+        """Create a BuildIssueList from a WarningList."""
+        return cls([BuildIssue(description=warning.get_message()) for warning in warning_list])

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/transformation.py

@@ -26,6 +26,8 @@
 # limitations under the License.
 
 
+import random
+import time
 import warnings
 from collections import defaultdict
 from collections.abc import Callable, Hashable, Iterable, Sequence
@@ -427,25 +429,58 @@ class TransformationCRUD(ResourceCRUD[str, TransformationWrite, Transformation])
                     raise error from e
                 raise e
             except CogniteAPIError as e:
-                if "Failed to bind session using nonce for" in e.message and len(chunk) > 1:
-                    MediumSeverityWarning(
-                        f"Failed to create {len(chunk)} transformations in a batch due to nonce binding error. "
-                        "Trying to recover by creating them one by one."
-                    ).print_warning(console=self.console)
-                    # Retry one by one
-                    for item in chunk:
-                        recovered = self._execute_in_batches(items=[item], api_call=api_call)
-                        results.extend(recovered)
-                    if self.console:
-                        self.console.print(
-                            f"  [bold green]RECOVERED:[/] Successfully created {len(chunk)} transformations one by one."
-                        )
+                if "Failed to bind session using nonce" in e.message and len(chunk) > 1:
+                    results.extend(self._execute_one_by_one(chunk, api_call))
                 else:
                     raise
             else:
                 results.extend(chunk_results)
         return results
 
+    def _execute_one_by_one(
+        self,
+        chunk: Sequence[TransformationWrite],
+        api_call: Callable[[Sequence[TransformationWrite]], TransformationList],
+    ) -> TransformationList:
+        MediumSeverityWarning(
+            f"Failed to create {len(chunk)} transformations in a batch due to nonce binding error. "
+            "Trying to recover by creating them one by one."
+        ).print_warning(console=self.client.console)
+        # Retry one by one
+        failed_ids: list[str] = []
+        success_count = 0
+        delay = 0.3
+        self._sleep_with_jitter(delay, delay + 0.3)
+        results = TransformationList([])
+        for item in chunk:
+            try:
+                recovered = api_call([item])
+            except CogniteAPIError as e:
+                if "Failed to bind session using nonce" in e.message:
+                    failed_ids.append(item.external_id or "<missing>")
+                    self._sleep_with_jitter(delay, delay + 0.3)
+                else:
+                    raise
+            else:
+                results.extend(recovered)
+                success_count += 1
+        message = f"  [bold]RECOVERY COMPLETE:[/] Successfully created {success_count:,} transformations"
+        if failed_ids:
+            message += f", failed to create {len(failed_ids):,} transformations: {humanize_collection(failed_ids)}"
+        else:
+            message += "."
+        if failed_ids:
+            HighSeverityWarning(message).print_warning(include_timestamp=True, console=self.client.console)
+        else:
+            self.client.console.print(message)
+        return results
+
+    @staticmethod
+    def _sleep_with_jitter(base_delay: float, max_delay: float) -> None:
+        """Sleeps for a random duration between base_delay and max_delay (inclusive)."""
+        sleep_time = random.uniform(base_delay, max_delay)
+        time.sleep(sleep_time)
+
     def _update_nonce(self, items: Sequence[TransformationWrite]) -> None:
         for item in items:
             if not item.external_id:

cognite_toolkit/_cdf_tk/resource_classes/workflow_version.py

@@ -1,4 +1,5 @@
-from typing import Literal
+from abc import ABC
+from typing import Annotated, Literal
 
 from cognite.client.data_classes import WorkflowVersionUpsert
 from pydantic import Field, JsonValue
@@ -6,18 +7,141 @@ from pydantic import Field, JsonValue
 from .base import BaseModelResource, ToolkitResource
 
 
+class WorkflowVersionId(BaseModelResource):
+    workflow_external_id: str = Field(
+        max_length=255,
+        description="Identifier for a workflow. Must be unique for the project. No trailing or leading whitespace and no null characters allowed.",
+    )
+    version: str = Field(
+        max_length=255,
+        description="Identifier for a version. Must be unique for the workflow. No trailing or leading whitespace and no null characters allowed.",
+    )
+
+
+class CogniteFunctionRef(BaseModelResource):
+    external_id: str = Field(
+        description="The external id of the Cognite Function in the project. This can be either a function external ID or a reference like ${myTaskExternalId.output.someKey}"
+    )
+    data: str | JsonValue | None = Field(
+        None, description="Input data that will be passed to the Cognite Function. Limited to 100KB in size."
+    )
+
+
+class FunctionTaskParameters(BaseModelResource):
+    function: CogniteFunctionRef
+    is_async_complete: bool = Field(
+        False, description="Defines if the execution of the task should be completed asynchronously."
+    )
+
+
+class TransformationRef(BaseModelResource):
+    external_id: str = Field(
+        description="The external id of the Transformation in the project. This can be either a transformation external ID or a reference like ${myTaskExternalId.output.someKey}"
+    )
+    concurrency_policy: Literal["fail", "waitForCurrent", "restartAfterCurrent"] = Field(
+        "fail",
+        description="""Determines the behavior of the task if the Transformation is already running.
+
+fail: The task fails if another instance of the Transformation is currently running.
+waitForCurrent: The task will pause and wait for the already running Transformation to complete. Once completed, the task is completed. This mode is useful for preventing redundant Transformation runs.
+restartAfterCurrent: The task waits for the ongoing Transformation to finish. After completion, the task restarts the Transformation. This mode ensures that the most recent data can be used by following tasks.""",
+    )
+    use_transformation_credentials: bool = Field(
+        False,
+        description="If set to true, the transformation will run using the client credentials configured on the transformation. If set to false, the transformation will run using the client credentials used to trigger the workflow.",
+    )
+
+
+class TransformationTaskParameters(BaseModelResource):
+    transformation: TransformationRef
+
+
+class CDFRequest(BaseModelResource):
+    resource_path: str = Field(
+        description="The path of the request. The path should be prefixed by {cluster}.cognitedata.com/api/v1/project/{project} based on the relevant cluster and project. It can also contain references like ${myTaskExternalId.output.someKey}"
+    )
+    method: Literal["POST", "GET", "PUT"] | str = Field(
+        description="The HTTP method of the request. It can also be a reference like ${myTaskExternalId.output.someKey}"
+    )
+    query_parameters: dict[str, JsonValue] | str | None = Field(
+        None,
+        description="The query parameters of the request. It can also be a reference like ${myTaskExternalId.output.someKey}",
+    )
+    body: JsonValue | str | None = Field(
+        None, description="The body of the request. It can also be a reference like ${myTaskExternalId.output.someKey}"
+    )
+    request_timeout_in_millis: float | str | None = Field(
+        None,
+        description="The timeout for the request in milliseconds. It can also be a reference like ${myTaskExternalId.output.someKey}",
+    )
+    cdf_version_header: Literal["alpha", "beta"] | str | None = Field(
+        None, description="The Cognite Data Fusion version header to use for the request."
+    )
+
+
+class CDFTaskParameters(BaseModelResource):
+    cdf_request: CDFRequest
+
+
+class DynamicRef(BaseModelResource):
+    tasks: str = Field(
+        description="A Reference is an expression that allows dynamically injecting input to a task during execution. References can be used to reference the input of the Workflow, the output of a previous task in the Workflow, or the input of a previous task in the Workflow. Note that the injected value must be valid in the context of the property it is injected into. Example Task reference: ${myTaskExternalId.output.someKey} Example Workflow input reference: ${workflow.input.myKey}"
+    )
+
+
+class DynamicTaskParameters(BaseModelResource):
+    dynamic: DynamicRef = Field(description="Reference to another task to use as the definition for this task.")
+
+
+class SubworkflowRef(BaseModelResource):
+    tasks: "WorkflowVersionId | list[Task]" = Field(
+        description="Reference to the subworkflow to execute. This can be either a reference to an existing workflow version or an inline definition of tasks."
+    )
+
+
+class SubworkflowTaskParameters(BaseModelResource):
+    subworkflow: SubworkflowRef = Field(description="Reference to the subworkflow to execute.")
+
+
+class SimulatorInputUnit(BaseModelResource):
+    name: str = Field(description="Name of the unit.")
+
+
+class SimulatorInput(BaseModelResource):
+    reference_id: str = Field(description="Reference id of the value to override.")
+    value: str | int | float | list[str] | list[int] | list[float] = Field(
+        description="Override the value used for a simulation run."
+    )
+    unit: SimulatorInputUnit | None = Field(None, description="Override the unit of the value")
+
+
+class SimulationRef(BaseModelResource):
+    routine_external_id: str = Field(description="The external id of the routine to be executed.")
+    run_time: int | None = Field(
+        None,
+        description="Run time in milliseconds. Reference timestamp used for data pre-processing and data sampling.",
+    )
+    inputs: list[SimulatorInput] | None = Field(
+        None, description="List of inputs to be provided to the simulation.", max_length=200
+    )
+
+
+class SimulationTaskParameters(BaseModelResource):
+    simulation: SimulationRef = Field(description="Reference to the simulation to execute.")
+
+
 class TaskId(BaseModelResource):
     external_id: str = Field(
         max_length=255, description="The external ID provided by the client. Must be unique for the resource type."
     )
 
 
-class TaskDefinition(BaseModelResource):
+class TaskDefinition(BaseModelResource, ABC):
     external_id: str = Field(
         max_length=255,
         description="Identifier for the task. Must be unique within the version. No trailing or leading whitespace and no null characters allowed.",
     )
-    type: Literal["function", "transformation", "cdf", "dynamic", "subworkflow", "simulation"]
+    type: str
     name: str | None = Field(
         default=None,
         max_length=255,
@@ -28,7 +152,6 @@ class TaskDefinition(BaseModelResource):
         max_length=500,
         description="Description of the intention of the task",
     )
-    parameters: JsonValue = Field()
     retries: int = Field(
         3,
         ge=0,
@@ -52,13 +175,49 @@ class TaskDefinition(BaseModelResource):
     )
 
 
+class FunctionTask(TaskDefinition):
+    type: Literal["function"] = "function"
+    parameters: FunctionTaskParameters
+
+
+class TransformationTask(TaskDefinition):
+    type: Literal["transformation"] = "transformation"
+    parameters: TransformationTaskParameters
+
+
+class CDFTask(TaskDefinition):
+    type: Literal["cdfRequest"] = "cdfRequest"
+    parameters: CDFTaskParameters
+
+
+class DynamicTask(TaskDefinition):
+    type: Literal["dynamic"] = "dynamic"
+    parameters: DynamicTaskParameters
+
+
+class SubworkflowTask(TaskDefinition):
+    type: Literal["subworkflow"] = "subworkflow"
+    parameters: SubworkflowTaskParameters
+
+
+class SimulationTask(TaskDefinition):
+    type: Literal["simulation"] = "simulation"
+    parameters: SimulationTaskParameters
+
+
+Task = Annotated[
+    FunctionTask | TransformationTask | CDFTask | DynamicTask | SubworkflowTask | SimulationTask,
+    Field(discriminator="type"),
+]
+
+
 class WorkflowDefinition(BaseModelResource):
     description: str | None = Field(
         default=None,
         max_length=500,
         description="The description of the workflow version.",
     )
-    tasks: list[TaskDefinition]
+    tasks: list[Task]
 
 
 class WorkflowVersionYAML(ToolkitResource):