prefect-client 3.4.11.dev4__tar.gz → 3.4.12.dev1__tar.gz

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.11.dev4
+Version: 3.4.12.dev1
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect_client-3.4.12.dev1/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.12.dev1"
+__build_date__ = "2025-08-02 08:08:42.755918+00:00"
+__git_commit__ = "4fee08bf0dfe814941b70db3585eab891397519c"
+__dirty__ = False

prefect_client-3.4.12.dev1/src/prefect/_internal/installation.py

@@ -0,0 +1,60 @@
+import importlib
+import subprocess
+import sys
+
+import prefect.utilities.processutils
+
+
+def install_packages(
+    packages: list[str], stream_output: bool = False, upgrade: bool = False
+):
+    """
+    Install packages using uv if available, otherwise use pip.
+    """
+    base_command = ["pip", "install", *packages]
+    if upgrade:
+        base_command.append("--upgrade")
+    if stream_output:
+        stdout = sys.stdout
+        stderr = sys.stderr
+    else:
+        stdout = subprocess.DEVNULL
+        stderr = subprocess.DEVNULL
+    try:
+        uv = importlib.import_module("uv")
+
+        command = [uv.find_uv_bin(), *base_command]
+        subprocess.check_call(
+            command,
+            stdout=stdout,
+            stderr=stderr,
+        )
+    except (ImportError, ModuleNotFoundError, FileNotFoundError):
+        command = [sys.executable, "-m", *base_command]
+        subprocess.check_call(
+            command,
+            stdout=stdout,
+            stderr=stderr,
+        )
+
+
+async def ainstall_packages(
+    packages: list[str], stream_output: bool = False, upgrade: bool = False
+):
+    """
+    Install packages using uv if available, otherwise use pip.
+    """
+    base_command = ["pip", "install", *packages]
+    if upgrade:
+        base_command.append("--upgrade")
+    try:
+        uv = importlib.import_module("uv")
+
+        await prefect.utilities.processutils.run_process(
+            [uv.find_uv_bin(), *base_command], stream_output=stream_output
+        )
+    except (ImportError, ModuleNotFoundError, FileNotFoundError):
+        await prefect.utilities.processutils.run_process(
+            [sys.executable, "-m", *base_command],
+            stream_output=stream_output,
+        )

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/client/__init__.py

@@ -1,5 +1,5 @@
 """
-Asynchronous client implementation for communicating with the [Prefect REST API](/api-ref/rest-api/).
+Asynchronous client implementation for communicating with the [Prefect REST API](https://docs.prefect.io/v3/api-ref/rest-api/).
 
 Explore the client by communicating with an in-memory webserver - no setup required:
 

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/client/orchestration/__init__.py

@@ -279,7 +279,7 @@ class PrefectClient(
     WorkPoolAsyncClient,
 ):
     """
