prefect-client 3.0.0rc3__py3-none-any.whl → 3.0.0rc5__py3-none-any.whl

prefect/__init__.py

@@ -43,15 +43,12 @@ import prefect.runtime
 
 # Import modules that register types
 import prefect.serializers
-import prefect.blocks.kubernetes
 import prefect.blocks.notifications
 import prefect.blocks.system
 
 # Initialize the process-wide profile and registry at import time
 import prefect.context
 
-prefect.context.initialize_object_registry()
-
 # Perform any forward-ref updates needed for Pydantic models
 import prefect.client.schemas
 

prefect/client/schemas/schedules.py

@@ -3,13 +3,14 @@ Schedule schemas
 """
 
 import datetime
-from typing import Annotated, Optional, Union
+from typing import Annotated, Any, Optional, Union
 
 import dateutil
 import dateutil.rrule
 import pendulum
 from pydantic import AfterValidator, ConfigDict, Field, field_validator, model_validator
 from pydantic_extra_types.pendulum_dt import DateTime
+from typing_extensions import TypeAlias, TypeGuard
 
 from prefect._internal.schemas.bases import PrefectBaseModel
 from prefect._internal.schemas.validators import (
@@ -279,7 +280,13 @@ class NoSchedule(PrefectBaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
-SCHEDULE_TYPES = Union[IntervalSchedule, CronSchedule, RRuleSchedule, NoSchedule]
+SCHEDULE_TYPES: TypeAlias = Union[
+    IntervalSchedule, CronSchedule, RRuleSchedule, NoSchedule
+]
+
+
+def is_schedule_type(obj: Any) -> TypeGuard[SCHEDULE_TYPES]:
+    return isinstance(obj, (IntervalSchedule, CronSchedule, RRuleSchedule, NoSchedule))
 
 
 def construct_schedule(

prefect/client/subscriptions.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Dict, Generic, List, Optional, Type, TypeVar
+from typing import Any, Dict, Generic, Iterable, Optional, Type, TypeVar
 
 import orjson
 import websockets
@@ -21,7 +21,7 @@ class Subscription(Generic[S]):
         self,
         model: Type[S],
         path: str,
-        keys: List[str],
+        keys: Iterable[str],
         client_id: Optional[str] = None,
         base_url: Optional[str] = None,
     ):
@@ -30,7 +30,7 @@ class Subscription(Generic[S]):
         base_url = base_url.replace("http", "ws", 1)
         self.subscription_url = f"{base_url}{path}"
 
-        self.keys = keys
+        self.keys = list(keys)
 
         self._connect = websockets.connect(
             self.subscription_url,

prefect/client/types/flexible_schedule_list.py

@@ -0,0 +1,11 @@
+from typing import TYPE_CHECKING, Any, Sequence, Union
+
+from typing_extensions import TypeAlias
+
+if TYPE_CHECKING:
+    from prefect.client.schemas.actions import DeploymentScheduleCreate
+    from prefect.client.schemas.schedules import SCHEDULE_TYPES
+
+FlexibleScheduleList: TypeAlias = Sequence[
+    Union[DeploymentScheduleCreate, dict[str, Any], "SCHEDULE_TYPES"]
+]

prefect/concurrency/asyncio.py

@@ -13,7 +13,6 @@ except ImportError:
 
 from prefect.client.orchestration 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,6 +25,10 @@ class ConcurrencySlotAcquisitionError(Exception):
     """Raised when an unhandlable occurs while acquiring concurrency slots."""
 
 
+class AcquireConcurrencySlotTimeoutError(TimeoutError):
+    """Raised when acquiring a concurrency slot times out."""
+
+
 @asynccontextmanager
 async def concurrency(
     names: Union[str, List[str]],
@@ -58,8 +61,9 @@ async def concurrency(
     ```
     """
     names = names if isinstance(names, list) else [names]
-    with timeout_async(seconds=timeout_seconds):
-        limits = await _acquire_concurrency_slots(names, occupy)
+    limits = await _acquire_concurrency_slots(
+        names, occupy, timeout_seconds=timeout_seconds
+    )
     acquisition_time = pendulum.now("UTC")
     emitted_events = _emit_concurrency_acquisition_events(limits, occupy)
 
@@ -91,12 +95,18 @@ async def _acquire_concurrency_slots(
     names: List[str],
     slots: int,
     mode: Union[Literal["concurrency"], Literal["rate_limit"]] = "concurrency",
+    timeout_seconds: Optional[float] = None,
 ) -> List[MinimalConcurrencyLimitResponse]:
     service = ConcurrencySlotAcquisitionService.instance(frozenset(names))
-    future = service.send((slots, mode))
+    future = service.send((slots, mode, timeout_seconds))
     response_or_exception = await asyncio.wrap_future(future)
 
     if isinstance(response_or_exception, Exception):
+        if isinstance(response_or_exception, TimeoutError):
+            raise AcquireConcurrencySlotTimeoutError(
+                f"Attempt to acquire concurrency slots timed out after {timeout_seconds} second(s)"
+            ) from response_or_exception
+
         raise ConcurrencySlotAcquisitionError(
             f"Unable to acquire concurrency slots on {names!r}"
         ) from response_or_exception

prefect/concurrency/services.py

@@ -4,6 +4,7 @@ from contextlib import asynccontextmanager
 from typing import (
     TYPE_CHECKING,
     FrozenSet,
+    Optional,
     Tuple,
 )
 
@@ -13,6 +14,7 @@ from starlette import status
 from prefect._internal.concurrency import logger
 from prefect._internal.concurrency.services import QueueService
 from prefect.client.orchestration import get_client
+from prefect.utilities.timeout import timeout_async
 
 if TYPE_CHECKING:
     from prefect.client.orchestration import PrefectClient
@@ -30,10 +32,12 @@ class ConcurrencySlotAcquisitionService(QueueService):
             self._client = client
             yield
 
-    async def _handle(self, item: Tuple[int, str, concurrent.futures.Future]):
-        occupy, mode, future = item
+    async def _handle(
+        self, item: Tuple[int, str, Optional[float], concurrent.futures.Future]
+    ):
+        occupy, mode, timeout_seconds, future = item
         try:
-            response = await self.acquire_slots(occupy, mode)
+            response = await self.acquire_slots(occupy, mode, timeout_seconds)
         except Exception as exc:
             # If the request to the increment endpoint fails in a non-standard
             # way, we need to set the future's result so that the caller can
@@ -43,25 +47,28 @@ class ConcurrencySlotAcquisitionService(QueueService):
         else:
             future.set_result(response)
 
-    async def acquire_slots(self, slots: int, mode: str) -> httpx.Response:
-        while True:
-            try:
-                response = await self._client.increment_concurrency_slots(
-                    names=self.concurrency_limit_names, slots=slots, mode=mode
-                )
-            except Exception as exc:
-                if (
-                    isinstance(exc, httpx.HTTPStatusError)
-                    and exc.response.status_code == status.HTTP_423_LOCKED
-                ):
-                    retry_after = float(exc.response.headers["Retry-After"])
-                    await asyncio.sleep(retry_after)
+    async def acquire_slots(
+        self, slots: int, mode: str, timeout_seconds: Optional[float] = None
+    ) -> httpx.Response:
+        with timeout_async(seconds=timeout_seconds):
+            while True:
+                try:
+                    response = await self._client.increment_concurrency_slots(
+                        names=self.concurrency_limit_names, slots=slots, mode=mode
+                    )
+                except Exception as exc:
+                    if (
+                        isinstance(exc, httpx.HTTPStatusError)
+                        and exc.response.status_code == status.HTTP_423_LOCKED
+                    ):
+                        retry_after = float(exc.response.headers["Retry-After"])
+                        await asyncio.sleep(retry_after)
+                    else:
+                        raise exc
                 else:
-                    raise exc
-            else:
-                return response
+                    return response
 
-    def send(self, item: Tuple[int, str]):
+    def send(self, item: Tuple[int, str, Optional[float]]) -> concurrent.futures.Future:
         with self._lock:
             if self._stopped:
                 raise RuntimeError("Cannot put items in a stopped service instance.")
@@ -69,7 +76,7 @@ class ConcurrencySlotAcquisitionService(QueueService):
             logger.debug("Service %r enqueuing item %r", self, item)
             future: concurrent.futures.Future = concurrent.futures.Future()
 
-            occupy, mode = item
-            self._queue.put_nowait((occupy, mode, future))
+            occupy, mode, timeout_seconds = item
+            self._queue.put_nowait((occupy, mode, timeout_seconds, future))
 
         return future

prefect/concurrency/sync.py

