prefect-client 3.1.9__py3-none-any.whl → 3.1.11__py3-none-any.whl

prefect/events/clients.py

@@ -16,6 +16,7 @@ from typing import (
     cast,
 )
 from urllib.parse import urlparse
+from urllib.request import proxy_bypass
 from uuid import UUID
 
 import orjson
@@ -95,6 +96,9 @@ class WebsocketProxyConnect(Connect):
         u = urlparse(uri)
         host = u.hostname
 
+        if not host:
+            raise ValueError(f"Invalid URI {uri}, no hostname found")
+
         if u.scheme == "ws":
             port = u.port or 80
             proxy_url = os.environ.get("HTTP_PROXY")
@@ -107,7 +111,9 @@ class WebsocketProxyConnect(Connect):
                 "Unsupported scheme %s. Expected 'ws' or 'wss'. " % u.scheme
             )
 
-        self._proxy = Proxy.from_url(proxy_url) if proxy_url else None
+        self._proxy = (
+            Proxy.from_url(proxy_url) if proxy_url and not proxy_bypass(host) else None
+        )
         self._host = host
         self._port = port
 

prefect/events/schemas/events.py

@@ -2,6 +2,7 @@ import copy
 from collections import defaultdict
 from typing import (
     Any,
+    ClassVar,
     Dict,
     Iterable,
     List,
@@ -108,7 +109,7 @@ def _validate_related_resources(value) -> List:
 class Event(PrefectBaseModel):
     """The client-side view of an event that has happened to a Resource"""
 
-    model_config = ConfigDict(extra="ignore")
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
 
     occurred: DateTime = Field(
         default_factory=lambda: DateTime.now("UTC"),
@@ -177,7 +178,7 @@ class ReceivedEvent(Event):
     """The server-side view of an event that has happened to a Resource after it has
     been received by the server"""
 
-    model_config = ConfigDict(from_attributes=True)
+    model_config: ClassVar[ConfigDict] = ConfigDict(from_attributes=True)
 
     received: DateTime = Field(
         ...,

prefect/flow_engine.py

@@ -55,7 +55,6 @@ from prefect.logging.loggers import (
     patch_print,
 )
 from prefect.results import (
-    BaseResult,
     ResultStore,
     get_result_store,
     should_persist_result,
@@ -307,10 +306,7 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
         if self._return_value is not NotSet and not isinstance(
             self._return_value, State
         ):
-            if isinstance(self._return_value, BaseResult):
-                _result = self._return_value.get()
-            else:
-                _result = self._return_value
+            _result = self._return_value
 
             if asyncio.iscoroutine(_result):
                 # getting the value for a BaseResult may return an awaitable
@@ -490,24 +486,13 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             ):
                 return subflow_run
 
-        flow_run = client.create_flow_run(
+        return client.create_flow_run(
             flow=self.flow,
             parameters=self.flow.serialize_parameters(parameters),
             state=Pending(),
             parent_task_run_id=getattr(parent_task_run, "id", None),
             tags=TagsContext.get().current_tags,
         )
-        if flow_run_ctx:
-            parent_logger = get_run_logger(flow_run_ctx)
-            parent_logger.info(
-                f"Created subflow run {flow_run.name!r} for flow {self.flow.name!r}"
-            )
-        else:
-            self.logger.info(
-                f"Created flow run {flow_run.name!r} for flow {self.flow.name!r}"
-            )
-
-        return flow_run
 
     def call_hooks(self, state: Optional[State] = None):
         if state is None:
@@ -606,6 +591,7 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             stack.enter_context(ConcurrencyContext())
 
             # set the logger to the flow run logger
+
             self.logger = flow_run_logger(flow_run=self.flow_run, flow=self.flow)
 
             # update the flow run name if necessary
@@ -616,12 +602,32 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                 self.client.set_flow_run_name(
                     flow_run_id=self.flow_run.id, name=flow_run_name
                 )
+
                 self.logger.extra["flow_run_name"] = flow_run_name
                 self.logger.debug(
                     f"Renamed flow run {self.flow_run.name!r} to {flow_run_name!r}"
                 )
                 self.flow_run.name = flow_run_name
                 self._flow_run_name_set = True
+
+                self._telemetry.update_run_name(name=flow_run_name)
+
+            if self.flow_run.parent_task_run_id:
+                _logger = get_run_logger(FlowRunContext.get())
+                run_type = "subflow"
+            else:
+                _logger = self.logger
+                run_type = "flow"
+
+            _logger.info(
+                f"Beginning {run_type} run {self.flow_run.name!r} for flow {self.flow.name!r}"
+            )
+
+            if flow_run_url := url_for(self.flow_run):
+                self.logger.info(
+                    f"View at {flow_run_url}", extra={"send_to_api": False}
+                )
+
             yield
 
     @contextmanager
@@ -635,12 +641,6 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
 
             if not self.flow_run:
                 self.flow_run = self.create_flow_run(self.client)
-                flow_run_url = url_for(self.flow_run)
-
-                if flow_run_url:
-                    self.logger.info(
-                        f"View at {flow_run_url}", extra={"send_to_api": False}
-                    )
             else:
                 # Update the empirical policy to match the flow if it is not set
                 if self.flow_run.empirical_policy.retry_delay is None:
@@ -658,7 +658,6 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                 )
 
             self._telemetry.start_span(
-                name=self.flow.name,
                 run=self.flow_run,
                 client=self.client,
                 parameters=self.parameters,
@@ -705,9 +704,11 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
     @contextmanager
     def start(self) -> Generator[None, None, None]:
         with self.initialize_run():
-            with trace.use_span(
-                self._telemetry.span
-            ) if self._telemetry.span else nullcontext():
+            with (
+                trace.use_span(self._telemetry.span)
+                if self._telemetry.span
+                else nullcontext()
+            ):
                 self.begin_run()
 
                 if self.state.is_running():
@@ -870,10 +871,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         if self._return_value is not NotSet and not isinstance(
             self._return_value, State
         ):
-            if isinstance(self._return_value, BaseResult):
-                _result = self._return_value.get()
-            else:
-                _result = self._return_value
+            _result = self._return_value
 
             if asyncio.iscoroutine(_result):
                 # getting the value for a BaseResult may return an awaitable
@@ -1052,24 +1050,13 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             ):
                 return subflow_run
 
-        flow_run = await client.create_flow_run(
+        return await client.create_flow_run(
             flow=self.flow,
             parameters=self.flow.serialize_parameters(parameters),
             state=Pending(),
             parent_task_run_id=getattr(parent_task_run, "id", None),
             tags=TagsContext.get().current_tags,
         )
-        if flow_run_ctx:
-            parent_logger = get_run_logger(flow_run_ctx)
-            parent_logger.info(
-                f"Created subflow run {flow_run.name!r} for flow {self.flow.name!r}"
-            )
-        else:
-            self.logger.info(
-                f"Created flow run {flow_run.name!r} for flow {self.flow.name!r}"
-            )
-
-        return flow_run
 
     async def call_hooks(self, state: Optional[State] = None):
         if state is None:
@@ -1171,6 +1158,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             self.logger = flow_run_logger(flow_run=self.flow_run, flow=self.flow)
 
             # update the flow run name if necessary
+
             if not self._flow_run_name_set and self.flow.flow_run_name:
                 flow_run_name = resolve_custom_flow_run_name(
                     flow=self.flow, parameters=self.parameters
@@ -1184,6 +1172,24 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                 )
                 self.flow_run.name = flow_run_name
                 self._flow_run_name_set = True
+
+                self._telemetry.update_run_name(name=flow_run_name)
+            if self.flow_run.parent_task_run_id:
+                _logger = get_run_logger(FlowRunContext.get())
+                run_type = "subflow"
+            else:
+                _logger = self.logger
+                run_type = "flow"
+
+            _logger.info(
+                f"Beginning {run_type} run {self.flow_run.name!r} for flow {self.flow.name!r}"
+            )
+
+            if flow_run_url := url_for(self.flow_run):
+                self.logger.info(
+                    f"View at {flow_run_url}", extra={"send_to_api": False}
+                )
+
             yield
 
     @asynccontextmanager
@@ -1220,7 +1226,6 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                 )
 
             await self._telemetry.async_start_span(
-                name=self.flow.name,
                 run=self.flow_run,
                 client=self.client,
                 parameters=self.parameters,
@@ -1267,9 +1272,11 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
     @asynccontextmanager
     async def start(self) -> AsyncGenerator[None, None]:
         async with self.initialize_run():
-            with trace.use_span(
-                self._telemetry.span
-            ) if self._telemetry.span else nullcontext():
+            with (
+                trace.use_span(self._telemetry.span)
+                if self._telemetry.span
+                else nullcontext()
+            ):
                 await self.begin_run()
 
                 if self.state.is_running():

prefect/flows.py

@@ -37,7 +37,6 @@ from typing import (
 from uuid import UUID
 
 import pydantic
-from fastapi.encoders import jsonable_encoder
 from pydantic.v1 import BaseModel as V1BaseModel
 from pydantic.v1.decorator import ValidatedFunction as V1ValidatedFunction
 from pydantic.v1.errors import ConfigError  # TODO
@@ -613,6 +612,8 @@ class Flow(Generic[P, R]):
                 serialized_parameters[key] = f"<{type(value).__name__}>"
                 continue
             try:
+                from fastapi.encoders import jsonable_encoder
+
                 serialized_parameters[key] = jsonable_encoder(value)
             except (TypeError, ValueError):
                 logger.debug(

prefect/futures.py

@@ -1,17 +1,15 @@
 import abc
 import asyncio
-import collections
 import concurrent.futures
 import threading
 import uuid
 from collections.abc import Generator, Iterator
 from functools import partial
-from typing import Any, Callable, Generic, List, Optional, Set, Union, cast
+from typing import Any, Callable, Generic, Optional, Union
 
-from typing_extensions import TypeVar
+from typing_extensions import NamedTuple, Self, TypeVar
 
 from prefect.client.orchestration import get_client
-from prefect.client.schemas.objects import TaskRun
 from prefect.exceptions import ObjectNotFound
 from prefect.logging.loggers import get_logger, get_run_logger
 from prefect.states import Pending, State
@@ -50,7 +48,7 @@ class PrefectFuture(abc.ABC, Generic[R]):
             return self._final_state
         client = get_client(sync_client=True)
         try:
-            task_run = cast(TaskRun, client.read_task_run(task_run_id=self.task_run_id))
+            task_run = client.read_task_run(task_run_id=self.task_run_id)
         except ObjectNotFound:
             # We'll be optimistic and assume this task will eventually start
             # TODO: Consider using task run events to wait for the task to start
@@ -92,7 +90,7 @@ class PrefectFuture(abc.ABC, Generic[R]):
         """
 
     @abc.abstractmethod
-    def add_done_callback(self, fn):
+    def add_done_callback(self, fn: Callable[["PrefectFuture[R]"], None]):
         """
         Add a callback to be run when the future completes or is cancelled.
 
@@ -102,13 +100,17 @@ class PrefectFuture(abc.ABC, Generic[R]):
         ...
 
 
-class PrefectWrappedFuture(PrefectFuture, abc.ABC, Generic[R, F]):
+class PrefectWrappedFuture(PrefectFuture[R], abc.ABC, Generic[R, F]):
     """
     A Prefect future that wraps another future object.
+
+    Type Parameters:
+        R: The return type of the future
+        F: The type of the wrapped future
     """
 
     def __init__(self, task_run_id: uuid.UUID, wrapped_future: F):
-        self._wrapped_future = wrapped_future
+        self._wrapped_future: F = wrapped_future
         super().__init__(task_run_id)
 
     @property
@@ -116,10 +118,11 @@ class PrefectWrappedFuture(PrefectFuture, abc.ABC, Generic[R, F]):
         """The underlying future object wrapped by this Prefect future"""
         return self._wrapped_future
 
-    def add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]):
+    def add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]) -> None:
+        """Add a callback to be executed when the future completes."""
         if not self._final_state:
 
-            def call_with_self(future):
+            def call_with_self(future: F):
                 """Call the callback with self as the argument, this is necessary to ensure we remove the future from the pending set"""
                 fn(self)
 
@@ -128,7 +131,7 @@ class PrefectWrappedFuture(PrefectFuture, abc.ABC, Generic[R, F]):
         fn(self)
 
 
-class PrefectConcurrentFuture(PrefectWrappedFuture[R, concurrent.futures.Future]):
+class PrefectConcurrentFuture(PrefectWrappedFuture[R, concurrent.futures.Future[R]]):
     """
     A Prefect future that wraps a concurrent.futures.Future. This future is used
     when the task run is submitted to a ThreadPoolExecutor.
@@ -193,7 +196,7 @@ class PrefectDistributedFuture(PrefectFuture[R]):
     any task run scheduled in Prefect's API.
     """
 
-    done_callbacks: List[Callable[[PrefectFuture[R]], None]] = []
+    done_callbacks: list[Callable[[PrefectFuture[R]], None]] = []
     waiter = None
 
     def wait(self, timeout: Optional[float] = None) -> None:
@@ -270,7 +273,7 @@ class PrefectDistributedFuture(PrefectFuture[R]):
                 return
             TaskRunWaiter.add_done_callback(self._task_run_id, partial(fn, self))
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, PrefectDistributedFuture):
             return False
         return self.task_run_id == other.task_run_id
@@ -279,7 +282,7 @@ class PrefectDistributedFuture(PrefectFuture[R]):
         return hash(self.task_run_id)
 
 
-class PrefectFutureList(list, Iterator, Generic[F]):
+class PrefectFutureList(list[PrefectFuture[R]], Iterator[PrefectFuture[R]]):
     """
     A list of Prefect futures.
 
@@ -298,10 +301,10 @@ class PrefectFutureList(list, Iterator, Generic[F]):
         wait(self, timeout=timeout)
 
     def result(
-        self: "PrefectFutureList[R]",
+        self: Self,
         timeout: Optional[float] = None,
         raise_on_failure: bool = True,
-    ) -> List[R]:
+    ) -> list[R]:
         """
         Get the results of all task runs associated with the futures in the list.
 
@@ -331,21 +334,22 @@ class PrefectFutureList(list, Iterator, Generic[F]):
 
 
 def as_completed(
-    futures: List[PrefectFuture[R]], timeout: Optional[float] = None
+    futures: list[PrefectFuture[R]], timeout: Optional[float] = None
 ) -> Generator[PrefectFuture[R], None]:
-    unique_futures: Set[PrefectFuture[R]] = set(futures)
+    unique_futures: set[PrefectFuture[R]] = set(futures)
     total_futures = len(unique_futures)
+    pending = unique_futures
     try:
         with timeout_context(timeout):
-            done = {f for f in unique_futures if f._final_state}
+            done = {f for f in unique_futures if f._final_state}  # type: ignore[privateUsage]
             pending = unique_futures - done
             yield from done
 
             finished_event = threading.Event()
             finished_lock = threading.Lock()
-            finished_futures = []
+            finished_futures: list[PrefectFuture[R]] = []
 
-            def add_to_done(future):
+            def add_to_done(future: PrefectFuture[R]):
                 with finished_lock:
                     finished_futures.append(future)
                     finished_event.set()
@@ -370,10 +374,19 @@ def as_completed(
         )
 
 
-DoneAndNotDoneFutures = collections.namedtuple("DoneAndNotDoneFutures", "done not_done")
+class DoneAndNotDoneFutures(NamedTuple, Generic[R]):
+    """A named 2-tuple of sets.
+
+    multiple inheritance supported in 3.11+, use typing_extensions.NamedTuple
+    """
+
+    done: set[PrefectFuture[R]]
+    not_done: set[PrefectFuture[R]]
 
 
-def wait(futures: List[PrefectFuture[R]], timeout=None) -> DoneAndNotDoneFutures:
+def wait(
+    futures: list[PrefectFuture[R]], timeout: Optional[float] = None
+) -> DoneAndNotDoneFutures[R]:
     """
     Wait for the futures in the given sequence to complete.
 
@@ -431,9 +444,11 @@ def resolve_futures_to_states(
 
     Unsupported object types will be returned without modification.
     """
-    futures: Set[PrefectFuture[R]] = set()
+    futures: set[PrefectFuture[R]] = set()
 
-    def _collect_futures(futures, expr, context):
+    def _collect_futures(
+        futures: set[PrefectFuture[R]], expr: Any, context: Any
+    ) -> Union[PrefectFuture[R], Any]:
         # Expressions inside quotes should not be traversed
         if isinstance(context.get("annotation"), quote):
             raise StopVisiting()
@@ -455,14 +470,14 @@ def resolve_futures_to_states(
         return expr
 
     # Get final states for each future
-    states = []
+    states: list[State] = []
     for future in futures:
         future.wait()
         states.append(future.state)
 
     states_by_future = dict(zip(futures, states))
 
-    def replace_futures_with_states(expr, context):
+    def replace_futures_with_states(expr: Any, context: Any) -> Any:
         # Expressions inside quotes should not be modified
         if isinstance(context.get("annotation"), quote):
             raise StopVisiting()

prefect/input/run_input.py

@@ -64,6 +64,7 @@ from inspect import isclass
 from typing import (
     TYPE_CHECKING,
     Any,
+    ClassVar,
     Dict,
     Generic,
     Literal,
@@ -144,7 +145,7 @@ class RunInputMetadata(pydantic.BaseModel):
 
 
 class RunInput(pydantic.BaseModel):
-    model_config = ConfigDict(extra="forbid")
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
 
     _description: Optional[str] = pydantic.PrivateAttr(default=None)
     _metadata: RunInputMetadata = pydantic.PrivateAttr()

prefect/locking/filesystem.py

@@ -1,6 +1,7 @@
 import time
+from logging import Logger
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Optional
 
 import anyio
 import pendulum
@@ -11,7 +12,7 @@ from prefect.logging.loggers import get_logger
 
 from .protocol import LockManager
 
-logger = get_logger(__name__)
+logger: Logger = get_logger(__name__)
 
 
 class _LockInfo(TypedDict):
@@ -37,11 +38,11 @@ class FileSystemLockManager(LockManager):
         lock_files_directory: the directory where lock files are stored
     """
 
-    def __init__(self, lock_files_directory: Path):
-        self.lock_files_directory = lock_files_directory.expanduser().resolve()
-        self._locks: Dict[str, _LockInfo] = {}
+    def __init__(self, lock_files_directory: Path) -> None:
+        self.lock_files_directory: Path = lock_files_directory.expanduser().resolve()
+        self._locks: dict[str, _LockInfo] = {}
 
-    def _ensure_lock_files_directory_exists(self):
+    def _ensure_lock_files_directory_exists(self) -> None:
         self.lock_files_directory.mkdir(parents=True, exist_ok=True)
 
     def _lock_path_for_key(self, key: str) -> Path:
@@ -49,7 +50,7 @@ class FileSystemLockManager(LockManager):
             return lock_info["path"]
         return self.lock_files_directory.joinpath(key).with_suffix(".lock")
 
-    def _get_lock_info(self, key: str, use_cache=True) -> Optional[_LockInfo]:
+    def _get_lock_info(self, key: str, use_cache: bool = True) -> Optional[_LockInfo]:
         if use_cache:
             if (lock_info := self._locks.get(key)) is not None:
                 return lock_info

prefect/locking/memory.py

@@ -1,6 +1,8 @@
 import asyncio
 import threading
-from typing import Dict, Optional, TypedDict
+from typing import Any, Optional, TypedDict
+
+from typing_extensions import Self
 
 from .protocol import LockManager
 
@@ -30,14 +32,14 @@ class MemoryLockManager(LockManager):
 
     _instance = None
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
         if cls._instance is None:
             cls._instance = super().__new__(cls)
         return cls._instance
 
     def __init__(self):
         self._locks_dict_lock = threading.Lock()
-        self._locks: Dict[str, _LockInfo] = {}
+        self._locks: dict[str, _LockInfo] = {}
 
     def _expire_lock(self, key: str):
         """

prefect/locking/protocol.py

@@ -57,7 +57,7 @@ class LockManager(Protocol):
         """
         ...
 
-    def release_lock(self, key: str, holder: str):
+    def release_lock(self, key: str, holder: str) -> None:
         """
         Releases the lock on the corresponding transaction record.
 

prefect/main.py

@@ -1,6 +1,5 @@
 # Import user-facing API
 from typing import Any
-
 from prefect.deployments import deploy
 from prefect.states import State
 from prefect.logging import get_run_logger
@@ -9,7 +8,7 @@ from prefect.transactions import Transaction
 from prefect.tasks import task, Task
 from prefect.context import tags
 from prefect.utilities.annotations import unmapped, allow_failure
-from prefect.results import BaseResult, ResultRecordMetadata
+from prefect.results import ResultRecordMetadata
 from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
 from prefect.client.orchestration import get_client
 from prefect.client.cloud import get_cloud_client
@@ -30,7 +29,6 @@ import prefect.client.schemas
 _types: dict[str, Any] = dict(
     Task=Task,
     Flow=Flow,
-    BaseResult=BaseResult,
     ResultRecordMetadata=ResultRecordMetadata,
 )
 prefect.context.FlowRunContext.model_rebuild(_types_namespace=_types)

prefect/plugins.py

@@ -9,15 +9,15 @@ Currently supported entrypoints:
 """
 
 from types import ModuleType
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import prefect.settings
 from prefect.utilities.compat import EntryPoints, entry_points
 
-COLLECTIONS: Union[None, Dict[str, Union[ModuleType, Exception]]] = None
+_collections: Union[None, dict[str, Union[ModuleType, Exception]]] = None
 
 
-def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception, Any]]:
+def safe_load_entrypoints(entrypoints: EntryPoints) -> dict[str, Union[Exception, Any]]:
     """
     Load entry points for a group capturing any exceptions that occur.
     """
@@ -26,7 +26,7 @@ def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception
     #       also want to validate the type for the group for entrypoints that have
     #       a specific type we expect.
 
-    results = {}
+    results: dict[str, Union[Exception, Any]] = {}
 
     for entrypoint in entrypoints:
         result = None
@@ -40,18 +40,20 @@ def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception
     return results
 
 
-def load_prefect_collections() -> Dict[str, Union[ModuleType, Exception]]:
+def load_prefect_collections() -> dict[str, Union[ModuleType, Exception]]:
     """
     Load all Prefect collections that define an entrypoint in the group
     `prefect.collections`.
     """
-    global COLLECTIONS
+    global _collections
 
-    if COLLECTIONS is not None:
-        return COLLECTIONS
+    if _collections is not None:
+        return _collections
 
     collection_entrypoints: EntryPoints = entry_points(group="prefect.collections")
-    collections = safe_load_entrypoints(collection_entrypoints)
+    collections: dict[str, Union[Exception, Any]] = safe_load_entrypoints(
+        collection_entrypoints
+    )
 
     # TODO: Consider the utility of this once we've established this pattern.
     #       We cannot use a logger here because logging is not yet initialized.
@@ -68,5 +70,5 @@ def load_prefect_collections() -> Dict[str, Union[ModuleType, Exception]]:
             if prefect.settings.PREFECT_DEBUG_MODE:
                 print(f"Loaded collection {name!r}.")
 
-    COLLECTIONS = collections
+    _collections = collections
     return collections