wandb 0.18.1__py3-none-win32.whl → 0.18.2__py3-none-win32.whl

wandb/sdk/artifacts/storage_handlers/gcs_handler.py

@@ -1,8 +1,10 @@
 """GCS storage handler."""
 
+from __future__ import annotations
+
 import time
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import ParseResult, urlparse
 
 from wandb import util
@@ -26,17 +28,17 @@ class _GCSIsADirectoryError(Exception):
 
 
 class GCSHandler(StorageHandler):
-    _client: Optional["gcs_module.client.Client"]
+    _client: gcs_module.client.Client | None
 
-    def __init__(self, scheme: Optional[str] = None) -> None:
+    def __init__(self, scheme: str | None = None) -> None:
         self._scheme = scheme or "gs"
         self._client = None
         self._cache = get_artifact_file_cache()
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
-    def init_gcs(self) -> "gcs_module.client.Client":
+    def init_gcs(self) -> gcs_module.client.Client:
         if self._client is not None:
             return self._client
         storage = util.get_module(
@@ -46,7 +48,7 @@ class GCSHandler(StorageHandler):
         self._client = storage.Client()
         return self._client
 
-    def _parse_uri(self, uri: str) -> Tuple[str, str, Optional[str]]:
+    def _parse_uri(self, uri: str) -> tuple[str, str, str | None]:
         url = urlparse(uri)
         bucket = url.netloc
         key = url.path[1:]
@@ -57,7 +59,7 @@ class GCSHandler(StorageHandler):
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         assert manifest_entry.ref is not None
         if not local:
             return manifest_entry.ref
@@ -106,11 +108,11 @@ class GCSHandler(StorageHandler):
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         self.init_gcs()
         assert self._client is not None  # mypy: unwraps optionality
@@ -159,9 +161,9 @@ class GCSHandler(StorageHandler):
 
     def _entry_from_obj(
         self,
-        obj: "gcs_module.blob.Blob",
+        obj: gcs_module.blob.Blob,
         path: str,
-        name: Optional[StrPath] = None,
+        name: StrPath | None = None,
         prefix: str = "",
         multi: bool = False,
     ) -> ArtifactManifestEntry:

wandb/sdk/artifacts/storage_handlers/http_handler.py

@@ -1,7 +1,9 @@
 """HTTP storage handler."""
 
+from __future__ import annotations
+
 import os
-from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import ParseResult
 
 from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
@@ -13,26 +15,25 @@ from wandb.sdk.lib.paths import FilePathStr, StrPath, URIStr
 
 if TYPE_CHECKING:
     import requests
+    from requests.structures import CaseInsensitiveDict
 
     from wandb.sdk.artifacts.artifact import Artifact
 
 
 class HTTPHandler(StorageHandler):
-    def __init__(
-        self, session: "requests.Session", scheme: Optional[str] = None
-    ) -> None:
+    def __init__(self, session: requests.Session, scheme: str | None = None) -> None:
         self._scheme = scheme or "http"
         self._cache = get_artifact_file_cache()
         self._session = session
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
     def load_path(
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         if not local:
             assert manifest_entry.ref is not None
             return manifest_entry.ref
@@ -55,7 +56,7 @@ class HTTPHandler(StorageHandler):
         )
         response.raise_for_status()
 
-        digest: Optional[Union[ETag, FilePathStr, URIStr]]
+        digest: ETag | FilePathStr | URIStr | None
         digest, size, extra = self._entry_from_headers(response.headers)
         digest = digest or manifest_entry.ref
         if manifest_entry.digest != digest:
@@ -70,11 +71,11 @@ class HTTPHandler(StorageHandler):
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         name = name or os.path.basename(path)
         if not checksum:
@@ -87,7 +88,7 @@ class HTTPHandler(StorageHandler):
             headers=_thread_local_api_settings.headers,
         ) as response:
             response.raise_for_status()
-            digest: Optional[Union[ETag, FilePathStr, URIStr]]
+            digest: ETag | FilePathStr | URIStr | None
             digest, size, extra = self._entry_from_headers(response.headers)
             digest = digest or path
         return [
@@ -97,8 +98,8 @@ class HTTPHandler(StorageHandler):
         ]
 
     def _entry_from_headers(
-        self, headers: "requests.structures.CaseInsensitiveDict"
-    ) -> Tuple[Optional[ETag], Optional[int], Dict[str, str]]:
+        self, headers: CaseInsensitiveDict
+    ) -> tuple[ETag | None, int | None, dict[str, str]]:
         response_headers = {k.lower(): v for k, v in headers.items()}
         size = None
         if response_headers.get("content-length", None):

wandb/sdk/artifacts/storage_handlers/local_file_handler.py

@@ -1,9 +1,11 @@
 """Local file storage handler."""
 
+from __future__ import annotations
+
 import os
 import shutil
 import time
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import ParseResult
 
 from wandb import util
@@ -22,7 +24,7 @@ if TYPE_CHECKING:
 class LocalFileHandler(StorageHandler):
     """Handles file:// references."""
 