-    An asynchronous client for interacting with the [Prefect REST API](/api-ref/rest-api/).
+    An asynchronous client for interacting with the [Prefect REST API](https://docs.prefect.io/v3/api-ref/rest-api/).
 
     Args:
         api: the REST API URL or FastAPI application to connect to
@@ -1142,7 +1142,7 @@ class SyncPrefectClient(
     WorkPoolClient,
 ):
     """
-    A synchronous client for interacting with the [Prefect REST API](/api-ref/rest-api/).
+    A synchronous client for interacting with the [Prefect REST API](https://docs.prefect.io/v3/api-ref/rest-api/).
 
     Args:
         api: the REST API URL or FastAPI application to connect to

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/client/schemas/objects.py

@@ -185,6 +185,9 @@ class StateDetails(PrefectBaseModel):
     task_parameters_id: Optional[UUID] = None
     # Captures the trace_id and span_id of the span where this state was created
     traceparent: Optional[str] = None
+    # The ID of the lease that is currently holding the deployment concurrency slot
+    # for this run.
+    deployment_concurrency_lease_id: Optional[UUID] = None
 
     def to_run_result(
         self, run_type: RunType

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/concurrency/_asyncio.py

@@ -131,27 +131,6 @@ async def aacquire_concurrency_slots_with_lease(
         ) from exc
 
 
-async def amaintain_concurrency_lease(
-    lease_id: UUID,
-    lease_duration: float,
-) -> None:
-    """
-    Maintain a concurrency lease by renewing it after the given interval.
-
-    Args:
-        lease_id: The ID of the lease to maintain.
-        lease_duration: The duration of the lease in seconds.
-    """
-    async with get_client() as client:
-        while True:
-            await asyncio.sleep(  # Renew the lease 3/4 of the way through the lease duration
-                lease_duration * 0.75
-            )
-            await client.renew_concurrency_lease(
-                lease_id=lease_id, lease_duration=lease_duration
-            )
-
-
 async def arelease_concurrency_slots(
     names: list[str], slots: int, occupancy_seconds: float
 ) -> list[MinimalConcurrencyLimitResponse]:

prefect_client-3.4.12.dev1/src/prefect/concurrency/_leases.py

@@ -0,0 +1,139 @@
+import asyncio
+import concurrent.futures
+from contextlib import asynccontextmanager, contextmanager
+from typing import AsyncGenerator, Generator
+from uuid import UUID
+
+from prefect._internal.concurrency.api import create_call
+from prefect._internal.concurrency.cancellation import (
+    AsyncCancelScope,
+    WatcherThreadCancelScope,
+)
+from prefect._internal.concurrency.threads import get_global_loop
+from prefect.client.orchestration import get_client
+from prefect.logging.loggers import get_logger, get_run_logger
+
+
+async def _lease_renewal_loop(
+    lease_id: UUID,
+    lease_duration: float,
+) -> None:
+    """
+    Maintain a concurrency lease by renewing it after the given interval.
+
+    Args:
+        lease_id: The ID of the lease to maintain.
+        lease_duration: The duration of the lease in seconds.
+    """
+    async with get_client() as client:
+        while True:
+            await client.renew_concurrency_lease(
+                lease_id=lease_id, lease_duration=lease_duration
+            )
+            await asyncio.sleep(  # Renew the lease 3/4 of the way through the lease duration
+                lease_duration * 0.75
+            )
+
+
+@contextmanager
+def maintain_concurrency_lease(
+    lease_id: UUID,
+    lease_duration: float,
+    raise_on_lease_renewal_failure: bool = False,
+) -> Generator[None, None, None]:
+    """
+    Maintain a concurrency lease for the given lease ID.
+
+    Args:
+        lease_id: The ID of the lease to maintain.
+        lease_duration: The duration of the lease in seconds.
+        raise_on_lease_renewal_failure: A boolean specifying whether to raise an error if the lease renewal fails.
+    """
+    # Start a loop to renew the lease on the global event loop to avoid blocking the main thread
+    global_loop = get_global_loop()
+    lease_renewal_call = create_call(
+        _lease_renewal_loop,
+        lease_id,
+        lease_duration,
+    )
+    global_loop.submit(lease_renewal_call)
+
+    with WatcherThreadCancelScope() as cancel_scope:
+
+        def handle_lease_renewal_failure(future: concurrent.futures.Future[None]):
+            if future.cancelled():
+                return
+            exc = future.exception()
+            if exc:
+                try:
+                    # Use a run logger if available
+                    logger = get_run_logger()
+                except Exception:
+                    logger = get_logger("concurrency")
+                if raise_on_lease_renewal_failure:
+                    logger.error(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
+                    )
+                    assert cancel_scope.cancel()
+                else:
+                    logger.warning(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                    )
+
+        lease_renewal_call.future.add_done_callback(handle_lease_renewal_failure)
+
+        try:
+            yield
+        finally:
+            # Cancel the lease renewal loop
+            lease_renewal_call.cancel()
+
+
+@asynccontextmanager
+async def amaintain_concurrency_lease(
+    lease_id: UUID,
+    lease_duration: float,
+    raise_on_lease_renewal_failure: bool = False,
+) -> AsyncGenerator[None, None]:
+    """
+    Maintain a concurrency lease for the given lease ID.
+
+    Args:
+        lease_id: The ID of the lease to maintain.
+        lease_duration: The duration of the lease in seconds.
+        raise_on_lease_renewal_failure: A boolean specifying whether to raise an error if the lease renewal fails.
+    """
+    lease_renewal_task = asyncio.create_task(
+        _lease_renewal_loop(lease_id, lease_duration)
+    )
+    with AsyncCancelScope() as cancel_scope:
+
+        def handle_lease_renewal_failure(task: asyncio.Task[None]):
+            exc = task.exception()
+            if exc:
+                try:
+                    # Use a run logger if available
+                    logger = get_run_logger()
+                except Exception:
+                    logger = get_logger("concurrency")
+                if raise_on_lease_renewal_failure:
+                    logger.error(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
+                    )
+                    cancel_scope.cancel()
+                else:
+                    logger.warning(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                    )
+
+        # Add a callback to stop execution if the lease renewal fails and strict is True
+        lease_renewal_task.add_done_callback(handle_lease_renewal_failure)
+        try:
+            yield
+        finally:
+            lease_renewal_task.cancel()
+            try:
+                await lease_renewal_task
+            except (asyncio.CancelledError, Exception):
+                # Handling for errors will be done in the callback
+                pass

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/concurrency/asyncio.py

@@ -1,12 +1,10 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from typing import Optional, Union
 
 import anyio
 
-from prefect._internal.concurrency.cancellation import AsyncCancelScope
-from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.concurrency._leases import amaintain_concurrency_lease
 
 from ._asyncio import (
     AcquireConcurrencySlotTimeoutError as AcquireConcurrencySlotTimeoutError,
@@ -15,7 +13,6 @@ from ._asyncio import ConcurrencySlotAcquisitionError as ConcurrencySlotAcquisit
 from ._asyncio import (
     aacquire_concurrency_slots,
     aacquire_concurrency_slots_with_lease,
-    amaintain_concurrency_lease,
     arelease_concurrency_slots_with_lease,
 )
 from ._events import (
@@ -81,43 +78,12 @@ async def concurrency(
     )
     emitted_events = emit_concurrency_acquisition_events(response.limits, occupy)
 
-    lease_renewal_task = asyncio.create_task(
-        amaintain_concurrency_lease(response.lease_id, lease_duration)
-    )
-
     try:
-        with AsyncCancelScope() as cancel_scope:
-
-            def handle_lease_renewal_failure(task: asyncio.Task[None]):
-                exc = task.exception()
-                if exc:
-                    try:
-                        # Use a run logger if available
-                        logger = get_run_logger()
-                    except Exception:
-                        logger = get_logger("concurrency")
-                    if strict:
-                        logger.error(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
-                        )
-                        cancel_scope.cancel()
-                    else:
-                        logger.warning(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
-                        )
-
-            # Add a callback to stop execution if the lease renewal fails and strict is True
-            lease_renewal_task.add_done_callback(handle_lease_renewal_failure)
-
+        async with amaintain_concurrency_lease(
+            response.lease_id, lease_duration, raise_on_lease_renewal_failure=strict
+        ):
             yield
     finally:
-        lease_renewal_task.cancel()
-        try:
-            await lease_renewal_task
-        except (asyncio.CancelledError, Exception):
-            # Handling for errors will be done in the callback
-            pass
-
         try:
             await arelease_concurrency_slots_with_lease(
                 lease_id=response.lease_id,

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/concurrency/sync.py

@@ -1,4 +1,3 @@
-import concurrent.futures
 from collections.abc import Generator
 from contextlib import contextmanager
 from typing import Optional, TypeVar, Union
@@ -6,22 +5,16 @@ from uuid import UUID
 
 from typing_extensions import Literal
 
-from prefect._internal.concurrency.api import create_call
-from prefect._internal.concurrency.cancellation import (
-    WatcherThreadCancelScope,
-)
-from prefect._internal.concurrency.threads import get_global_loop
 from prefect.client.schemas.responses import (
     ConcurrencyLimitWithLeaseResponse,
     MinimalConcurrencyLimitResponse,
 )
-from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.concurrency._leases import maintain_concurrency_lease
 from prefect.utilities.asyncutils import run_coro_as_sync
 
 from ._asyncio import (
     aacquire_concurrency_slots,
     aacquire_concurrency_slots_with_lease,
-    amaintain_concurrency_lease,
     arelease_concurrency_slots_with_lease,
 )
 from ._events import (
@@ -126,42 +119,14 @@ def concurrency(
         acquisition_response.limits, occupy
     )
 
-    # Start a loop to renew the lease on the global event loop to avoid blocking the main thread
-    global_loop = get_global_loop()
-    lease_renewal_call = create_call(
-        amaintain_concurrency_lease,
-        acquisition_response.lease_id,
-        lease_duration,
-    )
-    global_loop.submit(lease_renewal_call)
-
     try:
-        with WatcherThreadCancelScope() as cancel_scope:
-
-            def handle_lease_renewal_failure(future: concurrent.futures.Future[None]):
-                exc = future.exception()
-                if exc:
-                    try:
-                        # Use a run logger if available
-                        logger = get_run_logger()
-                    except Exception:
-                        logger = get_logger("concurrency")
-                    if strict:
-                        logger.error(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
-                        )
-                        assert cancel_scope.cancel()
-                    else:
-                        logger.warning(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
-                        )
-
-            lease_renewal_call.future.add_done_callback(handle_lease_renewal_failure)
+        with maintain_concurrency_lease(
+            acquisition_response.lease_id,
+            lease_duration,
+            raise_on_lease_renewal_failure=strict,
+        ):
             yield
     finally:
-        # Cancel the lease renewal loop
-        lease_renewal_call.cancel()
-
         _release_concurrency_slots_with_lease(acquisition_response.lease_id)
         emit_concurrency_release_events(
             acquisition_response.limits, occupy, emitted_events

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/context.py

@@ -3,7 +3,7 @@ Async and thread safe models for passing runtime context data.
 
 These contexts should never be directly mutated by the user.
 
-For more user-accessible information about the current run, see [`prefect.runtime`](../runtime/flow_run).
+For more user-accessible information about the current run, see [`prefect.runtime`](https://docs.prefect.io/v3/api-ref/python/prefect-runtime-flow_run).
 """
 
 import asyncio

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/deployments/base.py

@@ -2,7 +2,7 @@
 Core primitives for managing Prefect deployments via `prefect deploy`, providing a minimally opinionated
 build system for managing flows and deployments.
 
-To get started, follow along with [the deloyments tutorial](/tutorials/deployments/).
+To get started, follow along with [the deployments tutorial](https://docs.prefect.io/v3/how-to-guides/deployments/create-deployments).
 """
 
 from __future__ import annotations

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/deployments/steps/core.py

@@ -5,16 +5,17 @@ Deployment steps are YAML representations of Python functions along with their i
 
 Whenever a step is run, the following actions are taken:
 
-- The step's inputs and block / variable references are resolved (see [the `prefect deploy` documentation](/guides/prefect-deploy/#templating-options) for more details)
+- The step's inputs and block / variable references are resolved (see [the `prefect deploy` documentation](https://docs.prefect.io/v3/how-to-guides/deployments/prefect-yaml#templating-options) for more details)
 - The step's function is imported; if it cannot be found, the `requires` keyword is used to install the necessary packages
 - The step's function is called with the resolved inputs
 - The step's output is returned and used to resolve inputs for subsequent steps
 """
 
+from __future__ import annotations
+
 import os
 import re
 import subprocess
-import sys
 import warnings
 from copy import deepcopy
 from importlib import import_module
@@ -22,6 +23,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 from prefect._internal.compatibility.deprecated import PrefectDeprecationWarning
 from prefect._internal.concurrency.api import Call, from_async
+from prefect._internal.installation import install_packages
 from prefect._internal.integrations import KNOWN_EXTRAS_FOR_PACKAGES
 from prefect.logging.loggers import get_logger
 from prefect.settings import PREFECT_DEBUG_MODE
@@ -90,7 +92,8 @@ def _get_function_for_step(
             for package in packages
             if package
         ]
-        subprocess.check_call([sys.executable, "-m", "pip", "install", *packages])
+        install_packages(packages, stream_output=True)
+
     except subprocess.CalledProcessError:
         get_logger("deployments.steps.core").warning(
             "Unable to install required packages for %s", fully_qualified_name

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/deployments/steps/pull.py

@@ -157,7 +157,7 @@ def git_clone(
                 repository: https://github.com/org/repo.git
                 access_token: "{{ prefect.blocks.secret.github-access-token }}" # Requires creation of a Secret block
         ```
-        Note that you will need to [create a Secret block](/concepts/blocks/#using-existing-block-types) to store the
+        Note that you will need to [create a Secret block](https://docs.prefect.io/v3/concepts/blocks/#pre-registered-blocks) to store the
         value of your git credentials. You can also store a username/password combo or token prefix (e.g. `x-token-auth`)
         in your secret block. Refer to your git providers documentation for the correct authentication schema.
 

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/flow_engine.py

@@ -6,7 +6,13 @@ import multiprocessing
 import multiprocessing.context
 import os
 import time
-from contextlib import ExitStack, asynccontextmanager, contextmanager, nullcontext
+from contextlib import (
+    AsyncExitStack,
+    ExitStack,
+    asynccontextmanager,
+    contextmanager,
+    nullcontext,
+)
 from dataclasses import dataclass, field
 from functools import wraps
 from typing import (
@@ -35,7 +41,11 @@ from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_c
 from prefect.client.schemas import FlowRun, TaskRun
 from prefect.client.schemas.filters import FlowRunFilter
 from prefect.client.schemas.sorting import FlowRunSort
+from prefect.concurrency.asyncio import (
+    amaintain_concurrency_lease,
+)
 from prefect.concurrency.context import ConcurrencyContext
+from prefect.concurrency.sync import maintain_concurrency_lease
 from prefect.concurrency.v1.context import ConcurrencyContext as ConcurrencyContextV1
 from prefect.context import (
     AsyncClientContext,
@@ -618,6 +628,13 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             )
             stack.enter_context(ConcurrencyContextV1())
             stack.enter_context(ConcurrencyContext())
+            if lease_id := self.state.state_details.deployment_concurrency_lease_id:
+                stack.enter_context(
+                    maintain_concurrency_lease(
+                        lease_id,
+                        300,
+                    )
+                )
 
             # set the logger to the flow run logger
 
@@ -1157,7 +1174,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         self.flow_run = await client.read_flow_run(self.flow_run.id)
         log_prints = should_log_prints(self.flow)
 
-        with ExitStack() as stack:
+        async with AsyncExitStack() as stack:
             # TODO: Explore closing task runner before completing the flow to
             # wait for futures to complete
             stack.enter_context(capture_sigterm())
@@ -1182,6 +1199,13 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             )
             stack.enter_context(ConcurrencyContextV1())
             stack.enter_context(ConcurrencyContext())
+            if lease_id := self.state.state_details.deployment_concurrency_lease_id:
+                await stack.enter_async_context(
+                    amaintain_concurrency_lease(
+                        lease_id,
+                        300,
+                    )
+                )
 
             # set the logger to the flow run logger
             self.logger: "logging.Logger" = flow_run_logger(

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/infrastructure/provisioners/coiled.py

@@ -1,6 +1,4 @@
 import importlib
-import shlex
-import sys
 from copy import deepcopy
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Dict, Optional
@@ -10,6 +8,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
+from prefect._internal.installation import ainstall_packages
 from prefect.client.schemas.actions import BlockDocumentCreate
 from prefect.client.schemas.objects import BlockDocument
 from prefect.client.utilities import inject_client
@@ -66,9 +65,7 @@ class CoiledPushProvisioner:
             task = progress.add_task("coiled install")
             progress.start()
             global coiled
-            await run_process(
-                [shlex.quote(sys.executable), "-m", "pip", "install", "coiled"]
-            )
+            await ainstall_packages(["coiled"])
             coiled = importlib.import_module("coiled")
             progress.advance(task)
 

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/infrastructure/provisioners/ecs.py

@@ -6,8 +6,6 @@ import contextvars
 import importlib
 import ipaddress
 import json
-import shlex
-import sys
 from copy import deepcopy
 from functools import partial
 from textwrap import dedent
@@ -23,6 +21,7 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 from rich.syntax import Syntax
 
+from prefect._internal.installation import ainstall_packages
 from prefect.cli._prompts import prompt
 from prefect.client.schemas.actions import BlockDocumentCreate
 from prefect.client.utilities import inject_client
@@ -1121,9 +1120,7 @@ class ElasticContainerServicePushProvisioner:
 
     async def _prompt_boto3_installation(self):
         global boto3
-        await run_process(
-            [shlex.quote(sys.executable), "-m", "pip", "install", "boto3"]
-        )
+        await ainstall_packages(["boto3"])
         boto3 = importlib.import_module("boto3")
 
     @staticmethod

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/infrastructure/provisioners/modal.py

@@ -10,6 +10,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
+from prefect._internal.installation import ainstall_packages
 from prefect.client.schemas.actions import BlockDocumentCreate
 from prefect.client.schemas.objects import BlockDocument
 from prefect.client.utilities import inject_client
@@ -66,9 +67,7 @@ class ModalPushProvisioner:
             task = progress.add_task("modal install")
             progress.start()
             global modal
-            await run_process(
-                [shlex.quote(sys.executable), "-m", "pip", "install", "modal"]
-            )
+            await ainstall_packages(["modal"])
             modal = importlib.import_module("modal")
             progress.advance(task)
 

{prefect_client-3.4.11.dev4 → prefect_client-3.4.12.dev1}/src/prefect/locking/memory.py

@@ -33,6 +33,7 @@ class MemoryLockManager(LockManager):
     """
 
     _instance = None
+    _initialized = False
 
     def __new__(cls, *args: Any, **kwargs: Any) -> Self:
         if cls._instance is None:
@@ -40,8 +41,11 @@ class MemoryLockManager(LockManager):
         return cls._instance
 
     def __init__(self):
+        if self.__class__._initialized:
+            return
         self._locks_dict_lock = threading.Lock()
         self._locks: dict[str, _LockInfo] = {}
+        self.__class__._initialized = True
 
     def _expire_lock(self, key: str):
         """