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

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

Validates the regular expression

@field_validator('status')

def status_validate_enum(cls, value): View Source

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

Validates the enum

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

def to_str(self) -> str: View Source

70    def to_str(self) -> str:
71        """Returns the string representation of the model using alias"""
72        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

74    def to_json(self) -> str:
75        """Returns the JSON representation of the model using alias"""
76        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
77        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

79    @classmethod
80    def from_json(cls, json_str: str) -> Optional[Self]:
81        """Create an instance of UpdateBoardSubscriptionRequest from a JSON string"""
82        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

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

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