prefect-client 2.18.3__py3-none-any.whl → 2.19.1__py3-none-any.whl

prefect/client/schemas/actions.py

@@ -19,14 +19,17 @@ from prefect._internal.schemas.serializers import orjson_dumps_extra_compatible
 from prefect._internal.schemas.validators import (
     raise_on_name_alphanumeric_dashes_only,
     raise_on_name_alphanumeric_underscores_only,
+    raise_on_name_with_banned_characters,
     remove_old_deployment_fields,
     return_none_schedule,
     validate_message_template_variables,
     validate_name_present_on_nonanonymous_blocks,
+    validate_schedule_max_scheduled_runs,
 )
 from prefect.client.schemas.objects import StateDetails, StateType
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
-from prefect.types import NonNegativeInteger
+from prefect.settings import PREFECT_DEPLOYMENT_SCHEDULE_MAX_SCHEDULED_RUNS
+from prefect.types import NonNegativeFloat, NonNegativeInteger, PositiveInteger
 from prefect.utilities.collections import listrepr
 from prefect.utilities.pydantic import get_class_fields_only
 
@@ -101,6 +104,24 @@ class DeploymentScheduleCreate(ActionBaseModel):
     active: bool = Field(
         default=True, description="Whether or not the schedule is active."
     )
+    max_active_runs: Optional[PositiveInteger] = Field(
+        default=None,
+        description="The maximum number of active runs for the schedule.",
+    )
+    max_scheduled_runs: Optional[PositiveInteger] = Field(
+        default=None,
+        description="The maximum number of scheduled runs for the schedule.",
+    )
+    catchup: bool = Field(
+        default=False,
+        description="Whether or not a worker should catch up on Late runs for the schedule.",
+    )
+
+    @validator("max_scheduled_runs")
+    def validate_max_scheduled_runs(cls, v):
+        return validate_schedule_max_scheduled_runs(
+            v, PREFECT_DEPLOYMENT_SCHEDULE_MAX_SCHEDULED_RUNS.value()
+        )
 
 
 class DeploymentScheduleUpdate(ActionBaseModel):
@@ -111,6 +132,27 @@ class DeploymentScheduleUpdate(ActionBaseModel):
         default=True, description="Whether or not the schedule is active."
     )
 
+    max_active_runs: Optional[PositiveInteger] = Field(
+        default=None,
+        description="The maximum number of active runs for the schedule.",
+    )
+
+    max_scheduled_runs: Optional[PositiveInteger] = Field(
+        default=None,
+        description="The maximum number of scheduled runs for the schedule.",
+    )
+
+    catchup: Optional[bool] = Field(
+        default=None,
+        description="Whether or not a worker should catch up on Late runs for the schedule.",
+    )
+
+    @validator("max_scheduled_runs")
+    def validate_max_scheduled_runs(cls, v):
+        return validate_schedule_max_scheduled_runs(
+            v, PREFECT_DEPLOYMENT_SCHEDULE_MAX_SCHEDULED_RUNS.value()
+        )
+
 
 class DeploymentCreate(DeprecatedInfraOverridesField, ActionBaseModel):
     """Data used by the Prefect REST API to create a deployment."""
@@ -704,7 +746,7 @@ class GlobalConcurrencyLimitCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a global concurrency limit."""
 
     name: str = Field(description="The name of the global concurrency limit.")
-    limit: int = Field(
+    limit: NonNegativeInteger = Field(
         description=(
             "The maximum number of slots that can be occupied on this concurrency"
             " limit."
@@ -714,11 +756,11 @@ class GlobalConcurrencyLimitCreate(ActionBaseModel):
         default=True,
         description="Whether or not the concurrency limit is in an active state.",
     )
-    active_slots: Optional[int] = Field(
+    active_slots: Optional[NonNegativeInteger] = Field(
         default=0,
         description="Number of tasks currently using a concurrency slot.",
     )
-    slot_decay_per_second: Optional[float] = Field(
+    slot_decay_per_second: Optional[NonNegativeFloat] = Field(
         default=0.0,
         description=(
             "Controls the rate at which slots are released when the concurrency limit"
@@ -726,12 +768,20 @@ class GlobalConcurrencyLimitCreate(ActionBaseModel):
         ),
     )
 
+    @validator("name", check_fields=False)
+    def validate_name_characters(cls, v):
+        return raise_on_name_with_banned_characters(v)
+
 
 class GlobalConcurrencyLimitUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a global concurrency limit."""
 
     name: Optional[str] = Field(None)
