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

wandb/sdk/artifacts/artifact_file_cache.py

@@ -1,5 +1,7 @@
 """Artifact cache."""
 
+from __future__ import annotations
+
 import contextlib
 import errno
 import hashlib
@@ -9,7 +11,7 @@ import subprocess
 import sys
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import IO, TYPE_CHECKING, ContextManager, Iterator, Optional, Tuple
+from typing import IO, TYPE_CHECKING, ContextManager, Iterator
 
 import wandb
 from wandb import env, util
@@ -49,11 +51,11 @@ class ArtifactFileCache:
         # [1] https://stackoverflow.com/questions/10541760/can-i-set-the-umask-for-tempfile-namedtemporaryfile-in-python
         self._sys_umask = _get_sys_umask_threadsafe()
 
-        self._override_cache_path: Optional[StrPath] = None
+        self._override_cache_path: StrPath | None = None
 
     def check_md5_obj_path(
         self, b64_md5: B64MD5, size: int
-    ) -> Tuple[FilePathStr, bool, "Opener"]:
+    ) -> tuple[FilePathStr, bool, Opener]:
         # Check if we're using vs skipping the cache
         if self._override_cache_path is not None:
             skip_cache = True
@@ -71,7 +73,7 @@ class ArtifactFileCache:
         url: URIStr,
         etag: ETag,
         size: int,
-    ) -> Tuple[FilePathStr, bool, "Opener"]:
+    ) -> tuple[FilePathStr, bool, Opener]:
         # Check if we're using vs skipping the cache
         if self._override_cache_path is not None:
             skip_cache = True
@@ -87,16 +89,16 @@ class ArtifactFileCache:
 
     def _check_or_create(
         self, path: Path, size: int, skip_cache: bool = False
-    ) -> Tuple[FilePathStr, bool, "Opener"]:
+    ) -> tuple[FilePathStr, bool, Opener]:
         opener = self._opener(path, size, skip_cache=skip_cache)
         hit = path.is_file() and path.stat().st_size == size
         return FilePathStr(str(path)), hit, opener
 
     def cleanup(
         self,
-        target_size: Optional[int] = None,
+        target_size: int | None = None,
         remove_temp: bool = False,
-        target_fraction: Optional[float] = None,
+        target_fraction: float | None = None,
     ) -> int:
         """Clean up the cache, removing the least recently used files first.
 
@@ -121,9 +123,9 @@ class ArtifactFileCache:
             target_size = 0
         if target_size is not None and target_fraction is not None:
             raise ValueError("Cannot specify both target_size and target_fraction")
-        if target_size and target_size < 0:
+        if target_size is not None and target_size < 0:
             raise ValueError("target_size must be non-negative")
-        if target_fraction and (target_fraction < 0 or target_fraction > 1):
+        if target_fraction is not None and (target_fraction < 0 or target_fraction > 1):
             raise ValueError("target_fraction must be between 0 and 1")
 
         bytes_reclaimed = 0
@@ -198,7 +200,7 @@ class ArtifactFileCache:
         if size > self._free_space():
             raise OSError(errno.ENOSPC, f"Insufficient free space in {self._cache_dir}")
 
-    def _opener(self, path: Path, size: int, skip_cache: bool = False) -> "Opener":
+    def _opener(self, path: Path, size: int, skip_cache: bool = False) -> Opener:
         @contextlib.contextmanager
         def atomic_open(mode: str = "w") -> Iterator[IO]:
             if "a" in mode:
@@ -240,7 +242,7 @@ class ArtifactFileCache:
             ) from e
 
 
-_artifact_file_cache: Optional[ArtifactFileCache] = None
+_artifact_file_cache: ArtifactFileCache | None = None
 
 
 def get_artifact_file_cache() -> ArtifactFileCache:

wandb/sdk/artifacts/artifact_instance_cache.py

@@ -4,7 +4,9 @@ Artifacts are registered in the cache to ensure they won't be immediately garbag
 collected and can be retrieved by their ID.
 """
 
