"""
Cortex Inference API.

OpenAPI 3.0 specification for the Cortex REST API  # noqa: E501

The version of the OpenAPI document: 0.1.0
Contact: support@snowflake.com
Generated by: https://openapi-generator.tech

Do not edit this file manually.
"""

from __future__ import annotations

import json
import pprint
import re  # noqa: F401

from typing import Any

from pydantic import BaseModel, ConfigDict, StrictStr


class AnthropicThinking(BaseModel):
    """A model object representing the AnthropicThinking resource.

    Constructs an object of type AnthropicThinking with the provided properties.

    Parameters
    __________
    thinking : str
        Thinking tokens generated during the model response.
        This field can also be used in the follow-up requests to continue the conversation.
    signature : str
        The signature field is an opaque field and should not be interpreted or parsed.
        It should only be used for verifying that the thinking blocks were generated by that specific model.
    """

    thinking: StrictStr

    signature: StrictStr

    __properties = ["thinking", "signature"]

    model_config = ConfigDict(
        validate_by_name=True,
        validate_assignment=True,
    )

    def to_str(self) -> str:
        """Returns the string representation of the model using alias."""
        return pprint.pformat(self.dict(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias."""
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> AnthropicThinking:
        """Create an instance of AnthropicThinking from a JSON string."""
        return cls.from_dict(json.loads(json_str))

    def to_dict(
        self,
        hide_readonly_properties: bool = False,
    ) -> dict[str, Any]:
        """Returns the dictionary representation of the model using alias."""
        exclude_properties = set()

        if hide_readonly_properties:
            exclude_properties.update({})

        _dict = self.model_dump(serialize_as_any=True, by_alias=True, exclude=exclude_properties, exclude_none=True)

        return _dict

    def to_dict_without_readonly_properties(self) -> dict[str, Any]:
        """Return the dictionary representation of the model without readonly properties."""
        return self.to_dict(hide_readonly_properties=True)

    @classmethod
    def from_dict(cls, obj: dict) -> AnthropicThinking:
        """Create an instance of AnthropicThinking from a dict."""
        if obj is None:
            return None

        if type(obj) is not dict:
            return AnthropicThinking.model_validate(obj)

        _obj = AnthropicThinking.model_validate(
            {
                "thinking": obj.get("thinking"),
                "signature": obj.get("signature"),
            }
        )

        return _obj


class AnthropicThinkingModel:
    def __init__(
        self,
        thinking: str,
        signature: str,
        # optional properties
    ):
        """A model object representing the AnthropicThinking resource.

                Constructs an object of type AnthropicThinking with the provided properties.

                Parameters
                __________
                thinking : str
                    Thinking tokens generated during the model response.
        This field can also be used in the follow-up requests to continue the conversation.

                signature : str
                    The signature field is an opaque field and should not be interpreted or parsed.
        It should only be used for verifying that the thinking blocks were generated by that specific model.
        """
        self.thinking = thinking
        self.signature = signature

    __properties = ["thinking", "signature"]

    def __repr__(self) -> str:
        return repr(self._to_model())

    def _to_model(self):
        return AnthropicThinking(
            thinking=self.thinking,
            signature=self.signature,
        )

    @classmethod
    def _from_model(cls, model) -> AnthropicThinkingModel:
        return AnthropicThinkingModel(
            thinking=model.thinking,
            signature=model.signature,
        )

    def to_dict(self):
        """Create a dictionary of the properties from a AnthropicThinking.

        This method constructs a dictionary with the key-value entries corresponding to the properties of the AnthropicThinking object.

        Returns
        _______
        dict
            A dictionary object created using the input model.
        """
        return self._to_model().to_dict()

    @classmethod
    def from_dict(cls, obj: dict) -> AnthropicThinkingModel:
        """Create an instance of AnthropicThinking from a dict.

        This method constructs a AnthropicThinking object from a dictionary with the key-value pairs of its properties.

        Parameters
        ----------
        obj : dict
            A dictionary whose keys and values correspond to the properties of the resource object.

        Returns
        _______
        AnthropicThinking
            A AnthropicThinking object created using the input dictionary; this will fail if the required properties are missing.
        """
        return cls._from_model(AnthropicThinking.from_dict(obj))


AnthropicThinking._model_class = AnthropicThinkingModel