-    limit: Optional[int] = Field(None)
-    active: Optional[bool] = Field(None)
-    active_slots: Optional[int] = Field(None)
-    slot_decay_per_second: Optional[float] = Field(None)
+    limit: Optional[NonNegativeInteger] = Field(None)
+    active: Optional[NonNegativeInteger] = Field(None)
+    active_slots: Optional[NonNegativeInteger] = Field(None)
+    slot_decay_per_second: Optional[NonNegativeFloat] = Field(None)
+
+    @validator("name", check_fields=False)
+    def validate_name_characters(cls, v):
+        return raise_on_name_with_banned_characters(v)

prefect/client/schemas/objects.py

@@ -690,7 +690,9 @@ class TaskRun(ObjectBaseModel):
     task_inputs: Dict[str, List[Union[TaskRunResult, Parameter, Constant]]] = Field(
         default_factory=dict,
         description=(
-            "Tracks the source of inputs to a task run. Used for internal bookkeeping."
+            "Tracks the source of inputs to a task run. Used for internal bookkeeping. "
+            "Note the special __parents__ key, used to indicate a parent/child "
+            "relationship that may or may not include an input or wait_for semantic."
         ),
     )
     state_type: Optional[StateType] = Field(
@@ -931,6 +933,18 @@ class DeploymentSchedule(ObjectBaseModel):
     active: bool = Field(
         default=True, description="Whether or not the schedule is active."
     )
+    max_active_runs: Optional[PositiveInteger] = Field(
+        default=None,
+        description="The maximum number of active runs for the schedule.",
+    )
+    max_scheduled_runs: Optional[PositiveInteger] = Field(
+        default=None,
+        description="The maximum number of scheduled runs for the schedule.",
+    )
+    catchup: bool = Field(
+        default=False,
+        description="Whether or not a worker should catch up on Late runs for the schedule.",
+    )
 
 
 class Deployment(DeprecatedInfraOverridesField, ObjectBaseModel):

prefect/client/schemas/responses.py

@@ -429,3 +429,22 @@ class MinimalConcurrencyLimitResponse(PrefectBaseModel):
     id: UUID
     name: str
     limit: int
+
+
+class GlobalConcurrencyLimitResponse(ObjectBaseModel):
+    """
+    A response object for global concurrency limits.
+    """
+
+    active: bool = Field(
+        default=True, description="Whether the global concurrency limit is active."
+    )
+    name: str = Field(
+        default=..., description="The name of the global concurrency limit."
+    )
+    limit: int = Field(default=..., description="The concurrency limit.")
+    active_slots: int = Field(default=..., description="The number of active slots.")
+    slot_decay_per_second: float = Field(
+        default=2.0,
+        description="The decay rate for active slots when used as a rate limit.",
+    )

prefect/client/schemas/schedules.py

@@ -65,7 +65,7 @@ class IntervalSchedule(PrefectBaseModel):
         exclude_none = True
 
     interval: PositiveDuration
-    anchor_date: DateTimeTZ = None
+    anchor_date: Optional[DateTimeTZ] = None
     timezone: Optional[str] = Field(default=None, examples=["America/New_York"])
 
     @validator("anchor_date", always=True)

prefect/client/utilities.py

@@ -49,12 +49,12 @@ def get_or_create_client(
 
     if (
         flow_run_context
-        and getattr(flow_run_context.client, "_loop") == get_running_loop()
+        and getattr(flow_run_context.client, "_loop", None) == get_running_loop()
     ):
         return flow_run_context.client, True
     elif (
         task_run_context
-        and getattr(task_run_context.client, "_loop") == get_running_loop()
+        and getattr(task_run_context.client, "_loop", None) == get_running_loop()
     ):
         return task_run_context.client, True
     else:

prefect/concurrency/asyncio.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextlib import asynccontextmanager
-from typing import List, Literal, Union, cast
+from typing import List, Literal, Optional, Union, cast
 
 import httpx
 import pendulum
@@ -13,6 +13,7 @@ except ImportError:
 
 from prefect import get_client
 from prefect.client.schemas.responses import MinimalConcurrencyLimitResponse
+from prefect.utilities.timeout import timeout_async
 
 from .events import (
     _emit_concurrency_acquisition_events,
@@ -26,10 +27,39 @@ class ConcurrencySlotAcquisitionError(Exception):
 
 
 @asynccontextmanager
-async def concurrency(names: Union[str, List[str]], occupy: int = 1):
-    names = names if isinstance(names, list) else [names]
+async def concurrency(
+    names: Union[str, List[str]],
+    occupy: int = 1,
+    timeout_seconds: Optional[float] = None,
+):
+    """A context manager that acquires and releases concurrency slots from the
+    given concurrency limits.
+
+    Args:
+        names: The names of the concurrency limits to acquire slots from.
+        occupy: The number of slots to acquire and hold from each limit.
+        timeout_seconds: The number of seconds to wait for the slots to be acquired before
+            raising a `TimeoutError`. A timeout of `None` will wait indefinitely.
 
-    limits = await _acquire_concurrency_slots(names, occupy)
+    Raises:
+        TimeoutError: If the slots are not acquired within the given timeout.
+
+    Example:
+    A simple example of using the async `concurrency` context manager:
+    ```python
+    from prefect.concurrency.asyncio import concurrency
+
+    async def resource_heavy():
+        async with concurrency("test", occupy=1):
+            print("Resource heavy task")
+
+    async def main():
+        await resource_heavy()
+    ```
+    """
+    names = names if isinstance(names, list) else [names]
+    with timeout_async(seconds=timeout_seconds):
+        limits = await _acquire_concurrency_slots(names, occupy)
     acquisition_time = pendulum.now("UTC")
     emitted_events = _emit_concurrency_acquisition_events(limits, occupy)
 

prefect/concurrency/sync.py

@@ -1,5 +1,5 @@
 from contextlib import contextmanager
-from typing import List, Union, cast
+from typing import List, Optional, Union, cast
 
 import pendulum
 
@@ -12,6 +12,7 @@ except ImportError:
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect._internal.concurrency.event_loop import get_running_loop
 from prefect.client.schemas.responses import MinimalConcurrencyLimitResponse
+from prefect.utilities.timeout import timeout
 
 from .asyncio import (
     _acquire_concurrency_slots,
@@ -24,12 +25,42 @@ from .events import (
 
 
 @contextmanager
-def concurrency(names: Union[str, List[str]], occupy: int = 1):
+def concurrency(
+    names: Union[str, List[str]],
+    occupy: int = 1,
+    timeout_seconds: Optional[float] = None,
+):
+    """A context manager that acquires and releases concurrency slots from the
+    given concurrency limits.
+
+    Args:
+        names: The names of the concurrency limits to acquire slots from.
+        occupy: The number of slots to acquire and hold from each limit.
+        timeout_seconds: The number of seconds to wait for the slots to be acquired before
+            raising a `TimeoutError`. A timeout of `None` will wait indefinitely.
+
+    Raises:
+        TimeoutError: If the slots are not acquired within the given timeout.
+
+    Example:
+    A simple example of using the sync `concurrency` context manager:
+    ```python
+    from prefect.concurrency.sync import concurrency
+
+    def resource_heavy():
+        with concurrency("test", occupy=1):
+            print("Resource heavy task")
+
+    def main():
+        resource_heavy()
+    ```
+    """
     names = names if isinstance(names, list) else [names]
 
-    limits: List[MinimalConcurrencyLimitResponse] = _call_async_function_from_sync(
-        _acquire_concurrency_slots, names, occupy
-    )
+    with timeout(seconds=timeout_seconds):
+        limits: List[MinimalConcurrencyLimitResponse] = _call_async_function_from_sync(
+            _acquire_concurrency_slots, names, occupy
+        )
     acquisition_time = pendulum.now("UTC")
     emitted_events = _emit_concurrency_acquisition_events(limits, occupy)
 
@@ -38,7 +69,10 @@ def concurrency(names: Union[str, List[str]], occupy: int = 1):
     finally:
         occupancy_period = cast(Interval, pendulum.now("UTC") - acquisition_time)
         _call_async_function_from_sync(
-            _release_concurrency_slots, names, occupy, occupancy_period.total_seconds()
+            _release_concurrency_slots,
+            names,
+            occupy,
+            occupancy_period.total_seconds(),
         )
         _emit_concurrency_release_events(limits, occupy, emitted_events)
 

prefect/context.py

@@ -43,7 +43,7 @@ import prefect.logging
 import prefect.logging.configuration
 import prefect.settings
 from prefect._internal.schemas.fields import DateTimeTZ
-from prefect.client.orchestration import PrefectClient
+from prefect.client.orchestration import PrefectClient, SyncPrefectClient
 from prefect.client.schemas import FlowRun, TaskRun
 from prefect.events.worker import EventsWorker
 from prefect.exceptions import MissingContextError
@@ -213,7 +213,7 @@ class RunContext(ContextModel):
 
     start_time: DateTimeTZ = Field(default_factory=lambda: pendulum.now("UTC"))
     input_keyset: Optional[Dict[str, Dict[str, str]]] = None
-    client: PrefectClient
+    client: Union[PrefectClient, SyncPrefectClient]
 
 
 class EngineContext(RunContext):

prefect/engine.py

@@ -2438,14 +2438,14 @@ if __name__ == "__main__":
         if PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE.value():
             from prefect.new_flow_engine import (
                 load_flow_and_flow_run,
-                run_flow,
+                run_flow_async,
                 run_flow_sync,
             )
 
             flow_run, flow = run_sync(load_flow_and_flow_run)
             # run the flow
             if flow.isasync:
-                run_sync(run_flow(flow, flow_run=flow_run))
+                run_sync(run_flow_async(flow, flow_run=flow_run))
             else:
                 run_flow_sync(flow, flow_run=flow_run)
         else:

prefect/events/clients.py

@@ -28,7 +28,7 @@ from websockets.exceptions import (
     ConnectionClosedOK,
 )
 
-from prefect.client.base import PrefectHttpxClient
+from prefect.client.base import PrefectHttpxAsyncClient
 from prefect.events import Event
 from prefect.logging import get_logger
 from prefect.settings import (
@@ -193,7 +193,7 @@ class PrefectEphemeralEventsClient(EventsClient):
 
         app = create_app()
 
-        self._http_client = PrefectHttpxClient(
+        self._http_client = PrefectHttpxAsyncClient(
             transport=httpx.ASGITransport(app=app, raise_app_exceptions=False),
             base_url="http://ephemeral-prefect/api",
             enable_csrf_support=False,

prefect/flows.py

@@ -343,23 +343,6 @@ class Flow(Generic[P, R]):
         self.result_storage = result_storage
         self.result_serializer = result_serializer
         self.cache_result_in_memory = cache_result_in_memory
-
-        # Check for collision in the registry
-        registry = PrefectObjectRegistry.get()
-
-        if registry and any(
-            other
-            for other in registry.get_instances(Flow)
-            if other.name == self.name and id(other.fn) != id(self.fn)
-        ):
-            file = inspect.getsourcefile(self.fn)
-            line_number = inspect.getsourcelines(self.fn)[1]
-            warnings.warn(
-                f"A flow named {self.name!r} and defined at '{file}:{line_number}' "
-                "conflicts with another flow. Consider specifying a unique `name` "
-                "parameter in the flow definition:\n\n "
-                "`@flow(name='my_unique_name', ...)`"
-            )
         self.on_completion = on_completion
         self.on_failure = on_failure
         self.on_cancellation = on_cancellation
@@ -1719,3 +1702,94 @@ def load_flow_from_text(script_contents: AnyStr, flow_name: str):
         tmpfile.close()
         os.remove(tmpfile.name)
     return flow
+
+
+@sync_compatible
+async def serve(
+    *args: "RunnerDeployment",
+    pause_on_shutdown: bool = True,
+    print_starting_message: bool = True,
+    limit: Optional[int] = None,
+    **kwargs,
+):
+    """
+    Serve the provided list of deployments.
+
+    Args:
+        *args: A list of deployments to serve.
+        pause_on_shutdown: A boolean for whether or not to automatically pause
+            deployment schedules on shutdown.
+        print_starting_message: Whether or not to print message to the console
+            on startup.
+        limit: The maximum number of runs that can be executed concurrently.
+        **kwargs: Additional keyword arguments to pass to the runner.
+
+    Examples:
+        Prepare two deployments and serve them:
+
+        ```python
+        import datetime
+
+        from prefect import flow, serve
+
+        @flow
+        def my_flow(name):
+            print(f"hello {name}")
+
+        @flow
+        def my_other_flow(name):
+            print(f"goodbye {name}")
+
+        if __name__ == "__main__":
+            # Run once a day
+            hello_deploy = my_flow.to_deployment(
+                "hello", tags=["dev"], interval=datetime.timedelta(days=1)
+            )
+
+            # Run every Sunday at 4:00 AM
+            bye_deploy = my_other_flow.to_deployment(
+                "goodbye", tags=["dev"], cron="0 4 * * sun"
+            )
+
+            serve(hello_deploy, bye_deploy)
+        ```
+    """
+    from rich.console import Console, Group
+    from rich.table import Table
+
+    from prefect.runner import Runner
+
+    runner = Runner(pause_on_shutdown=pause_on_shutdown, limit=limit, **kwargs)
+    for deployment in args:
+        await runner.add_deployment(deployment)
+
+    if print_starting_message:
+        help_message_top = (
+            "[green]Your deployments are being served and polling for"
+            " scheduled runs!\n[/]"
+        )
+
+        table = Table(title="Deployments", show_header=False)
+
+        table.add_column(style="blue", no_wrap=True)
+
+        for deployment in args:
+            table.add_row(f"{deployment.flow_name}/{deployment.name}")
+
+        help_message_bottom = (
+            "\nTo trigger any of these deployments, use the"
+            " following command:\n[blue]\n\t$ prefect deployment run"
+            " [DEPLOYMENT_NAME]\n[/]"
+        )
+        if PREFECT_UI_URL:
+            help_message_bottom += (
+                "\nYou can also trigger your deployments via the Prefect UI:"
+                f" [blue]{PREFECT_UI_URL.value()}/deployments[/]\n"
+            )
+
+        console = Console()
+        console.print(
+            Group(help_message_top, table, help_message_bottom), soft_wrap=True
+        )
+
+    await runner.start()

prefect/infrastructure/process.py

@@ -7,7 +7,6 @@ It has been replaced by the process worker from the `prefect.workers` module, wh
 For upgrade instructions, see https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/.
 """
 
-import asyncio
 import contextlib
 import os
 import shlex
@@ -21,7 +20,6 @@ from typing import Dict, Tuple, Union
 
 import anyio
 import anyio.abc
-import sniffio
 
 from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
@@ -43,20 +41,6 @@ if sys.platform == "win32":
     STATUS_CONTROL_C_EXIT = 0xC000013A
 
 
-def _use_threaded_child_watcher():
-    if (
-        sys.version_info < (3, 8)
-        and sniffio.current_async_library() == "asyncio"
-        and sys.platform != "win32"
-    ):
-        from prefect.utilities.compat import ThreadedChildWatcher
-
-        # Python < 3.8 does not use a `ThreadedChildWatcher` by default which can
-        # lead to errors in tests on unix as the previous default `SafeChildWatcher`
-        # is not compatible with threaded event loops.
-        asyncio.get_event_loop_policy().set_child_watcher(ThreadedChildWatcher())
-
-
 def _infrastructure_pid_from_process(process: anyio.abc.Process) -> str:
     hostname = socket.gethostname()
     return f"{hostname}:{process.pid}"
@@ -121,7 +105,6 @@ class Process(Infrastructure):
         if not self.command:
             raise ValueError("Process cannot be run with empty command.")
 
-        _use_threaded_child_watcher()
         display_name = f" {self.name!r}" if self.name else ""
 
         # Open a subprocess to execute the flow run

prefect/logging/formatters.py

@@ -99,10 +99,7 @@ class PrefectFormatter(logging.Formatter):
             style_kwargs["defaults"] = defaults
 
         # validate added in 3.8
-        if sys.version_info >= (3, 8):
-            init_kwargs["validate"] = validate
-        else:
-            validate = False
+        init_kwargs["validate"] = validate
 
         super().__init__(format, datefmt, style, **init_kwargs)