prefect-client 2.16.3__py3-none-any.whl → 2.16.5__py3-none-any.whl

prefect/client/orchestration.py

@@ -15,11 +15,21 @@ from typing import (
 )
 from uuid import UUID, uuid4
 
+import certifi
 import httpcore
 import httpx
 import pendulum
 
+from prefect._internal.compatibility.experimental import (
+    EXPERIMENTAL_WARNING,
+    ExperimentalFeature,
+    experiment_enabled,
+)
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect.settings import (
+    PREFECT_EXPERIMENTAL_WARN,
+    PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES,
+)
 
 if HAS_PYDANTIC_V2:
     import pydantic.v1 as pydantic
@@ -125,8 +135,10 @@ from prefect.settings import (
     PREFECT_API_ENABLE_HTTP2,
     PREFECT_API_KEY,
     PREFECT_API_REQUEST_TIMEOUT,
+    PREFECT_API_SSL_CERT_FILE,
     PREFECT_API_TLS_INSECURE_SKIP_VERIFY,
     PREFECT_API_URL,
+    PREFECT_CLIENT_CSRF_SUPPORT_ENABLED,
     PREFECT_CLOUD_API_URL,
     PREFECT_UNIT_TEST_MODE,
 )
@@ -211,6 +223,11 @@ class PrefectClient:
 
         if PREFECT_API_TLS_INSECURE_SKIP_VERIFY:
             httpx_settings.setdefault("verify", False)
+        else:
+            cert_file = PREFECT_API_SSL_CERT_FILE.value()
+            if not cert_file:
+                cert_file = certifi.where()
+            httpx_settings.setdefault("verify", cert_file)
 
         if api_version is None:
             api_version = SERVER_API_VERSION
@@ -307,7 +324,15 @@ class PrefectClient:
 
         if not PREFECT_UNIT_TEST_MODE:
             httpx_settings.setdefault("follow_redirects", True)
-        self._client = PrefectHttpxClient(**httpx_settings)
+
+        enable_csrf_support = (
+            self.server_type != ServerType.CLOUD
+            and PREFECT_CLIENT_CSRF_SUPPORT_ENABLED.value()
+        )
+
+        self._client = PrefectHttpxClient(
+            **httpx_settings, enable_csrf_support=enable_csrf_support
+        )
         self._loop = None
 
         # See https://www.python-httpx.org/advanced/#custom-transports
@@ -506,6 +531,7 @@ class PrefectClient:
         idempotency_key: str = None,
         parent_task_run_id: UUID = None,
         work_queue_name: str = None,
+        job_variables: Optional[Dict[str, Any]] = None,
     ) -> FlowRun:
         """
         Create a flow run for a deployment.
@@ -529,6 +555,7 @@ class PrefectClient:
             work_queue_name: An optional work queue name to add this run to. If not provided,
                 will default to the deployment's set work queue.  If one is provided that does not
                 exist, a new work queue will be created within the deployment's work pool.
+            job_variables: Optional variables that will be supplied to the flow run job.
 
         Raises:
             httpx.RequestError: if the Prefect API does not successfully create a run for any reason
@@ -536,6 +563,21 @@ class PrefectClient:
         Returns:
             The flow run model
         """
+        if job_variables is not None and experiment_enabled("flow_run_infra_overrides"):
+            if (
+                PREFECT_EXPERIMENTAL_WARN
+                and PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES
+            ):
+                warnings.warn(
+                    EXPERIMENTAL_WARNING.format(
+                        feature="Flow run job variables",
+                        group="flow_run_infra_overrides",
+                        help="To use this feature, update your workers to Prefect 2.16.4 or later. ",
+                    ),
+                    ExperimentalFeature,
+                    stacklevel=3,
+                )
+
         parameters = parameters or {}
         context = context or {}
         state = state or prefect.states.Scheduled()
@@ -549,6 +591,7 @@ class PrefectClient:
             name=name,
             idempotency_key=idempotency_key,
             parent_task_run_id=parent_task_run_id,