-from typing import TYPE_CHECKING, Dict
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from wandb.sdk.lib.capped_dict import CappedDict
 
@@ -12,4 +14,4 @@ if TYPE_CHECKING:
     from wandb.sdk.artifacts.artifact import Artifact
 
 # There is nothing special about the artifact cache, it's just a global capped dict.
-artifact_instance_cache: Dict[str, "Artifact"] = CappedDict(100)
+artifact_instance_cache: dict[str, Artifact] = CappedDict(100)

wandb/sdk/artifacts/artifact_manifest.py

@@ -1,6 +1,8 @@
 """Artifact manifest."""
 
-from typing import TYPE_CHECKING, Dict, List, Mapping, Optional
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping
 
 from wandb.sdk.internal.internal_api import Api as InternalApi
 from wandb.sdk.lib.hashutil import HexMD5
@@ -11,12 +13,12 @@ if TYPE_CHECKING:
 
 
 class ArtifactManifest:
-    entries: Dict[str, "ArtifactManifestEntry"]
+    entries: dict[str, ArtifactManifestEntry]
 
     @classmethod
     def from_manifest_json(
-        cls, manifest_json: Dict, api: Optional[InternalApi] = None
-    ) -> "ArtifactManifest":
+        cls, manifest_json: dict, api: InternalApi | None = None
+    ) -> ArtifactManifest:
         if "version" not in manifest_json:
             raise ValueError("Invalid manifest format. Must contain version field.")
         version = manifest_json["version"]
@@ -31,8 +33,8 @@ class ArtifactManifest:
 
     def __init__(
         self,
-        storage_policy: "StoragePolicy",
-        entries: Optional[Mapping[str, "ArtifactManifestEntry"]] = None,
+        storage_policy: StoragePolicy,
+        entries: Mapping[str, ArtifactManifestEntry] | None = None,
     ) -> None:
         self.storage_policy = storage_policy
         self.entries = dict(entries) if entries else {}
@@ -40,13 +42,13 @@ class ArtifactManifest:
     def __len__(self) -> int:
         return len(self.entries)
 
-    def to_manifest_json(self) -> Dict:
+    def to_manifest_json(self) -> dict:
         raise NotImplementedError
 
     def digest(self) -> HexMD5:
         raise NotImplementedError
 
