[#38] code migration to use pydantic v2

api/adapters/hydroshare.py

@@ -3,7 +3,10 @@
 from typing import List, Optional, Union
 from pydantic import BaseModel, EmailStr, HttpUrl
 
-from api.adapters.base import AbstractRepositoryMetadataAdapter, AbstractRepositoryRequestHandler
+from api.adapters.base import (
+    AbstractRepositoryMetadataAdapter,
+    AbstractRepositoryRequestHandler,
+)
 from api.adapters.utils import RepositoryType, register_adapter
 from api.exceptions import RepositoryException
 from api.models import schema
@@ -12,31 +15,31 @@
 
 
 class Creator(BaseModel):
-    name: Optional[str]
-    email: Optional[EmailStr]
-    organization: Optional[str]
-    homepage: Optional[HttpUrl]
-    address: Optional[str]
+    name: Optional[str] = None
+    email: Optional[EmailStr] = None
+    organization: Optional[str] = None
+    homepage: Optional[HttpUrl] = None
+    address: Optional[str] = None
     identifiers: Optional[dict] = {}
 
     def to_dataset_creator(self):
         if self.name:
-            creator = schema.Creator.construct()
+            creator = schema.Creator.model_construct()
             creator.name = self.name
             if self.email:
                 creator.email = self.email
             if self.organization:
-                affiliation = schema.Organization.construct()
+                affiliation = schema.Organization.model_construct()
                 affiliation.name = self.organization
                 creator.affiliation = affiliation
             _ORCID_identifier = self.identifiers.get("ORCID", "")
             if _ORCID_identifier:
                 creator.identifier = _ORCID_identifier
         else:
-            creator = schema.Organization.construct()
+            creator = schema.Organization.model_construct()
             creator.name = self.organization
             if self.homepage:
-                creator.url = self.homepage
+                creator.url = str(self.homepage)
             if self.address:
                 creator.address = self.address
 
@@ -45,23 +48,23 @@ def to_dataset_creator(self):
 
 class Award(BaseModel):
     funding_agency_name: str
-    title: Optional[str]
-    number: Optional[str]
-    funding_agency_url: Optional[HttpUrl]
+    title: Optional[str] = None
+    number: Optional[str] = None
+    funding_agency_url: Optional[HttpUrl] = None
 
     def to_dataset_grant(self):
-        grant = schema.Grant.construct()
+        grant = schema.Grant.model_construct()
         if self.title:
             grant.name = self.title
         else:
             grant.name = self.funding_agency_name
         if self.number:
             grant.identifier = self.number
 
-        funder = schema.Organization.construct()
+        funder = schema.Organization.model_construct()
         funder.name = self.funding_agency_name
         if self.funding_agency_url:
-            funder.url = self.funding_agency_url
+            funder.url = str(self.funding_agency_url)
 
         grant.funder = funder
         return grant
@@ -72,7 +75,7 @@ class TemporalCoverage(BaseModel):
     end: datetime
 
     def to_dataset_temporal_coverage(self):
-        temp_cov = schema.TemporalCoverage.construct()
+        temp_cov = schema.TemporalCoverage.model_construct()
         if self.start:
             temp_cov.startDate = self.start
             if self.end:
@@ -81,32 +84,34 @@ def to_dataset_temporal_coverage(self):
 
 
 class SpatialCoverageBox(BaseModel):
-    name: Optional[str]
+    name: Optional[str] = None
     northlimit: float
     eastlimit: float
     southlimit: float
     westlimit: float
 
     def to_dataset_spatial_coverage(self):
-        place = schema.Place.construct()
+        place = schema.Place.model_construct()
         if self.name:
             place.name = self.name
 
-        place.geo = schema.GeoShape.construct()
-        place.geo.box = f"{self.northlimit} {self.eastlimit} {self.southlimit} {self.westlimit}"
+        place.geo = schema.GeoShape.model_construct()
+        place.geo.box = (
+            f"{self.northlimit} {self.eastlimit} {self.southlimit} {self.westlimit}"
+        )
         return place
 
 
 class SpatialCoveragePoint(BaseModel):
-    name: Optional[str]
+    name: Optional[str] = None
     north: float
     east: float
 
     def to_dataset_spatial_coverage(self):
-        place = schema.Place.construct()
+        place = schema.Place.model_construct()
         if self.name:
             place.name = self.name
-        place.geo = schema.GeoCoordinates.construct()
+        place.geo = schema.GeoCoordinates.model_construct()
         place.geo.latitude = self.north
         place.geo.longitude = self.east
         return place
@@ -122,8 +127,8 @@ class ContentFile(BaseModel):
     checksum: str
 
     def to_dataset_media_object(self):
-        media_object = schema.MediaObject.construct()
-        media_object.contentUrl = self.url
+        media_object = schema.MediaObject.model_construct()
+        media_object.contentUrl = str(self.url)
         media_object.encodingFormat = self.content_type
         media_object.contentSize = f"{self.size/1000.00} KB"
         media_object.name = self.file_name
@@ -137,13 +142,13 @@ class Relation(BaseModel):
     def to_dataset_part_relation(self, relation_type: str):
         relation = None
         if relation_type == "IsPartOf" and self.type.endswith("is part of"):
-            relation = schema.IsPartOf.construct()
+            relation = schema.IsPartOf.model_construct()
         elif relation_type == "HasPart" and self.type.endswith("resource includes"):
-            relation = schema.HasPart.construct()
+            relation = schema.HasPart.model_construct()
         else:
             return relation
 
-        description, url = self.value.rsplit(',', 1)
+        description, url = self.value.rsplit(",", 1)
         relation.description = description.strip()
         relation.url = url.strip()
         relation.name = self.value
@@ -155,22 +160,23 @@ class Rights(BaseModel):
     url: HttpUrl
 
     def to_dataset_license(self):
-        _license = schema.License.construct()
+        _license = schema.License.model_construct()
         _license.name = self.statement
-        _license.url = self.url
+        _license.url = str(self.url)
         return _license
 
 
 class _HydroshareRequestHandler(AbstractRepositoryRequestHandler):
-
     def get_metadata(self, record_id: str):
         hs_meta_url = self.settings.hydroshare_meta_read_url % record_id
         hs_file_url = self.settings.hydroshare_file_read_url % record_id
 
         def make_request(url, file_list=False) -> Union[dict, List[dict]]:
             response = requests.get(url)
             if response.status_code != 200:
-                raise RepositoryException(status_code=response.status_code, detail=response.text)
+                raise RepositoryException(
+                    status_code=response.status_code, detail=response.text
+                )
             if not file_list:
                 return response.json()
 
@@ -180,7 +186,9 @@ def make_request(url, file_list=False) -> Union[dict, List[dict]]:
             while response.json()["next"]:
                 response = requests.get(response.json()["next"])
                 if response.status_code != 200:
-                    raise RepositoryException(status_code=response.status_code, detail=response.text)
+                    raise RepositoryException(
+                        status_code=response.status_code, detail=response.text
+                    )
                 content_files.extend(response.json()["results"])
             return content_files
 
@@ -224,16 +232,16 @@ class _HydroshareResourceMetadata(BaseModel):
     creators: List[Creator]
     created: datetime
     modified: datetime
-    published: Optional[datetime]
-    subjects: Optional[List[str]]
+    published: Optional[datetime] = None
+    subjects: Optional[List[str]] = []
     language: str
     rights: Rights
-    awards: Optional[List[Award]]
-    spatial_coverage: Optional[Union[SpatialCoverageBox, SpatialCoveragePoint]]
-    period_coverage: Optional[TemporalCoverage]
-    relations: Optional[List[Relation]]
+    awards: Optional[List[Award]] = []
+    spatial_coverage: Optional[Union[SpatialCoverageBox, SpatialCoveragePoint]] = None
+    period_coverage: Optional[TemporalCoverage] = None
+    relations: Optional[List[Relation]] = []
     citation: str
-    content_files: Optional[List[ContentFile]]
+    content_files: Optional[List[ContentFile]] = []
 
     def to_dataset_creators(self):
         creators = []
@@ -287,18 +295,18 @@ def to_dataset_license(self):
 
     @staticmethod
     def to_dataset_provider():
-        provider = schema.Organization.construct()
+        provider = schema.Organization.model_construct()
         provider.name = RepositoryType.HYDROSHARE
         provider.url = "https://www.hydroshare.org/"
         return provider
 
     def to_catalog_dataset(self):
-        dataset = DatasetMetadataDOC.construct()
+        dataset = DatasetMetadataDOC.model_construct()
         dataset.provider = self.to_dataset_provider()
         dataset.name = self.title
         dataset.description = self.abstract
-        dataset.url = self.url
-        dataset.identifier = [self.identifier]
+        dataset.url = str(self.url)
+        dataset.identifier = [str(self.identifier)]
         dataset.creator = self.to_dataset_creators()
         dataset.dateCreated = self.created
         dataset.dateModified = self.modified

api/authentication/fastapi_resource_server.py

@@ -47,24 +47,24 @@ def fetch_jwks(well_known: dict) -> dict:
 
 
 class JwtDecodeOptions(BaseModel):
-    verify_signature: Optional[bool]
-    verify_aud: Optional[bool]
-    verify_iat: Optional[bool]
-    verify_exp: Optional[bool]
-    verify_nbf: Optional[bool]
-    verify_iss: Optional[bool]
-    verify_sub: Optional[bool]
-    verify_jti: Optional[bool]
-    verify_at_hash: Optional[bool]
-    require_aud: Optional[bool]
-    require_iat: Optional[bool]
-    require_exp: Optional[bool]
-    require_nbf: Optional[bool]
-    require_iss: Optional[bool]
-    require_sub: Optional[bool]
-    require_jti: Optional[bool]
-    require_at_hash: Optional[bool]
-    leeway: Optional[int]
+    verify_signature: Optional[bool] = None
+    verify_aud: Optional[bool] = None
+    verify_iat: Optional[bool] = None
+    verify_exp: Optional[bool] = None
+    verify_nbf: Optional[bool] = None
+    verify_iss: Optional[bool] = None
+    verify_sub: Optional[bool] = None
+    verify_jti: Optional[bool] = None
+    verify_at_hash: Optional[bool] = None
+    require_aud: Optional[bool] = None
+    require_iat: Optional[bool] = None
+    require_exp: Optional[bool] = None
+    require_nbf: Optional[bool] = None
+    require_iss: Optional[bool] = None
+    require_sub: Optional[bool] = None
+    require_jti: Optional[bool] = None
+    require_at_hash: Optional[bool] = None
+    leeway: Optional[int] = None
 
 
 class OidcResourceServer(SecurityBase):

api/config/__init__.py

@@ -1,7 +1,8 @@
 from functools import lru_cache
 from typing import Any
 
-from pydantic import BaseSettings, HttpUrl
+from pydantic import HttpUrl
+from pydantic_settings import BaseSettings, SettingsConfigDict
 from dotenv import load_dotenv
 
 # had to use load_dotenv() to get the env variables to work during testing
@@ -24,13 +25,14 @@ def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         if self.testing:
             self.database_name = f"{self.database_name}"
+        self.hydroshare_meta_read_url = str(self.hydroshare_meta_read_url)
+        self.hydroshare_file_read_url = str(self.hydroshare_file_read_url)
 
     @property
     def db_connection_string(self):
         return f"{self.db_protocol}://{self.db_username}:{self.db_password}@{self.db_host}/?retryWrites=true&w=majority"
 
-    class Config:
-        env_file = ".env"
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
 
 
 @lru_cache()

api/models/catalog.py

@@ -1,4 +1,5 @@
 import datetime
+from typing import Optional
 
 from beanie import Document
 
@@ -19,7 +20,7 @@ class Settings:
             ),
             datetime.datetime: lambda dt: datetime.datetime(
                 year=dt.year, month=dt.month, day=dt.day, hour=dt.hour, minute=dt.minute, second=dt.second
-            )
+            ),
         }
 
     def as_submission(self) -> Submission:
