wandb 0.16.5__py3-none-any.whl → 0.17.0__py3-none-any.whl

wandb/sdk/artifacts/storage_handlers/gcs_handler.py

@@ -1,7 +1,8 @@
 """GCS storage handler."""
+
 import time
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Sequence, Tuple, Union
 from urllib.parse import ParseResult, urlparse
 
 from wandb import util
@@ -9,7 +10,7 @@ from wandb.errors.term import termlog
 from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
 from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
 from wandb.sdk.artifacts.storage_handler import DEFAULT_MAX_OBJECTS, StorageHandler
-from wandb.sdk.lib.hashutil import B64MD5
+from wandb.sdk.lib.hashutil import ETag
 from wandb.sdk.lib.paths import FilePathStr, StrPath, URIStr
 
 if TYPE_CHECKING:
@@ -51,13 +52,14 @@ class GCSHandler(StorageHandler):
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
     ) -> Union[URIStr, FilePathStr]:
+        assert manifest_entry.ref is not None
         if not local:
-            assert manifest_entry.ref is not None
             return manifest_entry.ref
 
-        path, hit, cache_open = self._cache.check_md5_obj_path(
-            B64MD5(manifest_entry.digest),  # TODO(spencerpearson): unsafe cast
-            manifest_entry.size if manifest_entry.size is not None else 0,
+        path, hit, cache_open = self._cache.check_etag_obj_path(
+            url=URIStr(manifest_entry.ref),
+            etag=ETag(manifest_entry.digest),
+            size=manifest_entry.size if manifest_entry.size is not None else 0,
         )
         if hit:
             return path
@@ -81,10 +83,10 @@ class GCSHandler(StorageHandler):
                 raise ValueError(
                     f"Unable to download object {manifest_entry.ref} with generation {version}"
                 )
-            md5 = obj.md5_hash
-            if md5 != manifest_entry.digest:
+            if obj.etag != manifest_entry.digest:
                 raise ValueError(
-                    f"Digest mismatch for object {manifest_entry.ref}: expected {manifest_entry.digest} but found {md5}"
+                    f"Digest mismatch for object {manifest_entry.ref}: "
+                    f"expected {manifest_entry.digest} but found {obj.etag}"
                 )
 
         with cache_open(mode="wb") as f:
@@ -187,14 +189,7 @@ class GCSHandler(StorageHandler):
         return ArtifactManifestEntry(
             path=posix_name,
             ref=URIStr(f"{self._scheme}://{str(posix_ref)}"),
-            digest=obj.md5_hash,
+            digest=obj.etag,
             size=obj.size,
-            extra=self._extra_from_obj(obj),
+            extra={"versionID": obj.generation},
         )
-
-    @staticmethod
-    def _extra_from_obj(obj: "gcs_module.blob.Blob") -> Dict[str, str]:
-        return {
-            "etag": obj.etag,
-            "versionID": obj.generation,
-        }

wandb/sdk/artifacts/storage_handlers/http_handler.py

@@ -1,4 +1,5 @@
 """HTTP storage handler."""
+
 import os
 from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple, Union
 from urllib.parse import ParseResult

wandb/sdk/artifacts/storage_handlers/local_file_handler.py

@@ -1,4 +1,5 @@
 """Local file storage handler."""
+
 import os
 import shutil
 import time

wandb/sdk/artifacts/storage_handlers/multi_handler.py

@@ -1,4 +1,5 @@
 """Multi storage handler."""
+
 from typing import TYPE_CHECKING, List, Optional, Sequence, Union
 from urllib.parse import urlparse
 

wandb/sdk/artifacts/storage_handlers/s3_handler.py

@@ -1,4 +1,5 @@
 """S3 storage handler."""
+
 import os
 import time
 from pathlib import PurePosixPath
@@ -182,9 +183,10 @@ class S3Handler(StorageHandler):
                     multi = True
                 else:
                     raise CommError(
-                        "Unable to connect to S3 ({}): {}".format(
-                            e.response["Error"]["Code"], e.response["Error"]["Message"]
-                        )
+                        f"Unable to connect to S3 ({e.response['Error']['Code']}): "
+                        f"{e.response['Error']['Message']}. Check that your "
+                        "authentication credentials are valid and that your region is "
+                        "set correctly."
                     )
         else:
             multi = True

wandb/sdk/artifacts/storage_handlers/tracking_handler.py

@@ -1,4 +1,5 @@
 """Tracking storage handler."""
+
 from typing import TYPE_CHECKING, Optional, Sequence, Union
 from urllib.parse import urlparse
 

wandb/sdk/artifacts/storage_handlers/wb_artifact_handler.py

@@ -1,4 +1,5 @@
 """WB artifact storage handler."""
+
 import os
 from typing import TYPE_CHECKING, Optional, Sequence, Union
 from urllib.parse import urlparse

wandb/sdk/artifacts/storage_handlers/wb_local_artifact_handler.py

@@ -1,4 +1,5 @@
 """WB local artifact storage handler."""
+
 import os
 from typing import TYPE_CHECKING, Optional, Sequence, Union
 

wandb/sdk/artifacts/storage_policies/wandb_storage_policy.py

@@ -1,4 +1,5 @@
 """WandB storage policy."""
+
 import hashlib
 import math
 import os
@@ -262,7 +263,7 @@ class WandbStoragePolicy(StoragePolicy):
             return math.ceil(file_size / S3_MAX_PART_NUMBERS)
         return default_chunk_size
 
-    def store_file_sync(
+    def store_file(
         self,
         artifact_id: str,
         artifact_manifest_id: str,
@@ -300,7 +301,7 @@ class WandbStoragePolicy(StoragePolicy):
                     hex_digests[part_number] = hex_digest
                     part_number += 1
 
-        resp = preparer.prepare_sync(
+        resp = preparer.prepare(
             {
                 "artifactID": artifact_id,
                 "artifactManifestID": artifact_manifest_id,
@@ -346,46 +347,6 @@ class WandbStoragePolicy(StoragePolicy):
 
         return False
 
-    async def store_file_async(
-        self,
-        artifact_id: str,
-        artifact_manifest_id: str,
-        entry: "ArtifactManifestEntry",
-        preparer: "StepPrepare",
-        progress_callback: Optional["progress.ProgressFn"] = None,
-    ) -> bool:
-        """Async equivalent to `store_file_sync`."""
-        resp = await preparer.prepare_async(
-            {
-                "artifactID": artifact_id,
-                "artifactManifestID": artifact_manifest_id,
-                "name": entry.path,
-                "md5": entry.digest,
-            }
-        )
-
-        entry.birth_artifact_id = resp.birth_artifact_id
-        if resp.upload_url is None:
-            return True
-        if entry.local_path is None:
-            return False
-
-        with open(entry.local_path, "rb") as file:
-            # This fails if we don't send the first byte before the signed URL expires.
-            await self._api.upload_file_retry_async(
-                resp.upload_url,
-                file,
-                progress_callback,
-                extra_headers={
-                    header.split(":", 1)[0]: header.split(":", 1)[1]
-                    for header in (resp.upload_headers or {})
-                },
-            )
-
-        self._write_cache(entry)
-
-        return False
-
     def _write_cache(self, entry: "ArtifactManifestEntry") -> None:
         if entry.local_path is None:
             return

wandb/sdk/artifacts/storage_policy.py

@@ -1,4 +1,5 @@
 """Storage policy."""
+
 from typing import TYPE_CHECKING, Dict, Optional, Sequence, Type, Union
 
 from wandb.sdk.internal.internal_api import Api as InternalApi
@@ -42,17 +43,7 @@ class StoragePolicy:
     ) -> FilePathStr:
         raise NotImplementedError
 
-    def store_file_sync(
-        self,
-        artifact_id: str,
-        artifact_manifest_id: str,
-        entry: "ArtifactManifestEntry",
-        preparer: "StepPrepare",
-        progress_callback: Optional["ProgressFn"] = None,
-    ) -> bool:
-        raise NotImplementedError
-
-    async def store_file_async(
+    def store_file(
         self,
         artifact_id: str,
         artifact_manifest_id: str,
@@ -60,7 +51,6 @@ class StoragePolicy:
         preparer: "StepPrepare",
         progress_callback: Optional["ProgressFn"] = None,
     ) -> bool:
-        """Async equivalent to `store_file_sync`."""
         raise NotImplementedError
 
     def store_reference(

wandb/sdk/data_types/_dtypes.py

@@ -14,7 +14,7 @@ np = get_module("numpy")  # intentionally not required
 if t.TYPE_CHECKING:
     from wandb.sdk.artifacts.artifact import Artifact
 
-ConvertableToType = t.Union["Type", t.Type["Type"], type, t.Any]
+ConvertibleToType = t.Union["Type", t.Type["Type"], type, t.Any]
 
 
 class TypeRegistry:
@@ -84,7 +84,7 @@ class TypeRegistry:
         return _type.from_json(json_dict, artifact)
 
     @staticmethod
-    def type_from_dtype(dtype: ConvertableToType) -> "Type":
+    def type_from_dtype(dtype: ConvertibleToType) -> "Type":
         # The dtype is already an instance of Type
         if isinstance(dtype, Type):
             wbtype: Type = dtype
@@ -528,7 +528,7 @@ class UnionType(Type):
 
     def __init__(
         self,
-        allowed_types: t.Optional[t.Sequence[ConvertableToType]] = None,
+        allowed_types: t.Optional[t.Sequence[ConvertibleToType]] = None,
     ):
         assert allowed_types is None or (allowed_types.__class__ == list)
         if allowed_types is None:
@@ -576,7 +576,7 @@ class UnionType(Type):
         return "{}".format(" or ".join([str(t) for t in self.params["allowed_types"]]))
 
 
-def OptionalType(dtype: ConvertableToType) -> UnionType:  # noqa: N802
+def OptionalType(dtype: ConvertibleToType) -> UnionType:  # noqa: N802
     """Function that mimics the Type class API for constructing an "Optional Type".
 
     This is just a Union[wb_type, NoneType].
@@ -591,14 +591,14 @@ def OptionalType(dtype: ConvertableToType) -> UnionType:  # noqa: N802
 
 
 class ListType(Type):
-    """A list of homogenous types."""
+    """A list of homogeneous types."""
 
     name = "list"
     types: t.ClassVar[t.List[type]] = [list, tuple, set, frozenset]
 
     def __init__(
         self,
-        element_type: t.Optional[ConvertableToType] = None,
+        element_type: t.Optional[ConvertibleToType] = None,
         length: t.Optional[int] = None,
     ):
         if element_type is None:
@@ -691,7 +691,7 @@ class ListType(Type):
 
 
 class NDArrayType(Type):
-    """Represents a list of homogenous types."""
+    """Represents a list of homogeneous types."""
 
     name = "ndarray"
     types: t.ClassVar[t.List[type]] = []  # will manually add type if np is available
@@ -786,7 +786,7 @@ class TypedDictType(Type):
 
     def __init__(
         self,
-        type_map: t.Optional[t.Dict[str, ConvertableToType]] = None,
+        type_map: t.Optional[t.Dict[str, ConvertibleToType]] = None,
     ):
         if type_map is None:
             type_map = {}

wandb/sdk/data_types/base_types/media.py

@@ -177,9 +177,7 @@ class Media(WBValue):
                 json_obj["_latest_artifact_path"] = artifact_entry_latest_url
 
             if artifact_entry_url is None or self.is_bound():
-                assert (
-                    self.is_bound()
-                ), "Value of type {} must be bound to a run with bind_to_run() before being serialized to JSON.".format(
+                assert self.is_bound(), "Value of type {} must be bound to a run with bind_to_run() before being serialized to JSON.".format(
                     type(self).__name__
                 )
 
@@ -221,8 +219,7 @@ class Media(WBValue):
 
                     # if not, check to see if there is a source artifact for this object
                     if (
-                        self._artifact_source
-                        is not None
+                        self._artifact_source is not None
                         # and self._artifact_source.artifact != artifact
                     ):
                         default_root = self._artifact_source.artifact._default_root()
@@ -292,7 +289,7 @@ class BatchableMedia(Media):
 
 
 def _numpy_arrays_to_lists(
-    payload: Union[dict, Sequence, "np.ndarray"]
+    payload: Union[dict, Sequence, "np.ndarray"],
 ) -> Union[Sequence, dict, str, int, float, bool]:
     # Casts all numpy arrays to lists so we don't convert them to histograms, primarily for Plotly
 

wandb/sdk/data_types/helper_types/bounding_boxes_2d.py

@@ -231,8 +231,10 @@ class BoundingBoxes2D(JSONMetadata):
 
         for box in boxes:
             # Required arguments
-            error_str = "Each box must contain a position with: middle, width, and height or \
+            error_str = (
+                "Each box must contain a position with: middle, width, and height or \
                     \nminX, maxX, minY, maxY."
+            )
             if "position" not in box:
                 raise TypeError(error_str)
             else:

wandb/sdk/data_types/image.py

@@ -167,7 +167,7 @@ class Image(BatchableMedia):
         self._file_type = None
 
         # Allows the user to pass an Image object as the first parameter and have a perfect copy,
-        # only overriding additional metdata passed in. If this pattern is compelling, we can generalize.
+        # only overriding additional metadata passed in. If this pattern is compelling, we can generalize.
         if isinstance(data_or_path, Image):
             self._initialize_from_wbimage(data_or_path)
         elif isinstance(data_or_path, str):

wandb/sdk/data_types/video.py

@@ -24,7 +24,7 @@ if TYPE_CHECKING:  # pragma: no cover
 # https://github.com/wandb/wandb/issues/3472
 #
 # Essentially, the issue is that moviepy's write_gif function fails to close
-# the open write / file descripter returned from `imageio.save`. The following
+# the open write / file descriptor returned from `imageio.save`. The following
 # function is a simplified copy of the function in the moviepy source code.
 # See https://github.com/Zulko/moviepy/blob/7e3e8bb1b739eb6d1c0784b0cb2594b587b93b39/moviepy/video/io/gif_writers.py#L428
 #

wandb/sdk/integration_utils/auto_logging.py

@@ -27,11 +27,11 @@ V = TypeVar("V")
 
 
 class Response(Protocol[K, V]):
-    def __getitem__(self, key: K) -> V:
-        ...  # pragma: no cover
+    def __getitem__(self, key: K) -> V: ...  # pragma: no cover
 
-    def get(self, key: K, default: Optional[V] = None) -> Optional[V]:
-        ...  # pragma: no cover
+    def get(
+        self, key: K, default: Optional[V] = None
+    ) -> Optional[V]: ...  # pragma: no cover
 
 
 class ArgumentResponseResolver(Protocol):
@@ -42,8 +42,7 @@ class ArgumentResponseResolver(Protocol):
         response: Response,
         start_time: float,
         time_elapsed: float,
-    ) -> Optional[Dict[str, Any]]:
-        ...  # pragma: no cover
+    ) -> Optional[Dict[str, Any]]: ...  # pragma: no cover
 
 
 class PatchAPI:

wandb/sdk/integration_utils/data_logging.py

@@ -78,7 +78,7 @@ class ValidationDataLogger:
                 Defaults to `"wb_validation_data"`.
             artifact_type: The artifact type to use for the validation data.
                 Defaults to `"validation_dataset"`.
-            class_labels: Optional list of lables to use in the inferred
+            class_labels: Optional list of labels to use in the inferred
                 processors. If the model's `target` or `output` is inferred to be a class,
                 we will attempt to map the class to these labels. Defaults to `None`.
             infer_missing_processors: Determines if processors are inferred if
@@ -262,7 +262,7 @@ def _infer_single_example_keyed_processor(
     ):
         np = wandb.util.get_module(
             "numpy",
-            required="Infering processors require numpy",
+            required="Inferring processors require numpy",
         )
         # Assume these are logits
         class_names = class_labels_table.get_column("label")
@@ -291,13 +291,17 @@ def _infer_single_example_keyed_processor(
     ):
         # assume this is a class
         if class_labels_table is not None:
-            processors["class"] = lambda n, d, p: class_labels_table.index_ref(d[0]) if d[0] < len(class_labels_table.data) else d[0]  # type: ignore
+            processors["class"] = (
+                lambda n, d, p: class_labels_table.index_ref(d[0])
+                if d[0] < len(class_labels_table.data)
+                else d[0]
+            )  # type: ignore
         else:
             processors["val"] = lambda n, d, p: d[0]
     elif len(shape) == 1:
         np = wandb.util.get_module(
             "numpy",
-            required="Infering processors require numpy",
+            required="Inferring processors require numpy",
         )
         # This could be anything
         if shape[0] <= 10:
@@ -350,7 +354,7 @@ def _infer_validation_row_processor(
     input_col_name: str = "input",
     target_col_name: str = "target",
 ) -> Callable:
-    """Infers the composit processor for the validation data."""
+    """Infers the composite processor for the validation data."""
     single_processors = {}
     if isinstance(example_input, dict):
         for key in example_input:
@@ -427,7 +431,7 @@ def _infer_prediction_row_processor(
     input_col_name: str = "input",
     output_col_name: str = "output",
 ) -> Callable:
-    """Infers the composit processor for the prediction output data."""
+    """Infers the composite processor for the prediction output data."""
     single_processors = {}
 
     if isinstance(example_prediction, dict):

wandb/sdk/interface/interface.py

@@ -25,6 +25,7 @@ from typing import (
     Union,
 )
 
+from wandb import termwarn
 from wandb.proto import wandb_internal_pb2 as pb
 from wandb.proto import wandb_telemetry_pb2 as tpb
 from wandb.sdk.artifacts.artifact import Artifact
@@ -386,18 +387,30 @@ class InterfaceBase:
     def _make_partial_source_str(
         source: Any, job_info: Dict[str, Any], metadata: Dict[str, Any]
     ) -> str:
-        """Construct use_artifact.partial.source_info.sourc as str."""
+        """Construct use_artifact.partial.source_info.source as str."""
         source_type = job_info.get("source_type", "").strip()
         if source_type == "artifact":
             info_source = job_info.get("source", {})
             source.artifact.artifact = info_source.get("artifact", "")
             source.artifact.entrypoint.extend(info_source.get("entrypoint", []))
             source.artifact.notebook = info_source.get("notebook", False)
+            build_context = info_source.get("build_context")
+            if build_context:
+                source.artifact.build_context = build_context
+            dockerfile = info_source.get("dockerfile")
+            if dockerfile:
+                source.artifact.dockerfile = dockerfile
         elif source_type == "repo":
             source.git.git_info.remote = metadata.get("git", {}).get("remote", "")
             source.git.git_info.commit = metadata.get("git", {}).get("commit", "")
             source.git.entrypoint.extend(metadata.get("entrypoint", []))
             source.git.notebook = metadata.get("notebook", False)
+            build_context = metadata.get("build_context")
+            if build_context:
+                source.git.build_context = build_context
+            dockerfile = metadata.get("dockerfile")
+            if dockerfile:
+                source.git.dockerfile = dockerfile
         elif source_type == "image":
             source.image.image = metadata.get("docker", "")
         else:
@@ -423,7 +436,7 @@ class InterfaceBase:
             job_info=job_info,
             metadata=metadata,
         )
-        use_artifact.partial.source_info.source.ParseFromString(src_str)
+        use_artifact.partial.source_info.source.ParseFromString(src_str)  # type: ignore[arg-type]
 
         return use_artifact
 
@@ -447,16 +460,27 @@ class InterfaceBase:
                 path = artifact.get_entry("wandb-job.json").download()
                 with open(path) as f:
                     job_info = json.load(f)
+
             except Exception as e:
                 logger.warning(
                     f"Failed to download partial job info from artifact {artifact}, : {e}"
                 )
-            use_artifact = self._make_proto_use_artifact(
-                use_artifact=use_artifact,
-                job_name=artifact.name,
-                job_info=job_info,
-                metadata=artifact.metadata,
-            )
+                termwarn(
+                    f"Failed to download partial job info from artifact {artifact}, : {e}"
+                )
+                return
+
+            try:
+                use_artifact = self._make_proto_use_artifact(
+                    use_artifact=use_artifact,
+                    job_name=artifact.name,
+                    job_info=job_info,
+                    metadata=artifact.metadata,
+                )
+            except Exception as e:
+                logger.warning(f"Failed to construct use artifact proto: {e}")
+                termwarn(f"Failed to construct use artifact proto: {e}")
+                return
 
         self._publish_use_artifact(use_artifact)
 
@@ -504,11 +528,15 @@ class InterfaceBase:
         artifact_id: str,
         download_root: str,
         allow_missing_references: bool,
+        skip_cache: bool,
+        path_prefix: Optional[str],
     ) -> MailboxHandle:
         download_artifact = pb.DownloadArtifactRequest()
         download_artifact.artifact_id = artifact_id
         download_artifact.download_root = download_root
         download_artifact.allow_missing_references = allow_missing_references
+        download_artifact.skip_cache = skip_cache
+        download_artifact.path_prefix = path_prefix or ""
         resp = self._deliver_download_artifact(download_artifact)
         return resp
 
@@ -717,6 +745,56 @@ class InterfaceBase:
     def _publish_keepalive(self, keepalive: pb.KeepaliveRequest) -> None:
         raise NotImplementedError
 
+    def publish_job_input(
+        self,
+        include_paths: List[List[str]],
+        exclude_paths: List[List[str]],
+        run_config: bool = False,
+        file_path: str = "",
+    ):
+        """Publishes a request to add inputs to the job.
+
+        If run_config is True, the wandb.config will be added as a job input.
+        If file_path is provided, the file at file_path will be added as a job
+        input.
+
+        The paths provided as arguments are sequences of dictionary keys that
+        specify a path within the wandb.config. If a path is included, the
+        corresponding field will be treated as a job input. If a path is
+        excluded, the corresponding field will not be treated as a job input.
+
+        Args:
+            include_paths: paths within config to include as job inputs.
+            exclude_paths: paths within config to exclude as job inputs.
+            run_config: bool indicating whether wandb.config is the input source.
+            file_path: path to file to include as a job input.
+        """
+        if run_config and file_path:
+            raise ValueError(
+                "run_config and file_path are mutually exclusive arguments."
+            )
+        request = pb.JobInputRequest()
+        include_records = [pb.JobInputPath(path=path) for path in include_paths]
+        exclude_records = [pb.JobInputPath(path=path) for path in exclude_paths]
+        request.include_paths.extend(include_records)
+        request.exclude_paths.extend(exclude_records)
+        source = pb.JobInputSource(
+            run_config=pb.JobInputSource.RunConfigSource(),
+        )
+        if run_config:
+            source.run_config.CopyFrom(pb.JobInputSource.RunConfigSource())
+        else:
+            source.file.CopyFrom(
+                pb.JobInputSource.ConfigFileSource(path=file_path),
+            )
+        request.input_source.CopyFrom(source)
+
+        return self._publish_job_input(request)
+
+    @abstractmethod
+    def _publish_job_input(self, request: pb.JobInputRequest) -> MailboxHandle:
+        raise NotImplementedError
+
     def join(self) -> None:
         # Drop indicates that the internal process has already been shutdown
         if self._drop:
@@ -767,36 +845,6 @@ class InterfaceBase:
         run_start.run.CopyFrom(run_pb)
         return self._deliver_run_start(run_start)
 
-    def publish_launch_wandb_config_parameters(
-        self, include_paths: List[List[str]], exclude_paths: List[List[str]]
-    ):
-        """Tells the internal process to treat wandb.config fields as job inputs.
-
-        The paths provided as arguments are sequences of dictionary keys that
-        specify a path within the wandb.config. If a path is included, the
-        corresponding field will be treated as a job input. If a path is
-        excluded, the corresponding field will not be treated as a job input.
-
-        Args:
-            include_paths: paths within config to include as job inputs.
-            exclude_paths: paths within config to exclude as job inputs.
-
-        Returns:
-            None
-        """
-        config_parameters = pb.LaunchWandbConfigParametersRecord()
-        include_records = [pb.ConfigFilterPath(path=path) for path in include_paths]
-        exclude_records = [pb.ConfigFilterPath(path=path) for path in exclude_paths]
-        config_parameters.include_paths.extend(include_records)
-        config_parameters.exclude_paths.extend(exclude_records)
-        return self._publish_launch_wandb_config_parameters(config_parameters)
-
-    @abstractmethod
-    def _publish_launch_wandb_config_parameters(
-        self, config_parameters: pb.LaunchWandbConfigParametersRecord
-    ) -> None:
-        raise NotImplementedError
-
     @abstractmethod
     def _deliver_run_start(self, run_start: pb.RunStartRequest) -> MailboxHandle:
         raise NotImplementedError