-    def __init__(self, scheme: Optional[str] = None) -> None:
+    def __init__(self, scheme: str | None = None) -> None:
         """Track files or directories on a local filesystem.
 
         Expand directories to create an entry for each file contained.
@@ -30,14 +32,14 @@ class LocalFileHandler(StorageHandler):
         self._scheme = scheme or "file"
         self._cache = get_artifact_file_cache()
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
     def load_path(
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         if manifest_entry.ref is None:
             raise ValueError(f"Cannot add path with no ref: {manifest_entry.path}")
         local_path = util.local_file_uri_to_path(str(manifest_entry.ref))
@@ -69,11 +71,11 @@ class LocalFileHandler(StorageHandler):
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         local_path = util.local_file_uri_to_path(path)
         max_objects = max_objects or DEFAULT_MAX_OBJECTS

wandb/sdk/artifacts/storage_handlers/multi_handler.py

@@ -1,6 +1,8 @@
 """Multi storage handler."""
 
-from typing import TYPE_CHECKING, List, Optional, Sequence, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import urlparse
 
 from wandb.sdk.artifacts.storage_handler import StorageHandler
@@ -12,17 +14,17 @@ if TYPE_CHECKING:
 
 
 class MultiHandler(StorageHandler):
-    _handlers: List[StorageHandler]
+    _handlers: list[StorageHandler]
 
     def __init__(
         self,
-        handlers: Optional[List[StorageHandler]] = None,
-        default_handler: Optional[StorageHandler] = None,
+        handlers: list[StorageHandler] | None = None,
+        default_handler: StorageHandler | None = None,
     ) -> None:
         self._handlers = handlers or []
         self._default_handler = default_handler
 
-    def _get_handler(self, url: Union[FilePathStr, URIStr]) -> StorageHandler:
+    def _get_handler(self, url: FilePathStr | URIStr) -> StorageHandler:
         parsed_url = urlparse(url)
         for handler in self._handlers:
             if handler.can_handle(parsed_url):
@@ -33,21 +35,21 @@ class MultiHandler(StorageHandler):
 
     def load_path(
         self,
-        manifest_entry: "ArtifactManifestEntry",
+        manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         assert manifest_entry.ref is not None
         handler = self._get_handler(manifest_entry.ref)
         return handler.load_path(manifest_entry, local=local)
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[str] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: str | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
-    ) -> Sequence["ArtifactManifestEntry"]:
+        max_objects: int | None = None,
+    ) -> Sequence[ArtifactManifestEntry]:
         handler = self._get_handler(path)
         return handler.store_path(
             artifact, path, name=name, checksum=checksum, max_objects=max_objects

wandb/sdk/artifacts/storage_handlers/s3_handler.py

@@ -1,9 +1,11 @@
 """S3 storage handler."""
 
+from __future__ import annotations
+
 import os
 import time
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import parse_qsl, urlparse
 
 from wandb import util
@@ -31,18 +33,18 @@ if TYPE_CHECKING:
 
 
 class S3Handler(StorageHandler):
-    _s3: Optional["boto3.resources.base.ServiceResource"]
+    _s3: boto3.resources.base.ServiceResource | None
     _scheme: str
 
-    def __init__(self, scheme: Optional[str] = None) -> None:
+    def __init__(self, scheme: str | None = None) -> None:
         self._scheme = scheme or "s3"
         self._s3 = None
         self._cache = get_artifact_file_cache()
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
-    def init_boto(self) -> "boto3.resources.base.ServiceResource":
+    def init_boto(self) -> boto3.resources.base.ServiceResource:
         if self._s3 is not None:
             return self._s3
         boto: boto3 = util.get_module(
@@ -58,7 +60,7 @@ class S3Handler(StorageHandler):
         self._botocore = util.get_module("botocore")
         return self._s3
 
-    def _parse_uri(self, uri: str) -> Tuple[str, str, Optional[str]]:
+    def _parse_uri(self, uri: str) -> tuple[str, str, str | None]:
         url = urlparse(uri)
         query = dict(parse_qsl(url.query))
 
@@ -72,7 +74,7 @@ class S3Handler(StorageHandler):
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         if not local:
             assert manifest_entry.ref is not None
             return manifest_entry.ref
@@ -141,11 +143,11 @@ class S3Handler(StorageHandler):
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         self.init_boto()
         assert self._s3 is not None  # mypy: unwraps optionality
@@ -222,9 +224,7 @@ class S3Handler(StorageHandler):
             )
         return entries
 
-    def _size_from_obj(
-        self, obj: Union["boto3.s3.Object", "boto3.s3.ObjectSummary"]
-    ) -> int:
+    def _size_from_obj(self, obj: boto3.s3.Object | boto3.s3.ObjectSummary) -> int:
         # ObjectSummary has size, Object has content_length
         size: int
         if hasattr(obj, "size"):
@@ -235,9 +235,9 @@ class S3Handler(StorageHandler):
 
     def _entry_from_obj(
         self,
-        obj: Union["boto3.s3.Object", "boto3.s3.ObjectSummary"],
+        obj: boto3.s3.Object | boto3.s3.ObjectSummary,
         path: str,
-        name: Optional[StrPath] = None,
+        name: StrPath | None = None,
         prefix: str = "",
         multi: bool = False,
     ) -> ArtifactManifestEntry:
@@ -281,14 +281,14 @@ class S3Handler(StorageHandler):
         )
 
     @staticmethod
-    def _etag_from_obj(obj: Union["boto3.s3.Object", "boto3.s3.ObjectSummary"]) -> ETag:
+    def _etag_from_obj(obj: boto3.s3.Object | boto3.s3.ObjectSummary) -> ETag:
         etag: ETag
         etag = obj.e_tag[1:-1]  # escape leading and trailing quote
         return etag
 
     def _extra_from_obj(
-        self, obj: Union["boto3.s3.Object", "boto3.s3.ObjectSummary"]
-    ) -> Dict[str, str]:
+        self, obj: boto3.s3.Object | boto3.s3.ObjectSummary
+    ) -> dict[str, str]:
         extra = {
             "etag": obj.e_tag[1:-1],  # escape leading and trailing quote
         }

wandb/sdk/artifacts/storage_handlers/tracking_handler.py

@@ -1,6 +1,8 @@
 """Tracking storage handler."""
 
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import urlparse
 
 from wandb.errors.term import termwarn
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 
 
 class TrackingHandler(StorageHandler):
-    def __init__(self, scheme: Optional[str] = None) -> None:
+    def __init__(self, scheme: str | None = None) -> None:
         """Track paths with no modification or special processing.
 
         Useful when paths being tracked are on file systems mounted at a standardized