+            job_variables=job_variables,
         )
 
         # done separately to avoid including this field in payloads sent to older API versions
@@ -634,6 +677,7 @@ class PrefectClient:
         tags: Optional[Iterable[str]] = None,
         empirical_policy: Optional[FlowRunPolicy] = None,
         infrastructure_pid: Optional[str] = None,
+        job_variables: Optional[dict] = None,
     ) -> httpx.Response:
         """
         Update a flow run's details.
@@ -654,6 +698,21 @@ class PrefectClient:
         Returns:
             an `httpx.Response` object from the PATCH request
         """
+        if job_variables is not None and experiment_enabled("flow_run_infra_overrides"):
+            if (
+                PREFECT_EXPERIMENTAL_WARN
+                and PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES
+            ):
+                warnings.warn(
+                    EXPERIMENTAL_WARNING.format(
+                        feature="Flow run job variables",
+                        group="flow_run_infra_overrides",
+                        help="To use this feature, update your workers to Prefect 2.16.4 or later. ",
+                    ),
+                    ExperimentalFeature,
+                    stacklevel=3,
+                )
+
         params = {}
         if flow_version is not None:
             params["flow_version"] = flow_version
@@ -667,6 +726,8 @@ class PrefectClient:
             params["empirical_policy"] = empirical_policy
         if infrastructure_pid:
             params["infrastructure_pid"] = infrastructure_pid
+        if job_variables is not None:
+            params["job_variables"] = job_variables
 
         flow_run_data = FlowRunUpdate(**params)
 

prefect/client/schemas/actions.py

@@ -298,6 +298,7 @@ class FlowRunUpdate(ActionBaseModel):
     empirical_policy: objects.FlowRunPolicy = FieldFrom(objects.FlowRun)
     tags: List[str] = FieldFrom(objects.FlowRun)
     infrastructure_pid: Optional[str] = FieldFrom(objects.FlowRun)
+    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
 
 
 @copy_model_fields
@@ -380,6 +381,7 @@ class DeploymentFlowRunCreate(ActionBaseModel):
     idempotency_key: Optional[str] = FieldFrom(objects.FlowRun)
     parent_task_run_id: Optional[UUID] = FieldFrom(objects.FlowRun)
     work_queue_name: Optional[str] = FieldFrom(objects.FlowRun)
+    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
 
 
 @copy_model_fields

prefect/client/schemas/objects.py

@@ -526,6 +526,9 @@ class FlowRun(ObjectBaseModel):
         description="The state of the flow run.",
         example=State(type=StateType.COMPLETED),
     )
+    job_variables: Optional[dict] = Field(
+        default=None, description="Job variables for the flow run."
+    )
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -1629,3 +1632,16 @@ class GlobalConcurrencyLimit(ObjectBaseModel):
             " is used as a rate limit."
         ),
     )
+
+
+class CsrfToken(ObjectBaseModel):
+    token: str = Field(
+        default=...,
+        description="The CSRF token",
+    )
+    client: str = Field(
+        default=..., description="The client id associated with the CSRF token"
+    )
+    expiration: DateTimeTZ = Field(
+        default=..., description="The expiration time of the CSRF token"
+    )

prefect/client/schemas/responses.py

@@ -190,6 +190,7 @@ class FlowRunResponse(ObjectBaseModel):
         example="my-work-pool",
     )
     state: Optional[objects.State] = FieldFrom(objects.FlowRun)