-    def add_entry(self, entry: "ArtifactManifestEntry") -> None:
+    def add_entry(self, entry: ArtifactManifestEntry) -> None:
         if (
             entry.path in self.entries
             and entry.digest != self.entries[entry.path].digest
@@ -54,15 +56,15 @@ class ArtifactManifest:
             raise ValueError("Cannot add the same path twice: {}".format(entry.path))
         self.entries[entry.path] = entry
 
-    def remove_entry(self, entry: "ArtifactManifestEntry") -> None:
+    def remove_entry(self, entry: ArtifactManifestEntry) -> None:
         if entry.path not in self.entries:
             raise FileNotFoundError(f"Cannot remove missing entry: '{entry.path}'")
         del self.entries[entry.path]
 
-    def get_entry_by_path(self, path: str) -> Optional["ArtifactManifestEntry"]:
+    def get_entry_by_path(self, path: str) -> ArtifactManifestEntry | None:
         return self.entries.get(path)
 
-    def get_entries_in_directory(self, directory: str) -> List["ArtifactManifestEntry"]:
+    def get_entries_in_directory(self, directory: str) -> list[ArtifactManifestEntry]:
         return [
             self.entries[entry_key]
             for entry_key in self.entries

wandb/sdk/artifacts/artifact_manifest_entry.py

@@ -1,10 +1,12 @@
 """Artifact manifest entry."""
 
+from __future__ import annotations
+
 import json
 import logging
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Optional, Union
+from typing import TYPE_CHECKING
 from urllib.parse import urlparse
 
 from wandb.sdk.lib import filesystem
@@ -32,7 +34,7 @@ if TYPE_CHECKING:
         ref: str
         birthArtifactID: str
         size: int
-        extra: Dict
+        extra: dict
         local_path: str
 
 
@@ -40,27 +42,27 @@ class ArtifactManifestEntry:
     """A single entry in an artifact manifest."""
 
     path: LogicalPath
-    digest: Union[B64MD5, URIStr, FilePathStr, ETag]
+    digest: B64MD5 | URIStr | FilePathStr | ETag
     skip_cache: bool
-    ref: Optional[Union[FilePathStr, URIStr]]
-    birth_artifact_id: Optional[str]
-    size: Optional[int]
-    extra: Dict
-    local_path: Optional[str]
+    ref: FilePathStr | URIStr | None
+    birth_artifact_id: str | None
+    size: int | None
+    extra: dict
+    local_path: str | None
 
-    _parent_artifact: Optional["Artifact"] = None
-    _download_url: Optional[str] = None
+    _parent_artifact: Artifact | None = None
+    _download_url: str | None = None
 
     def __init__(
         self,
         path: StrPath,
-        digest: Union[B64MD5, URIStr, FilePathStr, ETag],
-        skip_cache: Optional[bool] = False,
-        ref: Optional[Union[FilePathStr, URIStr]] = None,
-        birth_artifact_id: Optional[str] = None,
-        size: Optional[int] = None,
-        extra: Optional[Dict] = None,
-        local_path: Optional[StrPath] = None,
+        digest: B64MD5 | URIStr | FilePathStr | ETag,
+        skip_cache: bool | None = False,
+        ref: FilePathStr | URIStr | None = None,
+        birth_artifact_id: str | None = None,
+        size: int | None = None,
+        extra: dict | None = None,
+        local_path: StrPath | None = None,
     ) -> None:
         self.path = LogicalPath(path)
         self.digest = digest
@@ -116,7 +118,7 @@ class ArtifactManifestEntry:
         )
         return self.path
 
-    def parent_artifact(self) -> "Artifact":
+    def parent_artifact(self) -> Artifact:
         """Get the artifact to which this artifact entry belongs.
 
         Returns:
@@ -127,7 +129,7 @@ class ArtifactManifestEntry:
         return self._parent_artifact
 
     def download(
-        self, root: Optional[str] = None, skip_cache: Optional[bool] = None
+        self, root: str | None = None, skip_cache: bool | None = None
     ) -> FilePathStr:
         """Download this artifact entry to the specified root path.
 
@@ -177,7 +179,7 @@ class ArtifactManifestEntry:
                 str(filesystem.copy_or_overwrite_changed(cache_path, dest_path))
             )
 
-    def ref_target(self) -> Union[FilePathStr, URIStr]:
+    def ref_target(self) -> FilePathStr | URIStr:
         """Get the reference URL that is targeted by this artifact entry.
 
         Returns:
@@ -219,7 +221,7 @@ class ArtifactManifestEntry:
             + self.path
         )
 
-    def to_json(self) -> "ArtifactManifestEntryDict":
+    def to_json(self) -> ArtifactManifestEntryDict:
         contents: ArtifactManifestEntryDict = {
             "path": self.path,
             "digest": self.digest,
@@ -241,7 +243,7 @@ class ArtifactManifestEntry:
     def _is_artifact_reference(self) -> bool:
         return self.ref is not None and urlparse(self.ref).scheme == "wandb-artifact"
 
-    def _referenced_artifact_id(self) -> Optional[str]:
+    def _referenced_artifact_id(self) -> str | None:
         if not self._is_artifact_reference():
             return None
         return hex_to_b64_id(urlparse(self.ref).netloc)

wandb/sdk/artifacts/artifact_manifests/artifact_manifest_v1.py

@@ -1,6 +1,8 @@
 """Artifact manifest v1."""
 
-from typing import Any, Dict, Mapping, Optional
+from __future__ import annotations
+
+from typing import Any, Mapping
 
 from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
 from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
@@ -16,8 +18,8 @@ class ArtifactManifestV1(ArtifactManifest):
 
     @classmethod
     def from_manifest_json(
-        cls, manifest_json: Dict, api: Optional[InternalApi] = None
-    ) -> "ArtifactManifestV1":
+        cls, manifest_json: dict, api: InternalApi | None = None
+    ) -> ArtifactManifestV1:
         if manifest_json["version"] != cls.version():
             raise ValueError(
                 "Expected manifest version 1, got {}".format(manifest_json["version"])
@@ -48,12 +50,12 @@ class ArtifactManifestV1(ArtifactManifest):
 
     def __init__(
         self,
-        storage_policy: "StoragePolicy",
-        entries: Optional[Mapping[str, ArtifactManifestEntry]] = None,
+        storage_policy: StoragePolicy,
+        entries: Mapping[str, ArtifactManifestEntry] | None = None,
     ) -> None:
         super().__init__(storage_policy, entries=entries)
 
-    def to_manifest_json(self) -> Dict:
+    def to_manifest_json(self) -> dict:
         """This is the JSON that's stored in wandb_manifest.json.
 
         If include_local is True we also include the local paths to files. This is
