Pydantic

python/lib/client/dmod/client/request_clients.py

@@ -1,14 +1,12 @@
 from abc import ABC, abstractmethod
-from datetime import datetime
-from dmod.core.execution import AllocationParadigm
 from dmod.communication import DataServiceClient, ExternalRequestClient, ManagementAction, ModelExecRequestClient, \
     NGENRequest, NGENRequestResponse, \
     NgenCalibrationRequest, NgenCalibrationResponse
 from dmod.communication.client import R
 from dmod.communication.dataset_management_message import DatasetManagementMessage, DatasetManagementResponse, \
     MaaSDatasetManagementMessage, MaaSDatasetManagementResponse, QueryType, DatasetQuery
 from dmod.communication.data_transmit_message import DataTransmitMessage, DataTransmitResponse
-from dmod.core.meta_data import DataCategory, DataDomain, TimeRange
+from dmod.core.meta_data import DataCategory, DataDomain
 from pathlib import Path
 from typing import List, Optional, Tuple, Type, Union
 
@@ -86,10 +84,10 @@ def _parse_list_of_dataset_names_from_response(self, response: DatasetManagement
             msg = "Can't parse list of datasets from non-{} (received a {} object)"
             raise RuntimeError(msg.format(DatasetManagementResponse.__name__, response.__class__.__name__))
         # Consider these as valid cases, and treat them as just not listing any datasets
-        elif not response.success or response.data is None or 'datasets' not in response.data:
+        elif not response.success or response.data is None or response.data.datasets is None:
             return []
         else:
-            return response.data['datasets']
+            return response.data.datasets
 
     @abstractmethod
     async def create_dataset(self, name: str, category: DataCategory, domain: DataDomain, **kwargs) -> bool:

python/lib/communication/dmod/communication/__init__.py

@@ -4,7 +4,7 @@
 from .maas_request import get_available_models, get_available_outputs, get_distribution_types, get_parameters, \
     get_request, AbstractNgenRequest, Distribution, DmodJobRequest, ExternalRequest, ExternalRequestResponse,\
     ModelExecRequest, ModelExecRequestResponse, NWMRequest, NWMRequestResponse, Scalar, NGENRequest, \
-    NGENRequestResponse, NgenCalibrationRequest, NgenCalibrationResponse
+    NGENRequestResponse, NgenCalibrationRequest, NgenCalibrationResponse, NGENRequestBody
 from .message import AbstractInitRequest, MessageEventType, Message, Response, InvalidMessage, InvalidMessageResponse, \
     InitRequestResponseReason
 from .metadata_message import MetadataPurpose, MetadataMessage, MetadataResponse

python/lib/communication/dmod/communication/data_transmit_message.py

@@ -1,10 +1,22 @@
+from dmod.core.serializable import Serializable
 from .message import AbstractInitRequest, MessageEventType, Response
-from typing import Dict, Optional, Union
-from numbers import Number
+from pydantic import Field
+from typing import ClassVar, Type, Union
+from typing_extensions import TypeAlias
 from uuid import UUID
 
 
-class DataTransmitMessage(AbstractInitRequest):
+class DataTransmitUUID(Serializable):
+    series_uuid: UUID = Field(description="A unique id for the collective series of transmission message this instance is a part of.")
+    """
+    The expectation is that a larger amount of data will be broken up into multiple messages in a series.
+    """
+
+    class Config:
+        field_serializers = {"series_uuid": lambda s: str(s)}
+
+
+class DataTransmitMessage(DataTransmitUUID, AbstractInitRequest):
     """
     Specialized message type for transmitting data.
 
@@ -18,64 +30,13 @@ class DataTransmitMessage(AbstractInitRequest):
     ::class:`str` object.  However, instances can be initialized using either ::class:`str` or ::class:`bytes` data.
     """
 
-    _KEY_SERIES_UUID = 'series_uuid'
+    event_type: ClassVar[MessageEventType] = MessageEventType.DATA_TRANSMISSION
 
-    event_type: MessageEventType = MessageEventType.DATA_TRANSMISSION
+    data: str = Field(description="The data carried by this message, in decoded string form.")
+    is_last: bool = Field(False, description="Whether this is the last data transmission message in this series.")
 
-    @classmethod
-    def factory_init_from_deserialized_json(cls, json_obj: dict) -> Optional['DataTransmitMessage']:
-        try:
-            return cls(data=json_obj['data'], series_uuid=UUID(json_obj[cls._KEY_SERIES_UUID]),
-                       is_last=json_obj['is_last'])
-        except Exception as e:
-            return None
 
-    def __init__(self, data: Union[str, bytes], series_uuid: UUID, is_last: bool = False, *args, **kwargs):
-        super(DataTransmitMessage, self).__init__(*args, **kwargs)
-        self._data: str = data if isinstance(data, str) else data.decode()
-        self._series_uuid = series_uuid
-        self._is_last: bool = is_last
-
-    @property
-    def data(self) -> str:
-        """
-        The data carried by this message, in decoded string form.
-
-        Returns
-        -------
-        str
-            The data carried by this message, in decoded string form.
-        """
-        return self._data
-
-    @property
-    def is_last(self) -> bool:
-        """
-        Whether this is the last data transmission message in this series.
-
-        Returns
-        -------
-        bool
-            Whether this is the last data transmission message in this series.
-        """
-        return self._is_last
-
-    @property
-    def series_uuid(self) -> UUID:
-        """
-        A unique id for the collective series of transmission message this instance is a part of.
-
-        The expectation is that a larger amount of data will be broken up into multiple messages in a series.
-
-        Returns
-        -------
-        UUID
-            A unique id for the collective series of transmission message this instance is a part of.
-        """
-        return self._series_uuid
-
-    def to_dict(self) -> Dict[str, Union[str, Number, dict, list]]:
-        return {'data': self.data, self._KEY_SERIES_UUID: str(self.series_uuid), 'is_last': self.is_last}
+DataTransmitResponseBody: TypeAlias = DataTransmitUUID
 
 
 class DataTransmitResponse(Response):
@@ -86,38 +47,24 @@ class DataTransmitResponse(Response):
     series of which it is a part.
     """
 
-    response_to_type = DataTransmitMessage
-
-    _KEY_SERIES_UUID = response_to_type._KEY_SERIES_UUID
-
-    @classmethod
-    def factory_init_from_deserialized_json(cls, json_obj: dict) -> 'DataTransmitResponse':
-        """
-        Factory create a new instance of this type based on a JSON object dictionary deserialized from received JSON.
-
-        Parameters
-        ----------
-        json_obj
-
-        Returns
-        -------
-        response_obj : Response
-            A new object of this type instantiated from the deserialize JSON object dictionary, or none if the provided
-            parameter could not be used to instantiated a new object.
-        """
-        try:
-            return cls(success=json_obj['success'], reason=json_obj['reason'], message=json_obj['message'],
-                       series_uuid=json_obj['data'][cls._KEY_SERIES_UUID], data=json_obj['data'])
-        except Exception as e:
-            return None
-
-    def __init__(self, series_uuid: Union[str, UUID], *args, **kwargs):
-        if 'data' not in kwargs:
-            kwargs['data'] = dict()
-        kwargs['data'][self._KEY_SERIES_UUID] = str(series_uuid)
-        super(DataTransmitResponse, self).__init__(*args, **kwargs)
+    response_to_type: ClassVar[Type[AbstractInitRequest]] = DataTransmitMessage
+
+    data: DataTransmitResponseBody
+
+    # `series_uuid` required in prior version of code
+    def __init__(self, series_uuid: Union[str, UUID] = None, **kwargs):
+        # assume no need for backwards compatibility
+        if series_uuid is None:
+            super().__init__(**kwargs)
+            return
+
+        if "data" not in kwargs:
+            kwargs["data"] = dict()
+
+        kwargs["data"]["series_uuid"] = series_uuid
+        super().__init__(**kwargs)
 
     @property
     def series_uuid(self) -> UUID:
-        return UUID(self.data[self._KEY_SERIES_UUID])
+        return self.data.series_uuid