+    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
 
     def __eq__(self, other: Any) -> bool:
         """

prefect/client/subscriptions.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Generic, List, Optional, Type, TypeVar
+from typing import Any, Dict, Generic, List, Optional, Type, TypeVar
 
 import orjson
 import websockets
@@ -71,23 +71,29 @@ class Subscription(Generic[S]):
                 ).decode()
             )
 
-            auth = orjson.loads(await websocket.recv())
-            assert auth["type"] == "auth_success"
+            auth: Dict[str, Any] = orjson.loads(await websocket.recv())
+            assert auth["type"] == "auth_success", auth.get("message")
 
-            message = {"type": "subscribe", "keys": self.keys} | {
-                **(dict(client_id=self.client_id) if self.client_id else {})
-            }
+            message = {"type": "subscribe", "keys": self.keys}
+            if self.client_id:
+                message.update({"client_id": self.client_id})
 
             await websocket.send(orjson.dumps(message).decode())
         except (
             AssertionError,
             websockets.exceptions.ConnectionClosedError,
         ) as e:
+            if isinstance(e, AssertionError) or e.code == WS_1008_POLICY_VIOLATION:
+                if isinstance(e, AssertionError):
+                    reason = e.args[0]
+                elif isinstance(e, websockets.exceptions.ConnectionClosedError):
+                    reason = e.reason
+
             if isinstance(e, AssertionError) or e.code == WS_1008_POLICY_VIOLATION:
                 raise Exception(
                     "Unable to authenticate to the subscription. Please "
                     "ensure the provided `PREFECT_API_KEY` you are using is "
-                    "valid for this environment."
+                    f"valid for this environment. Reason: {reason}"
                 ) from e
             raise
         else:

prefect/client/utilities.py

@@ -1,16 +1,60 @@
 """
 Utilities for working with clients.
 """
+
 # This module must not import from `prefect.client` when it is imported to avoid
 # circular imports for decorators such as `inject_client` which are widely used.
 
 from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, Tuple, cast
+
+from typing_extensions import ParamSpec
+
+if TYPE_CHECKING:
+    from prefect.client.orchestration import PrefectClient
+
+P = ParamSpec("P")
+
+
+def get_or_create_client(
+    client: Optional["PrefectClient"] = None,
+) -> Tuple["PrefectClient", bool]:
+    """
+    Returns provided client, infers a client from context if available, or creates a new client.
 
-from prefect._internal.concurrency.event_loop import get_running_loop
-from prefect.utilities.asyncutils import asyncnullcontext
+    Args:
+        - client (PrefectClient, optional): an optional client to use
 
+    Returns:
+        - tuple: a tuple of the client and a boolean indicating if the client was inferred from context
+    """
+    if client is not None:
+        return client, True
+    from prefect._internal.concurrency.event_loop import get_running_loop
+    from prefect.context import FlowRunContext, TaskRunContext
+
+    flow_run_context = FlowRunContext.get()
+    task_run_context = TaskRunContext.get()
+
+    if (
+        flow_run_context
+        and getattr(flow_run_context.client, "_loop") == get_running_loop()
+    ):
+        return flow_run_context.client, True
+    elif (
+        task_run_context
+        and getattr(task_run_context.client, "_loop") == get_running_loop()
+    ):
+        return task_run_context.client, True
+    else:
+        from prefect.client.orchestration import get_client as get_httpx_client
+
+        return get_httpx_client(), False
 
-def inject_client(fn):
+
+def inject_client(
+    fn: Callable[P, Coroutine[Any, Any, Any]],
+) -> Callable[P, Coroutine[Any, Any, Any]]:
     """
     Simple helper to provide a context managed client to a asynchronous function.
 