@@ -63,7 +65,7 @@ class ArtifactManifestV1(ArtifactManifest):
         """
         contents = {}
         for entry in sorted(self.entries.values(), key=lambda k: k.path):
-            json_entry: Dict[str, Any] = {
+            json_entry: dict[str, Any] = {
                 "digest": entry.digest,
             }
             if entry.birth_artifact_id:

wandb/sdk/artifacts/artifact_saver.py

@@ -1,11 +1,13 @@
 """Artifact saver."""
 
+from __future__ import annotations
+
 import concurrent.futures
 import json
 import os
 import sys
 import tempfile
-from typing import TYPE_CHECKING, Awaitable, Dict, Optional, Sequence
+from typing import TYPE_CHECKING, Awaitable, Sequence
 
 import wandb
 import wandb.filesync.step_prepare
@@ -27,26 +29,26 @@ if TYPE_CHECKING:
 
     class SaveFn(Protocol):
         def __call__(
-            self, entry: "ArtifactManifestEntry", progress_callback: "ProgressFn"
+            self, entry: ArtifactManifestEntry, progress_callback: ProgressFn
         ) -> bool:
             pass
 
     class SaveFnAsync(Protocol):
         def __call__(
-            self, entry: "ArtifactManifestEntry", progress_callback: "ProgressFn"
+            self, entry: ArtifactManifestEntry, progress_callback: ProgressFn
         ) -> Awaitable[bool]:
             pass
 
 
 class ArtifactSaver:
-    _server_artifact: Optional[Dict]  # TODO better define this dict
+    _server_artifact: dict | None  # TODO better define this dict
 
     def __init__(
         self,
-        api: "InternalApi",
+        api: InternalApi,
         digest: str,
-        manifest_json: Dict,
-        file_pusher: "FilePusher",
+        manifest_json: dict,
+        file_pusher: FilePusher,
         is_user_created: bool = False,
     ) -> None:
         self._api = api
@@ -65,18 +67,18 @@ class ArtifactSaver:
         name: str,
         client_id: str,
         sequence_client_id: str,
-        distributed_id: Optional[str] = None,
+        distributed_id: str | None = None,
         finalize: bool = True,
-        metadata: Optional[Dict] = None,
-        ttl_duration_seconds: Optional[int] = None,
-        description: Optional[str] = None,
-        aliases: Optional[Sequence[str]] = None,
-        tags: Optional[Sequence[str]] = None,
+        metadata: dict | None = None,
+        ttl_duration_seconds: int | None = None,
+        description: str | None = None,
+        aliases: Sequence[str] | None = None,
+        tags: Sequence[str] | None = None,
         use_after_commit: bool = False,
         incremental: bool = False,
-        history_step: Optional[int] = None,
-        base_id: Optional[str] = None,
-    ) -> Optional[Dict]:
+        history_step: int | None = None,
+        base_id: str | None = None,
+    ) -> dict | None:
         return self._save_internal(
             type,
             name,
@@ -101,18 +103,18 @@ class ArtifactSaver:
         name: str,
         client_id: str,
         sequence_client_id: str,
-        distributed_id: Optional[str] = None,
+        distributed_id: str | None = None,
         finalize: bool = True,
-        metadata: Optional[Dict] = None,
-        ttl_duration_seconds: Optional[int] = None,
-        description: Optional[str] = None,
-        aliases: Optional[Sequence[str]] = None,
-        tags: Optional[Sequence[str]] = None,
+        metadata: dict | None = None,
+        ttl_duration_seconds: int | None = None,
+        description: str | None = None,
+        aliases: Sequence[str] | None = None,
+        tags: Sequence[str] | None = None,
         use_after_commit: bool = False,
         incremental: bool = False,
-        history_step: Optional[int] = None,
-        base_id: Optional[str] = None,
-    ) -> Optional[Dict]:
+        history_step: int | None = None,
+        base_id: str | None = None,
+    ) -> dict | None:
         alias_specs = []
         for alias in aliases or []:
             alias_specs.append({"artifactCollectionName": name, "alias": alias})

wandb/sdk/artifacts/exceptions.py

@@ -1,55 +1,56 @@
 """Artifact exceptions."""
 
-from typing import TYPE_CHECKING, Optional
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
 
 from wandb import errors
 
 if TYPE_CHECKING:
     from wandb.sdk.artifacts.artifact import Artifact
 
+    ArtifactT = TypeVar("ArtifactT", bound=Artifact)
+
 
 class ArtifactStatusError(AttributeError):
     """Raised when an artifact is in an invalid state for the requested operation."""
 
     def __init__(
         self,
-        artifact: Optional["Artifact"] = None,
-        attr: Optional[str] = None,
         msg: str = "Artifact is in an invalid state for the requested operation.",
+        name: str | None = None,
+        obj: ArtifactT | None = None,
     ):
-        object_name = artifact.__class__.__name__ if artifact else "Artifact"
-        method_id = f"{object_name}.{attr}" if attr else object_name
-        super().__init__(msg.format(artifact=artifact, attr=attr, method_id=method_id))
-        # Follow the same pattern as AttributeError.
-        self.obj = artifact
-        self.name = attr or ""
+        # Follow the same pattern as AttributeError in python 3.10+ by `name/obj` attributes
+        # See: https://docs.python.org/3/library/exceptions.html#AttributeError
+        try:
+            super().__init__(msg, name=name, obj=obj)
+        except TypeError:
+            # The `name`/`obj` keyword args and attributes were only added in python >= 3.10
+            super().__init__(msg)
+            self.name = name or ""
+            self.obj = obj
 
 
 class ArtifactNotLoggedError(ArtifactStatusError):
     """Raised for Artifact methods or attributes only available after logging."""
 
-    def __init__(
-        self, artifact: Optional["Artifact"] = None, attr: Optional[str] = None
-    ):
-        super().__init__(
-            artifact,
-            attr,
-            "'{method_id}' used prior to logging artifact or while in offline mode. "
-            "Call wait() before accessing logged artifact properties.",
+    def __init__(self, fullname: str, obj: ArtifactT):
+        *_, name = fullname.split(".")
+        msg = (
+            f"{fullname!r} used prior to logging artifact or while in offline mode. "
+            f"Call {type(obj).wait.__qualname__}() before accessing logged artifact properties."
         )
+        super().__init__(msg=msg, name=name, obj=obj)
 
 
 class ArtifactFinalizedError(ArtifactStatusError):
     """Raised for Artifact methods or attributes that can't be changed after logging."""
 
