177 upgrade pydantic version

pyproject.toml

@@ -30,15 +30,16 @@ dynamic = [ "version" ]
 dependencies = [
   "aiohttp>=3.8.3",
   "aioresponses>=0.7.6",
-  "aleph-message>=0.5",
+  "aleph-message @ git+https://github.com/aleph-im/aleph-message@108-upgrade-pydantic-version#egg=aleph-message",
   "aleph-superfluid>=0.2.1",
-  "base58==2.1.1",                         # Needed now as default with _load_account changement
+  "base58==2.1.1",                                                                                                # Needed now as default with _load_account changement
   "coincurve; python_version<'3.11'",
   "coincurve>=19; python_version>='3.11'",
   "eth-abi>=4; python_version>='3.11'",
   "eth-typing==4.3.1",
   "jwcrypto==1.5.6",
-  "pynacl==1.5",                           # Needed now as default with _load_account changement
+  "pydantic-settings>=2",
+  "pynacl==1.5",                                                                                                  # Needed now as default with _load_account changement
   "python-magic",
   "typing-extensions",
   "web3==6.3",
@@ -154,6 +155,7 @@ dependencies = [
   "ruff==0.4.8",
   "isort==5.13.2",
   "pyproject-fmt==2.2.1",
+  "pydantic-settings>=2",
 ]
 [tool.hatch.envs.linting.scripts]
 typing = "mypy --config-file=pyproject.toml {args:} ./src/ ./tests/ ./examples/"

src/aleph/sdk/chains/common.py

@@ -72,7 +72,7 @@ async def sign_message(self, message: Dict) -> Dict:
         """
         message = self._setup_sender(message)
         signature = await self.sign_raw(get_verification_buffer(message))
-        message["signature"] = signature.hex()
+        message["signature"] = "0x" + signature.hex()
         return message
 
     @abstractmethod

src/aleph/sdk/chains/remote.py

@@ -52,7 +52,7 @@ async def from_crypto_host(
             session = aiohttp.ClientSession(connector=connector)
 
         async with session.get(f"{host}/properties") as response:
-            response.raise_for_status()
+            await response.raise_for_status()
             data = await response.json()
             properties = AccountProperties(**data)
 
@@ -75,7 +75,7 @@ def private_key(self):
     async def sign_message(self, message: Dict) -> Dict:
         """Sign a message inplace."""
         async with self._session.post(f"{self._host}/sign", json=message) as response:
-            response.raise_for_status()
+            await response.raise_for_status()
             return await response.json()
 
     async def sign_raw(self, buffer: bytes) -> bytes:

src/aleph/sdk/client/authenticated_http.py

@@ -259,7 +259,7 @@ async def _broadcast(
         url = "/api/v0/messages"
         logger.debug(f"Posting message on {url}")
 
-        message_dict = message.dict(include=self.BROADCAST_MESSAGE_FIELDS)
+        message_dict = message.model_dump(include=self.BROADCAST_MESSAGE_FIELDS)
         async with self.http_session.post(
             url,
             json={
@@ -301,7 +301,7 @@ async def create_post(
         )
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.post,
             channel=channel,
             allow_inlining=inline,
@@ -329,7 +329,7 @@ async def create_aggregate(
         )
 
         message, status, _ = await self.submit(
-            content=content_.dict(exclude_none=True),
+            content=content_.model_dump(exclude_none=True),
             message_type=MessageType.aggregate,
             channel=channel,
             allow_inlining=inline,
@@ -403,7 +403,7 @@ async def create_store(
         content = StoreContent(**values)
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.store,
             channel=channel,
             allow_inlining=True,
@@ -496,7 +496,7 @@ async def create_program(
         assert content.on.persistent == persistent
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.program,
             channel=channel,
             storage_engine=storage_engine,
@@ -572,7 +572,7 @@ async def create_instance(
             payment=payment,
         )
         message, status, response = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.instance,
             channel=channel,
             storage_engine=storage_engine,
@@ -618,7 +618,7 @@ async def forget(
         )
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.forget,
             channel=channel,
             storage_engine=storage_engine,
@@ -662,11 +662,11 @@ async def _storage_push_file_with_message(
         # Prepare the STORE message
         message = await self.generate_signed_message(
             message_type=MessageType.store,
-            content=store_content.dict(exclude_none=True),
+            content=store_content.model_dump(exclude_none=True),
             channel=channel,
         )
         metadata = {
-            "message": message.dict(exclude_none=True),
+            "message": message.model_dump(exclude_none=True),
             "sync": sync,
         }
         data.add_field(
@@ -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

@@ -180,7 +180,7 @@ async def get_posts(
             posts: List[Post] = []
             for post_raw in posts_raw:
                 try:
-                    posts.append(Post.parse_obj(post_raw))
+                    posts.append(Post.model_validate(post_raw))
                 except ValidationError as e:
                     if not ignore_invalid_messages:
                         raise e

src/aleph/sdk/client/vm_confidential_client.py

@@ -105,7 +105,7 @@ async def measurement(self, vm_id: ItemHash) -> SEVMeasurement:
         status, text = await self.perform_operation(
             vm_id, "confidential/measurement", method="GET"
         )
-        sev_measurement = SEVMeasurement.parse_raw(text)
+        sev_measurement = SEVMeasurement.model_validate_json(text)
         return sev_measurement
 
     async def validate_measure(

src/aleph/sdk/conf.py

@@ -3,11 +3,12 @@
 import os
 from pathlib import Path
 from shutil import which
-from typing import Dict, Optional, Union
+from typing import ClassVar, Dict, List, Optional, Union
 
 from aleph_message.models import Chain
 from aleph_message.models.execution.environment import HypervisorType
-from pydantic import BaseModel, BaseSettings, Field
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from aleph.sdk.types import ChainInfo
 
@@ -41,7 +42,7 @@ class Settings(BaseSettings):
     REMOTE_CRYPTO_HOST: Optional[str] = None
     REMOTE_CRYPTO_UNIX_SOCKET: Optional[str] = None
     ADDRESS_TO_USE: Optional[str] = None
-    HTTP_REQUEST_TIMEOUT = 15.0
+    HTTP_REQUEST_TIMEOUT: float = 15.0
 
     DEFAULT_CHANNEL: str = "ALEPH-CLOUDSOLUTIONS"
     DEFAULT_RUNTIME_ID: str = (
@@ -83,12 +84,12 @@ class Settings(BaseSettings):
 
     CODE_USES_SQUASHFS: bool = which("mksquashfs") is not None  # True if command exists
 
-    VM_URL_PATH = "https://aleph.sh/vm/{hash}"
-    VM_URL_HOST = "https://{hash_base32}.aleph.sh"
+    VM_URL_PATH: ClassVar[str] = "https://aleph.sh/vm/{hash}"
+    VM_URL_HOST: ClassVar[str] = "https://{hash_base32}.aleph.sh"
 
     # Web3Provider settings
-    TOKEN_DECIMALS = 18
-    TX_TIMEOUT = 60 * 3
+    TOKEN_DECIMALS: ClassVar[int] = 18
+    TX_TIMEOUT: ClassVar[int] = 60 * 3
     CHAINS: Dict[Union[Chain, str], ChainInfo] = {
         # TESTNETS
         "SEPOLIA": ChainInfo(
@@ -217,16 +218,15 @@ class Settings(BaseSettings):
     DEFAULT_CHAIN: Chain = Chain.ETH
 
     # Dns resolver
-    DNS_IPFS_DOMAIN = "ipfs.public.aleph.sh"
-    DNS_PROGRAM_DOMAIN = "program.public.aleph.sh"
-    DNS_INSTANCE_DOMAIN = "instance.public.aleph.sh"
-    DNS_STATIC_DOMAIN = "static.public.aleph.sh"
-    DNS_RESOLVERS = ["9.9.9.9", "1.1.1.1"]
-
-    class Config:
-        env_prefix = "ALEPH_"
-        case_sensitive = False
-        env_file = ".env"
+    DNS_IPFS_DOMAIN: ClassVar[str] = "ipfs.public.aleph.sh"
+    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[List[str]] = ["9.9.9.9", "1.1.1.1"]
+
+    model_config = SettingsConfigDict(
+        env_prefix="ALEPH_", case_sensitive=False, env_file=".env"
+    )
 
 
 class MainConfiguration(BaseModel):
@@ -237,8 +237,7 @@ class MainConfiguration(BaseModel):
     path: Path
     chain: Chain
 
-    class Config:
-        use_enum_values = True
+    model_config = SettingsConfigDict(use_enum_values=True)
 
 
 # Settings singleton
@@ -294,7 +293,7 @@ def save_main_configuration(file_path: Path, data: MainConfiguration):
     Synchronously save a single ChainAccount object as JSON to a file.
     """
     with file_path.open("w") as file:
-        data_serializable = data.dict()
+        data_serializable = data.model_dump()
         data_serializable["path"] = str(data_serializable["path"])
         json.dump(data_serializable, file, indent=4)
 

src/aleph/sdk/domain.py

@@ -52,11 +52,11 @@ def raise_error(self, status: Dict[str, bool]):
 def hostname_from_url(url: Union[HttpUrl, str]) -> Hostname:
     """Extract FQDN from url"""
 
-    parsed = urlparse(url)
+    parsed = urlparse(str(url))
     if all([parsed.scheme, parsed.netloc]) is True:
         url = parsed.netloc
 
-    return Hostname(url)
+    return Hostname(str(url))
 
 
 async def get_target_type(fqdn: Hostname) -> Optional[TargetType]:

src/aleph/sdk/query/responses.py

@@ -9,7 +9,7 @@
     ItemType,
     MessageConfirmation,
 )
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Post(BaseModel):
@@ -48,9 +48,9 @@ class Post(BaseModel):
     ref: Optional[Union[str, Any]] = Field(
         description="Other message referenced by this one"
     )
+    address: Optional[str] = Field(description="Address of the sender")
 
-    class Config:
-        allow_extra = False
+    model_config = ConfigDict(extra="forbid")
 
 
 class PaginationResponse(BaseModel):
@@ -64,14 +64,14 @@ class PostsResponse(PaginationResponse):
     """Response from an aleph.im node API on the path /api/v0/posts.json"""
 
     posts: List[Post]
-    pagination_item = "posts"
+    pagination_item: str = "posts"
 
 
 class MessagesResponse(PaginationResponse):
     """Response from an aleph.im node API on the path /api/v0/messages.json"""
 
     messages: List[AlephMessage]
-    pagination_item = "messages"
+    pagination_item: str = "messages"
 
 
 class PriceResponse(BaseModel):

src/aleph/sdk/utils.py

@@ -28,13 +28,13 @@
 from uuid import UUID
 from zipfile import BadZipFile, ZipFile
 
+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
-from pydantic.json import pydantic_encoder
 
 from aleph.sdk.conf import settings
 from aleph.sdk.types import GenericMessage, SEVInfo, SEVMeasurement
@@ -173,19 +173,15 @@ def extended_json_encoder(obj: Any) -> Any:
     elif isinstance(obj, time):
         return obj.hour * 3600 + obj.minute * 60 + obj.second + obj.microsecond / 1e6
     else:
-        return pydantic_encoder(obj)
+        return pydantic_core.to_jsonable_python(obj)
 
 
 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.parse_obj(volume_dict)
+            return volume_type.model_validate(volume_dict)
         except ValueError:
             continue
     else:

src/aleph/sdk/vm/cache.py

@@ -70,7 +70,7 @@ def __init__(
             )
 
         self.cache = {}
-        self.api_host = connector_url if connector_url else settings.API_HOST
+        self.api_host = str(connector_url) if connector_url else settings.API_HOST
 
     async def get(self, key: str) -> Optional[bytes]:
         sanitized_key = sanitize_cache_key(key)