@@ -12,7 +12,6 @@ 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,
@@ -57,10 +56,9 @@ def concurrency(
     """
     names = names if isinstance(names, list) else [names]
 
-    with timeout(seconds=timeout_seconds):
-        limits: List[MinimalConcurrencyLimitResponse] = _call_async_function_from_sync(
-            _acquire_concurrency_slots, names, occupy
-        )
+    limits: List[MinimalConcurrencyLimitResponse] = _call_async_function_from_sync(
+        _acquire_concurrency_slots, names, occupy, timeout_seconds=timeout_seconds
+    )
     acquisition_time = pendulum.now("UTC")
     emitted_events = _emit_concurrency_acquisition_events(limits, occupy)
 

prefect/context.py

@@ -9,21 +9,16 @@ For more user-accessible information about the current run, see [`prefect.runtim
 import os
 import sys
 import warnings
-from collections import defaultdict
 from contextlib import ExitStack, contextmanager
 from contextvars import ContextVar, Token
-from functools import update_wrapper
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
-    ContextManager,
     Dict,
     Generator,
-    List,
     Optional,
     Set,
-    Tuple,
     Type,
     TypeVar,
     Union,
@@ -46,7 +41,6 @@ from prefect.settings import PREFECT_HOME, Profile, Settings
 from prefect.states import State
 from prefect.task_runners import TaskRunner
 from prefect.utilities.asyncutils import run_coro_as_sync
-from prefect.utilities.importtools import load_script_as_module
 
 T = TypeVar("T")
 
@@ -180,86 +174,6 @@ class ContextModel(BaseModel):
         return self.model_dump(exclude_unset=True)
 
 
-class PrefectObjectRegistry(ContextModel):
-    """
-    A context that acts as a registry for all Prefect objects that are
-    registered during load and execution.
-
-    Attributes:
-        start_time: The time the object registry was created.
-        block_code_execution: If set, flow calls will be ignored.
-        capture_failures: If set, failures during __init__ will be silenced and tracked.
-    """
-
-    start_time: DateTime = Field(default_factory=lambda: pendulum.now("UTC"))
-
-    _instance_registry: Dict[Type[T], List[T]] = PrivateAttr(
-        default_factory=lambda: defaultdict(list)
-    )
-
-    # Failures will be a tuple of (exception, instance, args, kwargs)
-    _instance_init_failures: Dict[
-        Type[T], List[Tuple[Exception, T, Tuple, Dict]]
-    ] = PrivateAttr(default_factory=lambda: defaultdict(list))
-
-    block_code_execution: bool = False
-    capture_failures: bool = False
-
-    __var__ = ContextVar("object_registry")
-
-    def get_instances(self, type_: Type[T]) -> List[T]:
-        instances = []
-        for registered_type, type_instances in self._instance_registry.items():
-            if type_ in registered_type.mro():
-                instances.extend(type_instances)
-        return instances
-
-    def get_instance_failures(
-        self, type_: Type[T]
-    ) -> List[Tuple[Exception, T, Tuple, Dict]]:
-        failures = []
-        for type__ in type_.mro():
-            failures.extend(self._instance_init_failures[type__])
-        return failures
-
-    def register_instance(self, object):
-        # TODO: Consider using a 'Set' to avoid duplicate entries
-        self._instance_registry[type(object)].append(object)
-
-    def register_init_failure(
-        self, exc: Exception, object: Any, init_args: Tuple, init_kwargs: Dict
-    ):
-        self._instance_init_failures[type(object)].append(
-            (exc, object, init_args, init_kwargs)
-        )
-
-    @classmethod
-    def register_instances(cls, type_: Type[T]) -> Type[T]:
-        """
-        Decorator for a class that adds registration to the `PrefectObjectRegistry`
-        on initialization of instances.
-        """
-        original_init = type_.__init__
-
-        def __register_init__(__self__: T, *args: Any, **kwargs: Any) -> None:
-            registry = cls.get()
-            try:
-                original_init(__self__, *args, **kwargs)
-            except Exception as exc:
-                if not registry or not registry.capture_failures:
-                    raise
-                else:
-                    registry.register_init_failure(exc, __self__, args, kwargs)
-            else:
-                if registry:
-                    registry.register_instance(__self__)
-
-        update_wrapper(__register_init__, original_init)
-
-        type_.__init__ = __register_init__
-        return type_
-
-
 class ClientContext(ContextModel):
     """
     A context for managing the Prefect client instances.
@@ -594,23 +508,6 @@ def tags(*new_tags: str) -> Generator[Set[str], None, None]:
         yield new_tags
 
 
-def registry_from_script(
-    path: str,
-    block_code_execution: bool = True,
-    capture_failures: bool = True,
-) -> PrefectObjectRegistry:
-    """
-    Return a fresh registry with instances populated from execution of a script.
-    """
-    with PrefectObjectRegistry(
-        block_code_execution=block_code_execution,
-        capture_failures=capture_failures,
-    ) as registry:
-        load_script_as_module(path)
-
-    return registry
-
-
 @contextmanager
 def use_profile(
     profile: Union[Profile, str],
@@ -711,14 +608,3 @@ def root_settings_context():
 
 
 GLOBAL_SETTINGS_CONTEXT: SettingsContext = root_settings_context()
-GLOBAL_OBJECT_REGISTRY: Optional[ContextManager[PrefectObjectRegistry]] = None
-
-
-def initialize_object_registry():
-    global GLOBAL_OBJECT_REGISTRY
-
-    if GLOBAL_OBJECT_REGISTRY:
-        return
-
-    GLOBAL_OBJECT_REGISTRY = PrefectObjectRegistry()
-    GLOBAL_OBJECT_REGISTRY.__enter__()

prefect/deployments/__init__.py

@@ -8,7 +8,7 @@ from prefect.deployments.base import (
 from prefect.deployments.runner import (
     RunnerDeployment,
     deploy,
-    DeploymentImage,
+    DockerImage,
     EntrypointType,
 )
 

prefect/deployments/runner.py

@@ -29,7 +29,6 @@ Example:
 
 """
 
-import enum
 import importlib
 import tempfile
 from datetime import datetime, timedelta
@@ -37,7 +36,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
 from uuid import UUID
 
-import pendulum
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -61,9 +59,9 @@ from prefect.client.schemas.schedules import (
     construct_schedule,
 )
 from prefect.deployments.schedules import (
-    FlexibleScheduleList,
     create_deployment_schedule_create,
 )
+from prefect.docker.docker_image import DockerImage
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     ObjectNotFound,
@@ -71,24 +69,19 @@ from prefect.exceptions import (
 )
 from prefect.runner.storage import RunnerStorage
 from prefect.settings import (
-    PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE,
     PREFECT_DEFAULT_WORK_POOL_NAME,
     PREFECT_UI_URL,
 )
+from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
 from prefect.utilities.collections import get_from_dict, isiterable
 from prefect.utilities.dockerutils import (
-    PushError,
-    build_image,
-    docker_client,
-    generate_default_dockerfile,
     parse_image_tag,
-    split_repository_path,
 )
-from prefect.utilities.slugify import slugify
 
 if TYPE_CHECKING:
+    from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
     from prefect.flows import Flow
 
 __all__ = ["RunnerDeployment"]
@@ -100,18 +93,6 @@ class DeploymentApplyError(RuntimeError):
     """
 
 
-class EntrypointType(enum.Enum):
-    """
-    Enum representing a entrypoint type.
-
-    File path entrypoints are in the format: `path/to/file.py:function_name`.
-    Module path entrypoints are in the format: `path.to.module.function_name`.
-    """
-
-    FILE_PATH = "file_path"
-    MODULE_PATH = "module_path"
-
-
 class RunnerDeployment(BaseModel):
     """
     A Prefect RunnerDeployment definition, used for specifying and building deployments.
@@ -363,8 +344,8 @@ class RunnerDeployment(BaseModel):
         rrule: Optional[Union[Iterable[str], str]] = None,
         timezone: Optional[str] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
-        schedules: Optional[FlexibleScheduleList] = None,
-    ) -> Union[List[DeploymentScheduleCreate], FlexibleScheduleList]:
+        schedules: Optional["FlexibleScheduleList"] = None,
+    ) -> Union[List[DeploymentScheduleCreate], "FlexibleScheduleList"]:
         """
         Construct a schedule or schedules from the provided arguments.
 
@@ -455,7 +436,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
-        schedules: Optional[FlexibleScheduleList] = None,
+        schedules: Optional["FlexibleScheduleList"] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
@@ -591,7 +572,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
-        schedules: Optional[FlexibleScheduleList] = None,
+        schedules: Optional["FlexibleScheduleList"] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
@@ -689,7 +670,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
-        schedules: Optional[FlexibleScheduleList] = None,
+        schedules: Optional["FlexibleScheduleList"] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
@@ -786,74 +767,11 @@ class RunnerDeployment(BaseModel):
         return deployment
 
 
-class DeploymentImage:
-    """
-    Configuration used to build and push a Docker image for a deployment.
-
-    Attributes:
-        name: The name of the Docker image to build, including the registry and
-            repository.
-        tag: The tag to apply to the built image.
-        dockerfile: The path to the Dockerfile to use for building the image. If
-            not provided, a default Dockerfile will be generated.
-        **build_kwargs: Additional keyword arguments to pass to the Docker build request.
-            See the [`docker-py` documentation](https://docker-py.readthedocs.io/en/stable/images.html#docker.models.images.ImageCollection.build)
-            for more information.
-
-    """
-
-    def __init__(self, name, tag=None, dockerfile="auto", **build_kwargs):
-        image_name, image_tag = parse_image_tag(name)
-        if tag and image_tag:
-            raise ValueError(
-                f"Only one tag can be provided - both {image_tag!r} and {tag!r} were"
-                " provided as tags."
-            )
-        namespace, repository = split_repository_path(image_name)
-        # if the provided image name does not include a namespace (registry URL or user/org name),
-        # use the default namespace
-        if not namespace:
-            namespace = PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE.value()
-        # join the namespace and repository to create the full image name
-        # ignore namespace if it is None
-        self.name = "/".join(filter(None, [namespace, repository]))
-        self.tag = tag or image_tag or slugify(pendulum.now("utc").isoformat())
-        self.dockerfile = dockerfile
-        self.build_kwargs = build_kwargs
-
-    @property
-    def reference(self):
-        return f"{self.name}:{self.tag}"
-
-    def build(self):
-        full_image_name = self.reference
-        build_kwargs = self.build_kwargs.copy()
-        build_kwargs["context"] = Path.cwd()
-        build_kwargs["tag"] = full_image_name
-        build_kwargs["pull"] = build_kwargs.get("pull", True)
-
-        if self.dockerfile == "auto":
-            with generate_default_dockerfile():
-                build_image(**build_kwargs)
-        else:
-            build_kwargs["dockerfile"] = self.dockerfile
-            build_image(**build_kwargs)
-
-    def push(self):
-        with docker_client() as client:
-            events = client.api.push(
-                repository=self.name, tag=self.tag, stream=True, decode=True
-            )
-            for event in events:
-                if "error" in event:
-                    raise PushError(event["error"])
-
-
 @sync_compatible
 async def deploy(
     *deployments: RunnerDeployment,
     work_pool_name: Optional[str] = None,
-    image: Optional[Union[str, DeploymentImage]] = None,
+    image: Optional[Union[str, DockerImage]] = None,
     build: bool = True,
     push: bool = True,
     print_next_steps_message: bool = True,
@@ -875,7 +793,7 @@ async def deploy(
         work_pool_name: The name of the work pool to use for these deployments. Defaults to
             the value of `PREFECT_DEFAULT_WORK_POOL_NAME`.
         image: The name of the Docker image to build, including the registry and
-            repository. Pass a DeploymentImage instance to customize the Dockerfile used
+            repository. Pass a DockerImage instance to customize the Dockerfile used
             and build arguments.
         build: Whether or not to build a new image for the flow. If False, the provided
             image will be used as-is and pulled at runtime.
@@ -930,7 +848,7 @@ async def deploy(
 
     if image and isinstance(image, str):
         image_name, image_tag = parse_image_tag(image)
-        image = DeploymentImage(name=image_name, tag=image_tag)
+        image = DockerImage(name=image_name, tag=image_tag)
 
     try:
         async with get_client() as client:

prefect/deployments/schedules.py

@@ -1,11 +1,11 @@
-from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Union, get_args
+from typing import TYPE_CHECKING, Any, List, Optional
 
 from prefect.client.schemas.actions import DeploymentScheduleCreate
+from prefect.client.schemas.schedules import is_schedule_type
 
 if TYPE_CHECKING:
     from prefect.client.schemas.schedules import SCHEDULE_TYPES
-
-FlexibleScheduleList = Sequence[Union[DeploymentScheduleCreate, dict, "SCHEDULE_TYPES"]]
+    from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
 
 
 def create_deployment_schedule_create(
@@ -26,12 +26,10 @@ def create_deployment_schedule_create(
 def normalize_to_deployment_schedule_create(
     schedules: Optional["FlexibleScheduleList"],
 ) -> List[DeploymentScheduleCreate]:
-    from prefect.client.schemas.schedules import SCHEDULE_TYPES
-
-    normalized = []
+    normalized: list[DeploymentScheduleCreate] = []
     if schedules is not None:
         for obj in schedules:
-            if isinstance(obj, get_args(SCHEDULE_TYPES)):
+            if is_schedule_type(obj):
                 normalized.append(create_deployment_schedule_create(obj))
             elif isinstance(obj, dict):
                 normalized.append(create_deployment_schedule_create(**obj))

prefect/docker/__init__.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from prefect.docker.docker_image import DockerImage
+
+__all__ = ["DockerImage"]
+
+_public_api: dict[str, tuple[str, str]] = {
+    "DockerImage": ("prefect.docker.docker_image", "DockerImage"),
+}
+
+
+def __getattr__(name: str) -> object:
+    from importlib import import_module
+
+    if name in _public_api:
+        module, attr = _public_api[name]
+        return getattr(import_module(module), attr)
+
+    raise ImportError(f"module {__name__!r} has no attribute {name!r}")