hotdata 0.0.1__py3-none-any.whl

hotdata/models/query_run_info.py

@@ -0,0 +1,176 @@
+# coding: utf-8
+
+"""
+    Hotdata API
+
+    Powerful data platform API for datasets, queries, and analytics.
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: developers@hotdata.dev
+    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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryRunInfo(BaseModel):
+    """
+    Single query run for listing
+    """ # noqa: E501
+    completed_at: Optional[datetime] = None
+    created_at: datetime
+    error_message: Optional[StrictStr] = None
+    execution_time_ms: Optional[StrictInt] = None
+    id: StrictStr
+    result_id: Optional[StrictStr] = None
+    row_count: Optional[StrictInt] = None
+    saved_query_id: Optional[StrictStr] = None
+    saved_query_version: Optional[StrictInt] = None
+    server_processing_ms: Optional[StrictInt] = Field(default=None, description="Total server-side processing time for this query (milliseconds). Measured from query start to result ready. Includes SQL execution, task spawning, and result preparation. Does not include network transit. Populated for all completed query runs (sync and async).")
+    snapshot_id: StrictStr
+    sql_hash: StrictStr
+    sql_text: StrictStr
+    status: StrictStr
+    trace_id: Optional[StrictStr] = None
+    user_public_id: Optional[StrictStr] = Field(default=None, description="Caller identity derived from the Authorization Bearer token (SHA-256 hash). Format: `user_{first_10_hex_chars}`. Mirrors the webapp's `user_public_id_from_auth_header`.")
+    warning_message: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["completed_at", "created_at", "error_message", "execution_time_ms", "id", "result_id", "row_count", "saved_query_id", "saved_query_version", "server_processing_ms", "snapshot_id", "sql_hash", "sql_text", "status", "trace_id", "user_public_id", "warning_message"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryRunInfo 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 completed_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.completed_at is None and "completed_at" in self.model_fields_set:
+            _dict['completed_at'] = 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['error_message'] = None
+
+        # set to None if execution_time_ms (nullable) is None
+        # and model_fields_set contains the field
+        if self.execution_time_ms is None and "execution_time_ms" in self.model_fields_set:
+            _dict['execution_time_ms'] = None
+
+        # set to None if result_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.result_id is None and "result_id" in self.model_fields_set:
+            _dict['result_id'] = None
+
+        # set to None if row_count (nullable) is None
+        # and model_fields_set contains the field
+        if self.row_count is None and "row_count" in self.model_fields_set:
+            _dict['row_count'] = None
+
+        # set to None if saved_query_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.saved_query_id is None and "saved_query_id" in self.model_fields_set:
+            _dict['saved_query_id'] = None
+
+        # set to None if saved_query_version (nullable) is None
+        # and model_fields_set contains the field
+        if self.saved_query_version is None and "saved_query_version" in self.model_fields_set:
+            _dict['saved_query_version'] = None
+
+        # set to None if server_processing_ms (nullable) is None
+        # and model_fields_set contains the field
+        if self.server_processing_ms is None and "server_processing_ms" in self.model_fields_set:
+            _dict['server_processing_ms'] = None
+
+        # set to None if trace_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.trace_id is None and "trace_id" in self.model_fields_set:
+            _dict['trace_id'] = None
+
+        # set to None if user_public_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.user_public_id is None and "user_public_id" in self.model_fields_set:
+            _dict['user_public_id'] = None
+
+        # set to None if warning_message (nullable) is None
+        # and model_fields_set contains the field
+        if self.warning_message is None and "warning_message" in self.model_fields_set:
+            _dict['warning_message'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryRunInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "completed_at": obj.get("completed_at"),
+            "created_at": obj.get("created_at"),
+            "error_message": obj.get("error_message"),
+            "execution_time_ms": obj.get("execution_time_ms"),
+            "id": obj.get("id"),
+            "result_id": obj.get("result_id"),
+            "row_count": obj.get("row_count"),
+            "saved_query_id": obj.get("saved_query_id"),
+            "saved_query_version": obj.get("saved_query_version"),
+            "server_processing_ms": obj.get("server_processing_ms"),
+            "snapshot_id": obj.get("snapshot_id"),
+            "sql_hash": obj.get("sql_hash"),
+            "sql_text": obj.get("sql_text"),
+            "status": obj.get("status"),
+            "trace_id": obj.get("trace_id"),
+            "user_public_id": obj.get("user_public_id"),
+            "warning_message": obj.get("warning_message")
+        })
+        return _obj
+
+

hotdata/models/refresh_dataset_response.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Hotdata API
+
+    Powerful data platform API for datasets, queries, and analytics.
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: developers@hotdata.dev
+    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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RefreshDatasetResponse(BaseModel):
+    """
+    Response body for POST /v1/datasets/{id}/refresh
+    """ # noqa: E501
+    created_at: datetime
+    id: StrictStr
+    status: StrictStr
+    version: StrictInt
+    __properties: ClassVar[List[str]] = ["created_at", "id", "status", "version"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RefreshDatasetResponse 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RefreshDatasetResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "created_at": obj.get("created_at"),
+            "id": obj.get("id"),
+            "status": obj.get("status"),
+            "version": obj.get("version")
+        })
+        return _obj
+
+

hotdata/models/refresh_request.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+    Hotdata API
+
+    Powerful data platform API for datasets, queries, and analytics.
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: developers@hotdata.dev
+    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
+
+class RefreshRequest(BaseModel):
+    """
+    Request body for POST /refresh
+    """ # noqa: E501
+    var_async: Optional[StrictBool] = Field(default=None, description="When true, submit the refresh as a background job and return immediately with a job ID for status polling. Only supported for data refresh operations.", alias="async")
+    connection_id: Optional[StrictStr] = None
+    data: Optional[StrictBool] = None
+    dataset_id: Optional[StrictStr] = None
+    include_uncached: Optional[StrictBool] = Field(default=None, description="Controls whether uncached tables are included in connection-wide data refresh.  - `false` (default): Only refresh tables that already have cached data.   This is the common case for keeping existing data up-to-date. - `true`: Also sync tables that haven't been cached yet, essentially performing   an initial sync for any new tables discovered since the connection was created.  This field only applies to connection-wide data refresh (when `data=true` and `table_name` is not specified). It has no effect on single-table refresh or schema refresh operations.")
+    schema_name: Optional[StrictStr] = None
+    table_name: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["async", "connection_id", "data", "dataset_id", "include_uncached", "schema_name", "table_name"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RefreshRequest 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 connection_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.connection_id is None and "connection_id" in self.model_fields_set:
+            _dict['connection_id'] = None
+
+        # set to None if dataset_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.dataset_id is None and "dataset_id" in self.model_fields_set:
+            _dict['dataset_id'] = None
+
+        # set to None if schema_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.schema_name is None and "schema_name" in self.model_fields_set:
+            _dict['schema_name'] = None
+
+        # set to None if table_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.table_name is None and "table_name" in self.model_fields_set:
+            _dict['table_name'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RefreshRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "async": obj.get("async"),
+            "connection_id": obj.get("connection_id"),
+            "data": obj.get("data"),
+            "dataset_id": obj.get("dataset_id"),
+            "include_uncached": obj.get("include_uncached"),
+            "schema_name": obj.get("schema_name"),
+            "table_name": obj.get("table_name")
+        })
+        return _obj
+
+

hotdata/models/refresh_response.py

@@ -0,0 +1,180 @@
+# coding: utf-8
+
+"""
+    Hotdata API
+
+    Powerful data platform API for datasets, queries, and analytics.
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: developers@hotdata.dev
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from hotdata.models.connection_refresh_result import ConnectionRefreshResult
+from hotdata.models.refresh_dataset_response import RefreshDatasetResponse
+from hotdata.models.schema_refresh_result import SchemaRefreshResult
+from hotdata.models.submit_job_response import SubmitJobResponse
+from hotdata.models.table_refresh_result import TableRefreshResult
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+REFRESHRESPONSE_ONE_OF_SCHEMAS = ["ConnectionRefreshResult", "RefreshDatasetResponse", "SchemaRefreshResult", "SubmitJobResponse", "TableRefreshResult"]
+
+class RefreshResponse(BaseModel):
+    """
+    Unified response type for refresh operations
+    """
+    # data type: SchemaRefreshResult
+    oneof_schema_1_validator: Optional[SchemaRefreshResult] = None
+    # data type: TableRefreshResult
+    oneof_schema_2_validator: Optional[TableRefreshResult] = None
+    # data type: ConnectionRefreshResult
+    oneof_schema_3_validator: Optional[ConnectionRefreshResult] = None
+    # data type: RefreshDatasetResponse
+    oneof_schema_4_validator: Optional[RefreshDatasetResponse] = None
+    # data type: SubmitJobResponse
+    oneof_schema_5_validator: Optional[SubmitJobResponse] = None
+    actual_instance: Optional[Union[ConnectionRefreshResult, RefreshDatasetResponse, SchemaRefreshResult, SubmitJobResponse, TableRefreshResult]] = None
+    one_of_schemas: Set[str] = { "ConnectionRefreshResult", "RefreshDatasetResponse", "SchemaRefreshResult", "SubmitJobResponse", "TableRefreshResult" }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = RefreshResponse.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: SchemaRefreshResult
+        if not isinstance(v, SchemaRefreshResult):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `SchemaRefreshResult`")
+        else:
+            match += 1
+        # validate data type: TableRefreshResult
+        if not isinstance(v, TableRefreshResult):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `TableRefreshResult`")
+        else:
+            match += 1
+        # validate data type: ConnectionRefreshResult
+        if not isinstance(v, ConnectionRefreshResult):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `ConnectionRefreshResult`")
+        else:
+            match += 1
+        # validate data type: RefreshDatasetResponse
+        if not isinstance(v, RefreshDatasetResponse):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `RefreshDatasetResponse`")
+        else:
+            match += 1
+        # validate data type: SubmitJobResponse
+        if not isinstance(v, SubmitJobResponse):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `SubmitJobResponse`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in RefreshResponse with oneOf schemas: ConnectionRefreshResult, RefreshDatasetResponse, SchemaRefreshResult, SubmitJobResponse, TableRefreshResult. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in RefreshResponse with oneOf schemas: ConnectionRefreshResult, RefreshDatasetResponse, SchemaRefreshResult, SubmitJobResponse, TableRefreshResult. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into SchemaRefreshResult
+        try:
+            instance.actual_instance = SchemaRefreshResult.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into TableRefreshResult
+        try:
+            instance.actual_instance = TableRefreshResult.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into ConnectionRefreshResult
+        try:
+            instance.actual_instance = ConnectionRefreshResult.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into RefreshDatasetResponse
+        try:
+            instance.actual_instance = RefreshDatasetResponse.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into SubmitJobResponse
+        try:
+            instance.actual_instance = SubmitJobResponse.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into RefreshResponse with oneOf schemas: ConnectionRefreshResult, RefreshDatasetResponse, SchemaRefreshResult, SubmitJobResponse, TableRefreshResult. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into RefreshResponse with oneOf schemas: ConnectionRefreshResult, RefreshDatasetResponse, SchemaRefreshResult, SubmitJobResponse, TableRefreshResult. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], ConnectionRefreshResult, RefreshDatasetResponse, SchemaRefreshResult, SubmitJobResponse, TableRefreshResult]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

hotdata/models/refresh_warning.py

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+    Hotdata API
+
+    Powerful data platform API for datasets, queries, and analytics.
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: developers@hotdata.dev
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RefreshWarning(BaseModel):
+    """
+    Non-fatal warning that occurred during a refresh operation. Used to report issues like failed deletion scheduling that don't prevent the refresh from succeeding.
+    """ # noqa: E501
+    message: StrictStr
+    schema_name: Optional[StrictStr] = None
+    table_name: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["message", "schema_name", "table_name"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RefreshWarning 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 schema_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.schema_name is None and "schema_name" in self.model_fields_set:
+            _dict['schema_name'] = None
+
+        # set to None if table_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.table_name is None and "table_name" in self.model_fields_set:
+            _dict['table_name'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RefreshWarning from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message"),
+            "schema_name": obj.get("schema_name"),
+            "table_name": obj.get("table_name")
+        })
+        return _obj
+
+