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

acceldata/models/api/catalog/data_quality_rules_response.py

@@ -0,0 +1,102 @@
+# 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.data_quality_rule_response import DataQualityRuleResponse
+from acceldata.models.api.catalog.meta_data import MetaData
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class DataQualityRulesResponse(BaseModel):
+    """
+    DataQualityRulesResponse
+    """ # noqa: E501
+    meta: MetaData
+    rules: List[DataQualityRuleResponse]
+    __properties: ClassVar[List[str]] = ["meta", "rules"]
+
+    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 DataQualityRulesResponse 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 meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in rules (list)
+        _items = []
+        if self.rules:
+            for _item_rules in self.rules:
+                if _item_rules:
+                    _items.append(_item_rules.to_dict())
+            _dict['rules'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataQualityRulesResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "meta": MetaData.from_dict(obj["meta"]) if obj.get("meta") is not None else None,
+            "rules": [DataQualityRuleResponse.from_dict(_item) for _item in obj["rules"]] if obj.get("rules") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/databricks_compute_config.py

@@ -0,0 +1,113 @@
+# 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, StrictInt, 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 DatabricksComputeConfig(BaseModel):
+    """
+    DatabricksComputeConfig
+    """ # noqa: E501
+    cluster_driver_type: Optional[StrictStr] = Field(default=None, alias="clusterDriverType")
+    cluster_worker_type: Optional[StrictStr] = Field(default=None, alias="clusterWorkerType")
+    is_enabled: Optional[StrictBool] = Field(default=None, alias="isEnabled")
+    job_cluster_type: Optional[StrictStr] = Field(default=None, alias="jobClusterType")
+    max_workers: Optional[StrictInt] = Field(default=None, alias="maxWorkers")
+    min_workers: Optional[StrictInt] = Field(default=None, alias="minWorkers")
+    __properties: ClassVar[List[str]] = ["clusterDriverType", "clusterWorkerType", "isEnabled", "jobClusterType", "maxWorkers", "minWorkers"]
+
+    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 DatabricksComputeConfig 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,
+        )
+        # set to None if cluster_driver_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.cluster_driver_type is None and "cluster_driver_type" in self.model_fields_set:
+            _dict['clusterDriverType'] = None
+
+        # set to None if cluster_worker_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.cluster_worker_type is None and "cluster_worker_type" in self.model_fields_set:
+            _dict['clusterWorkerType'] = None
+
+        # set to None if job_cluster_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_cluster_type is None and "job_cluster_type" in self.model_fields_set:
+            _dict['jobClusterType'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DatabricksComputeConfig from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "clusterDriverType": obj.get("clusterDriverType"),
+            "clusterWorkerType": obj.get("clusterWorkerType"),
+            "isEnabled": obj.get("isEnabled"),
+            "jobClusterType": obj.get("jobClusterType"),
+            "maxWorkers": obj.get("maxWorkers"),
+            "minWorkers": obj.get("minWorkers")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/dataplane_engine.py

@@ -0,0 +1,105 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.data_quality_engine import DataQualityEngine
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class DataplaneEngine(BaseModel):
+    """
+    DataplaneEngine
+    """ # noqa: E501
+    current: StrictStr = Field(description="Allowed values at generation time: SPARK, JDBC_SQL, POD.")
+    display_name: StrictStr = Field(alias="displayName")
+    supported: Optional[List[DataQualityEngine]] = None
+    __properties: ClassVar[List[str]] = ["current", "displayName", "supported"]
+
+    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 DataplaneEngine 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 supported (list)
+        _items = []
+        if self.supported:
+            for _item_supported in self.supported:
+                if _item_supported:
+                    _items.append(_item_supported.to_dict())
+            _dict['supported'] = _items
+        # set to None if supported (nullable) is None
+        # and model_fields_set contains the field
+        if self.supported is None and "supported" in self.model_fields_set:
+            _dict['supported'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataplaneEngine from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "current": obj.get("current"),
+            "displayName": obj.get("displayName"),
+            "supported": [DataQualityEngine.from_dict(_item) for _item in obj["supported"]] if obj.get("supported") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/dataplane_health_metrics.py

@@ -0,0 +1,101 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.kubernetes_metrics import KubernetesMetrics
+from acceldata.models.api.catalog.process_metrics import ProcessMetrics
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class DataplaneHealthMetrics(BaseModel):
+    """
+    DataplaneHealthMetrics
+    """ # noqa: E501
+    kubernetes: Optional[KubernetesMetrics] = None
+    process: ProcessMetrics
+    reporting_time: datetime = Field(alias="reportingTime")
+    __properties: ClassVar[List[str]] = ["kubernetes", "process", "reportingTime"]
+
+    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 DataplaneHealthMetrics 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 kubernetes
+        if self.kubernetes:
+            _dict['kubernetes'] = self.kubernetes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of process
+        if self.process:
+            _dict['process'] = self.process.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataplaneHealthMetrics from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "kubernetes": KubernetesMetrics.from_dict(obj["kubernetes"]) if obj.get("kubernetes") is not None else None,
+            "process": ProcessMetrics.from_dict(obj["process"]) if obj.get("process") is not None else None,
+            "reportingTime": obj.get("reportingTime")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/dataplane_job.py

@@ -0,0 +1,216 @@
+# 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.analysis_job_context import AnalysisJobContext
+from acceldata.models.api.catalog.dataplane_request import DataplaneRequest
+from acceldata.models.api.catalog.job_spec import JobSpec
+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 DataplaneJob(BaseModel):
+    """
+    DataplaneJob
+    """ # noqa: E501
+    analysis_job_context: Optional[AnalysisJobContext] = Field(default=None, alias="analysisJobContext")
+    analysis_service_job_id: Optional[StrictInt] = Field(default=None, alias="analysisServiceJobId")
+    analytics_pipeline_id: Optional[StrictInt] = Field(default=None, alias="analyticsPipelineId")
+    asset_id: Optional[StrictInt] = Field(default=None, alias="assetId")
+    asset_uid: Optional[StrictStr] = Field(default=None, alias="assetUid")
+    auto_retries: Optional[StrictInt] = Field(default=None, alias="autoRetries")
+    auto_retry_enabled: Optional[StrictBool] = Field(default=None, alias="autoRetryEnabled")
+    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
+    data_source_id: Optional[StrictStr] = Field(default=None, alias="dataSourceId")
+    data_source_type: Optional[StrictStr] = Field(default=None, alias="dataSourceType")
+    engine_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: SPARK, JDBC_SQL, POD.", alias="engineType")
+    error_message: Optional[StrictStr] = Field(default=None, alias="errorMessage")
+    execution_id: Optional[StrictInt] = Field(default=None, alias="executionId")
+    execution_status: StrictStr = Field(description="Allowed values at generation time: WAITING, SKIPPED, SUBMITTED, QUEUED, IN_PROGRESS, ABORTED, FAILED, POSTPROCESSING, ANOMALY_DETECTION, EXECUTION_RESULT, SUCCESSFUL.", alias="executionStatus")
+    finished_at: Optional[datetime] = Field(default=None, alias="finishedAt")
+    job_spec: Optional[JobSpec] = Field(default=None, alias="jobSpec")
+    job_state: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: ACKNOWLEDGED, SUBMITTED, QUEUED, SKIPPED, RUNNING, READ_DATA, REFERENCE_DATA, PROFILE_STAGE_1, PROFILE_STAGE_2, PROFILE_STAGE_3, PROFILE_STAGE_4, DQ_BATCH_RULES, DQ_ROW_RULES, DQ_CUSTOM_RULES, DQ_SEGMENT, DQ_GOOD_RESULT_STORE, DQ_BAD_RESULT_STORE, VALIDATE, PROCESSING, PREPARE_RESULT, SEND_RESULT, SEND_RESULT_FAILED, SUCCESSFUL, FAILED, ABORTED, WAITING, METRICS_REQUEST_SENT, PARTIAL_RESPONSE_PUBLISHED, COMPLETE_RESPONSE_PUBLISHED, METRICS_RESPONSE_RECEIVED, ANOMALY_DETECTION_INITIATED, PARTIAL_ANOMALY_RESULT_RECEIVED, COMPLETE_ANOMALY_RESULT_RECEIVED, POLICY_EXECUTION_SUCCESSFUL, POLICY_EXECUTION_FAILURE, EXECUTION_RESULT.", alias="jobState")
+    job_type: StrictStr = Field(description="Allowed values at generation time: SAMPLE_DATA, FILE_INFO_CRAWLER, SAMPLE_DATA_CRAWLER, UDF_VALIDATION, SQL_VIEW_SAMPLE_DATA, VISUAL_VIEW_SAMPLE_DATA, DATA_VIOLATIONS_SAMPLE_DATA, DATA_VIOLATIONS_SAMPLE_DATA_S3, DATA_VIOLATIONS_SAMPLE_DATA_ADLS, DATA_VIOLATIONS_SAMPLE_DATA_GCS, DATA_VIOLATIONS_SAMPLE_DATA_HDFS, DATA_VIOLATIONS_SAMPLE_DATA_LOCAL, PROFILE, DATA_QUALITY, RECONCILIATION, ROW_COUNT_EQUALITY, FILE_CRAWLER, KAFKA_CRAWLER, PUBSUB_CRAWLER, CRAWLER, ASSET_FILE_MONITORING, ASSET_MONITORING, ASSET_REFERENCE_VALIDATION, AUTO_TAG, EXECUTION_RESULT, CONNECTION_VALIDATION, PARENT_LIST, CADENCE, AUTO_ANOMALY, SQL_VALIDATION, RESULT, DATA_VIOLATIONS, DOWNLOAD_DATA_VIOLATIONS, FRESHNESS, DATA_SOURCE_QUERY.", alias="jobType")
+    last_health_update_at: Optional[datetime] = Field(default=None, alias="lastHealthUpdateAt")
+    request: Optional[DataplaneRequest] = None
+    request_id: Optional[StrictStr] = Field(default=None, alias="requestId")
+    resource_strategy_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: INVENTORY, CUSTOM.", alias="resourceStrategyType")
+    selected_resource_inventory: Optional[StrictStr] = Field(default=None, alias="selectedResourceInventory")
+    spark_cluster_context: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: LOCAL, LIVY, DATABRICKS, KUBERNETES, DATAPROC.", alias="sparkClusterContext")
+    spark_resource_config: Optional[SparkResourceConfig] = Field(default=None, alias="sparkResourceConfig")
+    started_at: datetime = Field(alias="startedAt")
+    started_running_at: Optional[datetime] = Field(default=None, alias="startedRunningAt")
+    tenant_id: Optional[StrictStr] = Field(default=None, alias="tenantId")
+    updated_at: Optional[datetime] = Field(default=None, alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["analysisJobContext", "analysisServiceJobId", "analyticsPipelineId", "assetId", "assetUid", "autoRetries", "autoRetryEnabled", "createdAt", "dataSourceId", "dataSourceType", "engineType", "errorMessage", "executionId", "executionStatus", "finishedAt", "jobSpec", "jobState", "jobType", "lastHealthUpdateAt", "request", "requestId", "resourceStrategyType", "selectedResourceInventory", "sparkClusterContext", "sparkResourceConfig", "startedAt", "startedRunningAt", "tenantId", "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 DataplaneJob 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_context
+        if self.analysis_job_context:
+            _dict['analysisJobContext'] = self.analysis_job_context.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of job_spec
+        if self.job_spec:
+            _dict['jobSpec'] = self.job_spec.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of request
+        if self.request:
+            _dict['request'] = self.request.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 asset_uid (nullable) is None
+        # and model_fields_set contains the field
+        if self.asset_uid is None and "asset_uid" in self.model_fields_set:
+            _dict['assetUid'] = None
+
+        # set to None if data_source_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.data_source_id is None and "data_source_id" in self.model_fields_set:
+            _dict['dataSourceId'] = None
+
+        # set to None if data_source_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.data_source_type is None and "data_source_type" in self.model_fields_set:
+            _dict['dataSourceType'] = None
+
+        # 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_message (nullable) is None
+        # and model_fields_set contains the field
+        if self.error_message is None and "error_message" in self.model_fields_set:
+            _dict['errorMessage'] = None
+
+        # set to None if job_state (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_state is None and "job_state" in self.model_fields_set:
+            _dict['jobState'] = None
+
+        # set to None if request_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.request_id is None and "request_id" in self.model_fields_set:
+            _dict['requestId'] = 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
+
+        # set to None if spark_cluster_context (nullable) is None
+        # and model_fields_set contains the field
+        if self.spark_cluster_context is None and "spark_cluster_context" in self.model_fields_set:
+            _dict['sparkClusterContext'] = None
+
+        # set to None if tenant_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.tenant_id is None and "tenant_id" in self.model_fields_set:
+            _dict['tenantId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataplaneJob from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "analysisJobContext": AnalysisJobContext.from_dict(obj["analysisJobContext"]) if obj.get("analysisJobContext") is not None else None,
+            "analysisServiceJobId": obj.get("analysisServiceJobId"),
+            "analyticsPipelineId": obj.get("analyticsPipelineId"),
+            "assetId": obj.get("assetId"),
+            "assetUid": obj.get("assetUid"),
+            "autoRetries": obj.get("autoRetries"),
+            "autoRetryEnabled": obj.get("autoRetryEnabled"),
+            "createdAt": obj.get("createdAt"),
+            "dataSourceId": obj.get("dataSourceId"),
+            "dataSourceType": obj.get("dataSourceType"),
+            "engineType": obj.get("engineType"),
+            "errorMessage": obj.get("errorMessage"),
+            "executionId": obj.get("executionId"),
+            "executionStatus": obj.get("executionStatus"),
+            "finishedAt": obj.get("finishedAt"),
+            "jobSpec": JobSpec.from_dict(obj["jobSpec"]) if obj.get("jobSpec") is not None else None,
+            "jobState": obj.get("jobState"),
+            "jobType": obj.get("jobType"),
+            "lastHealthUpdateAt": obj.get("lastHealthUpdateAt"),
+            "request": DataplaneRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
+            "requestId": obj.get("requestId"),
+            "resourceStrategyType": obj.get("resourceStrategyType"),
+            "selectedResourceInventory": obj.get("selectedResourceInventory"),
+            "sparkClusterContext": obj.get("sparkClusterContext"),
+            "sparkResourceConfig": SparkResourceConfig.from_dict(obj["sparkResourceConfig"]) if obj.get("sparkResourceConfig") is not None else None,
+            "startedAt": obj.get("startedAt"),
+            "startedRunningAt": obj.get("startedRunningAt"),
+            "tenantId": obj.get("tenantId"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+