@@ -26,14 +28,14 @@ class TrackingHandler(StorageHandler):
         """
         self._scheme = scheme or ""
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
     def load_path(
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         if local:
             # Likely a user error. The tracking handler is
             # oblivious to the underlying paths, so it has
@@ -48,11 +50,11 @@ class TrackingHandler(StorageHandler):
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         url = urlparse(path)
         if name is None:

wandb/sdk/artifacts/storage_handlers/wb_artifact_handler.py

@@ -1,7 +1,9 @@
 """WB artifact storage handler."""
 
+from __future__ import annotations
+
 import os
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import urlparse
 
 import wandb
@@ -22,14 +24,14 @@ if TYPE_CHECKING:
 class WBArtifactHandler(StorageHandler):
     """Handles loading and storing Artifact reference-type files."""
 
-    _client: Optional[PublicApi]
+    _client: PublicApi | None
 
     def __init__(self) -> None:
         self._scheme = "wandb-artifact"
         self._cache = get_artifact_file_cache()
         self._client = None
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
     @property
@@ -42,7 +44,7 @@ class WBArtifactHandler(StorageHandler):
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         """Load the file in the specified artifact given its corresponding entry.
 
         Download the referenced artifact; create and return a new symlink to the caller.
@@ -67,7 +69,7 @@ class WBArtifactHandler(StorageHandler):
             hex_to_b64_id(artifact_id), self.client.client
         )
         assert dep_artifact is not None
-        link_target_path: Union[URIStr, FilePathStr]
+        link_target_path: URIStr | FilePathStr
         if local:
             link_target_path = dep_artifact.get_entry(artifact_file_path).download()
         else:
@@ -77,11 +79,11 @@ class WBArtifactHandler(StorageHandler):
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         """Store the file or directory at the given path into the specified artifact.
 
@@ -97,7 +99,7 @@ class WBArtifactHandler(StorageHandler):
         """
         # Recursively resolve the reference until a concrete asset is found
         # TODO: Consider resolving server-side for performance improvements.
-        iter_path: Union[URIStr, FilePathStr, None] = path
+        iter_path: URIStr | FilePathStr | None = path
         while iter_path is not None and urlparse(iter_path).scheme == self._scheme:
             artifact_id = util.host_from_path(iter_path)
             artifact_file_path = util.uri_from_path(iter_path)

wandb/sdk/artifacts/storage_handlers/wb_local_artifact_handler.py

@@ -1,7 +1,9 @@
 """WB local artifact storage handler."""
 
+from __future__ import annotations
+
 import os
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Sequence
 
 import wandb
 from wandb import util
@@ -22,25 +24,25 @@ class WBLocalArtifactHandler(StorageHandler):
     def __init__(self) -> None:
         self._scheme = "wandb-client-artifact"
 
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == self._scheme
 
     def load_path(
         self,
         manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         raise NotImplementedError(
             "Should not be loading a path for an artifact entry with unresolved client id."
         )
 
     def store_path(
         self,
-        artifact: "Artifact",
-        path: Union[URIStr, FilePathStr],
-        name: Optional[StrPath] = None,
+        artifact: Artifact,
+        path: URIStr | FilePathStr,
+        name: StrPath | None = None,
         checksum: bool = True,
-        max_objects: Optional[int] = None,
+        max_objects: int | None = None,
     ) -> Sequence[ArtifactManifestEntry]:
         """Store the file or directory at the given path within the specified artifact.