acceldata-sdk-python 26.7.0__py3-none-any.whl

acceldata/models/api/catalog/profile_request.py

@@ -0,0 +1,211 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.dataplane_job import DataplaneJob
+from acceldata.models.api.catalog.marker import Marker
+from acceldata.models.api.catalog.marker_config import MarkerConfig
+from acceldata.models.api.catalog.pattern_configuration import PatternConfiguration
+from acceldata.models.api.catalog.spark_resource_config import SparkResourceConfig
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileRequest(BaseModel):
+    """
+    ProfileRequest
+    """ # noqa: E501
+    analysis_job: Optional[DataplaneJob] = Field(default=None, alias="analysisJob")
+    asset_id: StrictInt = Field(alias="assetId")
+    auto_profile_id: Optional[StrictInt] = Field(default=None, alias="autoProfileId")
+    auto_retries: Optional[StrictInt] = Field(default=0, alias="autoRetries")
+    auto_retry_enabled: Optional[StrictBool] = Field(default=False, alias="autoRetryEnabled")
+    created_at: datetime = Field(alias="createdAt")
+    engine_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: SPARK, JDBC_SQL, POD.", alias="engineType")
+    error: Optional[StrictStr] = None
+    executed_by: Optional[StrictStr] = Field(default=None, alias="executedBy")
+    execution_mode: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: MANUAL, SCHEDULED.", alias="executionMode")
+    id: StrictInt
+    is_data_change: StrictBool = Field(alias="isDataChange")
+    is_profile_anomalous: StrictBool = Field(alias="isProfileAnomalous")
+    job_id: Optional[StrictStr] = Field(default=None, alias="jobId")
+    job_type: Optional[StrictStr] = Field(default=None, alias="jobType")
+    marker: Optional[Marker] = None
+    marker_config: Optional[MarkerConfig] = Field(default=None, alias="markerConfig")
+    no_of_columns_per_batch: StrictInt = Field(alias="noOfColumnsPerBatch")
+    pattern_configuration: Optional[PatternConfiguration] = Field(default=None, alias="patternConfiguration")
+    profile_capabilities: List[StrictStr] = Field(alias="profileCapabilities")
+    profile_data_available: StrictBool = Field(alias="profileDataAvailable")
+    profiled_data: Optional[Dict[str, Any]] = Field(default=None, alias="profiledData")
+    profiling_type: StrictStr = Field(description="Allowed values at generation time: SELECTIVE, FULL, INCREMENTAL.", alias="profilingType")
+    resource_strategy_type: Optional[StrictStr] = Field(default='CUSTOM', description="Allowed values at generation time: INVENTORY, CUSTOM.", alias="resourceStrategyType")
+    rows: Optional[StrictInt] = None
+    run_type: StrictStr = Field(description="Allowed values at generation time: FULL_DATA_LOAD, BATCH_DATA_LOAD.", alias="runType")
+    selected_columns: List[StrictStr] = Field(alias="selectedColumns")
+    selected_resource_inventory: Optional[StrictStr] = Field(default=None, alias="selectedResourceInventory")
+    spark_resource_config: Optional[SparkResourceConfig] = Field(default=None, alias="sparkResourceConfig")
+    status: StrictStr
+    total_rows: Optional[StrictInt] = Field(default=None, alias="totalRows")
+    updated_at: datetime = Field(alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["analysisJob", "assetId", "autoProfileId", "autoRetries", "autoRetryEnabled", "createdAt", "engineType", "error", "executedBy", "executionMode", "id", "isDataChange", "isProfileAnomalous", "jobId", "jobType", "marker", "markerConfig", "noOfColumnsPerBatch", "patternConfiguration", "profileCapabilities", "profileDataAvailable", "profiledData", "profilingType", "resourceStrategyType", "rows", "runType", "selectedColumns", "selectedResourceInventory", "sparkResourceConfig", "status", "totalRows", "updatedAt"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of analysis_job
+        if self.analysis_job:
+            _dict['analysisJob'] = self.analysis_job.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of marker
+        if self.marker:
+            _dict['marker'] = self.marker.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of marker_config
+        if self.marker_config:
+            _dict['markerConfig'] = self.marker_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of pattern_configuration
+        if self.pattern_configuration:
+            _dict['patternConfiguration'] = self.pattern_configuration.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of spark_resource_config
+        if self.spark_resource_config:
+            _dict['sparkResourceConfig'] = self.spark_resource_config.to_dict()
+        # set to None if engine_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.engine_type is None and "engine_type" in self.model_fields_set:
+            _dict['engineType'] = None
+
+        # set to None if error (nullable) is None
+        # and model_fields_set contains the field
+        if self.error is None and "error" in self.model_fields_set:
+            _dict['error'] = None
+
+        # set to None if executed_by (nullable) is None
+        # and model_fields_set contains the field
+        if self.executed_by is None and "executed_by" in self.model_fields_set:
+            _dict['executedBy'] = None
+
+        # set to None if execution_mode (nullable) is None
+        # and model_fields_set contains the field
+        if self.execution_mode is None and "execution_mode" in self.model_fields_set:
+            _dict['executionMode'] = None
+
+        # set to None if job_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_id is None and "job_id" in self.model_fields_set:
+            _dict['jobId'] = None
+
+        # set to None if job_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_type is None and "job_type" in self.model_fields_set:
+            _dict['jobType'] = None
+
+        # set to None if resource_strategy_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.resource_strategy_type is None and "resource_strategy_type" in self.model_fields_set:
+            _dict['resourceStrategyType'] = None
+
+        # set to None if selected_resource_inventory (nullable) is None
+        # and model_fields_set contains the field
+        if self.selected_resource_inventory is None and "selected_resource_inventory" in self.model_fields_set:
+            _dict['selectedResourceInventory'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "analysisJob": DataplaneJob.from_dict(obj["analysisJob"]) if obj.get("analysisJob") is not None else None,
+            "assetId": obj.get("assetId"),
+            "autoProfileId": obj.get("autoProfileId"),
+            "autoRetries": obj.get("autoRetries") if obj.get("autoRetries") is not None else 0,
+            "autoRetryEnabled": obj.get("autoRetryEnabled") if obj.get("autoRetryEnabled") is not None else False,
+            "createdAt": obj.get("createdAt"),
+            "engineType": obj.get("engineType"),
+            "error": obj.get("error"),
+            "executedBy": obj.get("executedBy"),
+            "executionMode": obj.get("executionMode"),
+            "id": obj.get("id"),
+            "isDataChange": obj.get("isDataChange") if obj.get("isDataChange") is not None else False,
+            "isProfileAnomalous": obj.get("isProfileAnomalous") if obj.get("isProfileAnomalous") is not None else False,
+            "jobId": obj.get("jobId"),
+            "jobType": obj.get("jobType"),
+            "marker": Marker.from_dict(obj["marker"]) if obj.get("marker") is not None else None,
+            "markerConfig": MarkerConfig.from_dict(obj["markerConfig"]) if obj.get("markerConfig") is not None else None,
+            "noOfColumnsPerBatch": obj.get("noOfColumnsPerBatch") if obj.get("noOfColumnsPerBatch") is not None else 300,
+            "patternConfiguration": PatternConfiguration.from_dict(obj["patternConfiguration"]) if obj.get("patternConfiguration") is not None else None,
+            "profileCapabilities": obj.get("profileCapabilities"),
+            "profileDataAvailable": obj.get("profileDataAvailable") if obj.get("profileDataAvailable") is not None else False,
+            "profiledData": obj.get("profiledData"),
+            "profilingType": obj.get("profilingType"),
+            "resourceStrategyType": obj.get("resourceStrategyType") if obj.get("resourceStrategyType") is not None else 'CUSTOM',
+            "rows": obj.get("rows"),
+            "runType": obj.get("runType") if obj.get("runType") is not None else 'FULL_DATA_LOAD',
+            "selectedColumns": obj.get("selectedColumns"),
+            "selectedResourceInventory": obj.get("selectedResourceInventory"),
+            "sparkResourceConfig": SparkResourceConfig.from_dict(obj["sparkResourceConfig"]) if obj.get("sparkResourceConfig") is not None else None,
+            "status": obj.get("status"),
+            "totalRows": obj.get("totalRows"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/profile_request_response.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.profile_request import ProfileRequest
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileRequestResponse(BaseModel):
+    """
+    ProfileRequestResponse
+    """ # noqa: E501
+    profile_request: Optional[ProfileRequest] = Field(default=None, alias="profileRequest")
+    __properties: ClassVar[List[str]] = ["profileRequest"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileRequestResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of profile_request
+        if self.profile_request:
+            _dict['profileRequest'] = self.profile_request.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileRequestResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "profileRequest": ProfileRequest.from_dict(obj["profileRequest"]) if obj.get("profileRequest") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/property_template.py

@@ -0,0 +1,178 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class PropertyTemplate(BaseModel):
+    """
+    PropertyTemplate
+    """ # noqa: E501
+    children: List[PropertyTemplate]
+    config_key: Optional[StrictStr] = Field(default=None, alias="configKey")
+    config_value: Optional[Any] = Field(default=None, alias="configValue")
+    data_validator: Optional[StrictStr] = Field(default=None, alias="dataValidator")
+    data_validator_message: Optional[StrictStr] = Field(default=None, alias="dataValidatorMessage")
+    description: Optional[StrictStr] = None
+    disable_update: Optional[StrictBool] = Field(default=None, alias="disableUpdate")
+    display_label: StrictStr = Field(alias="displayLabel")
+    hidden: StrictBool
+    key: StrictStr
+    multi_select: Optional[StrictBool] = Field(default=None, alias="multiSelect")
+    options: List[StrictStr]
+    read_only: StrictBool = Field(alias="readOnly")
+    replacement_for: Optional[StrictStr] = Field(default=None, alias="replacementFor")
+    required: StrictBool
+    sub_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: STRING, INT, FLOAT, BOOLEAN.", alias="subType")
+    type: StrictStr = Field(description="Allowed values at generation time: INT, FLOAT, STRING, BOOLEAN, JSON, DURATION, OBJECT, OPTIONS, URL, URI, PASSWORD, EMAIL, CRONEXPRESSION, FILE, ARRAY.")
+    value: Optional[Any] = None
+    visibility: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["children", "configKey", "configValue", "dataValidator", "dataValidatorMessage", "description", "disableUpdate", "displayLabel", "hidden", "key", "multiSelect", "options", "readOnly", "replacementFor", "required", "subType", "type", "value", "visibility"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PropertyTemplate from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in children (list)
+        _items = []
+        if self.children:
+            for _item_children in self.children:
+                if _item_children:
+                    _items.append(_item_children.to_dict())
+            _dict['children'] = _items
+        # set to None if config_key (nullable) is None
+        # and model_fields_set contains the field
+        if self.config_key is None and "config_key" in self.model_fields_set:
+            _dict['configKey'] = None
+
+        # set to None if config_value (nullable) is None
+        # and model_fields_set contains the field
+        if self.config_value is None and "config_value" in self.model_fields_set:
+            _dict['configValue'] = None
+
+        # set to None if data_validator (nullable) is None
+        # and model_fields_set contains the field
+        if self.data_validator is None and "data_validator" in self.model_fields_set:
+            _dict['dataValidator'] = None
+
+        # set to None if data_validator_message (nullable) is None
+        # and model_fields_set contains the field
+        if self.data_validator_message is None and "data_validator_message" in self.model_fields_set:
+            _dict['dataValidatorMessage'] = None
+
+        # set to None if description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict['description'] = None
+
+        # set to None if replacement_for (nullable) is None
+        # and model_fields_set contains the field
+        if self.replacement_for is None and "replacement_for" in self.model_fields_set:
+            _dict['replacementFor'] = None
+
+        # set to None if sub_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.sub_type is None and "sub_type" in self.model_fields_set:
+            _dict['subType'] = None
+
+        # set to None if value (nullable) is None
+        # and model_fields_set contains the field
+        if self.value is None and "value" in self.model_fields_set:
+            _dict['value'] = None
+
+        # set to None if visibility (nullable) is None
+        # and model_fields_set contains the field
+        if self.visibility is None and "visibility" in self.model_fields_set:
+            _dict['visibility'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PropertyTemplate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "children": [PropertyTemplate.from_dict(_item) for _item in obj["children"]] if obj.get("children") is not None else None,
+            "configKey": obj.get("configKey"),
+            "configValue": obj.get("configValue"),
+            "dataValidator": obj.get("dataValidator"),
+            "dataValidatorMessage": obj.get("dataValidatorMessage"),
+            "description": obj.get("description"),
+            "disableUpdate": obj.get("disableUpdate"),
+            "displayLabel": obj.get("displayLabel"),
+            "hidden": obj.get("hidden"),
+            "key": obj.get("key"),
+            "multiSelect": obj.get("multiSelect"),
+            "options": obj.get("options"),
+            "readOnly": obj.get("readOnly"),
+            "replacementFor": obj.get("replacementFor"),
+            "required": obj.get("required"),
+            "subType": obj.get("subType"),
+            "type": obj.get("type"),
+            "value": obj.get("value"),
+            "visibility": obj.get("visibility")
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+PropertyTemplate.model_rebuild(raise_errors=False)
+

acceldata/models/api/catalog/property_templates.py

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from acceldata.models.api.catalog.property_template import PropertyTemplate
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class PropertyTemplates(BaseModel):
+    """
+    PropertyTemplates
+    """ # noqa: E501
+    assemblies: Dict[str, List[PropertyTemplate]]
+    connections: Dict[str, List[PropertyTemplate]]
+    __properties: ClassVar[List[str]] = ["assemblies", "connections"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PropertyTemplates from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each value in assemblies (dict of array)
+        _field_dict_of_array = {}
+        if self.assemblies:
+            for _key_assemblies in self.assemblies:
+                if self.assemblies[_key_assemblies] is not None:
+                    _field_dict_of_array[_key_assemblies] = [
+                        _item.to_dict() for _item in self.assemblies[_key_assemblies]
+                    ]
+            _dict['assemblies'] = _field_dict_of_array
+        # override the default output from pydantic by calling `to_dict()` of each value in connections (dict of array)
+        _field_dict_of_array = {}
+        if self.connections:
+            for _key_connections in self.connections:
+                if self.connections[_key_connections] is not None:
+                    _field_dict_of_array[_key_connections] = [
+                        _item.to_dict() for _item in self.connections[_key_connections]
+                    ]
+            _dict['connections'] = _field_dict_of_array
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PropertyTemplates from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "assemblies": dict(
+                (_k,
+                        [PropertyTemplate.from_dict(_item) for _item in _v]
+                        if _v is not None
+                        else None
+                )
+                for _k, _v in obj.get("assemblies", {}).items()
+            ),
+            "connections": dict(
+                (_k,
+                        [PropertyTemplate.from_dict(_item) for _item in _v]
+                        if _v is not None
+                        else None
+                )
+                for _k, _v in obj.get("connections", {}).items()
+            )
+        })
+        return _obj
+
+