@@ -20,33 +64,16 @@ def inject_client(fn):
     """
 
     @wraps(fn)
-    async def with_injected_client(*args, **kwargs):
-        from prefect.client.orchestration import get_client
-        from prefect.context import FlowRunContext, TaskRunContext
-
-        flow_run_context = FlowRunContext.get()
-        task_run_context = TaskRunContext.get()
-        client = None
-        client_context = asyncnullcontext()
-
-        if "client" in kwargs and kwargs["client"] is not None:
-            # Client provided in kwargs
-            client = kwargs["client"]
-        elif flow_run_context and flow_run_context.client._loop == get_running_loop():
-            # Client available from flow run context
-            client = flow_run_context.client
-        elif task_run_context and task_run_context.client._loop == get_running_loop():
-            # Client available from task run context
-            client = task_run_context.client
-
+    async def with_injected_client(*args: P.args, **kwargs: P.kwargs) -> Any:
+        client = cast(Optional["PrefectClient"], kwargs.pop("client", None))
+        client, inferred = get_or_create_client(client)
+        if not inferred:
+            context = client
         else:
-            # A new client is needed
-            client_context = get_client()
-
-        # Removes existing client to allow it to be set by setdefault below
-        kwargs.pop("client", None)
+            from prefect.utilities.asyncutils import asyncnullcontext
 
-        async with client_context as new_client:
+            context = asyncnullcontext()
+        async with context as new_client:
             kwargs.setdefault("client", new_client or client)
             return await fn(*args, **kwargs)
 

prefect/deployments/deployments.py

@@ -16,6 +16,10 @@ import anyio
 import pendulum
 import yaml
 
+from prefect._internal.compatibility.deprecated import (
+    deprecated_callable,
+    deprecated_class,
+)
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect.client.schemas.actions import DeploymentScheduleCreate
 
@@ -24,12 +28,10 @@ if HAS_PYDANTIC_V2:
 else:
     from pydantic import BaseModel, Field, parse_obj_as, root_validator, validator
 
-from prefect._internal.compatibility.experimental import experimental_field
 from prefect.blocks.core import Block
 from prefect.blocks.fields import SecretDict
 from prefect.client.orchestration import PrefectClient, ServerType, get_client
 from prefect.client.schemas.objects import (
-    DEFAULT_AGENT_WORK_POOL_NAME,
     FlowRun,
     MinimalDeploymentSchedule,
 )
@@ -38,6 +40,7 @@ from prefect.client.utilities import inject_client
 from prefect.context import FlowRunContext, PrefectObjectRegistry, TaskRunContext
 from prefect.deployments.schedules import (
     FlexibleScheduleList,
+    create_minimal_deployment_schedule,
     normalize_to_minimal_deployment_schedules,
 )
 from prefect.deployments.steps.core import run_steps
@@ -53,6 +56,7 @@ from prefect.infrastructure import Infrastructure, Process
 from prefect.logging.loggers import flow_run_logger, get_logger
 from prefect.states import Scheduled
 from prefect.tasks import Task
+from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
 from prefect.utilities.filesystem import relative_path_to_current_platform, tmpchdir
@@ -75,6 +79,7 @@ async def run_deployment(
     idempotency_key: Optional[str] = None,
     work_queue_name: Optional[str] = None,
     as_subflow: Optional[bool] = True,
+    job_variables: Optional[dict] = None,
 ) -> FlowRun:
     """
     Create a flow run for a deployment and return it after completion or a timeout.
@@ -194,6 +199,7 @@ async def run_deployment(
         idempotency_key=idempotency_key,
         parent_task_run_id=parent_task_run_id,
         work_queue_name=work_queue_name,
+        job_variables=job_variables,
     )
 
     flow_run_id = flow_run.id
