prefect-client 3.0.2__py3-none-any.whl → 3.0.4__py3-none-any.whl

prefect/_internal/retries.py

@@ -2,11 +2,9 @@ import asyncio
 from functools import wraps
 from typing import Any, Callable, Tuple, Type
 
-from prefect.logging.loggers import get_logger
+from prefect._internal._logging import logger
 from prefect.utilities.math import clamped_poisson_interval
 
-logger = get_logger("retries")
-
 
 def exponential_backoff_with_jitter(
     attempt: int, base_delay: float, max_delay: float

prefect/_internal/schemas/validators.py

@@ -70,7 +70,7 @@ def validate_schema(schema: dict):
     try:
         if schema is not None:
             # Most closely matches the schemas generated by pydantic
-            jsonschema.Draft4Validator.check_schema(schema)
+            jsonschema.Draft202012Validator.check_schema(schema)
     except jsonschema.SchemaError as exc:
         raise ValueError(
             "The provided schema is not a valid json schema. Schema error:"

prefect/blocks/core.py

@@ -40,7 +40,6 @@ from pydantic import (
 from pydantic.json_schema import GenerateJsonSchema
 from typing_extensions import Literal, ParamSpec, Self, get_args
 
-import prefect
 import prefect.exceptions
 from prefect.client.schemas import (
     DEFAULT_BLOCK_SCHEMA_VERSION,
@@ -52,6 +51,7 @@ from prefect.client.schemas import (
 from prefect.client.utilities import inject_client
 from prefect.events import emit_event
 from prefect.logging.loggers import disable_logger
+from prefect.plugins import load_prefect_collections
 from prefect.types import SecretDict
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.collections import listrepr, remove_nested_keys, visit_collection
@@ -86,7 +86,7 @@ class InvalidBlockRegistration(Exception):
     """
 
 
-def _collect_nested_reference_strings(obj: Dict):
+def _collect_nested_reference_strings(obj: Dict) -> List[str]:
     """
     Collects all nested reference strings (e.g. #/definitions/Model) from a given object.
     """
@@ -739,9 +739,10 @@ class Block(BaseModel, ABC):
         """
         Retrieve the block class implementation given a key.
         """
+
         # Ensure collections are imported and have the opportunity to register types
-        # before looking up the block class
-        prefect.plugins.load_prefect_collections()
+        # before looking up the block class, but only do this once
+        load_prefect_collections()
 
         return lookup_type(cls, key)
 

prefect/blocks/webhook.py

@@ -11,6 +11,7 @@ from prefect.utilities.urls import validate_restricted_url
 # Use a global HTTP transport to maintain a process-wide connection pool for
 # interservice requests
 _http_transport = AsyncHTTPTransport()
+_insecure_http_transport = AsyncHTTPTransport(verify=False)
 
 
 class Webhook(Block):
@@ -44,9 +45,16 @@ class Webhook(Block):
         default=True,
         description="Whether to allow notifications to private URLs. Defaults to True.",
     )
+    verify: bool = Field(
+        default=True,
+        description="Whether or not to enforce a secure connection to the webhook.",
+    )
 
     def block_initialization(self):
-        self._client = AsyncClient(transport=_http_transport)
+        if self.verify:
+            self._client = AsyncClient(transport=_http_transport)
+        else:
+            self._client = AsyncClient(transport=_insecure_http_transport)
 
     async def call(self, payload: Optional[dict] = None) -> Response:
         """

prefect/cache_policies.py

@@ -1,10 +1,19 @@
 import inspect
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional
+from copy import deepcopy
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, Optional, Union
+
+from typing_extensions import Self
 
 from prefect.context import TaskRunContext
 from prefect.utilities.hashing import hash_objects
 
+if TYPE_CHECKING:
+    from prefect.filesystems import WritableFileSystem
+    from prefect.locking.protocol import LockManager
+    from prefect.transactions import IsolationLevel
+
 
 @dataclass
 class CachePolicy:
@@ -12,6 +21,14 @@ class CachePolicy:
     Base class for all cache policies.
     """
 
+    key_storage: Union["WritableFileSystem", str, Path, None] = None
+    isolation_level: Union[
+        Literal["READ_COMMITTED", "SERIALIZABLE"],
+        "IsolationLevel",
+        None,
+    ] = None
+    lock_manager: Optional["LockManager"] = None
+
     @classmethod
     def from_cache_key_fn(
         cls, cache_key_fn: Callable[["TaskRunContext", Dict[str, Any]], Optional[str]]
@@ -21,6 +38,37 @@ class CachePolicy:
         """
         return CacheKeyFnPolicy(cache_key_fn=cache_key_fn)
 
+    def configure(
+        self,
+        key_storage: Union["WritableFileSystem", str, Path, None] = None,
+        lock_manager: Optional["LockManager"] = None,
+        isolation_level: Union[
+            Literal["READ_COMMITTED", "SERIALIZABLE"], "IsolationLevel", None
+        ] = None,
+    ) -> Self:
+        """
+        Configure the cache policy with the given key storage, lock manager, and isolation level.
+
+        Args:
+            key_storage: The storage to use for cache keys. If not provided,
+                the current key storage will be used.
+            lock_manager: The lock manager to use for the cache policy. If not provided,
+                the current lock manager will be used.
+            isolation_level: The isolation level to use for the cache policy. If not provided,
+                the current isolation level will be used.
+
+        Returns:
+            A new cache policy with the given key storage, lock manager, and isolation level.
+        """
+        new = deepcopy(self)
+        if key_storage is not None:
+            new.key_storage = key_storage
+        if lock_manager is not None:
+            new.lock_manager = lock_manager
+        if isolation_level is not None:
+            new.isolation_level = isolation_level
+        return new
+
     def compute_key(
         self,
         task_ctx: TaskRunContext,
@@ -30,35 +78,48 @@ class CachePolicy:
     ) -> Optional[str]:
         raise NotImplementedError
 
-    def __sub__(self, other: str) -> "CompoundCachePolicy":
+    def __sub__(self, other: str) -> "CachePolicy":
         if not isinstance(other, str):
             raise TypeError("Can only subtract strings from key policies.")
-        if isinstance(self, Inputs):
-            exclude = self.exclude or []
-            return Inputs(exclude=exclude + [other])
-        elif isinstance(self, CompoundCachePolicy):
-            new = Inputs(exclude=[other])
-            policies = self.policies or []
-            return CompoundCachePolicy(policies=policies + [new])
-        else:
-            new = Inputs(exclude=[other])
-            return CompoundCachePolicy(policies=[self, new])
-
-    def __add__(self, other: "CachePolicy") -> "CompoundCachePolicy":
+        new = Inputs(exclude=[other])
+        return CompoundCachePolicy(policies=[self, new])
+
+    def __add__(self, other: "CachePolicy") -> "CachePolicy":
         # adding _None is a no-op
         if isinstance(other, _None):
             return self
-        elif isinstance(self, _None):
-            return other
 
-        if isinstance(self, CompoundCachePolicy):
-            policies = self.policies or []
-            return CompoundCachePolicy(policies=policies + [other])
-        elif isinstance(other, CompoundCachePolicy):
-            policies = other.policies or []
-            return CompoundCachePolicy(policies=policies + [self])
-        else:
-            return CompoundCachePolicy(policies=[self, other])
+        if (
+            other.key_storage is not None
+            and self.key_storage is not None
+            and other.key_storage != self.key_storage
+        ):
+            raise ValueError(
+                "Cannot add CachePolicies with different storage locations."
+            )
+        if (
+            other.isolation_level is not None
+            and self.isolation_level is not None
+            and other.isolation_level != self.isolation_level
+        ):
+            raise ValueError(
+                "Cannot add CachePolicies with different isolation levels."
+            )
+        if (
+            other.lock_manager is not None
+            and self.lock_manager is not None
+            and other.lock_manager != self.lock_manager
+        ):
+            raise ValueError(
+                "Cannot add CachePolicies with different lock implementations."
+            )
+
+        return CompoundCachePolicy(
+            policies=[self, other],
+            key_storage=self.key_storage or other.key_storage,
+            isolation_level=self.isolation_level or other.isolation_level,
+            lock_manager=self.lock_manager or other.lock_manager,
+        )
 
 
 @dataclass
@@ -93,7 +154,7 @@ class CompoundCachePolicy(CachePolicy):
     Any keys that return `None` will be ignored.
     """
 
-    policies: Optional[list] = None
+    policies: List[CachePolicy] = field(default_factory=list)
 
     def compute_key(
         self,
@@ -103,7 +164,7 @@ class CompoundCachePolicy(CachePolicy):
         **kwargs,
     ) -> Optional[str]:
         keys = []
-        for policy in self.policies or []:
+        for policy in self.policies:
             policy_key = policy.compute_key(
                 task_ctx=task_ctx,
                 inputs=inputs,
@@ -133,6 +194,10 @@ class _None(CachePolicy):
     ) -> Optional[str]:
         return None
 
+    def __add__(self, other: "CachePolicy") -> "CachePolicy":
+        # adding _None is a no-op
+        return other
+
 
 @dataclass
 class TaskSource(CachePolicy):
@@ -208,7 +273,7 @@ class Inputs(CachePolicy):
     Policy that computes a cache key based on a hash of the runtime inputs provided to the task..
     """
 
-    exclude: Optional[list] = None
+    exclude: List[str] = field(default_factory=list)
 
     def compute_key(
         self,
@@ -230,6 +295,11 @@ class Inputs(CachePolicy):
 
         return hash_objects(hashed_inputs)
 
+    def __sub__(self, other: str) -> "CachePolicy":
+        if not isinstance(other, str):
+            raise TypeError("Can only subtract strings from key policies.")
+        return Inputs(exclude=self.exclude + [other])
+
 
 INPUTS = Inputs()
 NONE = _None()

prefect/client/cloud.py

@@ -17,6 +17,7 @@ from prefect.client.schemas.objects import (
 from prefect.exceptions import ObjectNotFound, PrefectException
 from prefect.settings import (
     PREFECT_API_KEY,
+    PREFECT_API_URL,
     PREFECT_CLOUD_API_URL,
     PREFECT_UNIT_TEST_MODE,
 )
@@ -110,6 +111,14 @@ class CloudClient:
         )
         return workspaces
 
+    async def read_current_workspace(self) -> Workspace:
+        workspaces = await self.read_workspaces()
+        current_api_url = PREFECT_API_URL.value()
+        for workspace in workspaces:
+            if workspace.api_url() == current_api_url.rstrip("/"):
+                return workspace
+        raise ValueError("Current workspace not found")
+
     async def read_worker_metadata(self) -> Dict[str, Any]:
         response = await self.get(
             f"{self.workspace_base_url}/collections/work_pool_types"

prefect/client/orchestration.py

@@ -86,6 +86,7 @@ from prefect.client.schemas.objects import (
     BlockSchema,
     BlockType,
     ConcurrencyLimit,
+    ConcurrencyOptions,
     Constant,
     DeploymentSchedule,
     Flow,
@@ -1639,6 +1640,7 @@ class PrefectClient:
         version: Optional[str] = None,
         schedules: Optional[List[DeploymentScheduleCreate]] = None,
         concurrency_limit: Optional[int] = None,
+        concurrency_options: Optional[ConcurrencyOptions] = None,
         parameters: Optional[Dict[str, Any]] = None,
         description: Optional[str] = None,
         work_queue_name: Optional[str] = None,
@@ -1697,6 +1699,7 @@ class PrefectClient:
             paused=paused,
             schedules=schedules or [],
             concurrency_limit=concurrency_limit,
+            concurrency_options=concurrency_options,
             pull_steps=pull_steps,
             enforce_parameter_schema=enforce_parameter_schema,
         )

prefect/client/schemas/actions.py

@@ -161,6 +161,10 @@ class DeploymentCreate(ActionBaseModel):
         default=None,
         description="The concurrency limit for the deployment.",
     )
+    concurrency_options: Optional[objects.ConcurrencyOptions] = Field(
+        default=None,
+        description="The concurrency options for the deployment.",
+    )
     enforce_parameter_schema: Optional[bool] = Field(
         default=None,
         description=(
@@ -237,6 +241,10 @@ class DeploymentUpdate(ActionBaseModel):
         default=None,
         description="The concurrency limit for the deployment.",
     )
+    concurrency_options: Optional[objects.ConcurrencyOptions] = Field(
+        default=None,
+        description="The concurrency options for the deployment.",
+    )
     tags: List[str] = Field(default_factory=list)
     work_queue_name: Optional[str] = Field(None)
     work_pool_name: Optional[str] = Field(

prefect/client/schemas/filters.py

@@ -506,7 +506,7 @@ class DeploymentFilterTags(PrefectBaseModel, OperatorMixin):
 
 
 class DeploymentFilterConcurrencyLimit(PrefectBaseModel):
-    """Filter by `Deployment.concurrency_limit`."""
+    """DEPRECATED: Prefer `Deployment.concurrency_limit_id` over `Deployment.concurrency_limit`."""
 
     ge_: Optional[int] = Field(
         default=None,
@@ -538,7 +538,9 @@ class DeploymentFilter(PrefectBaseModel, OperatorMixin):
         default=None, description="Filter criteria for `Deployment.work_queue_name`"
     )
     concurrency_limit: Optional[DeploymentFilterConcurrencyLimit] = Field(
-        default=None, description="Filter criteria for `Deployment.concurrency_limit`"
+        default=None,
+        description="DEPRECATED: Prefer `Deployment.concurrency_limit_id` over `Deployment.concurrency_limit`. If provided, will be ignored for backwards-compatibility. Will be removed after December 2024.",
+        deprecated=True,
     )
 
 

prefect/client/schemas/objects.py

@@ -141,6 +141,30 @@ class WorkQueueStatus(AutoEnum):
     PAUSED = AutoEnum.auto()
 
 
+class ConcurrencyLimitStrategy(AutoEnum):
+    """Enumeration of concurrency limit strategies."""
+
+    ENQUEUE = AutoEnum.auto()
+    CANCEL_NEW = AutoEnum.auto()
+
+
+class ConcurrencyOptions(PrefectBaseModel):
+    """
+    Class for storing the concurrency config in database.
+    """
+
+    collision_strategy: ConcurrencyLimitStrategy
+
+
+class ConcurrencyLimitConfig(PrefectBaseModel):
+    """
+    Class for storing the concurrency limit config in database.
+    """
+
+    limit: int
+    collision_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.ENQUEUE
+
+
 class StateDetails(PrefectBaseModel):
     flow_run_id: Optional[UUID] = None
     task_run_id: Optional[UUID] = None
@@ -207,7 +231,9 @@ class State(ObjectBaseModel, Generic[R]):
 
         Args:
             raise_on_failure: a boolean specifying whether to raise an exception
-                if the state is of type `FAILED` and the underlying data is an exception
+                if the state is of type `FAILED` and the underlying data is an exception. When flow
+                was run in a different memory space (using `run_deployment`), this will only raise
+                if `fetch` is `True`.
             fetch: a boolean specifying whether to resolve references to persisted
                 results into data. For synchronous users, this defaults to `True`.
                 For asynchronous users, this defaults to `False` for backwards
@@ -273,6 +299,15 @@ class State(ObjectBaseModel, Generic[R]):
             >>> state = await my_flow(return_state=True)
             >>> await state.result()
             hello
+
+            Get the result with `raise_on_failure` from a flow run in a different memory space
+
+            >>> @flow
+            >>> async def my_flow():
+            >>>     raise ValueError("oh no!")
+            >>> my_flow.deploy("my_deployment/my_flow")
+            >>> flow_run = run_deployment("my_deployment/my_flow")
+            >>> await flow_run.state.result(raise_on_failure=True, fetch=True) # Raises `ValueError("oh no!")`
         """
         from prefect.states import get_state_result
 

prefect/client/schemas/responses.py

@@ -314,11 +314,25 @@ class DeploymentResponse(ObjectBaseModel):
         default=..., description="The flow id associated with the deployment."
     )
     concurrency_limit: Optional[int] = Field(
-        default=None, description="The concurrency limit for the deployment."
+        default=None,
+        description="DEPRECATED: Prefer `global_concurrency_limit`. Will always be None for backwards compatibility. Will be removed after December 2024.",
+        deprecated=True,
+    )
+    global_concurrency_limit: Optional["GlobalConcurrencyLimitResponse"] = Field(
+        default=None,
+        description="The global concurrency limit object for enforcing the maximum number of flow runs that can be active at once.",
+    )
+    concurrency_options: Optional[objects.ConcurrencyOptions] = Field(
+        default=None,
+        description="The concurrency options for the deployment.",
     )
     paused: bool = Field(
         default=False, description="Whether or not the deployment is paused."
     )
+    concurrency_options: Optional[objects.ConcurrencyOptions] = Field(
+        default=None,
+        description="The concurrency options for the deployment.",
+    )
     schedules: List[objects.DeploymentSchedule] = Field(
         default_factory=list, description="A list of schedules for the deployment."
     )

prefect/client/subscriptions.py

@@ -84,13 +84,13 @@ class Subscription(Generic[S]):
             AssertionError,
             websockets.exceptions.ConnectionClosedError,
         ) as e:
-            if isinstance(e, AssertionError) or e.code == WS_1008_POLICY_VIOLATION:
+            if isinstance(e, AssertionError) or e.rcvd.code == WS_1008_POLICY_VIOLATION:
                 if isinstance(e, AssertionError):
                     reason = e.args[0]
                 elif isinstance(e, websockets.exceptions.ConnectionClosedError):
-                    reason = e.reason
+                    reason = e.rcvd.reason
 
-            if isinstance(e, AssertionError) or e.code == WS_1008_POLICY_VIOLATION:
+            if isinstance(e, AssertionError) or e.rcvd.code == WS_1008_POLICY_VIOLATION:
                 raise Exception(
                     "Unable to authenticate to the subscription. Please "
                     "ensure the provided `PREFECT_API_KEY` you are using is "

prefect/context.py

@@ -9,7 +9,6 @@ For more user-accessible information about the current run, see [`prefect.runtim
 import os
 import sys
 import warnings
-import weakref
 from contextlib import ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar, Token
 from pathlib import Path
@@ -353,10 +352,7 @@ class EngineContext(RunContext):
 
     # Tracking for result from task runs in this flow run for dependency tracking
     # Holds the ID of the object returned by the task run and task run state
-    # This is a weakref dictionary to avoid undermining garbage collection
-    task_run_results: Mapping[int, State] = Field(
-        default_factory=weakref.WeakValueDictionary
-    )
+    task_run_results: Mapping[int, State] = Field(default_factory=dict)
 
     # Events worker to emit events
     events: Optional[EventsWorker] = None

prefect/deployments/base.py

@@ -20,6 +20,7 @@ import yaml
 from ruamel.yaml import YAML
 
 from prefect.client.schemas.actions import DeploymentScheduleCreate
+from prefect.client.schemas.objects import ConcurrencyLimitStrategy
 from prefect.client.schemas.schedules import IntervalSchedule
 from prefect.logging import get_logger
 from prefect.settings import PREFECT_DEBUG_MODE
@@ -277,6 +278,17 @@ def _format_deployment_for_saving_to_prefect_file(
 
         deployment["schedules"] = schedules
 
+    if deployment.get("concurrency_limit"):
+        concurrency_limit = deployment["concurrency_limit"]
+        if isinstance(concurrency_limit, dict):
+            if isinstance(
+                concurrency_limit["collision_strategy"], ConcurrencyLimitStrategy
+            ):
+                concurrency_limit["collision_strategy"] = str(
+                    concurrency_limit["collision_strategy"].value
+                )
+        deployment["concurrency_limit"] = concurrency_limit
+
     return deployment
 
 

prefect/deployments/runner.py

@@ -54,6 +54,7 @@ from prefect._internal.schemas.validators import (
 )
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.actions import DeploymentScheduleCreate
+from prefect.client.schemas.objects import ConcurrencyLimitConfig, ConcurrencyOptions
 from prefect.client.schemas.schedules import (
     SCHEDULE_TYPES,
     construct_schedule,
@@ -147,6 +148,10 @@ class RunnerDeployment(BaseModel):
         default=None,
         description="The maximum number of concurrent runs of this deployment.",
     )
+    concurrency_options: Optional[ConcurrencyOptions] = Field(
+        default=None,
+        description="The concurrency limit config for the deployment.",
+    )
     paused: Optional[bool] = Field(
         default=None, description="Whether or not the deployment is paused."
     )
@@ -279,6 +284,7 @@ class RunnerDeployment(BaseModel):
                 paused=self.paused,
                 schedules=self.schedules,
                 concurrency_limit=self.concurrency_limit,
+                concurrency_options=self.concurrency_options,
                 parameters=self.parameters,
                 description=self.description,
                 tags=self.tags,
@@ -437,7 +443,7 @@ class RunnerDeployment(BaseModel):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        concurrency_limit: Optional[int] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -488,11 +494,20 @@ class RunnerDeployment(BaseModel):
 
         job_variables = job_variables or {}
 
+        if isinstance(concurrency_limit, ConcurrencyLimitConfig):
+            concurrency_options = {
+                "collision_strategy": concurrency_limit.collision_strategy
+            }
+            concurrency_limit = concurrency_limit.limit
+        else:
+            concurrency_options = None
+
         deployment = cls(
             name=Path(name).stem,
             flow_name=flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,
+            concurrency_options=concurrency_options,
             paused=paused,
             tags=tags or [],
             triggers=triggers or [],
@@ -559,6 +574,7 @@ class RunnerDeployment(BaseModel):
         cls,
         entrypoint: str,
         name: str,
+        flow_name: Optional[str] = None,
         interval: Optional[
             Union[Iterable[Union[int, float, timedelta]], int, float, timedelta]
         ] = None,
@@ -566,7 +582,7 @@ class RunnerDeployment(BaseModel):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        concurrency_limit: Optional[int] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -584,6 +600,7 @@ class RunnerDeployment(BaseModel):
             entrypoint:  The path to a file containing a flow and the name of the flow function in
                 the format `./path/to/file.py:flow_func_name`.
             name: A name for the deployment
+            flow_name: The name of the flow to deploy
             interval: An interval on which to execute the current flow. Accepts either a number
                 or a timedelta object. If a number is given, it will be interpreted as seconds.
             cron: A cron schedule of when to execute runs of this flow.
@@ -619,11 +636,20 @@ class RunnerDeployment(BaseModel):
             schedules=schedules,
         )
 
+        if isinstance(concurrency_limit, ConcurrencyLimitConfig):
+            concurrency_options = {
+                "collision_strategy": concurrency_limit.collision_strategy
+            }
+            concurrency_limit = concurrency_limit.limit
+        else:
+            concurrency_options = None
+
         deployment = cls(
             name=Path(name).stem,
-            flow_name=flow.name,
+            flow_name=flow_name or flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,
+            concurrency_options=concurrency_options,
             paused=paused,
             tags=tags or [],
             triggers=triggers or [],
@@ -649,6 +675,7 @@ class RunnerDeployment(BaseModel):
         storage: RunnerStorage,
         entrypoint: str,
         name: str,
+        flow_name: Optional[str] = None,
         interval: Optional[
             Union[Iterable[Union[int, float, timedelta]], int, float, timedelta]
         ] = None,
@@ -656,7 +683,7 @@ class RunnerDeployment(BaseModel):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        concurrency_limit: Optional[int] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -675,6 +702,7 @@ class RunnerDeployment(BaseModel):
             entrypoint:  The path to a file containing a flow and the name of the flow function in
                 the format `./path/to/file.py:flow_func_name`.
             name: A name for the deployment
+            flow_name: The name of the flow to deploy
             storage: A storage object to use for retrieving flow code. If not provided, a
                 URL must be provided.
             interval: An interval on which to execute the current flow. Accepts either a number
@@ -706,6 +734,14 @@ class RunnerDeployment(BaseModel):
             schedules=schedules,
         )
 
+        if isinstance(concurrency_limit, ConcurrencyLimitConfig):
+            concurrency_options = {
+                "collision_strategy": concurrency_limit.collision_strategy
+            }
+            concurrency_limit = concurrency_limit.limit
+        else:
+            concurrency_options = None
+
         job_variables = job_variables or {}
 
         with tempfile.TemporaryDirectory() as tmpdir:
@@ -719,9 +755,10 @@ class RunnerDeployment(BaseModel):
 
         deployment = cls(
             name=Path(name).stem,
-            flow_name=flow.name,
+            flow_name=flow_name or flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,
+            concurrency_options=concurrency_options,
             paused=paused,
             tags=tags or [],
             triggers=triggers or [],