-    def __init__(
-        self, artifact: Optional["Artifact"] = None, attr: Optional[str] = None
-    ):
-        super().__init__(
-            artifact,
-            attr,
-            "'{method_id}' used on logged artifact. Can't modify finalized artifact.",
-        )
+    def __init__(self, fullname: str, obj: ArtifactT):
+        *_, name = fullname.split(".")
+        msg = f"{fullname!r} used on logged artifact. Can't modify finalized artifact."
+        super().__init__(msg=msg, name=name, obj=obj)
 
 
 class WaitTimeoutError(errors.Error):

wandb/sdk/artifacts/storage_handler.py

@@ -1,6 +1,8 @@
 """Storage handler."""
 
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
 
 from wandb.sdk.lib.paths import FilePathStr, URIStr
 
@@ -14,7 +16,7 @@ DEFAULT_MAX_OBJECTS = 10**7
 
 
 class StorageHandler:
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         """Checks whether this handler can handle the given url.
 
         Returns:
@@ -24,9 +26,9 @@ class StorageHandler:
 
     def load_path(
         self,
-        manifest_entry: "ArtifactManifestEntry",
+        manifest_entry: ArtifactManifestEntry,
         local: bool = False,
-    ) -> Union[URIStr, FilePathStr]:
+    ) -> URIStr | FilePathStr:
         """Load a file or directory given the corresponding index entry.
 
         Args:
