fix: lint tests were failing

- Updated all instances of **extra_fields to ensure proper handling of
Optional dictionaries using `(extra_fields or {})` pattern.
- Added proper return statements in `AlephHttpClient.get_message_status`
to return parsed JSON data as a `MessageStatus` object.
- Updated `Settings` class in `conf.py` to correct DNS resolvers type
and simplify the `model_config` definition.
- Refactored `parse_volume` to ensure correct handling of Mapping types
and MachineVolume types, avoiding TypeErrors.
- Improved field validation and model validation in `SignedPubKeyHeader` by
using correct Pydantic v2 validation decorators and ensuring compatibility with the new model behavior.
- Applied formatting and consistency fixes for `model_dump` usage and indentation improvements in test files.

Author: Antonyjin

src/aleph/sdk/client/authenticated_http.py

@@ -710,7 +710,7 @@ async def _upload_file_native(
             item_hash=file_hash,
             mime_type=mime_type,
             time=time.time(),
-            **extra_fields,
+            **(extra_fields or {}),
         )
         message, _ = await self._storage_push_file_with_message(
             file_content=file_content,

src/aleph/sdk/client/http.py

@@ -467,3 +467,6 @@ async def get_message_status(self, item_hash: str) -> MessageStatus:
             if resp.status == HTTPNotFound.status_code:
                 raise MessageNotFoundError(f"No such hash {item_hash}")
             resp.raise_for_status()
+
+        data = await resp.json()
+        return MessageStatus(**data)

src/aleph/sdk/conf.py

@@ -5,11 +5,10 @@
 from shutil import which
 from typing import ClassVar, Dict, Optional, Union
 
-from pydantic_settings import BaseSettings
-
 from aleph_message.models import Chain
 from aleph_message.models.execution.environment import HypervisorType
 from pydantic import BaseModel, ConfigDict, Field
+from pydantic_settings import BaseSettings
 
 from aleph.sdk.types import ChainInfo
 
@@ -142,12 +141,10 @@ class Settings(BaseSettings):
     DNS_PROGRAM_DOMAIN: ClassVar[str] = "program.public.aleph.sh"
     DNS_INSTANCE_DOMAIN: ClassVar[str] = "instance.public.aleph.sh"
     DNS_STATIC_DOMAIN: ClassVar[str] = "static.public.aleph.sh"
-    DNS_RESOLVERS: ClassVar[str] = ["9.9.9.9", "1.1.1.1"]
+    DNS_RESOLVERS: ClassVar[list[str]] = ["9.9.9.9", "1.1.1.1"]
 
     model_config = ConfigDict(
-       env_prefix="ALEPH_",
-       case_sensitive=False,
-       env_file=".env"
+        env_prefix="ALEPH_", case_sensitive=False, env_file=".env"
     )
 
 
@@ -159,7 +156,7 @@ class MainConfiguration(BaseModel):
     path: Path
     chain: Chain
 
-    model_config = ConfigDict(use_enum_values = True)
+    model_config = ConfigDict(use_enum_values=True)
 
 
 # Settings singleton

src/aleph/sdk/utils.py

@@ -28,15 +28,13 @@
 from uuid import UUID
 from zipfile import BadZipFile, ZipFile
 
-from pydantic import BaseModel
-
+import pydantic_core
 from aleph_message.models import ItemHash, MessageType
 from aleph_message.models.execution.program import Encoding
 from aleph_message.models.execution.volume import MachineVolume
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from jwcrypto.jwa import JWA
-import pydantic_core
 
 from aleph.sdk.conf import settings
 from aleph.sdk.types import GenericMessage, SEVInfo, SEVMeasurement
@@ -181,17 +179,18 @@ def extended_json_encoder(obj: Any) -> Any:
 def parse_volume(volume_dict: Union[Mapping, MachineVolume]) -> MachineVolume:
     # Python 3.9 does not support `isinstance(volume_dict, MachineVolume)`,
     # so we need to iterate over all types.
-    if any(
-        isinstance(volume_dict, volume_type) for volume_type in get_args(MachineVolume)
-    ):
-        return volume_dict
     for volume_type in get_args(MachineVolume):
-        try:
-            return volume_type.model_validate(volume_dict)
-        except ValueError:
-            continue
-    else:
-        raise ValueError(f"Could not parse volume: {volume_dict}")
+        if isinstance(volume_dict, volume_type):
+            return volume_dict
+
+    if isinstance(volume_dict, Mapping):
+        for volume_type in get_args(MachineVolume):
+            try:
+                return volume_type(**volume_dict)
+            except (TypeError, ValueError):
+                continue
+
+    raise ValueError("Invalid volume data, could not be parsed into a MachineVolume")
 
 
 def compute_sha256(s: str) -> str:

tests/unit/aleph_vm_authentication.py

@@ -13,7 +13,7 @@
 from eth_account.messages import encode_defunct
 from jwcrypto import jwk
 from jwcrypto.jwa import JWA
-from pydantic import BaseModel, ValidationError, model_validator, field_validator
+from pydantic import BaseModel, ValidationError, field_validator, model_validator
 
 from aleph.sdk.utils import bytes_from_hex
 
@@ -66,17 +66,15 @@ class SignedPubKeyHeader(BaseModel):
     @field_validator("signature")
     def signature_must_be_hex(cls, value: bytes) -> bytes:
         """Convert the signature from hexadecimal to bytes"""
-
         return bytes_from_hex(value.decode())
 
     @field_validator("payload")
     def payload_must_be_hex(cls, value: bytes) -> bytes:
         """Convert the payload from hexadecimal to bytes"""
-
         return bytes_from_hex(value.decode())
 
     @model_validator(mode="after")
-    def check_expiry(cls, values) -> Dict[str, bytes]:
+    def check_expiry(cls, values: "SignedPubKeyHeader") -> "SignedPubKeyHeader":
         """Check that the token has not expired"""
         payload: bytes = values.payload
         content = SignedPubKeyPayload.model_validate_json(payload)
@@ -88,7 +86,7 @@ def check_expiry(cls, values) -> Dict[str, bytes]:
         return values
 
     @model_validator(mode="after")
-    def check_signature(cls, values: Dict[str, bytes]) -> Dict[str, bytes]:
+    def check_signature(cls, values: "SignedPubKeyHeader") -> "SignedPubKeyHeader":
         """Check that the signature is valid"""
         signature: bytes = values.signature
         payload: bytes = values.payload

tests/unit/conftest.py

@@ -135,7 +135,9 @@ def json_post() -> dict:
 def raw_messages_response(aleph_messages) -> Callable[[int], Dict[str, Any]]:
     return lambda page: {
         "messages": (
-            [message.model_dump() for message in aleph_messages] if int(page) == 1 else []
+            [message.model_dump() for message in aleph_messages]
+            if int(page) == 1
+            else []
         ),
         "pagination_item": "messages",
         "pagination_page": int(page),

tests/unit/test_utils.py

@@ -12,7 +12,6 @@
     ProgramMessage,
     StoreMessage,
 )
-from aleph_message.models.execution.environment import MachineResources
 from aleph_message.models.execution.volume import (
     EphemeralVolume,
     ImmutableVolume,
@@ -115,17 +114,17 @@ def test_enum_as_str():
         (
             MessageType.aggregate,
             {
-                'address': '0x1',
-                'content': {
-                    'Hello': {
-                        'vcpus': 1,
-                        'memory': 1024,
-                        'seconds': 1,
-                        'published_ports': None,
+                "address": "0x1",
+                "content": {
+                    "Hello": {
+                        "vcpus": 1,
+                        "memory": 1024,
+                        "seconds": 1,
+                        "published_ports": None,
                     },
                 },
-                'key': 'test',
-                'time': 1.0,
+                "key": "test",
+                "time": 1.0,
             },
         ),
     ],