@@ -293,6 +299,7 @@ async def load_flow_from_flow_run(
     return flow
 
 
+@deprecated_callable(start_date="Mar 2024")
 def load_deployments_from_yaml(
     path: str,
 ) -> PrefectObjectRegistry:
@@ -316,13 +323,20 @@ def load_deployments_from_yaml(
     return registry
 
 
-@experimental_field(
-    "work_pool_name",
-    group="work_pools",
-    when=lambda x: x is not None and x != DEFAULT_AGENT_WORK_POOL_NAME,
+@deprecated_class(
+    start_date="Mar 2024",
+    help="Use `flow.deploy` to deploy your flows instead."
+    " Refer to the upgrade guide for more information:"
+    " https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/.",
 )
 class Deployment(BaseModel):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of March 2024 and will not be available after September 2024.
+    It has been replaced by `flow.deploy`, which offers enhanced functionality and better a better user experience.
+    For upgrade instructions, see https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/.
+
     A Prefect Deployment definition, used for specifying and building deployments.
 
     Args:
@@ -647,21 +661,27 @@ class Deployment(BaseModel):
             )
         return values
 
-    @validator("schedule")
-    def validate_schedule(cls, value):
-        if value:
-            cls._validate_schedule(value)
-        return value
-
     @root_validator(pre=True)
-    def validate_schedules(cls, values):
-        if "schedules" in values:
-            values["schedules"] = normalize_to_minimal_deployment_schedules(
-                values["schedules"]
-            )
+    def reconcile_schedules(cls, values):
+        schedule = values.get("schedule", NotSet)
+        schedules = values.get("schedules", NotSet)
 
-            for schedule in values["schedules"]:
-                cls._validate_schedule(schedule.schedule)
+        if schedules is not NotSet:
+            values["schedules"] = normalize_to_minimal_deployment_schedules(schedules)
+        elif schedule is not NotSet:
+            values["schedule"] = None
+
+            if schedule is None:
+                values["schedules"] = []
+            else:
+                values["schedules"] = [
+                    create_minimal_deployment_schedule(
+                        schedule=schedule, active=values.get("is_schedule_active")
+                    )
+                ]
+
+        for schedule in values.get("schedules", []):
+            cls._validate_schedule(schedule.schedule)
 
         return values
 
@@ -982,11 +1002,17 @@ class Deployment(BaseModel):
 
         # note that `deployment.load` only updates settings that were *not*
         # provided at initialization
-        deployment = cls(
-            name=name,
-            schedules=schedules,
+
+        deployment_args = {
+            "name": name,
+            "flow_name": flow.name,
             **kwargs,
-        )
+        }
+
+        if schedules is not None:
+            deployment_args["schedules"] = schedules
+
+        deployment = cls(**deployment_args)
         deployment.flow_name = flow.name
         if not deployment.entrypoint:
             ## first see if an entrypoint can be determined

prefect/deployments/schedules.py

@@ -3,6 +3,14 @@ from typing import List, Optional, Sequence, Union, get_args
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 
+try:
+    from prefect.server.schemas.schedules import SCHEDULE_TYPES as SERVER_SCHEDULE_TYPES
+
+    SERVER_SCHEDULE_TYPES = get_args(SERVER_SCHEDULE_TYPES)
+except ImportError:
+    # `prefect-client` does not have access to the server schemas.
+    SERVER_SCHEDULE_TYPES = ()
+
 FlexibleScheduleList = Sequence[Union[MinimalDeploymentSchedule, dict, SCHEDULE_TYPES]]
 
 
@@ -28,6 +36,11 @@ def normalize_to_minimal_deployment_schedules(
                 normalized.append(create_minimal_deployment_schedule(**obj))
             elif isinstance(obj, MinimalDeploymentSchedule):
                 normalized.append(obj)
+            elif isinstance(obj, SERVER_SCHEDULE_TYPES):
+                raise ValueError(
+                    "Server schema schedules are not supported. Please use "
+                    "the schedule objects from `prefect.client.schemas.schedules`"
+                )
             else:
                 raise ValueError(
                     "Invalid schedule provided. Must be a schedule object, a dict,"

prefect/deprecated/data_documents.py

@@ -32,7 +32,7 @@ from prefect._internal.compatibility.deprecated import (
 from prefect._internal.schemas.bases import PrefectBaseModel
 
 if TYPE_CHECKING:
-    from prefect.packaging.base import PackageManifest
+    from prefect.deprecated.packaging.base import PackageManifest
 
 T = TypeVar("T", bound="DataDocument")  # Generic for DataDocument class types
 D = TypeVar("D", bound=Any)  # Generic for DataDocument data types
@@ -243,7 +243,7 @@ class PackageManifestSerializer:
 
     @staticmethod
     def loads(blob: bytes) -> "PackageManifest":
-        from prefect.packaging.base import PackageManifest
+        from prefect.deprecated.packaging.base import PackageManifest
 
         return PackageManifest.parse_raw(blob)
 

prefect/deprecated/packaging/__init__.py

@@ -0,0 +1,12 @@
+"""
+DEPRECATION WARNING:
+This module is deprecated as of March 2024 and will not be available after September 2024.
+ """
+from prefect.deprecated.packaging.docker import DockerPackager
+from prefect.deprecated.packaging.file import FilePackager
+from prefect.deprecated.packaging.orion import OrionPackager
+
+# isort: split
+
+# Register any packaging serializers
+import prefect.deprecated.packaging.serializers

prefect/{packaging → deprecated/packaging}/base.py

@@ -1,6 +1,12 @@
+"""
+DEPRECATION WARNING:
+This module is deprecated as of March 2024 and will not be available after September 2024.
+"""
+
 import abc
 from typing import Generic, TypeVar
 
+from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
@@ -16,9 +22,14 @@ from prefect.utilities.pydantic import PartialModel, add_type_dispatch
 D = TypeVar("D")
 
 
+@deprecated_class(start_date="Mar 2024")
 @add_type_dispatch
 class Serializer(BaseModel, Generic[D], abc.ABC):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of version March 2024 and will not be available after September 2024.
+
     A serializer that can encode objects of type 'D' into bytes.
     """
 
@@ -31,9 +42,14 @@ class Serializer(BaseModel, Generic[D], abc.ABC):
         """Decode the blob of bytes into an object."""
 
 
+@deprecated_class(start_date="Mar 2024")
 @add_type_dispatch
 class PackageManifest(BaseModel, abc.ABC):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of version March 2024 and will not be available after September 2024.
+
     Describes a package.
     """
 
@@ -48,9 +64,14 @@ class PackageManifest(BaseModel, abc.ABC):
         """
 
 
+@deprecated_class(start_date="Mar 2024")
 @add_type_dispatch
 class Packager(BaseModel, abc.ABC):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of version March 2024 and will not be available after September 2024.
+
     Creates a package for a flow.
 
     A package contains the flow and is typically stored outside of Prefect. To

prefect/{packaging → deprecated/packaging}/docker.py

@@ -1,8 +1,14 @@
+"""
+DEPRECATION WARNING:
+This module is deprecated as of March 2024 and will not be available after September 2024.
+"""
+
 import json
 import sys
 from pathlib import Path
 from typing import Any, Mapping, Optional, Union
 
+from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
@@ -11,9 +17,9 @@ else:
     from pydantic import AnyHttpUrl, root_validator, validator
 from typing_extensions import Literal
 
+from prefect.deprecated.packaging.base import PackageManifest, Packager
+from prefect.deprecated.packaging.serializers import SourceSerializer
 from prefect.flows import Flow, load_flow_from_script
-from prefect.packaging.base import PackageManifest, Packager
-from prefect.packaging.serializers import SourceSerializer
 from prefect.software import CondaEnvironment, PythonEnvironment
 from prefect.utilities.asyncutils import run_sync_in_worker_thread
 from prefect.utilities.dockerutils import (
@@ -26,8 +32,13 @@ from prefect.utilities.dockerutils import (
 from prefect.utilities.slugify import slugify
 
 
+@deprecated_class(start_date="Mar 2024")
 class DockerPackageManifest(PackageManifest):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of version March 2024 and will not be available after September 2024.
+
     Represents a flow packaged in a Docker image
     """
 
@@ -40,8 +51,13 @@ class DockerPackageManifest(PackageManifest):
         return load_flow_from_script(self.image_flow_location, self.flow_name)
 
 
+@deprecated_class(start_date="Mar 2024")
 class DockerPackager(Packager):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of version March 2024 and will not be available after September 2024.
+
     This packager builds a Docker image containing the flow and the runtime environment
     necessary to run the flow.  The resulting image is optionally pushed to a container
     registry, given by `registry_url`.