@@ -31,6 +32,10 @@ def as_submission(self) -> Submission:
             url=self.url,
         )
 
+    def delete_revision_id(self):
+        if hasattr(self, "revision_id"):
+            del self.revision_id
+
 
 class DatasetMetadataDOC(CoreMetadataDOC):
-    repository_identifier: str = None
+    repository_identifier: Optional[str] = None

api/models/management/generate_schema.py

@@ -7,22 +7,23 @@
 
 
 def main(output_name: str = "api/models/schemas/schema.json"):
-    schema = DatasetSchema.schema()
-    json_schema = DatasetSchema.schema_json()#indent=2)
+    schema = DatasetSchema.model_json_schema()
+    json_schema = json.dumps(schema)
     # Have to run it a few times for the definitions to get updated before inserted into another model
-    while "#/definitions/" in json_schema:
-        for definition in schema["definitions"]:
-            class_definition = schema["definitions"][definition]
+    while "#/$defs/" in json_schema:
+        for definition in schema["$defs"]:
+            class_definition = schema["$defs"][definition]
             # replace allOf with a single definition
             json_schema = json_schema.replace(
-                f'"allOf": [{{"$ref": "#/definitions/{definition}"}}]', 
+                f'"allOf": [{{"$ref": "#/$defs/{definition}"}}]',
                 json.dumps(class_definition)[1:-1]
             )
-            #replace definition directly
+            # replace definition directly
             json_schema = json_schema.replace(
-                f'"$ref": "#/definitions/{definition}"', 
+                f'"$ref": "#/$defs/{definition}"',
                 json.dumps(class_definition)[1:-1]
             )
+
     embedded_schema = json.loads(json_schema)
     current_directory = absolute_directory(output_name)
     with open(current_directory, "w") as f: