miro_api.models.update_board_subscription

callback_url: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MinLen(min_length=8), MaxLen(max_length=256)])]]

status: Optional[Annotated[str, Strict(strict=True)]]

additional_properties: Dict[str, Any]

@field_validator('callback_url')

def callback_url_validate_regular_expression(cls, value): View Source

45    @field_validator("callback_url")
46    def callback_url_validate_regular_expression(cls, value):
47        """Validates the regular expression"""
48        if value is None:
49            return value
50
51        if not re.match(r"^https:\/\/(.*)", value):
52            raise ValueError(r"must validate the regular expression /^https:\/\/(.*)/")
53        return value

Validates the regular expression

@field_validator('status')

def status_validate_enum(cls, value): View Source

55    @field_validator("status")
56    def status_validate_enum(cls, value):
57        """Validates the enum"""
58        if value is None:
59            return value
60
61        if value not in set(["enabled", "disabled"]):
62            raise ValueError("must be one of enum values ('enabled', 'disabled')")
63        return value

Validates the enum

model_config = {'populate_by_name': True, 'validate_assignment': True, 'protected_namespaces': ()}

def to_str(self) -> str: View Source

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

Returns the string representation of the model using alias

def to_json(self) -> str: View Source

75    def to_json(self) -> str:
76        """Returns the JSON representation of the model using alias"""
77        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
78        return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

@classmethod

def from_json(cls, json_str: str) -> Optional[typing_extensions.Self]: View Source

80    @classmethod
81    def from_json(cls, json_str: str) -> Optional[Self]:
82        """Create an instance of UpdateBoardSubscriptionRequest from a JSON string"""
83        return cls.from_dict(json.loads(json_str))

Create an instance of UpdateBoardSubscriptionRequest from a JSON string

def to_dict(self) -> Dict[str, Any]: View Source

 85    def to_dict(self) -> Dict[str, Any]:
 86        """Return the dictionary representation of the model using alias.
 87
 88        This has the following differences from calling pydantic's
 89        `self.model_dump(by_alias=True)`:
 90
 91        * `None` is only added to the output dict for nullable fields that
 92          were set at model initialization. Other fields with value `None`
 93          are ignored.
 94        * Fields in `self.additional_properties` are added to the output dict.
 95        """
 96        excluded_fields: Set[str] = set(
 97            [
 98                "additional_properties",
 99            ]
100        )
101
102        _dict = self.model_dump(
103            by_alias=True,
104            exclude=excluded_fields,
105            exclude_none=True,
106        )
107        # puts key-value pairs in additional_properties in the top level
108        if self.additional_properties is not None:
109            for _key, _value in self.additional_properties.items():
110                _dict[_key] = _value
111
112        return _dict

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.
Fields in self.additional_properties are added to the output dict.

@classmethod

def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[typing_extensions.Self]: View Source

114    @classmethod
115    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
116        """Create an instance of UpdateBoardSubscriptionRequest from a dict"""
117        if obj is None:
118            return None
119
120        if not isinstance(obj, dict):
121            return cls.model_validate(obj)
122
123        _obj = cls.model_validate(
124            {
125                "callbackUrl": obj.get("callbackUrl"),
126                "status": obj.get("status") if obj.get("status") is not None else "enabled",
127            }
128        )
129        # store additional fields in additional_properties
130        for _key in obj.keys():
131            if _key not in cls.__properties:
132                _obj.additional_properties[_key] = obj.get(_key)
133
134        return _obj

Create an instance of UpdateBoardSubscriptionRequest from a dict

def model_post_init(self: pydantic.main.BaseModel, __context: Any) -> None: View Source

265def init_private_attributes(self: BaseModel, __context: Any) -> None:
266    """This function is meant to behave like a BaseModel method to initialise private attributes.
267
268    It takes context as an argument since that's what pydantic-core passes when calling it.
269
270    Args:
271        self: The BaseModel instance.
272        __context: The context.
273    """
274    if getattr(self, '__pydantic_private__', None) is None:
275        pydantic_private = {}
276        for name, private_attr in self.__private_attributes__.items():
277            default = private_attr.get_default()
278            if default is not PydanticUndefined:
279                pydantic_private[name] = default
280        object_setattr(self, '__pydantic_private__', pydantic_private)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that's what pydantic-core passes when calling it.

Args: self: The BaseModel instance. __context: The context.

model_fields = {'callback_url': FieldInfo(annotation=Union[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MinLen(min_length=8), MaxLen(max_length=256)])], NoneType], required=False, alias='callbackUrl', alias_priority=2, description='Indicates the HTTPS URL to which Miro sends a webhook when an event occurs.'), 'status': FieldInfo(annotation=Union[Annotated[str, Strict(strict=True)], NoneType], required=False, default='enabled', description='Indicates whether the status of the webhook subscription. `enabled`: Miro sends a webhook when an event occurs in the associated board. `disabled`: Miro does not send a webhook even when an event occurs in the associated board. `lost_access`: The user with which the webhook subscription is associated has lost access to the board. The user needs to regain access to the board, and then reenable the webhook subscription by updating the webhook subscription status to `enabled` by using the update webhook endpoint.'), 'additional_properties': FieldInfo(annotation=Dict[str, Any], required=False, default={})}

model_computed_fields = {}

miro_api.models.update_board_subscription_request

Inherited Members