flyte 2.0.0b22__py3-none-any.whl → 2.0.0b23__py3-none-any.whl

flyte/_protos/workflow/trigger_service_pb2_grpc.py

@@ -0,0 +1,281 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from flyte._protos.workflow import trigger_service_pb2 as workflow_dot_trigger__service__pb2
+
+
+class TriggerServiceStub(object):
+    """TriggerService provides an interface for managing triggers.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.DeployTrigger = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/DeployTrigger',
+                request_serializer=workflow_dot_trigger__service__pb2.DeployTriggerRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.DeployTriggerResponse.FromString,
+                )
+        self.GetTriggerDetails = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/GetTriggerDetails',
+                request_serializer=workflow_dot_trigger__service__pb2.GetTriggerDetailsRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.GetTriggerDetailsResponse.FromString,
+                )
+        self.GetTriggerRevisionDetails = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/GetTriggerRevisionDetails',
+                request_serializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionDetailsRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionDetailsResponse.FromString,
+                )
+        self.ListTriggers = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/ListTriggers',
+                request_serializer=workflow_dot_trigger__service__pb2.ListTriggersRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.ListTriggersResponse.FromString,
+                )
+        self.GetTriggerRevisionHistory = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/GetTriggerRevisionHistory',
+                request_serializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionHistoryRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionHistoryResponse.FromString,
+                )
+        self.UpdateTriggers = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/UpdateTriggers',
+                request_serializer=workflow_dot_trigger__service__pb2.UpdateTriggersRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.UpdateTriggersResponse.FromString,
+                )
+        self.DeleteTriggers = channel.unary_unary(
+                '/cloudidl.workflow.TriggerService/DeleteTriggers',
+                request_serializer=workflow_dot_trigger__service__pb2.DeleteTriggersRequest.SerializeToString,
+                response_deserializer=workflow_dot_trigger__service__pb2.DeleteTriggersResponse.FromString,
+                )
+
+
+class TriggerServiceServicer(object):
+    """TriggerService provides an interface for managing triggers.
+    """
+
+    def DeployTrigger(self, request, context):
+        """Create if trigger didn't exist previously.
+        Update if it already exists.
+        Re-create(or undelete) if it was soft-deleted.
+        Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`.
+        If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend.
+        If trigger is found, client should set `trigger.id.revision` to the <latest>.
+        Backend validates that version is the latest and creates a new revision of the trigger.
+        Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTriggerDetails(self, request, context):
+        """Get detailed info about the latest trigger revision
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTriggerRevisionDetails(self, request, context):
+        """Get detailed info about a specific trigger revision
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListTriggers(self, request, context):
+        """List basic info about triggers based on various filtering and sorting rules.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetTriggerRevisionHistory(self, request, context):
+        """GetTriggerRevisionHistory returns all revisions for a given trigger
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def UpdateTriggers(self, request, context):
+        """Update some trigger spec fields for multiple triggers at once
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DeleteTriggers(self, request, context):
+        """Soft-delete multiple triggers at once.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_TriggerServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'DeployTrigger': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeployTrigger,
+                    request_deserializer=workflow_dot_trigger__service__pb2.DeployTriggerRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.DeployTriggerResponse.SerializeToString,
+            ),
+            'GetTriggerDetails': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTriggerDetails,
+                    request_deserializer=workflow_dot_trigger__service__pb2.GetTriggerDetailsRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.GetTriggerDetailsResponse.SerializeToString,
+            ),
+            'GetTriggerRevisionDetails': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTriggerRevisionDetails,
+                    request_deserializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionDetailsRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionDetailsResponse.SerializeToString,
+            ),
+            'ListTriggers': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTriggers,
+                    request_deserializer=workflow_dot_trigger__service__pb2.ListTriggersRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.ListTriggersResponse.SerializeToString,
+            ),
+            'GetTriggerRevisionHistory': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTriggerRevisionHistory,
+                    request_deserializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionHistoryRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.GetTriggerRevisionHistoryResponse.SerializeToString,
+            ),
+            'UpdateTriggers': grpc.unary_unary_rpc_method_handler(
+                    servicer.UpdateTriggers,
+                    request_deserializer=workflow_dot_trigger__service__pb2.UpdateTriggersRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.UpdateTriggersResponse.SerializeToString,
+            ),
+            'DeleteTriggers': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeleteTriggers,
+                    request_deserializer=workflow_dot_trigger__service__pb2.DeleteTriggersRequest.FromString,
+                    response_serializer=workflow_dot_trigger__service__pb2.DeleteTriggersResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'cloudidl.workflow.TriggerService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class TriggerService(object):
+    """TriggerService provides an interface for managing triggers.
+    """
+
+    @staticmethod
+    def DeployTrigger(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/DeployTrigger',
+            workflow_dot_trigger__service__pb2.DeployTriggerRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.DeployTriggerResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetTriggerDetails(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/GetTriggerDetails',
+            workflow_dot_trigger__service__pb2.GetTriggerDetailsRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.GetTriggerDetailsResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetTriggerRevisionDetails(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/GetTriggerRevisionDetails',
+            workflow_dot_trigger__service__pb2.GetTriggerRevisionDetailsRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.GetTriggerRevisionDetailsResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def ListTriggers(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/ListTriggers',
+            workflow_dot_trigger__service__pb2.ListTriggersRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.ListTriggersResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetTriggerRevisionHistory(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/GetTriggerRevisionHistory',
+            workflow_dot_trigger__service__pb2.GetTriggerRevisionHistoryRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.GetTriggerRevisionHistoryResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def UpdateTriggers(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/UpdateTriggers',
+            workflow_dot_trigger__service__pb2.UpdateTriggersRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.UpdateTriggersResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def DeleteTriggers(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TriggerService/DeleteTriggers',
+            workflow_dot_trigger__service__pb2.DeleteTriggersRequest.SerializeToString,
+            workflow_dot_trigger__service__pb2.DeleteTriggersResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

flyte/_run.py

@@ -90,9 +90,10 @@ class _Runner:
         env_vars: Dict[str, str] | None = None,
         labels: Dict[str, str] | None = None,
         annotations: Dict[str, str] | None = None,
-        interruptible: bool = False,
+        interruptible: bool | None = None,
         log_level: int | None = None,
         disable_run_cache: bool = False,
+        queue: Optional[str] = None,
     ):
         from flyte._tools import ipython_check
 
@@ -111,8 +112,8 @@ class _Runner:
         self._copy_bundle_to = copy_bundle_to
         self._interactive_mode = interactive_mode if interactive_mode else ipython_check()
         self._raw_data_path = raw_data_path
-        self._metadata_path = metadata_path or "/tmp"
-        self._run_base_dir = run_base_dir or "/tmp/base"
+        self._metadata_path = metadata_path
+        self._run_base_dir = run_base_dir
         self._overwrite_cache = overwrite_cache
         self._project = project
         self._domain = domain
@@ -122,6 +123,7 @@ class _Runner:
         self._interruptible = interruptible
         self._log_level = log_level
         self._disable_run_cache = disable_run_cache
+        self._queue = queue
 
     @requires_initialization
     async def _run_remote(self, obj: TaskTemplate[P, R] | LazyEntity, *args: P.args, **kwargs: P.kwargs) -> Run:
@@ -150,6 +152,7 @@ class _Runner:
             version = task.pb2.task_id.version
             code_bundle = None
         else:
+            task = cast(TaskTemplate[P, R], obj)
             if obj.parent_env is None:
                 raise ValueError("Task is not attached to an environment. Please attach the task to an environment")
 
@@ -204,10 +207,11 @@ class _Runner:
             inputs = await convert_from_native_to_inputs(obj.native_interface, *args, **kwargs)
 
         env = self._env_vars or {}
-        if self._log_level:
-            env["LOG_LEVEL"] = str(self._log_level)
-        else:
-            env["LOG_LEVEL"] = str(logger.getEffectiveLevel())
+        if env.get("LOG_LEVEL") is None:
+            if self._log_level:
+                env["LOG_LEVEL"] = str(self._log_level)
+            else:
+                env["LOG_LEVEL"] = str(logger.getEffectiveLevel())
 
         if not self._dry_run:
             if get_client() is None:
@@ -263,10 +267,13 @@ class _Runner:
                         inputs=inputs.proto_inputs,
                         run_spec=run_definition_pb2.RunSpec(
                             overwrite_cache=self._overwrite_cache,
-                            interruptible=wrappers_pb2.BoolValue(value=self._interruptible),
+                            interruptible=wrappers_pb2.BoolValue(value=self._interruptible)
+                            if self._interruptible is not None
+                            else None,
                             annotations=annotations,
                             labels=labels,
                             envs=env_kv,
+                            cluster=self._queue or task.queue,
                         ),
                     ),
                 )
@@ -385,6 +392,7 @@ class _Runner:
                 " flyte.with_runcontext(run_base_dir='s3://bucket/metadata/outputs')",
             )
         output_path = self._run_base_dir
+        run_base_dir = self._run_base_dir
         raw_data_path = f"{output_path}/rd/{random_id}"
         raw_data_path_obj = RawDataPath(path=raw_data_path)
         checkpoint_path = f"{raw_data_path}/checkpoint"
@@ -401,7 +409,7 @@ class _Runner:
                 version=version if version else "na",
                 raw_data_path=raw_data_path_obj,
                 compiled_image_cache=image_cache,
-                run_base_dir=self._run_base_dir,
+                run_base_dir=run_base_dir,
                 report=flyte.report.Report(name=action.name),
             )
             async with ctx.replace_task_context(tctx):
@@ -426,6 +434,18 @@ class _Runner:
         else:
             action = ActionID(name=self._name)
 
+        metadata_path = self._metadata_path
+        if metadata_path is None:
+            metadata_path = pathlib.Path("/") / "tmp" / "flyte" / "metadata" / action.name
+        else:
+            metadata_path = pathlib.Path(metadata_path) / action.name
+        output_path = metadata_path / "a0"
+        if self._raw_data_path is None:
+            path = pathlib.Path("/") / "tmp" / "flyte" / "raw_data" / action.name
+            raw_data_path = RawDataPath(path=str(path))
+        else:
+            raw_data_path = RawDataPath(path=self._raw_data_path)
+
         ctx = internal_ctx()
         tctx = TaskContext(
             action=action,
@@ -434,10 +454,10 @@ class _Runner:
                 checkpoint_path=internal_ctx().raw_data.path,
             ),
             code_bundle=None,
-            output_path=self._metadata_path,
-            run_base_dir=self._metadata_path,
+            output_path=str(output_path),
+            run_base_dir=str(metadata_path),
             version="na",
-            raw_data_path=internal_ctx().raw_data,
+            raw_data_path=raw_data_path,
             compiled_image_cache=None,
             report=Report(name=action.name),
             mode="local",
@@ -469,7 +489,7 @@ class _Runner:
 
             @property
             def url(self) -> str:
-                return "local-run"
+                return str(metadata_path)
 
             def wait(
                 self,
@@ -550,9 +570,10 @@ def with_runcontext(
     env_vars: Dict[str, str] | None = None,
     labels: Dict[str, str] | None = None,
     annotations: Dict[str, str] | None = None,
-    interruptible: bool = False,
+    interruptible: bool | None = None,
     log_level: int | None = None,
     disable_run_cache: bool = False,
+    queue: Optional[str] = None,
 ) -> _Runner:
     """
     Launch a new run with the given parameters as the context.
@@ -590,15 +611,20 @@ def with_runcontext(
     :param env_vars: Optional Environment variables to set for the run
     :param labels: Optional Labels to set for the run
     :param annotations: Optional Annotations to set for the run
-    :param interruptible: Optional If true, the run can be interrupted by the user.
+    :param interruptible: Optional If true, the run can be scheduled on interruptible instances and false implies
+        that all tasks in the run should only be scheduled on non-interruptible instances. If not specified the
+        original setting on all tasks is retained.
     :param log_level: Optional Log level to set for the run. If not provided, it will be set to the default log level
         set using `flyte.init()`
     :param disable_run_cache: Optional If true, the run cache will be disabled. This is useful for testing purposes.
+    :param queue: Optional The queue to use for the run. This is used to specify the cluster to use for the run.
 
     :return: runner
     """
     if mode == "hybrid" and not name and not run_base_dir:
         raise ValueError("Run name and run base dir are required for hybrid mode")
+    if copy_style == "none" and not version:
+        raise ValueError("Version is required when copy_style is 'none'")
     return _Runner(
         force_mode=mode,
         name=name,
@@ -619,6 +645,7 @@ def with_runcontext(
         domain=domain,
         log_level=log_level,
         disable_run_cache=disable_run_cache,
+        queue=queue,
     )
 
 

flyte/_task.py

@@ -15,6 +15,7 @@ from typing import (
     Literal,
     Optional,
     ParamSpec,
+    Tuple,
     TypeAlias,
     TypeVar,
     Union,
@@ -38,6 +39,8 @@ from .models import MAX_INLINE_IO_BYTES, NativeInterface, SerializationContext
 if TYPE_CHECKING:
     from flyteidl.core.tasks_pb2 import DataLoadingConfig
 
+    from flyte.trigger import Trigger
+
     from ._task_environment import TaskEnvironment
 
 P = ParamSpec("P")  # capture the function's parameters
@@ -69,8 +72,8 @@ class TaskTemplate(Generic[P, R]):
     version with flyte installed
     :param resources: Optional The resources to use for the task
     :param cache: Optional The cache policy for the task, defaults to auto, which will cache the results of the task.
-    :param interruptable: Optional The interruptable policy for the task, defaults to False, which means the task
-     will not be scheduled on interruptable nodes. If set to True, the task will be scheduled on interruptable nodes,
+    :param interruptible: Optional The interruptible policy for the task, defaults to False, which means the task
+     will not be scheduled on interruptible nodes. If set to True, the task will be scheduled on interruptible nodes,
      and the code should handle interruptions and resumptions.
     :param retries: Optional The number of retries for the task, defaults to 0, which means no retries.
     :param reusable: Optional The reusability policy for the task, defaults to None, which means the task environment
@@ -81,6 +84,9 @@ class TaskTemplate(Generic[P, R]):
     :param timeout: Optional The timeout for the task.
     :param max_inline_io_bytes: Maximum allowed size (in bytes) for all inputs and outputs passed directly to the task
         (e.g., primitives, strings, dicts). Does not apply to files, directories, or dataframes.
+    :param pod_template: Optional The pod template to use for the task.
+    :param report: Optional Whether to report the task execution to the Flyte console, defaults to False.
+    :param queue: Optional The queue to use for the task. If not provided, the default queue will be used.
     """
 
     name: str
@@ -90,8 +96,8 @@ class TaskTemplate(Generic[P, R]):
     task_type_version: int = 0
     image: Union[str, Image, Literal["auto"]] = "auto"
     resources: Optional[Resources] = None
-    cache: CacheRequest = "auto"
-    interruptable: bool = False
+    cache: CacheRequest = "disable"
+    interruptible: bool = False
     retries: Union[int, RetryStrategy] = 0
     reusable: Union[ReusePolicy, None] = None
     docs: Optional[Documentation] = None
@@ -100,10 +106,12 @@ class TaskTemplate(Generic[P, R]):
     timeout: Optional[TimeoutType] = None
     pod_template: Optional[Union[str, PodTemplate]] = None
     report: bool = False
+    queue: Optional[str] = None
 
     parent_env: Optional[weakref.ReferenceType[TaskEnvironment]] = None
     ref: bool = field(default=False, init=False, repr=False, compare=False)
     max_inline_io_bytes: int = MAX_INLINE_IO_BYTES
+    triggers: Tuple[Trigger, ...] = field(default_factory=tuple)
 
     # Only used in python 3.10 and 3.11, where we cannot use markcoroutinefunction
     _call_as_synchronous: bool = False
@@ -327,11 +335,30 @@ class TaskTemplate(Generic[P, R]):
         secrets: Optional[SecretRequest] = None,
         max_inline_io_bytes: int | None = None,
         pod_template: Optional[Union[str, PodTemplate]] = None,
+        queue: Optional[str] = None,
+        interruptible: Optional[bool] = None,
         **kwargs: Any,
     ) -> TaskTemplate:
         """
         Override various parameters of the task template. This allows for dynamic configuration of the task
         when it is called, such as changing the image, resources, cache policy, etc.
+
+        :param short_name: Optional override for the short name of the task.
+        :param resources: Optional override for the resources to use for the task.
+        :param cache: Optional override for the cache policy for the task.
+        :param retries: Optional override for the number of retries for the task.
+        :param timeout: Optional override for the timeout for the task.
+        :param reusable: Optional override for the reusability policy for the task.
+        :param env_vars: Optional override for the environment variables to set for the task.
+        :param secrets: Optional override for the secrets that will be injected into the task at runtime.
+        :param max_inline_io_bytes: Optional override for the maximum allowed size (in bytes) for all inputs and outputs
+         passed directly to the task.
+        :param pod_template: Optional override for the pod template to use for the task.
+        :param queue: Optional override for the queue to use for the task.
+        :param kwargs: Additional keyword arguments for further overrides. Some fields like name, image, docs,
+         and interface cannot be overridden.
+
+        :return: A new TaskTemplate instance with the overridden parameters.
         """
         cache = cache or self.cache
         retries = retries or self.retries
@@ -366,6 +393,8 @@ class TaskTemplate(Generic[P, R]):
         env_vars = env_vars or self.env_vars
         secrets = secrets or self.secrets
 
+        interruptible = interruptible if interruptible is not None else self.interruptible
+
         for k, v in kwargs.items():
             if k == "name":
                 raise ValueError("Name cannot be overridden")
@@ -388,6 +417,8 @@ class TaskTemplate(Generic[P, R]):
             secrets=secrets,
             max_inline_io_bytes=max_inline_io_bytes,
             pod_template=pod_template,
+            interruptible=interruptible,
+            queue=queue or self.queue,
             **kwargs,
         )