@@ -40,12 +42,12 @@ class StorageHandler:
 
     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]:
         """Store the file or directory at the given path to the specified artifact.
 
         Args:

wandb/sdk/artifacts/storage_handlers/azure_handler.py

@@ -1,8 +1,10 @@
 """Azure storage handler."""
 
+from __future__ import annotations
+
 from pathlib import PurePosixPath
 from types import ModuleType
-from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Sequence
 from urllib.parse import ParseResult, parse_qsl, urlparse
 
 import wandb
@@ -21,16 +23,16 @@ if TYPE_CHECKING:
 
 
 class AzureHandler(StorageHandler):
-    def can_handle(self, parsed_url: "ParseResult") -> bool:
+    def can_handle(self, parsed_url: ParseResult) -> bool:
         return parsed_url.scheme == "https" and parsed_url.netloc.endswith(
             ".blob.core.windows.net"
         )
 
     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
         if not local:
             return manifest_entry.ref
@@ -91,12 +93,12 @@ class AzureHandler(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,
-    ) -> Sequence["ArtifactManifestEntry"]:
+        max_objects: int | None = None,
+    ) -> Sequence[ArtifactManifestEntry]:
         account_url, container_name, blob_name, query = self._parse_uri(path)
         path = URIStr(f"{account_url}/{container_name}/{blob_name}")
 
@@ -127,7 +129,7 @@ class AzureHandler(StorageHandler):
                     )
                 ]
 
-        entries: List[ArtifactManifestEntry] = []
+        entries: list[ArtifactManifestEntry] = []
         container_client = blob_service_client.get_container_client(container_name)
         max_objects = max_objects or DEFAULT_MAX_OBJECTS
         for blob_properties in container_client.list_blobs(
@@ -163,7 +165,7 @@ class AzureHandler(StorageHandler):
 
     def _get_credential(
         self, account_url: str
-    ) -> Union["azure.identity.DefaultAzureCredential", str]:
+    ) -> azure.identity.DefaultAzureCredential | str:
         if (
             wandb.run
             and wandb.run.settings.azure_account_url_to_access_key is not None
@@ -172,7 +174,7 @@ class AzureHandler(StorageHandler):
             return wandb.run.settings.azure_account_url_to_access_key[account_url]
         return self._get_module("azure.identity").DefaultAzureCredential()
 
-    def _parse_uri(self, uri: str) -> Tuple[str, str, str, Dict[str, str]]:
+    def _parse_uri(self, uri: str) -> tuple[str, str, str, dict[str, str]]:
         parsed_url = urlparse(uri)
         query = dict(parse_qsl(parsed_url.query))
         account_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
@@ -181,7 +183,7 @@ class AzureHandler(StorageHandler):
 
     def _create_entry(
         self,
-        blob_properties: "azure.storage.blob.BlobProperties",
+        blob_properties: azure.storage.blob.BlobProperties,
         path: StrPath,
         ref: URIStr,
     ) -> ArtifactManifestEntry:
@@ -197,7 +199,7 @@ class AzureHandler(StorageHandler):
         )
 
     def _is_directory_stub(
-        self, blob_properties: "azure.storage.blob.BlobProperties"
+        self, blob_properties: azure.storage.blob.BlobProperties
     ) -> bool:
         return (
             blob_properties.has_key("metadata")