Module slack_sdk.models.blocks
Block Kit data model objects
To learn more about Block Kit, please check the following resources and tools:
Sub-modules
slack_sdk.models.blocks.basic_components
slack_sdk.models.blocks.block_elements
slack_sdk.models.blocks.blocks
Classes
class ActionsBlock (*, elements: Sequence[Union[dict, InteractiveElement]], block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A block that is used to hold interactive elements. https://api.slack.com/reference/block-kit/blocks#actions
Args
elements
:required
- An array of interactive element objects - buttons, select menus, overflow menus, or date pickers. There is a maximum of 25 elements in each action block.
block_id
- A string acting as a unique identifier for a block. If not specified, a block_id will be generated. You can use this block_id when you receive an interaction payload to identify the source of the action. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
Expand source code
class ActionsBlock(Block): type = "actions" elements_max_length = 25 @property def attributes(self) -> Set[str]: return super().attributes.union({"elements"}) def __init__( self, *, elements: Sequence[Union[dict, InteractiveElement]], block_id: Optional[str] = None, **others: dict, ): """A block that is used to hold interactive elements. https://api.slack.com/reference/block-kit/blocks#actions Args: elements (required): An array of interactive element objects - buttons, select menus, overflow menus, or date pickers. There is a maximum of 25 elements in each action block. block_id: A string acting as a unique identifier for a block. If not specified, a block_id will be generated. You can use this block_id when you receive an interaction payload to identify the source of the action. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements) @JsonValidator(f"elements attribute cannot exceed {elements_max_length} elements") def _validate_elements_length(self): return self.elements is None or len(self.elements) <= self.elements_max_length
Ancestors
Class variables
var elements_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements"})
Inherited members
class Block (*, type: Optional[str] = None, subtype: Optional[str] = None, block_id: Optional[str] = None)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
Expand source code
class Block(JsonObject): """Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks """ attributes = {"block_id", "type"} block_id_max_length = 255 logger = logging.getLogger(__name__) def _subtype_warning(self): # skipcq: PYL-R0201 warnings.warn( "subtype is deprecated since slackclient 2.6.0, use type instead", DeprecationWarning, ) @property def subtype(self) -> Optional[str]: return self.type def __init__( self, *, type: Optional[str] = None, # skipcq: PYL-W0622 subtype: Optional[str] = None, # deprecated block_id: Optional[str] = None, ): if subtype: self._subtype_warning() self.type = type if type else subtype self.block_id = block_id self.color = None @JsonValidator(f"block_id cannot exceed {block_id_max_length} characters") def _validate_block_id_length(self): return self.block_id is None or len(self.block_id) <= self.block_id_max_length @classmethod def parse(cls, block: Union[dict, "Block"]) -> Optional["Block"]: if block is None: # skipcq: PYL-R1705 return None elif isinstance(block, Block): return block else: if "type" in block: type = block["type"] # skipcq: PYL-W0622 if type == SectionBlock.type: # skipcq: PYL-R1705 return SectionBlock(**block) elif type == DividerBlock.type: return DividerBlock(**block) elif type == ImageBlock.type: return ImageBlock(**block) elif type == ActionsBlock.type: return ActionsBlock(**block) elif type == ContextBlock.type: return ContextBlock(**block) elif type == InputBlock.type: return InputBlock(**block) elif type == FileBlock.type: return FileBlock(**block) elif type == CallBlock.type: return CallBlock(**block) elif type == HeaderBlock.type: return HeaderBlock(**block) elif type == VideoBlock.type: return VideoBlock(**block) elif type == RichTextBlock.type: return RichTextBlock(**block) else: cls.logger.warning(f"Unknown block detected and skipped ({block})") return None else: cls.logger.warning(f"Unknown block detected and skipped ({block})") return None @classmethod def parse_all(cls, blocks: Optional[Sequence[Union[dict, "Block"]]]) -> List["Block"]: return [cls.parse(b) for b in blocks or []] # type: ignore
Ancestors
Subclasses
- ActionsBlock
- CallBlock
- ContextBlock
- DividerBlock
- FileBlock
- HeaderBlock
- ImageBlock
- InputBlock
- RichTextBlock
- SectionBlock
- VideoBlock
Class variables
var block_id_max_length
var logger
Static methods
def parse(block: Union[dict, ForwardRef('Block')]) ‑> Optional[Block]
def parse_all(blocks: Optional[Sequence[Union[dict, ForwardRef('Block')]]]) ‑> List[Block]
Instance variables
prop subtype : Optional[str]
-
Expand source code
@property def subtype(self) -> Optional[str]: return self.type
Inherited members
class BlockElement (*, type: Optional[str] = None, subtype: Optional[str] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
Expand source code
class BlockElement(JsonObject, metaclass=ABCMeta): """Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements """ attributes = {"type"} logger = logging.getLogger(__name__) def _subtype_warning(self): # skipcq: PYL-R0201 warnings.warn( "subtype is deprecated since slackclient 2.6.0, use type instead", DeprecationWarning, ) @property def subtype(self) -> Optional[str]: return self.type def __init__( self, *, type: Optional[str] = None, # skipcq: PYL-W0622 subtype: Optional[str] = None, **others: dict, ): if subtype: self._subtype_warning() self.type = type if type else subtype show_unknown_key_warning(self, others) @classmethod def parse(cls, block_element: Union[dict, "BlockElement"]) -> Optional[Union["BlockElement", TextObject]]: if block_element is None: # skipcq: PYL-R1705 return None elif isinstance(block_element, dict): if "type" in block_element: d = copy.copy(block_element) t = d.pop("type") for subclass in cls._get_sub_block_elements(): if t == subclass.type: # type: ignore return subclass(**d) if t == PlainTextObject.type: # skipcq: PYL-R1705 return PlainTextObject(**d) elif t == MarkdownTextObject.type: return MarkdownTextObject(**d) elif isinstance(block_element, (TextObject, BlockElement)): return block_element cls.logger.warning(f"Unknown element detected and skipped ({block_element})") return None @classmethod def parse_all( cls, block_elements: Sequence[Union[dict, "BlockElement", TextObject]] ) -> List[Union["BlockElement", TextObject]]: return [cls.parse(e) for e in block_elements or []] # type: ignore @classmethod def _get_sub_block_elements(cls: Type["BlockElement"]) -> Iterator[Type["BlockElement"]]: for subclass in cls.__subclasses__(): if hasattr(subclass, "type"): yield subclass yield from subclass._get_sub_block_elements()
Ancestors
Subclasses
Class variables
var logger
Static methods
def parse(block_element: Union[dict, ForwardRef('BlockElement')]) ‑> Union[BlockElement, TextObject, ForwardRef(None)]
def parse_all(block_elements: Sequence[Union[dict, ForwardRef('BlockElement'), TextObject]]) ‑> List[Union[BlockElement, TextObject]]
Instance variables
prop subtype : Optional[str]
-
Expand source code
@property def subtype(self) -> Optional[str]: return self.type
Inherited members
class ButtonElement (*, text: Union[str, dict, TextObject], action_id: Optional[str] = None, url: Optional[str] = None, value: Optional[str] = None, style: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, accessibility_label: Optional[str] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
An interactive element that inserts a button. The button can be a trigger for anything from opening a simple link to starting a complex workflow. https://api.slack.com/reference/block-kit/block-elements#button
Args
text
:required
- A text object that defines the button's text. Can only be of type: plain_text. Maximum length for the text in this field is 75 characters.
action_id
:required
- An identifier for this action. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
url
- A URL to load in the user's browser when the button is clicked. Maximum length for this field is 3000 characters. If you're using url, you'll still receive an interaction payload and will need to send an acknowledgement response.
value
- The value to send along with the interaction payload. Maximum length for this field is 2000 characters.
style
- Decorates buttons with alternative visual color schemes. Use this option with restraint. "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. "primary" should only be used for one button within a set. "danger" gives buttons a red outline and text, and should be used when the action is destructive. Use "danger" even more sparingly than "primary". If you don't include this field, the default button style will be used.
confirm
- A confirm object that defines an optional confirmation dialog after the button is clicked.
accessibility_label
- A label for longer descriptive text about a button element. This label will be read out by screen readers instead of the button text object. Maximum length for this field is 75 characters.
Expand source code
class ButtonElement(InteractiveElement): type = "button" text_max_length = 75 url_max_length = 3000 value_max_length = 2000 @property def attributes(self) -> Set[str]: return super().attributes.union({"text", "url", "value", "style", "confirm", "accessibility_label"}) def __init__( self, *, text: Union[str, dict, TextObject], action_id: Optional[str] = None, url: Optional[str] = None, value: Optional[str] = None, style: Optional[str] = None, # primary, danger confirm: Optional[Union[dict, ConfirmObject]] = None, accessibility_label: Optional[str] = None, **others: dict, ): """An interactive element that inserts a button. The button can be a trigger for anything from opening a simple link to starting a complex workflow. https://api.slack.com/reference/block-kit/block-elements#button Args: text (required): A text object that defines the button's text. Can only be of type: plain_text. Maximum length for the text in this field is 75 characters. action_id (required): An identifier for this action. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. url: A URL to load in the user's browser when the button is clicked. Maximum length for this field is 3000 characters. If you're using url, you'll still receive an interaction payload and will need to send an acknowledgement response. value: The value to send along with the interaction payload. Maximum length for this field is 2000 characters. style: Decorates buttons with alternative visual color schemes. Use this option with restraint. "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. "primary" should only be used for one button within a set. "danger" gives buttons a red outline and text, and should be used when the action is destructive. Use "danger" even more sparingly than "primary". If you don't include this field, the default button style will be used. confirm: A confirm object that defines an optional confirmation dialog after the button is clicked. accessibility_label: A label for longer descriptive text about a button element. This label will be read out by screen readers instead of the button text object. Maximum length for this field is 75 characters. """ super().__init__(action_id=action_id, type=self.type) show_unknown_key_warning(self, others) # NOTE: default_type=PlainTextObject.type here is only for backward-compatibility with version 2.5.0 self.text = TextObject.parse(text, default_type=PlainTextObject.type) self.url = url self.value = value self.style = style self.confirm = ConfirmObject.parse(confirm) self.accessibility_label = accessibility_label @JsonValidator(f"text attribute cannot exceed {text_max_length} characters") def _validate_text_length(self) -> bool: return self.text is None or self.text.text is None or len(self.text.text) <= self.text_max_length @JsonValidator(f"url attribute cannot exceed {url_max_length} characters") def _validate_url_length(self) -> bool: return self.url is None or len(self.url) <= self.url_max_length @JsonValidator(f"value attribute cannot exceed {value_max_length} characters") def _validate_value_length(self) -> bool: return self.value is None or len(self.value) <= self.value_max_length @EnumValidator("style", ButtonStyles) def _validate_style_valid(self): return self.style is None or self.style in ButtonStyles @JsonValidator(f"accessibility_label attribute cannot exceed {text_max_length} characters") def _validate_accessibility_label_length(self) -> bool: return self.accessibility_label is None or len(self.accessibility_label) <= self.text_max_length
Ancestors
Subclasses
Class variables
var text_max_length
var type
var url_max_length
var value_max_length
Inherited members
class CallBlock (*, call_id: str, api_decoration_available: Optional[bool] = None, call: Optional[Dict[str, Dict[str, Any]]] = None, block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
Displays a call information https://api.slack.com/reference/block-kit/blocks#call
Expand source code
class CallBlock(Block): type = "call" @property def attributes(self) -> Set[str]: return super().attributes.union({"call_id", "api_decoration_available", "call"}) def __init__( self, *, call_id: str, api_decoration_available: Optional[bool] = None, call: Optional[Dict[str, Dict[str, Any]]] = None, block_id: Optional[str] = None, **others: dict, ): """Displays a call information https://api.slack.com/reference/block-kit/blocks#call """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.call_id = call_id self.api_decoration_available = api_decoration_available self.call = call
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"call_id", "api_decoration_available", "call"})
Inherited members
class ChannelMultiSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, initial_channels: Optional[Sequence[str]] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This multi-select menu will populate its options with a list of public channels visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#channel_multi_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_channels
- An array of one or more IDs of any valid public channel to be pre-selected when the menu loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted.
max_selected_items
- Specifies the maximum number of items that can be selected in the menu. Minimum number is 1.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class ChannelMultiSelectElement(InputInteractiveElement): type = "multi_channels_select" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_channels", "max_selected_items"}) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, initial_channels: Optional[Sequence[str]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This multi-select menu will populate its options with a list of public channels visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#channel_multi_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_channels: An array of one or more IDs of any valid public channel to be pre-selected when the menu loads. confirm: A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted. max_selected_items: Specifies the maximum number of items that can be selected in the menu. Minimum number is 1. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_channels = initial_channels self.max_selected_items = max_selected_items
Ancestors
Class variables
var type
Inherited members
class ChannelSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, initial_channel: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, response_url_enabled: Optional[bool] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This select menu will populate its options with a list of public channels visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#channel_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_channel
- The ID of any valid public channel to be pre-selected when the menu loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
response_url_enabled
- This field only works with menus in input blocks in modals. When set to true, the view_submission payload from the menu's parent view will contain a response_url. This response_url can be used for message responses. The target channel for the message will be determined by the value of this select menu
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class ChannelSelectElement(InputInteractiveElement): type = "channels_select" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_channel", "response_url_enabled"}) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, initial_channel: Optional[str] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, response_url_enabled: Optional[bool] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This select menu will populate its options with a list of public channels visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#channel_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_channel: The ID of any valid public channel to be pre-selected when the menu loads. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. response_url_enabled: This field only works with menus in input blocks in modals. When set to true, the view_submission payload from the menu's parent view will contain a response_url. This response_url can be used for message responses. The target channel for the message will be determined by the value of this select menu focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_channel = initial_channel self.response_url_enabled = response_url_enabled
Ancestors
Class variables
var type
Inherited members
class CheckboxesElement (*, action_id: Optional[str] = None, options: Optional[Sequence[Union[dict, Option]]] = None, initial_options: Optional[Sequence[Union[dict, Option]]] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
A checkbox group that allows a user to choose multiple items from a list of possible options. https://api.slack.com/reference/block-kit/block-elements#checkboxes
Args
action_id
:required
- An identifier for the action triggered when the checkbox group is changed. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
options
:required
- An array of option objects. A maximum of 10 options are allowed.
initial_options
- An array of option objects that exactly matches one or more of the options. These options will be selected when the checkbox group initially loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears after clicking one of the checkboxes in this element.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class CheckboxesElement(InputInteractiveElement): type = "checkboxes" @property def attributes(self) -> Set[str]: return super().attributes.union({"options", "initial_options"}) def __init__( self, *, action_id: Optional[str] = None, options: Optional[Sequence[Union[dict, Option]]] = None, initial_options: Optional[Sequence[Union[dict, Option]]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """A checkbox group that allows a user to choose multiple items from a list of possible options. https://api.slack.com/reference/block-kit/block-elements#checkboxes Args: action_id (required): An identifier for the action triggered when the checkbox group is changed. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. options (required): An array of option objects. A maximum of 10 options are allowed. initial_options: An array of option objects that exactly matches one or more of the options. These options will be selected when the checkbox group initially loads. confirm: A confirm object that defines an optional confirmation dialog that appears after clicking one of the checkboxes in this element. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.options = Option.parse_all(options) self.initial_options = Option.parse_all(initial_options)
Ancestors
Class variables
var type
Inherited members
class ConfirmObject (*, title: Union[str, Dict[str, Any], PlainTextObject], text: Union[str, Dict[str, Any], TextObject], confirm: Union[str, Dict[str, Any], PlainTextObject] = 'Yes', deny: Union[str, Dict[str, Any], PlainTextObject] = 'No', style: Optional[str] = None)
-
The base class for JSON serializable class objects
An object that defines a dialog that provides a confirmation step to any interactive element. This dialog will ask the user to confirm their action by offering a confirm and deny button. https://api.slack.com/reference/block-kit/composition-objects#confirm
Expand source code
class ConfirmObject(JsonObject): attributes = {} # no attributes because to_dict has unique implementations title_max_length = 100 text_max_length = 300 confirm_max_length = 30 deny_max_length = 30 @classmethod def parse(cls, confirm: Union["ConfirmObject", Dict[str, Any]]): if confirm: if isinstance(confirm, ConfirmObject): # skipcq: PYL-R1705 return confirm elif isinstance(confirm, dict): return ConfirmObject(**confirm) else: # Not yet implemented: show some warning here return None return None def __init__( self, *, title: Union[str, Dict[str, Any], PlainTextObject], text: Union[str, Dict[str, Any], TextObject], confirm: Union[str, Dict[str, Any], PlainTextObject] = "Yes", deny: Union[str, Dict[str, Any], PlainTextObject] = "No", style: Optional[str] = None, ): """ An object that defines a dialog that provides a confirmation step to any interactive element. This dialog will ask the user to confirm their action by offering a confirm and deny button. https://api.slack.com/reference/block-kit/composition-objects#confirm """ self._title = TextObject.parse(title, default_type=PlainTextObject.type) self._text = TextObject.parse(text, default_type=MarkdownTextObject.type) self._confirm = TextObject.parse(confirm, default_type=PlainTextObject.type) self._deny = TextObject.parse(deny, default_type=PlainTextObject.type) self._style = style # for backward-compatibility with version 2.0-2.5, the following fields return str values self.title = self._title.text if self._title else None self.text = self._text.text if self._text else None self.confirm = self._confirm.text if self._confirm else None self.deny = self._deny.text if self._deny else None self.style = self._style @JsonValidator(f"title attribute cannot exceed {title_max_length} characters") def title_length(self) -> bool: return self._title is None or len(self._title.text) <= self.title_max_length @JsonValidator(f"text attribute cannot exceed {text_max_length} characters") def text_length(self) -> bool: return self._text is None or len(self._text.text) <= self.text_max_length @JsonValidator(f"confirm attribute cannot exceed {confirm_max_length} characters") def confirm_length(self) -> bool: return self._confirm is None or len(self._confirm.text) <= self.confirm_max_length @JsonValidator(f"deny attribute cannot exceed {deny_max_length} characters") def deny_length(self) -> bool: return self._deny is None or len(self._deny.text) <= self.deny_max_length @JsonValidator('style for confirm must be either "primary" or "danger"') def _validate_confirm_style(self) -> bool: return self._style is None or self._style in ["primary", "danger"] def to_dict(self, option_type: str = "block") -> Dict[str, Any]: # skipcq: PYL-W0221 if option_type == "action": # skipcq: PYL-R1705 # deliberately skipping JSON validators here - can't find documentation # on actual limits here json = { "ok_text": self._confirm.text if self._confirm and self._confirm.text != "Yes" else "Okay", "dismiss_text": self._deny.text if self._deny and self._deny.text != "No" else "Cancel", } if self._title: json["title"] = self._title.text if self._text: json["text"] = self._text.text return json else: self.validate_json() json = {} if self._title: json["title"] = self._title.to_dict() if self._text: json["text"] = self._text.to_dict() if self._confirm: json["confirm"] = self._confirm.to_dict() if self._deny: json["deny"] = self._deny.to_dict() if self._style: json["style"] = self._style return json
Ancestors
Class variables
var confirm_max_length
var deny_max_length
var text_max_length
var title_max_length
Static methods
def parse(confirm: Union[ForwardRef('ConfirmObject'), Dict[str, Any]])
Methods
def confirm_length(self) ‑> bool
def deny_length(self) ‑> bool
def text_length(self) ‑> bool
def title_length(self) ‑> bool
Inherited members
class ContextBlock (*, elements: Sequence[Union[dict, ImageElement, TextObject]], block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
Displays message context, which can include both images and text. https://api.slack.com/reference/block-kit/blocks#context
Args
elements
:required
- An array of image elements and text objects. Maximum number of items is 10.
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
Expand source code
class ContextBlock(Block): type = "context" elements_max_length = 10 @property def attributes(self) -> Set[str]: return super().attributes.union({"elements"}) def __init__( self, *, elements: Sequence[Union[dict, ImageElement, TextObject]], block_id: Optional[str] = None, **others: dict, ): """Displays message context, which can include both images and text. https://api.slack.com/reference/block-kit/blocks#context Args: elements (required): An array of image elements and text objects. Maximum number of items is 10. block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements) @JsonValidator(f"elements attribute cannot exceed {elements_max_length} elements") def _validate_elements_length(self): return self.elements is None or len(self.elements) <= self.elements_max_length
Ancestors
Class variables
var elements_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements"})
Inherited members
class ConversationFilter (*, include: Optional[Sequence[str]] = None, exclude_bot_users: Optional[bool] = None, exclude_external_shared_channels: Optional[bool] = None)
-
The base class for JSON serializable class objects
Provides a way to filter the list of options in a conversations select menu or conversations multi-select menu. https://api.slack.com/reference/block-kit/composition-objects#filter_conversations
Args
include
- Indicates which type of conversations should be included in the list. When this field is provided, any conversations that do not match will be excluded. You should provide an array of strings from the following options: "im", "mpim", "private", and "public". The array cannot be empty.
exclude_bot_users
- Indicates whether to exclude bot users from conversation lists. Defaults to false.
exclude_external_shared_channels
- Indicates whether to exclude external shared channels from conversation lists. Defaults to false.
Expand source code
class ConversationFilter(JsonObject): attributes = {"include", "exclude_bot_users", "exclude_external_shared_channels"} logger = logging.getLogger(__name__) def __init__( self, *, include: Optional[Sequence[str]] = None, exclude_bot_users: Optional[bool] = None, exclude_external_shared_channels: Optional[bool] = None, ): """Provides a way to filter the list of options in a conversations select menu or conversations multi-select menu. https://api.slack.com/reference/block-kit/composition-objects#filter_conversations Args: include: Indicates which type of conversations should be included in the list. When this field is provided, any conversations that do not match will be excluded. You should provide an array of strings from the following options: "im", "mpim", "private", and "public". The array cannot be empty. exclude_bot_users: Indicates whether to exclude bot users from conversation lists. Defaults to false. exclude_external_shared_channels: Indicates whether to exclude external shared channels from conversation lists. Defaults to false. """ self.include = include self.exclude_bot_users = exclude_bot_users self.exclude_external_shared_channels = exclude_external_shared_channels @classmethod def parse(cls, filter: Union[dict, "ConversationFilter"]): # skipcq: PYL-W0622 if filter is None: # skipcq: PYL-R1705 return None elif isinstance(filter, ConversationFilter): return filter elif isinstance(filter, dict): d = copy.copy(filter) return ConversationFilter(**d) else: cls.logger.warning(f"Unknown conversation filter object detected and skipped ({filter})") return None
Ancestors
Class variables
var logger
Static methods
def parse(filter: Union[dict, ForwardRef('ConversationFilter')])
Inherited members
class ConversationMultiSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, initial_conversations: Optional[Sequence[str]] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, max_selected_items: Optional[int] = None, default_to_current_conversation: Optional[bool] = None, filter: Union[dict, ConversationFilter, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This multi-select menu will populate its options with a list of public and private channels, DMs, and MPIMs visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#conversation_multi_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_conversations
- An array of one or more IDs of any valid conversations to be pre-selected when the menu loads. If default_to_current_conversation is also supplied, initial_conversations will be ignored.
confirm
- A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted.
max_selected_items
- Specifies the maximum number of items that can be selected in the menu. Minimum number is 1.
default_to_current_conversation
- Pre-populates the select menu with the conversation that the user was viewing when they opened the modal, if available. Default is false.
filter
- A filter object that reduces the list of available conversations using the specified criteria.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class ConversationMultiSelectElement(InputInteractiveElement): type = "multi_conversations_select" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_conversations", "max_selected_items", "default_to_current_conversation", "filter", } ) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, initial_conversations: Optional[Sequence[str]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, max_selected_items: Optional[int] = None, default_to_current_conversation: Optional[bool] = None, filter: Optional[Union[dict, ConversationFilter]] = None, # skipcq: PYL-W0622 focus_on_load: Optional[bool] = None, **others: dict, ): """ This multi-select menu will populate its options with a list of public and private channels, DMs, and MPIMs visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#conversation_multi_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_conversations: An array of one or more IDs of any valid conversations to be pre-selected when the menu loads. If default_to_current_conversation is also supplied, initial_conversations will be ignored. confirm: A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted. max_selected_items: Specifies the maximum number of items that can be selected in the menu. Minimum number is 1. default_to_current_conversation: Pre-populates the select menu with the conversation that the user was viewing when they opened the modal, if available. Default is false. filter: A filter object that reduces the list of available conversations using the specified criteria. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_conversations = initial_conversations self.max_selected_items = max_selected_items self.default_to_current_conversation = default_to_current_conversation self.filter = ConversationFilter.parse(filter)
Ancestors
Class variables
var type
Inherited members
class ConversationSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, initial_conversation: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, response_url_enabled: Optional[bool] = None, default_to_current_conversation: Optional[bool] = None, filter: Optional[ConversationFilter] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This select menu will populate its options with a list of public and private channels, DMs, and MPIMs visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#conversation_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_conversation
- The ID of any valid conversation to be pre-selected when the menu loads. If default_to_current_conversation is also supplied, initial_conversation will take precedence.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
response_url_enabled
- This field only works with menus in input blocks in modals. When set to true, the view_submission payload from the menu's parent view will contain a response_url. This response_url can be used for message responses. The target conversation for the message will be determined by the value of this select menu.
default_to_current_conversation
- Pre-populates the select menu with the conversation that the user was viewing when they opened the modal, if available. Default is false.
filter
- A filter object that reduces the list of available conversations using the specified criteria.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class ConversationSelectElement(InputInteractiveElement): type = "conversations_select" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_conversation", "response_url_enabled", "filter", "default_to_current_conversation", } ) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, initial_conversation: Optional[str] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, response_url_enabled: Optional[bool] = None, default_to_current_conversation: Optional[bool] = None, filter: Optional[ConversationFilter] = None, # skipcq: PYL-W0622 focus_on_load: Optional[bool] = None, **others: dict, ): """ This select menu will populate its options with a list of public and private channels, DMs, and MPIMs visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#conversation_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_conversation: The ID of any valid conversation to be pre-selected when the menu loads. If default_to_current_conversation is also supplied, initial_conversation will take precedence. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. response_url_enabled: This field only works with menus in input blocks in modals. When set to true, the view_submission payload from the menu's parent view will contain a response_url. This response_url can be used for message responses. The target conversation for the message will be determined by the value of this select menu. default_to_current_conversation: Pre-populates the select menu with the conversation that the user was viewing when they opened the modal, if available. Default is false. filter: A filter object that reduces the list of available conversations using the specified criteria. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_conversation = initial_conversation self.response_url_enabled = response_url_enabled self.default_to_current_conversation = default_to_current_conversation self.filter = filter
Ancestors
Class variables
var type
Inherited members
class DatePickerElement (*, action_id: Optional[str] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, initial_date: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
An element which lets users easily select a date from a calendar style UI. Date picker elements can be used inside of SectionBlocks and ActionsBlocks. https://api.slack.com/reference/block-kit/block-elements#datepicker
Args
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
placeholder
- A plain_text only text object that defines the placeholder text shown on the datepicker. Maximum length for the text in this field is 150 characters.
initial_date
- The initial date that is selected when the element is loaded. This should be in the format YYYY-MM-DD.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a date is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class DatePickerElement(InputInteractiveElement): type = "datepicker" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_date"}) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_date: Optional[str] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ An element which lets users easily select a date from a calendar style UI. Date picker elements can be used inside of SectionBlocks and ActionsBlocks. https://api.slack.com/reference/block-kit/block-elements#datepicker Args: action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. placeholder: A plain_text only text object that defines the placeholder text shown on the datepicker. Maximum length for the text in this field is 150 characters. initial_date: The initial date that is selected when the element is loaded. This should be in the format YYYY-MM-DD. confirm: A confirm object that defines an optional confirmation dialog that appears after a date is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_date = initial_date @JsonValidator("initial_date attribute must be in format 'YYYY-MM-DD'") def _validate_initial_date_valid(self) -> bool: return ( self.initial_date is None or re.match(r"\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])", self.initial_date) is not None )
Ancestors
Class variables
var type
Inherited members
class DateTimePickerElement (*, action_id: Optional[str] = None, initial_date_time: Optional[int] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
An element that allows the selection of a time of day formatted as a UNIX timestamp. On desktop clients, this time picker will take the form of a dropdown list and the date picker will take the form of a dropdown calendar. Both options will have free-text entry for precise choices. On mobile clients, the time picker and date picker will use native UIs. https://api.slack.com/reference/block-kit/block-elements#datetimepicker
Args
action_id
:required
- An identifier for the action triggered when a time is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_date_time
- The initial date and time that is selected when the element is loaded, represented as a UNIX timestamp in seconds. This should be in the format of 10 digits, for example 1628633820 represents the date and time August 10th, 2021 at 03:17pm PST. and mm is minutes with leading zeros (00 to 59), for example 22:25 for 10:25pm.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a time is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class DateTimePickerElement(InputInteractiveElement): type = "datetimepicker" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_date_time"}) def __init__( self, *, action_id: Optional[str] = None, initial_date_time: Optional[int] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ An element that allows the selection of a time of day formatted as a UNIX timestamp. On desktop clients, this time picker will take the form of a dropdown list and the date picker will take the form of a dropdown calendar. Both options will have free-text entry for precise choices. On mobile clients, the time picker and date picker will use native UIs. https://api.slack.com/reference/block-kit/block-elements#datetimepicker Args: action_id (required): An identifier for the action triggered when a time is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_date_time: The initial date and time that is selected when the element is loaded, represented as a UNIX timestamp in seconds. This should be in the format of 10 digits, for example 1628633820 represents the date and time August 10th, 2021 at 03:17pm PST. and mm is minutes with leading zeros (00 to 59), for example 22:25 for 10:25pm. confirm: A confirm object that defines an optional confirmation dialog that appears after a time is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_date_time = initial_date_time @JsonValidator("initial_date_time attribute must be between 0 and 99999999 seconds") def _validate_initial_date_time_valid(self) -> bool: return self.initial_date_time is None or (0 <= self.initial_date_time <= 9999999999)
Ancestors
Class variables
var type
Inherited members
class DividerBlock (*, block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A content divider, like an
, to split up different blocks inside of a message. https://api.slack.com/reference/block-kit/blocks#dividerArgs
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. You can use this block_id when you receive an interaction payload to identify the source of the action. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
Expand source code
class DividerBlock(Block): type = "divider" def __init__( self, *, block_id: Optional[str] = None, **others: dict, ): """A content divider, like an <hr>, to split up different blocks inside of a message. https://api.slack.com/reference/block-kit/blocks#divider Args: block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. You can use this block_id when you receive an interaction payload to identify the source of the action. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others)
Ancestors
Class variables
var type
Inherited members
class EmailInputElement (*, action_id: Optional[str] = None, initial_value: Optional[str] = None, dispatch_action_config: Union[dict, DispatchActionConfig, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
https://api.slack.com/reference/block-kit/block-elements#email
Args
action_id
:required
- An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_value
- The initial value in the email input when it is loaded.
dispatch_action_config
- dispatch configuration object that determines when during text input the element returns a block_actions payload.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
placeholder
- A plain_text only text object that defines the placeholder text shown in the email input. Maximum length for the text in this field is 150 characters.
Expand source code
class EmailInputElement(InputInteractiveElement): type = "email_text_input" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_value", "dispatch_action_config", } ) def __init__( self, *, action_id: Optional[str] = None, initial_value: Optional[str] = None, dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, focus_on_load: Optional[bool] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, **others: dict, ): """ https://api.slack.com/reference/block-kit/block-elements#email Args: action_id (required): An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_value: The initial value in the email input when it is loaded. dispatch_action_config: dispatch configuration object that determines when during text input the element returns a block_actions payload. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. placeholder: A plain_text only text object that defines the placeholder text shown in the email input. Maximum length for the text in this field is 150 characters. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_value = initial_value self.dispatch_action_config = dispatch_action_config
Ancestors
Class variables
var type
Inherited members
class ExternalDataMultiSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, min_query_length: Optional[int] = None, initial_options: Optional[Sequence[Union[dict, Option]]] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This select menu will load its options from an external data source, allowing for a dynamic list of options. https://api.slack.com/reference/block-kit/block-elements#external_multi_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
min_query_length
- When the typeahead field is used, a request will be sent on every character change. If you prefer fewer requests or more fully ideated queries, use the min_query_length attribute to tell Slack the fewest number of typed characters required before dispatch. The default value is 3
initial_options
- An array of option objects that exactly match one or more of the options within options or option_groups. These options will be selected when the menu initially loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted.
max_selected_items
- Specifies the maximum number of items that can be selected in the menu. Minimum number is 1.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class ExternalDataMultiSelectElement(InputInteractiveElement): type = "multi_external_select" @property def attributes(self) -> Set[str]: return super().attributes.union({"min_query_length", "initial_options", "max_selected_items"}) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, min_query_length: Optional[int] = None, initial_options: Optional[Sequence[Union[dict, Option]]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This select menu will load its options from an external data source, allowing for a dynamic list of options. https://api.slack.com/reference/block-kit/block-elements#external_multi_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. min_query_length: When the typeahead field is used, a request will be sent on every character change. If you prefer fewer requests or more fully ideated queries, use the min_query_length attribute to tell Slack the fewest number of typed characters required before dispatch. The default value is 3 initial_options: An array of option objects that exactly match one or more of the options within options or option_groups. These options will be selected when the menu initially loads. confirm: A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted. max_selected_items: Specifies the maximum number of items that can be selected in the menu. Minimum number is 1. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.min_query_length = min_query_length self.initial_options = Option.parse_all(initial_options) self.max_selected_items = max_selected_items
Ancestors
Class variables
var type
Inherited members
class ExternalDataSelectElement (*, action_id: Optional[str] = None, placeholder: Union[str, TextObject, ForwardRef(None)] = None, initial_option: Union[Option, ForwardRef(None), OptionGroup] = None, min_query_length: Optional[int] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This select menu will load its options from an external data source, allowing for a dynamic list of options. https://api.slack.com/reference/block-kit/block-elements#external_select
Args
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
initial_option
- A single option that exactly matches one of the options within the options or option_groups loaded from the external data source. This option will be selected when the menu initially loads.
min_query_length
- When the typeahead field is used, a request will be sent on every character change. If you prefer fewer requests or more fully ideated queries, use the min_query_length attribute to tell Slack the fewest number of typed characters required before dispatch. The default value is 3.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class ExternalDataSelectElement(InputInteractiveElement): type = "external_select" @property def attributes(self) -> Set[str]: return super().attributes.union({"min_query_length", "initial_option"}) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, TextObject]] = None, initial_option: Union[Optional[Option], Optional[OptionGroup]] = None, min_query_length: Optional[int] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This select menu will load its options from an external data source, allowing for a dynamic list of options. https://api.slack.com/reference/block-kit/block-elements#external_select Args: action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. initial_option: A single option that exactly matches one of the options within the options or option_groups loaded from the external data source. This option will be selected when the menu initially loads. min_query_length: When the typeahead field is used, a request will be sent on every character change. If you prefer fewer requests or more fully ideated queries, use the min_query_length attribute to tell Slack the fewest number of typed characters required before dispatch. The default value is 3. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.min_query_length = min_query_length self.initial_option = initial_option
Ancestors
Class variables
var type
Inherited members
class FileBlock (*, external_id: str, source: str = 'remote', block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
Displays a remote file. https://api.slack.com/reference/block-kit/blocks#file
Args
external_id
:required
- The external unique ID for this file.
source
:required
- At the moment, source will always be remote for a remote file.
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
Expand source code
class FileBlock(Block): type = "file" @property def attributes(self) -> Set[str]: return super().attributes.union({"external_id", "source"}) def __init__( self, *, external_id: str, source: str = "remote", block_id: Optional[str] = None, **others: dict, ): """Displays a remote file. https://api.slack.com/reference/block-kit/blocks#file Args: external_id (required): The external unique ID for this file. source (required): At the moment, source will always be remote for a remote file. block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.external_id = external_id self.source = source
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"external_id", "source"})
Inherited members
class HeaderBlock (*, block_id: Optional[str] = None, text: Union[str, dict, TextObject, ForwardRef(None)] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A header is a plain-text block that displays in a larger, bold font. https://api.slack.com/reference/block-kit/blocks#header
Args
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
text
:required
- The text for the block, in the form of a plain_text text object. Maximum length for the text in this field is 150 characters.
Expand source code
class HeaderBlock(Block): type = "header" text_max_length = 150 @property def attributes(self) -> Set[str]: return super().attributes.union({"text"}) def __init__( self, *, block_id: Optional[str] = None, text: Optional[Union[str, dict, TextObject]] = None, **others: dict, ): """A header is a plain-text block that displays in a larger, bold font. https://api.slack.com/reference/block-kit/blocks#header Args: block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. text (required): The text for the block, in the form of a plain_text text object. Maximum length for the text in this field is 150 characters. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.text = TextObject.parse(text, default_type=PlainTextObject.type) @JsonValidator("text attribute must be specified") def _validate_text(self): return self.text is not None @JsonValidator(f"text attribute cannot exceed {text_max_length} characters") def _validate_alt_text_length(self): return self.text is None or len(self.text.text) <= self.text_max_length
Ancestors
Class variables
var text_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"text"})
Inherited members
class ImageBlock (*, alt_text: str, image_url: Optional[str] = None, slack_file: Union[Dict[str, Any], SlackFile, ForwardRef(None)] = None, title: Union[str, dict, PlainTextObject, ForwardRef(None)] = None, block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A simple image block, designed to make those cat photos really pop. https://api.slack.com/reference/block-kit/blocks#image
Args
alt_text
:required
- A plain-text summary of the image. This should not contain any markup. Maximum length for this field is 2000 characters.
image_url
- The URL of the image to be displayed. Maximum length for this field is 3000 characters.
slack_file
- A Slack image file object that defines the source of the image.
title
- An optional title for the image in the form of a text object that can only be of type: plain_text. Maximum length for the text in this field is 2000 characters.
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
Expand source code
class ImageBlock(Block): type = "image" @property def attributes(self) -> Set[str]: return super().attributes.union({"alt_text", "image_url", "title", "slack_file"}) image_url_max_length = 3000 alt_text_max_length = 2000 title_max_length = 2000 def __init__( self, *, alt_text: str, image_url: Optional[str] = None, slack_file: Optional[Union[Dict[str, Any], SlackFile]] = None, title: Optional[Union[str, dict, PlainTextObject]] = None, block_id: Optional[str] = None, **others: dict, ): """A simple image block, designed to make those cat photos really pop. https://api.slack.com/reference/block-kit/blocks#image Args: alt_text (required): A plain-text summary of the image. This should not contain any markup. Maximum length for this field is 2000 characters. image_url: The URL of the image to be displayed. Maximum length for this field is 3000 characters. slack_file: A Slack image file object that defines the source of the image. title: An optional title for the image in the form of a text object that can only be of type: plain_text. Maximum length for the text in this field is 2000 characters. block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.image_url = image_url self.alt_text = alt_text parsed_title = None if title is not None: if isinstance(title, str): parsed_title = PlainTextObject(text=title) elif isinstance(title, dict): if title.get("type") != PlainTextObject.type: raise SlackObjectFormationError(f"Unsupported type for title in an image block: {title.get('type')}") parsed_title = PlainTextObject(text=title.get("text"), emoji=title.get("emoji")) elif isinstance(title, PlainTextObject): parsed_title = title else: raise SlackObjectFormationError(f"Unsupported type for title in an image block: {type(title)}") if slack_file is not None: self.slack_file = ( slack_file if slack_file is None or isinstance(slack_file, SlackFile) else SlackFile(**slack_file) ) self.title = parsed_title @JsonValidator(f"image_url attribute cannot exceed {image_url_max_length} characters") def _validate_image_url_length(self): return self.image_url is None or len(self.image_url) <= self.image_url_max_length @JsonValidator(f"alt_text attribute cannot exceed {alt_text_max_length} characters") def _validate_alt_text_length(self): return len(self.alt_text) <= self.alt_text_max_length @JsonValidator(f"title attribute cannot exceed {title_max_length} characters") def _validate_title_length(self): return self.title is None or self.title.text is None or len(self.title.text) <= self.title_max_length
Ancestors
Class variables
var alt_text_max_length
var image_url_max_length
var title_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"alt_text", "image_url", "title", "slack_file"})
Inherited members
class ImageElement (*, alt_text: Optional[str] = None, image_url: Optional[str] = None, slack_file: Union[Dict[str, Any], SlackFile, ForwardRef(None)] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
An element to insert an image - this element can be used in section and context blocks only. If you want a block with only an image in it, you're looking for the image block. https://api.slack.com/reference/block-kit/block-elements#image
Args
alt_text
:required
- A plain-text summary of the image. This should not contain any markup.
image_url
- The URL of the image to be displayed.
slack_file
- A Slack image file object that defines the source of the image.
Expand source code
class ImageElement(BlockElement): type = "image" image_url_max_length = 3000 alt_text_max_length = 2000 @property def attributes(self) -> Set[str]: return super().attributes.union({"alt_text", "image_url", "slack_file"}) def __init__( self, *, alt_text: Optional[str] = None, image_url: Optional[str] = None, slack_file: Optional[Union[Dict[str, Any], SlackFile]] = None, **others: dict, ): """An element to insert an image - this element can be used in section and context blocks only. If you want a block with only an image in it, you're looking for the image block. https://api.slack.com/reference/block-kit/block-elements#image Args: alt_text (required): A plain-text summary of the image. This should not contain any markup. image_url: The URL of the image to be displayed. slack_file: A Slack image file object that defines the source of the image. """ super().__init__(type=self.type) show_unknown_key_warning(self, others) self.image_url = image_url self.alt_text = alt_text self.slack_file = slack_file if slack_file is None or isinstance(slack_file, SlackFile) else SlackFile(**slack_file) @JsonValidator(f"image_url attribute cannot exceed {image_url_max_length} characters") def _validate_image_url_length(self) -> bool: return self.image_url is None or len(self.image_url) <= self.image_url_max_length @JsonValidator(f"alt_text attribute cannot exceed {alt_text_max_length} characters") def _validate_alt_text_length(self) -> bool: return len(self.alt_text) <= self.alt_text_max_length
Ancestors
Class variables
var alt_text_max_length
var image_url_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"alt_text", "image_url", "slack_file"})
Inherited members
class InputBlock (*, label: Union[str, dict, PlainTextObject], element: Union[str, dict, InputInteractiveElement], block_id: Optional[str] = None, hint: Union[str, dict, PlainTextObject, ForwardRef(None)] = None, dispatch_action: Optional[bool] = None, optional: Optional[bool] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A block that collects information from users - it can hold a plain-text input element, a select menu element, a multi-select menu element, or a datepicker. https://api.slack.com/reference/block-kit/blocks#input
Args
label
:required
- A label that appears above an input element in the form of a text object that must have type of plain_text. Maximum length for the text in this field is 2000 characters.
element
:required
- An plain-text input element, a checkbox element, a radio button element, a select menu element, a multi-select menu element, or a datepicker.
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message or view and each iteration of a message or view. If a message or view is updated, use a new block_id.
hint
- An optional hint that appears below an input element in a lighter grey. It must be a text object with a type of plain_text. Maximum length for the text in this field is 2000 characters.
dispatch_action
- A boolean that indicates whether or not the use of elements in this block should dispatch a block_actions payload. Defaults to false.
optional
- A boolean that indicates whether the input element may be empty when a user submits the modal. Defaults to false.
Expand source code
class InputBlock(Block): type = "input" label_max_length = 2000 hint_max_length = 2000 @property def attributes(self) -> Set[str]: return super().attributes.union({"label", "hint", "element", "optional", "dispatch_action"}) def __init__( self, *, label: Union[str, dict, PlainTextObject], element: Union[str, dict, InputInteractiveElement], block_id: Optional[str] = None, hint: Optional[Union[str, dict, PlainTextObject]] = None, dispatch_action: Optional[bool] = None, optional: Optional[bool] = None, **others: dict, ): """A block that collects information from users - it can hold a plain-text input element, a select menu element, a multi-select menu element, or a datepicker. https://api.slack.com/reference/block-kit/blocks#input Args: label (required): A label that appears above an input element in the form of a text object that must have type of plain_text. Maximum length for the text in this field is 2000 characters. element (required): An plain-text input element, a checkbox element, a radio button element, a select menu element, a multi-select menu element, or a datepicker. block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message or view and each iteration of a message or view. If a message or view is updated, use a new block_id. hint: An optional hint that appears below an input element in a lighter grey. It must be a text object with a type of plain_text. Maximum length for the text in this field is 2000 characters. dispatch_action: A boolean that indicates whether or not the use of elements in this block should dispatch a block_actions payload. Defaults to false. optional: A boolean that indicates whether the input element may be empty when a user submits the modal. Defaults to false. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.label = TextObject.parse(label, default_type=PlainTextObject.type) self.element = BlockElement.parse(element) self.hint = TextObject.parse(hint, default_type=PlainTextObject.type) self.dispatch_action = dispatch_action self.optional = optional @JsonValidator(f"label attribute cannot exceed {label_max_length} characters") def _validate_label_length(self): return self.label is None or self.label.text is None or len(self.label.text) <= self.label_max_length @JsonValidator(f"hint attribute cannot exceed {hint_max_length} characters") def _validate_hint_length(self): return self.hint is None or self.hint.text is None or len(self.hint.text) <= self.label_max_length @JsonValidator( ( "element attribute must be a string, select element, multi-select element, " "or a datepicker. (Sub-classes of InputInteractiveElement)" ) ) def _validate_element_type(self): return self.element is None or isinstance(self.element, (str, InputInteractiveElement))
Ancestors
Class variables
var hint_max_length
var label_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"label", "hint", "element", "optional", "dispatch_action"})
Inherited members
class InputInteractiveElement (*, action_id: Optional[str] = None, placeholder: Union[str, TextObject, ForwardRef(None)] = None, type: Optional[str] = None, subtype: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
InteractiveElement that is usable in input blocks
We generally recommend using the concrete subclasses for better supports of available properties.
Expand source code
class InputInteractiveElement(InteractiveElement, metaclass=ABCMeta): placeholder_max_length = 150 attributes = {"type", "action_id", "placeholder", "confirm", "focus_on_load"} @property def subtype(self) -> Optional[str]: return self.type def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, TextObject]] = None, type: Optional[str] = None, # skipcq: PYL-W0622 subtype: Optional[str] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """InteractiveElement that is usable in input blocks We generally recommend using the concrete subclasses for better supports of available properties. """ if subtype: self._subtype_warning() super().__init__(action_id=action_id, type=type or subtype) # Note that we don't intentionally have show_unknown_key_warning for the unknown key warnings here. # It's fine to pass any kwargs to the held dict here although the class does not do any validation. # show_unknown_key_warning(self, others) self.placeholder = TextObject.parse(placeholder) self.confirm = ConfirmObject.parse(confirm) self.focus_on_load = focus_on_load @JsonValidator(f"placeholder attribute cannot exceed {placeholder_max_length} characters") def _validate_placeholder_length(self) -> bool: return ( self.placeholder is None or self.placeholder.text is None or len(self.placeholder.text) <= self.placeholder_max_length )
Ancestors
Subclasses
- ChannelMultiSelectElement
- ChannelSelectElement
- CheckboxesElement
- ConversationMultiSelectElement
- ConversationSelectElement
- DatePickerElement
- DateTimePickerElement
- EmailInputElement
- ExternalDataMultiSelectElement
- ExternalDataSelectElement
- FileInputElement
- NumberInputElement
- PlainTextInputElement
- RadioButtonsElement
- RichTextInputElement
- SelectElement
- StaticMultiSelectElement
- StaticSelectElement
- TimePickerElement
- UrlInputElement
- UserMultiSelectElement
- UserSelectElement
Class variables
var placeholder_max_length
Instance variables
prop subtype : Optional[str]
-
Expand source code
@property def subtype(self) -> Optional[str]: return self.type
Inherited members
class InteractiveElement (*, action_id: Optional[str] = None, type: Optional[str] = None, subtype: Optional[str] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
An interactive block element.
We generally recommend using the concrete subclasses for better supports of available properties.
Expand source code
class InteractiveElement(BlockElement): action_id_max_length = 255 @property def attributes(self) -> Set[str]: return super().attributes.union({"alt_text", "action_id"}) def __init__( self, *, action_id: Optional[str] = None, type: Optional[str] = None, # skipcq: PYL-W0622 subtype: Optional[str] = None, **others: dict, ): """An interactive block element. We generally recommend using the concrete subclasses for better supports of available properties. """ if subtype: self._subtype_warning() super().__init__(type=type or subtype) # Note that we don't intentionally have show_unknown_key_warning for the unknown key warnings here. # It's fine to pass any kwargs to the held dict here although the class does not do any validation. # show_unknown_key_warning(self, others) self.action_id = action_id @JsonValidator(f"action_id attribute cannot exceed {action_id_max_length} characters") def _validate_action_id_length(self) -> bool: return self.action_id is None or len(self.action_id) <= self.action_id_max_length
Ancestors
Subclasses
Class variables
var action_id_max_length
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"alt_text", "action_id"})
Inherited members
class LinkButtonElement (*, text: Union[str, dict, PlainTextObject], url: str, action_id: Optional[str] = None, style: Optional[str] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
A simple button that simply opens a given URL. You will still receive an interaction payload and will need to send an acknowledgement response. This is a helper class that makes creating links simpler. https://api.slack.com/reference/block-kit/block-elements#button
Args
text
:required
- A text object that defines the button's text. Can only be of type: plain_text. Maximum length for the text in this field is 75 characters.
url
:required
- A URL to load in the user's browser when the button is clicked. Maximum length for this field is 3000 characters. If you're using url, you'll still receive an interaction payload and will need to send an acknowledgement response.
action_id
:required
- An identifier for this action. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
style
- Decorates buttons with alternative visual color schemes. Use this option with restraint. "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. "primary" should only be used for one button within a set. "danger" gives buttons a red outline and text, and should be used when the action is destructive. Use "danger" even more sparingly than "primary". If you don't include this field, the default button style will be used.
Expand source code
class LinkButtonElement(ButtonElement): def __init__( self, *, text: Union[str, dict, PlainTextObject], url: str, action_id: Optional[str] = None, style: Optional[str] = None, **others: dict, ): """A simple button that simply opens a given URL. You will still receive an interaction payload and will need to send an acknowledgement response. This is a helper class that makes creating links simpler. https://api.slack.com/reference/block-kit/block-elements#button Args: text (required): A text object that defines the button's text. Can only be of type: plain_text. Maximum length for the text in this field is 75 characters. url (required): A URL to load in the user's browser when the button is clicked. Maximum length for this field is 3000 characters. If you're using url, you'll still receive an interaction payload and will need to send an acknowledgement response. action_id (required): An identifier for this action. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. style: Decorates buttons with alternative visual color schemes. Use this option with restraint. "primary" gives buttons a green outline and text, ideal for affirmation or confirmation actions. "primary" should only be used for one button within a set. "danger" gives buttons a red outline and text, and should be used when the action is destructive. Use "danger" even more sparingly than "primary". If you don't include this field, the default button style will be used. """ super().__init__( # NOTE: value must be always absent text=text, url=url, action_id=action_id, value=None, style=style, ) show_unknown_key_warning(self, others)
Ancestors
Inherited members
class MarkdownTextObject (*, text: str, verbatim: Optional[bool] = None)
-
mrkdwn typed text object
A Markdown text object, meaning markdown characters will be parsed as formatting information. https://api.slack.com/reference/block-kit/composition-objects#text
Args
text
:required
- The text for the block. This field accepts any of the standard text formatting markup when type is mrkdwn.
verbatim
- When set to false (as is default) URLs will be auto-converted into links, conversation names will be link-ified, and certain mentions will be automatically parsed. Using a value of true will skip any preprocessing of this nature, although you can still include manual parsing strings. This field is only usable when type is mrkdwn.
Expand source code
class MarkdownTextObject(TextObject): """mrkdwn typed text object""" type = "mrkdwn" @property def attributes(self) -> Set[str]: return super().attributes.union({"verbatim"}) def __init__(self, *, text: str, verbatim: Optional[bool] = None): """A Markdown text object, meaning markdown characters will be parsed as formatting information. https://api.slack.com/reference/block-kit/composition-objects#text Args: text (required): The text for the block. This field accepts any of the standard text formatting markup when type is mrkdwn. verbatim: When set to false (as is default) URLs will be auto-converted into links, conversation names will be link-ified, and certain mentions will be automatically parsed. Using a value of true will skip any preprocessing of this nature, although you can still include manual parsing strings. This field is only usable when type is mrkdwn. """ super().__init__(text=text, type=self.type) self.verbatim = verbatim @staticmethod def from_str(text: str) -> "MarkdownTextObject": """Transforms a string into the required object shape to act as a MarkdownTextObject""" return MarkdownTextObject(text=text) @staticmethod def direct_from_string(text: str) -> Dict[str, Any]: """Transforms a string into the required object shape to act as a MarkdownTextObject""" return MarkdownTextObject.from_str(text).to_dict() @staticmethod def from_link(link: Link, title: str = "") -> "MarkdownTextObject": """ Transform a Link object directly into the required object shape to act as a MarkdownTextObject """ if title: title = f": {title}" return MarkdownTextObject(text=f"{link}{title}") @staticmethod def direct_from_link(link: Link, title: str = "") -> Dict[str, Any]: """ Transform a Link object directly into the required object shape to act as a MarkdownTextObject """ return MarkdownTextObject.from_link(link, title).to_dict()
Ancestors
Class variables
var type
Static methods
def direct_from_link(link: Link, title: str = '') ‑> Dict[str, Any]
-
Transform a Link object directly into the required object shape to act as a MarkdownTextObject
def direct_from_string(text: str) ‑> Dict[str, Any]
-
Transforms a string into the required object shape to act as a MarkdownTextObject
def from_link(link: Link, title: str = '') ‑> MarkdownTextObject
-
Transform a Link object directly into the required object shape to act as a MarkdownTextObject
def from_str(text: str) ‑> MarkdownTextObject
-
Transforms a string into the required object shape to act as a MarkdownTextObject
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"verbatim"})
Inherited members
class NumberInputElement (*, action_id: Optional[str] = None, is_decimal_allowed: Optional[bool] = False, initial_value: Union[int, float, str, ForwardRef(None)] = None, min_value: Union[int, float, str, ForwardRef(None)] = None, max_value: Union[int, float, str, ForwardRef(None)] = None, dispatch_action_config: Union[dict, DispatchActionConfig, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
https://api.slack.com/reference/block-kit/block-elements#number
Args
action_id
:required
- An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
is_decimal_allowed
:required
- Decimal numbers are allowed if is_decimal_allowed= true, set the value to false otherwise.
initial_value
- The initial value in the number input when it is loaded.
min_value
- The minimum value, cannot be greater than max_value.
max_value
- The maximum value, cannot be less than min_value.
dispatch_action_config
- A dispatch configuration object that determines when during text input the element returns a block_actions payload.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
placeholder
- A plain_text only text object that defines the placeholder text shown in the plain-text input. Maximum length for the text in this field is 150 characters.
Expand source code
class NumberInputElement(InputInteractiveElement): type = "number_input" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_value", "is_decimal_allowed", "min_value", "max_value", "dispatch_action_config", } ) def __init__( self, *, action_id: Optional[str] = None, is_decimal_allowed: Optional[bool] = False, initial_value: Optional[Union[int, float, str]] = None, min_value: Optional[Union[int, float, str]] = None, max_value: Optional[Union[int, float, str]] = None, dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, focus_on_load: Optional[bool] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, **others: dict, ): """ https://api.slack.com/reference/block-kit/block-elements#number Args: action_id (required): An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. is_decimal_allowed (required): Decimal numbers are allowed if is_decimal_allowed= true, set the value to false otherwise. initial_value: The initial value in the number input when it is loaded. min_value: The minimum value, cannot be greater than max_value. max_value: The maximum value, cannot be less than min_value. dispatch_action_config: A dispatch configuration object that determines when during text input the element returns a block_actions payload. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. placeholder: A plain_text only text object that defines the placeholder text shown in the plain-text input. Maximum length for the text in this field is 150 characters. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_value = str(initial_value) if initial_value is not None else None self.is_decimal_allowed = is_decimal_allowed self.min_value = str(min_value) if min_value is not None else None self.max_value = str(max_value) if max_value is not None else None self.dispatch_action_config = dispatch_action_config
Ancestors
Class variables
var type
Inherited members
class Option (*, value: str, label: Optional[str] = None, text: Union[str, Dict[str, Any], TextObject, ForwardRef(None)] = None, description: Union[str, Dict[str, Any], TextObject, ForwardRef(None)] = None, url: Optional[str] = None, **others: Dict[str, Any])
-
Option object used in dialogs, legacy message actions (interactivity in attachments), and blocks. JSON must be retrieved with an explicit option_type - the Slack API has different required formats in different situations
An object that represents a single selectable item in a block element ( SelectElement, OverflowMenuElement) or dialog element (StaticDialogSelectElement)
Blocks: https://api.slack.com/reference/block-kit/composition-objects#option
Dialogs: https://api.slack.com/dialogs#select_elements
Legacy interactive attachments: https://api.slack.com/legacy/interactive-message-field-guide#option_fields
Args
label
- A short, user-facing string to label this option to users. Cannot exceed 75 characters.
value
- A short string that identifies this particular option to your application. It will be part of the payload when this option is selected . Cannot exceed 75 characters.
description
- A user-facing string that provides more details about this option. Only supported in legacy message actions, not in blocks or dialogs.
Expand source code
class Option(JsonObject): """Option object used in dialogs, legacy message actions (interactivity in attachments), and blocks. JSON must be retrieved with an explicit option_type - the Slack API has different required formats in different situations """ attributes = {} # no attributes because to_dict has unique implementations logger = logging.getLogger(__name__) label_max_length = 75 value_max_length = 75 def __init__( self, *, value: str, label: Optional[str] = None, text: Optional[Union[str, Dict[str, Any], TextObject]] = None, # Block Kit description: Optional[Union[str, Dict[str, Any], TextObject]] = None, url: Optional[str] = None, **others: Dict[str, Any], ): """ An object that represents a single selectable item in a block element ( SelectElement, OverflowMenuElement) or dialog element (StaticDialogSelectElement) Blocks: https://api.slack.com/reference/block-kit/composition-objects#option Dialogs: https://api.slack.com/dialogs#select_elements Legacy interactive attachments: https://api.slack.com/legacy/interactive-message-field-guide#option_fields Args: label: A short, user-facing string to label this option to users. Cannot exceed 75 characters. value: A short string that identifies this particular option to your application. It will be part of the payload when this option is selected . Cannot exceed 75 characters. description: A user-facing string that provides more details about this option. Only supported in legacy message actions, not in blocks or dialogs. """ if text: # For better compatibility with Block Kit ("mrkdwn" does not work for it), # we've changed the default text object type to plain_text since version 3.10.0 self._text: Optional[TextObject] = TextObject.parse( text=text, # "text" here can be either a str or a TextObject default_type=PlainTextObject.type, ) self._label: Optional[str] = None else: self._text: Optional[TextObject] = None self._label: Optional[str] = label # for backward-compatibility with version 2.0-2.5, the following fields return str values self.text: Optional[str] = self._text.text if self._text else None self.label: Optional[str] = self._label self.value: str = value # for backward-compatibility with version 2.0-2.5, the following fields return str values if isinstance(description, str): self.description = description self._block_description = PlainTextObject.from_str(description) elif isinstance(description, dict): self.description = description["text"] self._block_description = TextObject.parse(description) elif isinstance(description, TextObject): self.description = description.text self._block_description = description else: self.description = None self._block_description = None # A URL to load in the user's browser when the option is clicked. # The url attribute is only available in overflow menus. # Maximum length for this field is 3000 characters. # If you're using url, you'll still receive an interaction payload # and will need to send an acknowledgement response. self.url: Optional[str] = url show_unknown_key_warning(self, others) @JsonValidator(f"label attribute cannot exceed {label_max_length} characters") def _validate_label_length(self) -> bool: return self._label is None or len(self._label) <= self.label_max_length @JsonValidator(f"text attribute cannot exceed {label_max_length} characters") def _validate_text_length(self) -> bool: return self._text is None or self._text.text is None or len(self._text.text) <= self.label_max_length @JsonValidator(f"value attribute cannot exceed {value_max_length} characters") def _validate_value_length(self) -> bool: return len(self.value) <= self.value_max_length @classmethod def parse_all(cls, options: Optional[Sequence[Union[Dict[str, Any], "Option"]]]) -> Optional[List["Option"]]: if options is None: return None option_objects: List[Option] = [] for o in options: if isinstance(o, dict): d = copy.copy(o) option_objects.append(Option(**d)) elif isinstance(o, Option): option_objects.append(o) else: cls.logger.warning(f"Unknown option object detected and skipped ({o})") return option_objects def to_dict(self, option_type: str = "block") -> Dict[str, Any]: # skipcq: PYL-W0221 """ Different parent classes must call this with a valid value from OptionTypes - either "dialog", "action", or "block", so that JSON is returned in the correct shape. """ self.validate_json() if option_type == "dialog": # skipcq: PYL-R1705 return {"label": self.label, "value": self.value} elif option_type == "action" or option_type == "attachment": # "action" can be confusing but it means a legacy message action in attachments # we don't remove the type name for backward compatibility though json = {"text": self.label, "value": self.value} if self.description is not None: json["description"] = self.description return json else: # if option_type == "block"; this should be the most common case text: TextObject = self._text or PlainTextObject.from_str(self.label) json: Dict[str, Any] = { "text": text.to_dict(), "value": self.value, } if self._block_description: json["description"] = self._block_description.to_dict() if self.url: json["url"] = self.url return json @staticmethod def from_single_value(value_and_label: str): """Creates a simple Option instance with the same value and label""" return Option(value=value_and_label, label=value_and_label)
Ancestors
Class variables
var label_max_length
var logger
var value_max_length
Static methods
def from_single_value(value_and_label: str)
-
Creates a simple Option instance with the same value and label
def parse_all(options: Optional[Sequence[Union[Dict[str, Any], ForwardRef('Option')]]]) ‑> Optional[List[Option]]
Methods
def to_dict(self, option_type: str = 'block') ‑> Dict[str, Any]
-
Different parent classes must call this with a valid value from OptionTypes - either "dialog", "action", or "block", so that JSON is returned in the correct shape.
Inherited members
class OptionGroup (*, label: Union[str, Dict[str, Any], TextObject, ForwardRef(None)] = None, options: Sequence[Union[Dict[str, Any], Option]], **others: Dict[str, Any])
-
JSON must be retrieved with an explicit option_type - the Slack API has different required formats in different situations
Create a group of Option objects - pass in a label (that will be part of the UI) and a list of Option objects.
Blocks: https://api.slack.com/reference/block-kit/composition-objects#option-group
Dialogs: https://api.slack.com/dialogs#select_elements
Legacy interactive attachments: https://api.slack.com/legacy/interactive-message-field-guide#option_groups_to_place_within_message_menu_actions
Args
label
- Text to display at the top of this group of options.
options
- A list of no more than 100 Option objects.
Expand source code
class OptionGroup(JsonObject): """ JSON must be retrieved with an explicit option_type - the Slack API has different required formats in different situations """ attributes = {} # no attributes because to_dict has unique implementations label_max_length = 75 options_max_length = 100 logger = logging.getLogger(__name__) def __init__( self, *, label: Optional[Union[str, Dict[str, Any], TextObject]] = None, options: Sequence[Union[Dict[str, Any], Option]], **others: Dict[str, Any], ): """ Create a group of Option objects - pass in a label (that will be part of the UI) and a list of Option objects. Blocks: https://api.slack.com/reference/block-kit/composition-objects#option-group Dialogs: https://api.slack.com/dialogs#select_elements Legacy interactive attachments: https://api.slack.com/legacy/interactive-message-field-guide#option_groups_to_place_within_message_menu_actions Args: label: Text to display at the top of this group of options. options: A list of no more than 100 Option objects. """ # noqa prevent flake8 blowing up on the long URL # default_type=PlainTextObject.type is for backward-compatibility self._label: Optional[TextObject] = TextObject.parse(label, default_type=PlainTextObject.type) self.label: Optional[str] = self._label.text if self._label else None self.options = Option.parse_all(options) # compatible with version 2.5 show_unknown_key_warning(self, others) @JsonValidator(f"label attribute cannot exceed {label_max_length} characters") def _validate_label_length(self): return self.label is None or len(self.label) <= self.label_max_length @JsonValidator(f"options attribute cannot exceed {options_max_length} elements") def _validate_options_length(self): return self.options is None or len(self.options) <= self.options_max_length @classmethod def parse_all( cls, option_groups: Optional[Sequence[Union[Dict[str, Any], "OptionGroup"]]] ) -> Optional[List["OptionGroup"]]: if option_groups is None: return None option_group_objects = [] for o in option_groups: if isinstance(o, dict): d = copy.copy(o) option_group_objects.append(OptionGroup(**d)) elif isinstance(o, OptionGroup): option_group_objects.append(o) else: cls.logger.warning(f"Unknown option group object detected and skipped ({o})") return option_group_objects def to_dict(self, option_type: str = "block") -> Dict[str, Any]: # skipcq: PYL-W0221 self.validate_json() dict_options = [o.to_dict(option_type) for o in self.options] if option_type == "dialog": # skipcq: PYL-R1705 return { "label": self.label, "options": dict_options, } elif option_type == "action": return { "text": self.label, "options": dict_options, } else: # if option_type == "block"; this should be the most common case dict_label: Dict[str, Any] = self._label.to_dict() return { "label": dict_label, "options": dict_options, }
Ancestors
Class variables
var label_max_length
var logger
var options_max_length
Static methods
def parse_all(option_groups: Optional[Sequence[Union[Dict[str, Any], ForwardRef('OptionGroup')]]]) ‑> Optional[List[OptionGroup]]
Inherited members
class OverflowMenuElement (*, action_id: Optional[str] = None, options: Sequence[Option], confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This is like a cross between a button and a select menu - when a user clicks on this overflow button, they will be presented with a list of options to choose from. Unlike the select menu, there is no typeahead field, and the button always appears with an ellipsis ("…") rather than customisable text.
As such, it is usually used if you want a more compact layout than a select menu, or to supply a list of less visually important actions after a row of buttons. You can also specify simple URL links as overflow menu options, instead of actions.
https://api.slack.com/reference/block-kit/block-elements#overflow
Args
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
options
:required
- An array of option objects to display in the menu. Maximum number of options is 5, minimum is 1.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
Expand source code
class OverflowMenuElement(InteractiveElement): type = "overflow" options_min_length = 1 options_max_length = 5 @property def attributes(self) -> Set[str]: return super().attributes.union({"confirm", "options"}) def __init__( self, *, action_id: Optional[str] = None, options: Sequence[Option], confirm: Optional[Union[dict, ConfirmObject]] = None, **others: dict, ): """ This is like a cross between a button and a select menu - when a user clicks on this overflow button, they will be presented with a list of options to choose from. Unlike the select menu, there is no typeahead field, and the button always appears with an ellipsis ("…") rather than customisable text. As such, it is usually used if you want a more compact layout than a select menu, or to supply a list of less visually important actions after a row of buttons. You can also specify simple URL links as overflow menu options, instead of actions. https://api.slack.com/reference/block-kit/block-elements#overflow Args: action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. options (required): An array of option objects to display in the menu. Maximum number of options is 5, minimum is 1. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. """ super().__init__(action_id=action_id, type=self.type) show_unknown_key_warning(self, others) self.options = options self.confirm = ConfirmObject.parse(confirm) @JsonValidator(f"options attribute must have between {options_min_length} " f"and {options_max_length} items") def _validate_options_length(self) -> bool: return self.options_min_length <= len(self.options) <= self.options_max_length
Ancestors
Class variables
var options_max_length
var options_min_length
var type
Inherited members
class PlainTextInputElement (*, action_id: Optional[str] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, initial_value: Optional[str] = None, multiline: Optional[bool] = None, min_length: Optional[int] = None, max_length: Optional[int] = None, dispatch_action_config: Union[dict, DispatchActionConfig, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
A plain-text input, similar to the HTML tag, creates a field where a user can enter freeform data. It can appear as a single-line field or a larger textarea using the multiline flag. Plain-text input elements can be used inside of SectionBlocks and ActionsBlocks. https://api.slack.com/reference/block-kit/block-elements#input
Args
action_id
:required
- An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
placeholder
- A plain_text only text object that defines the placeholder text shown in the plain-text input. Maximum length for the text in this field is 150 characters.
initial_value
- The initial value in the plain-text input when it is loaded.
multiline
- Indicates whether the input will be a single line (false) or a larger textarea (true). Defaults to false.
min_length
- The minimum length of input that the user must provide. If the user provides less, they will receive an error. Maximum value is 3000.
max_length
- The maximum length of input that the user can provide. If the user provides more, they will receive an error.
dispatch_action_config
- A dispatch configuration object that determines when during text input the element returns a block_actions payload.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class PlainTextInputElement(InputInteractiveElement): type = "plain_text_input" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_value", "multiline", "min_length", "max_length", "dispatch_action_config", } ) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_value: Optional[str] = None, multiline: Optional[bool] = None, min_length: Optional[int] = None, max_length: Optional[int] = None, dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ A plain-text input, similar to the HTML <input> tag, creates a field where a user can enter freeform data. It can appear as a single-line field or a larger textarea using the multiline flag. Plain-text input elements can be used inside of SectionBlocks and ActionsBlocks. https://api.slack.com/reference/block-kit/block-elements#input Args: action_id (required): An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. placeholder: A plain_text only text object that defines the placeholder text shown in the plain-text input. Maximum length for the text in this field is 150 characters. initial_value: The initial value in the plain-text input when it is loaded. multiline: Indicates whether the input will be a single line (false) or a larger textarea (true). Defaults to false. min_length: The minimum length of input that the user must provide. If the user provides less, they will receive an error. Maximum value is 3000. max_length: The maximum length of input that the user can provide. If the user provides more, they will receive an error. dispatch_action_config: A dispatch configuration object that determines when during text input the element returns a block_actions payload. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_value = initial_value self.multiline = multiline self.min_length = min_length self.max_length = max_length self.dispatch_action_config = dispatch_action_config
Ancestors
Class variables
var type
Inherited members
class PlainTextObject (*, text: str, emoji: Optional[bool] = None)
-
plain_text typed text object
A plain text object, meaning markdown characters will not be parsed as formatting information. https://api.slack.com/reference/block-kit/composition-objects#text
Args
text
:required
- The text for the block. This field accepts any of the standard text formatting markup when type is mrkdwn.
emoji
- Indicates whether emojis in a text field should be escaped into the colon emoji format. This field is only usable when type is plain_text.
Expand source code
class PlainTextObject(TextObject): """plain_text typed text object""" type = "plain_text" @property def attributes(self) -> Set[str]: return super().attributes.union({"emoji"}) def __init__(self, *, text: str, emoji: Optional[bool] = None): """A plain text object, meaning markdown characters will not be parsed as formatting information. https://api.slack.com/reference/block-kit/composition-objects#text Args: text (required): The text for the block. This field accepts any of the standard text formatting markup when type is mrkdwn. emoji: Indicates whether emojis in a text field should be escaped into the colon emoji format. This field is only usable when type is plain_text. """ super().__init__(text=text, type=self.type) self.emoji = emoji @staticmethod def from_str(text: str) -> "PlainTextObject": return PlainTextObject(text=text, emoji=True) @staticmethod def direct_from_string(text: str) -> Dict[str, Any]: """Transforms a string into the required object shape to act as a PlainTextObject""" return PlainTextObject.from_str(text).to_dict()
Ancestors
Class variables
var type
Static methods
def direct_from_string(text: str) ‑> Dict[str, Any]
-
Transforms a string into the required object shape to act as a PlainTextObject
def from_str(text: str) ‑> PlainTextObject
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"emoji"})
Inherited members
class RadioButtonsElement (*, action_id: Optional[str] = None, options: Optional[Sequence[Union[dict, Option]]] = None, initial_option: Union[dict, Option, ForwardRef(None)] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
A radio button group that allows a user to choose one item from a list of possible options. https://api.slack.com/reference/block-kit/block-elements#radio
Args
action_id
:required
- An identifier for the action triggered when the radio button group is changed. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
options
:required
- An array of option objects. A maximum of 10 options are allowed.
initial_option
- An option object that exactly matches one of the options. This option will be selected when the radio button group initially loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears after clicking one of the radio buttons in this element.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class RadioButtonsElement(InputInteractiveElement): type = "radio_buttons" @property def attributes(self) -> Set[str]: return super().attributes.union({"options", "initial_option"}) def __init__( self, *, action_id: Optional[str] = None, options: Optional[Sequence[Union[dict, Option]]] = None, initial_option: Optional[Union[dict, Option]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """A radio button group that allows a user to choose one item from a list of possible options. https://api.slack.com/reference/block-kit/block-elements#radio Args: action_id (required): An identifier for the action triggered when the radio button group is changed. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. options (required): An array of option objects. A maximum of 10 options are allowed. initial_option: An option object that exactly matches one of the options. This option will be selected when the radio button group initially loads. confirm: A confirm object that defines an optional confirmation dialog that appears after clicking one of the radio buttons in this element. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.options = options self.initial_option = initial_option
Ancestors
Class variables
var type
Inherited members
class RichTextBlock (*, elements: Sequence[Union[dict, RichTextElement]], block_id: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A block that is used to hold interactive elements. https://api.slack.com/reference/block-kit/blocks#rich_text
Args
elements
:required
- An array of rich text objects - rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted
block_id
- A unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message or view and each iteration of a message or view. If a message or view is updated, use a new block_id.
Expand source code
class RichTextBlock(Block): type = "rich_text" @property def attributes(self) -> Set[str]: return super().attributes.union({"elements"}) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], block_id: Optional[str] = None, **others: dict, ): """A block that is used to hold interactive elements. https://api.slack.com/reference/block-kit/blocks#rich_text Args: elements (required): An array of rich text objects - rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted block_id: A unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message or view and each iteration of a message or view. If a message or view is updated, use a new block_id. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements)
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements"})
Inherited members
class RichTextElement (*, type: Optional[str] = None, subtype: Optional[str] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
Expand source code
class RichTextElement(BlockElement): pass
Ancestors
Subclasses
- RichTextElementParts.Broadcast
- RichTextElementParts.Channel
- RichTextElementParts.Color
- RichTextElementParts.Date
- RichTextElementParts.Emoji
- RichTextElementParts.Link
- RichTextElementParts.Team
- RichTextElementParts.Text
- RichTextElementParts.User
- RichTextElementParts.UserGroup
- RichTextListElement
- RichTextPreformattedElement
- RichTextQuoteElement
- RichTextSectionElement
Inherited members
class RichTextElementParts
-
Expand source code
class RichTextElementParts: class TextStyle: def __init__( self, *, bold: Optional[bool] = None, italic: Optional[bool] = None, strike: Optional[bool] = None, code: Optional[bool] = None, ): self.bold = bold self.italic = italic self.strike = strike self.code = code def to_dict(self, *args) -> dict: result = { "bold": self.bold, "italic": self.italic, "strike": self.strike, "code": self.code, } return {k: v for k, v in result.items() if v is not None} class Text(RichTextElement): type = "text" @property def attributes(self) -> Set[str]: return super().attributes.union({"text", "style"}) def __init__( self, *, text: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.text = text self.style = style class Channel(RichTextElement): type = "channel" @property def attributes(self) -> Set[str]: return super().attributes.union({"channel_id", "style"}) def __init__( self, *, channel_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.channel_id = channel_id self.style = style class User(RichTextElement): type = "user" @property def attributes(self) -> Set[str]: return super().attributes.union({"user_id", "style"}) def __init__( self, *, user_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.user_id = user_id self.style = style class Emoji(RichTextElement): type = "emoji" @property def attributes(self) -> Set[str]: return super().attributes.union({"name", "skin_tone", "unicode", "style"}) def __init__( self, *, name: str, skin_tone: Optional[int] = None, unicode: Optional[str] = None, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.name = name self.skin_tone = skin_tone self.unicode = unicode self.style = style class Link(RichTextElement): type = "link" @property def attributes(self) -> Set[str]: return super().attributes.union({"url", "text", "style"}) def __init__( self, *, url: str, text: Optional[str] = None, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.url = url self.text = text self.style = style class Team(RichTextElement): type = "team" @property def attributes(self) -> Set[str]: return super().attributes.union({"team_id", "style"}) def __init__( self, *, team_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.team_id = team_id self.style = style class UserGroup(RichTextElement): type = "usergroup" @property def attributes(self) -> Set[str]: return super().attributes.union({"usergroup_id", "style"}) def __init__( self, *, usergroup_id: str, style: Optional[Union[dict, "RichTextElementParts.TextStyle"]] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.usergroup_id = usergroup_id self.style = style class Date(RichTextElement): type = "date" @property def attributes(self) -> Set[str]: return super().attributes.union({"timestamp", "format", "url", "fallback"}) def __init__( self, *, timestamp: int, format: str, url: Optional[str] = None, fallback: Optional[str] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.timestamp = timestamp self.format = format self.url = url self.fallback = fallback class Broadcast(RichTextElement): type = "broadcast" @property def attributes(self) -> Set[str]: return super().attributes.union({"range"}) def __init__( self, *, range: str, # channel, here, .. **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.range = range class Color(RichTextElement): type = "color" @property def attributes(self) -> Set[str]: return super().attributes.union({"value"}) def __init__( self, *, value: str, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.value = value
Class variables
var Broadcast
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Channel
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Color
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Date
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Emoji
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Link
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Team
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var Text
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var TextStyle
var User
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
var UserGroup
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
class RichTextInputElement (*, action_id: Optional[str] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, initial_value: Optional[Dict[str, Any]] = None, dispatch_action_config: Union[dict, DispatchActionConfig, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
InteractiveElement that is usable in input blocks
We generally recommend using the concrete subclasses for better supports of available properties.
Expand source code
class RichTextInputElement(InputInteractiveElement): type = "rich_text_input" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_value", "dispatch_action_config", } ) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_value: Optional[Dict[str, Any]] = None, # TODO: Add rich_text block class and its element classes dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_value = initial_value self.dispatch_action_config = dispatch_action_config
Ancestors
Class variables
var type
Inherited members
class RichTextListElement (*, elements: Sequence[Union[dict, RichTextElement]], style: Optional[str] = None, indent: Optional[int] = None, offset: Optional[int] = None, border: Optional[int] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
Expand source code
class RichTextListElement(RichTextElement): type = "rich_text_list" @property def attributes(self) -> Set[str]: return super().attributes.union({"elements", "style", "indent", "offset", "border"}) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], style: Optional[str] = None, # bullet, ordered indent: Optional[int] = None, offset: Optional[int] = None, border: Optional[int] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements) self.style = style self.indent = indent self.offset = offset self.border = border
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements", "style", "indent", "offset", "border"})
Inherited members
class RichTextPreformattedElement (*, elements: Sequence[Union[dict, RichTextElement]], border: Optional[int] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
Expand source code
class RichTextPreformattedElement(RichTextElement): type = "rich_text_preformatted" @property def attributes(self) -> Set[str]: return super().attributes.union({"elements", "border"}) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], border: Optional[int] = None, **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements) self.border = border
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements", "border"})
Inherited members
class RichTextQuoteElement (*, elements: Sequence[Union[dict, RichTextElement]], **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
Expand source code
class RichTextQuoteElement(RichTextElement): type = "rich_text_quote" @property def attributes(self) -> Set[str]: return super().attributes.union({"elements"}) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements)
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements"})
Inherited members
class RichTextSectionElement (*, elements: Sequence[Union[dict, RichTextElement]], **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
Expand source code
class RichTextSectionElement(RichTextElement): type = "rich_text_section" @property def attributes(self) -> Set[str]: return super().attributes.union({"elements"}) def __init__( self, *, elements: Sequence[Union[dict, RichTextElement]], **others: dict, ): super().__init__(type=self.type) show_unknown_key_warning(self, others) self.elements = BlockElement.parse_all(elements)
Ancestors
Class variables
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"elements"})
Inherited members
class SectionBlock (*, block_id: Optional[str] = None, text: Union[str, dict, TextObject, ForwardRef(None)] = None, fields: Optional[Sequence[Union[str, dict, TextObject]]] = None, accessory: Union[dict, BlockElement, ForwardRef(None)] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A section is one of the most flexible blocks available. https://api.slack.com/reference/block-kit/blocks#section
Args
block_id
:required
- A string acting as a unique identifier for a block. If not specified, one will be generated. You can use this block_id when you receive an interaction payload to identify the source of the action. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
text
:preferred
- The text for the block, in the form of a text object. Maximum length for the text in this field is 3000 characters. This field is not required if a valid array of fields objects is provided instead.
fields
:required if no text is provided
- Required if no text is provided. An array of text objects. Any text objects included with fields will be rendered in a compact format that allows for 2 columns of side-by-side text. Maximum number of items is 10. Maximum length for the text in each item is 2000 characters.
accessory
- One of the available element objects.
Expand source code
class SectionBlock(Block): type = "section" fields_max_length = 10 text_max_length = 3000 @property def attributes(self) -> Set[str]: return super().attributes.union({"text", "fields", "accessory"}) def __init__( self, *, block_id: Optional[str] = None, text: Optional[Union[str, dict, TextObject]] = None, fields: Optional[Sequence[Union[str, dict, TextObject]]] = None, accessory: Optional[Union[dict, BlockElement]] = None, **others: dict, ): """A section is one of the most flexible blocks available. https://api.slack.com/reference/block-kit/blocks#section Args: block_id (required): A string acting as a unique identifier for a block. If not specified, one will be generated. You can use this block_id when you receive an interaction payload to identify the source of the action. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. text (preferred): The text for the block, in the form of a text object. Maximum length for the text in this field is 3000 characters. This field is not required if a valid array of fields objects is provided instead. fields (required if no text is provided): Required if no text is provided. An array of text objects. Any text objects included with fields will be rendered in a compact format that allows for 2 columns of side-by-side text. Maximum number of items is 10. Maximum length for the text in each item is 2000 characters. accessory: One of the available element objects. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.text = TextObject.parse(text) field_objects = [] for f in fields or []: if isinstance(f, str): field_objects.append(MarkdownTextObject.from_str(f)) elif isinstance(f, TextObject): field_objects.append(f) elif isinstance(f, dict) and "type" in f: d = copy.copy(f) t = d.pop("type") if t == MarkdownTextObject.type: field_objects.append(MarkdownTextObject(**d)) else: field_objects.append(PlainTextObject(**d)) else: self.logger.warning(f"Unsupported filed detected and skipped {f}") self.fields = field_objects self.accessory = BlockElement.parse(accessory) @JsonValidator("text or fields attribute must be specified") def _validate_text_or_fields_populated(self): return self.text is not None or self.fields @JsonValidator(f"fields attribute cannot exceed {fields_max_length} items") def _validate_fields_length(self): return self.fields is None or len(self.fields) <= self.fields_max_length @JsonValidator(f"text attribute cannot exceed {text_max_length} characters") def _validate_alt_text_length(self): return self.text is None or len(self.text.text) <= self.text_max_length
Ancestors
Class variables
var fields_max_length
var text_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union({"text", "fields", "accessory"})
Inherited members
class SelectElement (*, action_id: Optional[str] = None, placeholder: Optional[str] = None, options: Optional[Sequence[Option]] = None, option_groups: Optional[Sequence[OptionGroup]] = None, initial_option: Optional[Option] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This is the simplest form of select menu, with a static list of options passed in when defining the element. https://api.slack.com/reference/block-kit/block-elements#static_select
Args
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
options
:either options
oroption_groups is required
- An array of option objects. Maximum number of options is 100. If option_groups is specified, this field should not be.
option_groups
:either options
oroption_groups is required
- An array of option group objects. Maximum number of option groups is 100. If options is specified, this field should not be.
initial_option
- A single option that exactly matches one of the options or option_groups. This option will be selected when the menu initially loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class SelectElement(InputInteractiveElement): type = "static_select" options_max_length = 100 option_groups_max_length = 100 @property def attributes(self) -> Set[str]: return super().attributes.union({"options", "option_groups", "initial_option"}) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[str] = None, options: Optional[Sequence[Option]] = None, option_groups: Optional[Sequence[OptionGroup]] = None, initial_option: Optional[Option] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """This is the simplest form of select menu, with a static list of options passed in when defining the element. https://api.slack.com/reference/block-kit/block-elements#static_select Args: action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. options (either options or option_groups is required): An array of option objects. Maximum number of options is 100. If option_groups is specified, this field should not be. option_groups (either options or option_groups is required): An array of option group objects. Maximum number of option groups is 100. If options is specified, this field should not be. initial_option: A single option that exactly matches one of the options or option_groups. This option will be selected when the menu initially loads. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.options = options self.option_groups = option_groups self.initial_option = initial_option @JsonValidator(f"options attribute cannot exceed {options_max_length} elements") def _validate_options_length(self) -> bool: return self.options is None or len(self.options) <= self.options_max_length @JsonValidator(f"option_groups attribute cannot exceed {option_groups_max_length} elements") def _validate_option_groups_length(self) -> bool: return self.option_groups is None or len(self.option_groups) <= self.option_groups_max_length @JsonValidator("options and option_groups cannot both be specified") def _validate_options_and_option_groups_both_specified(self) -> bool: return not (self.options is not None and self.option_groups is not None) @JsonValidator("options or option_groups must be specified") def _validate_neither_options_or_option_groups_is_specified(self) -> bool: return self.options is not None or self.option_groups is not None
Ancestors
Class variables
var option_groups_max_length
var options_max_length
var type
Inherited members
class StaticMultiSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, options: Optional[Sequence[Option]] = None, option_groups: Optional[Sequence[OptionGroup]] = None, initial_options: Optional[Sequence[Option]] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This is the simplest form of select menu, with a static list of options passed in when defining the element. https://api.slack.com/reference/block-kit/block-elements#static_multi_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
options
:either options
oroption_groups is required
- An array of option objects. Maximum number of options is 100. If option_groups is specified, this field should not be.
option_groups
:either options
oroption_groups is required
- An array of option group objects. Maximum number of option groups is 100. If options is specified, this field should not be.
initial_options
- An array of option objects that exactly match one or more of the options within options or option_groups. These options will be selected when the menu initially loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted.
max_selected_items
- Specifies the maximum number of items that can be selected in the menu. Minimum number is 1.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class StaticMultiSelectElement(InputInteractiveElement): type = "multi_static_select" options_max_length = 100 option_groups_max_length = 100 @property def attributes(self) -> Set[str]: return super().attributes.union({"options", "option_groups", "initial_options", "max_selected_items"}) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, options: Optional[Sequence[Option]] = None, option_groups: Optional[Sequence[OptionGroup]] = None, initial_options: Optional[Sequence[Option]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This is the simplest form of select menu, with a static list of options passed in when defining the element. https://api.slack.com/reference/block-kit/block-elements#static_multi_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. options (either options or option_groups is required): An array of option objects. Maximum number of options is 100. If option_groups is specified, this field should not be. option_groups (either options or option_groups is required): An array of option group objects. Maximum number of option groups is 100. If options is specified, this field should not be. initial_options: An array of option objects that exactly match one or more of the options within options or option_groups. These options will be selected when the menu initially loads. confirm: A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted. max_selected_items: Specifies the maximum number of items that can be selected in the menu. Minimum number is 1. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.options = Option.parse_all(options) self.option_groups = OptionGroup.parse_all(option_groups) self.initial_options = Option.parse_all(initial_options) self.max_selected_items = max_selected_items @JsonValidator(f"options attribute cannot exceed {options_max_length} elements") def _validate_options_length(self) -> bool: return self.options is None or len(self.options) <= self.options_max_length @JsonValidator(f"option_groups attribute cannot exceed {option_groups_max_length} elements") def _validate_option_groups_length(self) -> bool: return self.option_groups is None or len(self.option_groups) <= self.option_groups_max_length @JsonValidator("options and option_groups cannot both be specified") def _validate_options_and_option_groups_both_specified(self) -> bool: return self.options is None or self.option_groups is None @JsonValidator("options or option_groups must be specified") def _validate_neither_options_or_option_groups_is_specified(self) -> bool: return self.options is not None or self.option_groups is not None
Ancestors
Class variables
var option_groups_max_length
var options_max_length
var type
Inherited members
class StaticSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, options: Optional[Sequence[Union[dict, Option]]] = None, option_groups: Optional[Sequence[Union[dict, OptionGroup]]] = None, initial_option: Union[dict, Option, ForwardRef(None)] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This is the simplest form of select menu, with a static list of options passed in when defining the element. https://api.slack.com/reference/block-kit/block-elements#static_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
options
:either options
oroption_groups is required
- An array of option objects. Maximum number of options is 100. If option_groups is specified, this field should not be.
option_groups
:either options
oroption_groups is required
- An array of option group objects. Maximum number of option groups is 100. If options is specified, this field should not be.
initial_option
- A single option that exactly matches one of the options or option_groups. This option will be selected when the menu initially loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class StaticSelectElement(InputInteractiveElement): type = "static_select" options_max_length = 100 option_groups_max_length = 100 @property def attributes(self) -> Set[str]: return super().attributes.union({"options", "option_groups", "initial_option"}) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, options: Optional[Sequence[Union[dict, Option]]] = None, option_groups: Optional[Sequence[Union[dict, OptionGroup]]] = None, initial_option: Optional[Union[dict, Option]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """This is the simplest form of select menu, with a static list of options passed in when defining the element. https://api.slack.com/reference/block-kit/block-elements#static_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. options (either options or option_groups is required): An array of option objects. Maximum number of options is 100. If option_groups is specified, this field should not be. option_groups (either options or option_groups is required): An array of option group objects. Maximum number of option groups is 100. If options is specified, this field should not be. initial_option: A single option that exactly matches one of the options or option_groups. This option will be selected when the menu initially loads. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.options = options self.option_groups = option_groups self.initial_option = initial_option @JsonValidator(f"options attribute cannot exceed {options_max_length} elements") def _validate_options_length(self) -> bool: return self.options is None or len(self.options) <= self.options_max_length @JsonValidator(f"option_groups attribute cannot exceed {option_groups_max_length} elements") def _validate_option_groups_length(self) -> bool: return self.option_groups is None or len(self.option_groups) <= self.option_groups_max_length @JsonValidator("options and option_groups cannot both be specified") def _validate_options_and_option_groups_both_specified(self) -> bool: return not (self.options is not None and self.option_groups is not None) @JsonValidator("options or option_groups must be specified") def _validate_neither_options_or_option_groups_is_specified(self) -> bool: return self.options is not None or self.option_groups is not None
Ancestors
Class variables
var option_groups_max_length
var options_max_length
var type
Inherited members
class TextObject (text: str, type: Optional[str] = None, subtype: Optional[str] = None, emoji: Optional[bool] = None, **kwargs)
-
The interface for text objects (types: plain_text, mrkdwn)
Super class for new text "objects" used in Block kit
Expand source code
class TextObject(JsonObject): """The interface for text objects (types: plain_text, mrkdwn)""" attributes = {"text", "type", "emoji"} logger = logging.getLogger(__name__) def _subtype_warning(self): # skipcq: PYL-R0201 warnings.warn( "subtype is deprecated since slackclient 2.6.0, use type instead", DeprecationWarning, ) @property def subtype(self) -> Optional[str]: return self.type @classmethod def parse( cls, text: Union[str, Dict[str, Any], "TextObject"], default_type: str = "mrkdwn", ) -> Optional["TextObject"]: if not text: # skipcq: PYL-R1705 return None elif isinstance(text, str): if default_type == PlainTextObject.type: # skipcq: PYL-R1705 return PlainTextObject.from_str(text) else: return MarkdownTextObject.from_str(text) elif isinstance(text, dict): d = copy.copy(text) t = d.pop("type") if t == PlainTextObject.type: # skipcq: PYL-R1705 return PlainTextObject(**d) else: return MarkdownTextObject(**d) elif isinstance(text, TextObject): return text else: cls.logger.warning(f"Unknown type ({type(text)}) detected when parsing a TextObject") return None def __init__( self, text: str, type: Optional[str] = None, # skipcq: PYL-W0622 subtype: Optional[str] = None, emoji: Optional[bool] = None, **kwargs, ): """Super class for new text "objects" used in Block kit""" if subtype: self._subtype_warning() self.text = text self.type = type if type else subtype self.emoji = emoji
Ancestors
Subclasses
Class variables
var logger
Static methods
def parse(text: Union[str, Dict[str, Any], ForwardRef('TextObject')], default_type: str = 'mrkdwn') ‑> Optional[TextObject]
Instance variables
prop subtype : Optional[str]
-
Expand source code
@property def subtype(self) -> Optional[str]: return self.type
Inherited members
class TimePickerElement (*, action_id: Optional[str] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, initial_time: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, timezone: Optional[str] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
An element which allows selection of a time of day. On desktop clients, this time picker will take the form of a dropdown list with free-text entry for precise choices. On mobile clients, the time picker will use native time picker UIs. https://api.slack.com/reference/block-kit/block-elements#timepicker
Args
action_id
:required
- An identifier for the action triggered when a time is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
placeholder
- A plain_text only text object that defines the placeholder text shown on the timepicker. Maximum length for the text in this field is 150 characters.
initial_time
- The initial time that is selected when the element is loaded. This should be in the format HH:mm, where HH is the 24-hour format of an hour (00 to 23) and mm is minutes with leading zeros (00 to 59), for example 22:25 for 10:25pm.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a time is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
timezone
- The timezone to consider for this input value.
Expand source code
class TimePickerElement(InputInteractiveElement): type = "timepicker" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_time", "timezone"}) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_time: Optional[str] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, timezone: Optional[str] = None, **others: dict, ): """ An element which allows selection of a time of day. On desktop clients, this time picker will take the form of a dropdown list with free-text entry for precise choices. On mobile clients, the time picker will use native time picker UIs. https://api.slack.com/reference/block-kit/block-elements#timepicker Args: action_id (required): An identifier for the action triggered when a time is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. placeholder: A plain_text only text object that defines the placeholder text shown on the timepicker. Maximum length for the text in this field is 150 characters. initial_time: The initial time that is selected when the element is loaded. This should be in the format HH:mm, where HH is the 24-hour format of an hour (00 to 23) and mm is minutes with leading zeros (00 to 59), for example 22:25 for 10:25pm. confirm: A confirm object that defines an optional confirmation dialog that appears after a time is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. timezone: The timezone to consider for this input value. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_time = initial_time self.timezone = timezone @JsonValidator("initial_time attribute must be in format 'HH:mm'") def _validate_initial_time_valid(self) -> bool: return self.initial_time is None or re.match(r"([0-1][0-9]|2[0-3]):([0-5][0-9])", self.initial_time) is not None
Ancestors
Class variables
var type
Inherited members
class UrlInputElement (*, action_id: Optional[str] = None, initial_value: Optional[str] = None, dispatch_action_config: Union[dict, DispatchActionConfig, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
A URL input element, similar to the Plain-text input element, creates a single line field where a user can enter URL-encoded data. https://api.slack.com/reference/block-kit/block-elements#url
Args
action_id
:required
- An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_value
- The initial value in the URL input when it is loaded.
dispatch_action_config
- A dispatch configuration object that determines when during text input the element returns a block_actions payload.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
placeholder
- A plain_text only text object that defines the placeholder text shown in the URL input. Maximum length for the text in this field is 150 characters.
Expand source code
class UrlInputElement(InputInteractiveElement): type = "url_text_input" @property def attributes(self) -> Set[str]: return super().attributes.union( { "initial_value", "dispatch_action_config", } ) def __init__( self, *, action_id: Optional[str] = None, initial_value: Optional[str] = None, dispatch_action_config: Optional[Union[dict, DispatchActionConfig]] = None, focus_on_load: Optional[bool] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, **others: dict, ): """ A URL input element, similar to the Plain-text input element, creates a single line field where a user can enter URL-encoded data. https://api.slack.com/reference/block-kit/block-elements#url Args: action_id (required): An identifier for the input value when the parent modal is submitted. You can use this when you receive a view_submission payload to identify the value of the input element. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_value: The initial value in the URL input when it is loaded. dispatch_action_config: A dispatch configuration object that determines when during text input the element returns a block_actions payload. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. placeholder: A plain_text only text object that defines the placeholder text shown in the URL input. Maximum length for the text in this field is 150 characters. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_value = initial_value self.dispatch_action_config = dispatch_action_config
Ancestors
Class variables
var type
Inherited members
class UserMultiSelectElement (*, action_id: Optional[str] = None, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, initial_users: Optional[Sequence[str]] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This select menu will populate its options with a list of Slack users visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#users_multi_select
Args
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
initial_users
- An array of user IDs of any valid users to be pre-selected when the menu loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted.
max_selected_items
- Specifies the maximum number of items that can be selected in the menu. Minimum number is 1.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class UserMultiSelectElement(InputInteractiveElement): type = "multi_users_select" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_users", "max_selected_items"}) def __init__( self, *, action_id: Optional[str] = None, placeholder: Optional[Union[str, dict, TextObject]] = None, initial_users: Optional[Sequence[str]] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, max_selected_items: Optional[int] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This select menu will populate its options with a list of Slack users visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#users_multi_select Args: action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. initial_users: An array of user IDs of any valid users to be pre-selected when the menu loads. confirm: A confirm object that defines an optional confirmation dialog that appears before the multi-select choices are submitted. max_selected_items: Specifies the maximum number of items that can be selected in the menu. Minimum number is 1. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_users = initial_users self.max_selected_items = max_selected_items
Ancestors
Class variables
var type
Inherited members
class UserSelectElement (*, placeholder: Union[str, dict, TextObject, ForwardRef(None)] = None, action_id: Optional[str] = None, initial_user: Optional[str] = None, confirm: Union[dict, ConfirmObject, ForwardRef(None)] = None, focus_on_load: Optional[bool] = None, **others: dict)
-
Block Elements are things that exists inside of your Blocks. https://api.slack.com/reference/block-kit/block-elements
This select menu will populate its options with a list of Slack users visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#users_select
Args
placeholder
:required
- A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.
action_id
:required
- An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters.
initial_user
- The user ID of any valid user to be pre-selected when the menu loads.
confirm
- A confirm object that defines an optional confirmation dialog that appears after a menu item is selected.
focus_on_load
- Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false.
Expand source code
class UserSelectElement(InputInteractiveElement): type = "users_select" @property def attributes(self) -> Set[str]: return super().attributes.union({"initial_user"}) def __init__( self, *, placeholder: Optional[Union[str, dict, TextObject]] = None, action_id: Optional[str] = None, initial_user: Optional[str] = None, confirm: Optional[Union[dict, ConfirmObject]] = None, focus_on_load: Optional[bool] = None, **others: dict, ): """ This select menu will populate its options with a list of Slack users visible to the current user in the active workspace. https://api.slack.com/reference/block-kit/block-elements#users_select Args: placeholder (required): A plain_text only text object that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters. action_id (required): An identifier for the action triggered when a menu option is selected. You can use this when you receive an interaction payload to identify the source of the action. Should be unique among all other action_ids in the containing block. Maximum length for this field is 255 characters. initial_user: The user ID of any valid user to be pre-selected when the menu loads. confirm: A confirm object that defines an optional confirmation dialog that appears after a menu item is selected. focus_on_load: Indicates whether the element will be set to auto focus within the view object. Only one element can be set to true. Defaults to false. """ super().__init__( type=self.type, action_id=action_id, placeholder=TextObject.parse(placeholder, PlainTextObject.type), confirm=ConfirmObject.parse(confirm), focus_on_load=focus_on_load, ) show_unknown_key_warning(self, others) self.initial_user = initial_user
Ancestors
Class variables
var type
Inherited members
class VideoBlock (*, block_id: Optional[str] = None, alt_text: Optional[str] = None, video_url: Optional[str] = None, thumbnail_url: Optional[str] = None, title: Union[str, dict, PlainTextObject, ForwardRef(None)] = None, title_url: Optional[str] = None, description: Union[str, dict, PlainTextObject, ForwardRef(None)] = None, provider_icon_url: Optional[str] = None, provider_name: Optional[str] = None, author_name: Optional[str] = None, **others: dict)
-
Blocks are a series of components that can be combined to create visually rich and compellingly interactive messages. https://api.slack.com/reference/block-kit/blocks
A video block is designed to embed videos in all app surfaces (e.g. link unfurls, messages, modals, App Home) — anywhere you can put blocks! To use the video block within your app, you must have the links.embed:write scope. https://api.slack.com/reference/block-kit/blocks#video
Args
block_id
- A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.
alt_text
:required
- A tooltip for the video. Required for accessibility
video_url
:required
- The URL to be embedded. Must match any existing unfurl domains within the app and point to a HTTPS URL.
thumbnail_url
:required
- The thumbnail image URL
title
:required
- Video title in plain text format. Must be less than 200 characters.
title_url
- Hyperlink for the title text. Must correspond to the non-embeddable URL for the video. Must go to an HTTPS URL.
description
- Description for video in plain text format.
provider_icon_url
- Icon for the video provider - ex. Youtube icon
provider_name
- The originating application or domain of the video ex. Youtube
author_name
- Author name to be displayed. Must be less than 50 characters.
Expand source code
class VideoBlock(Block): type = "video" title_max_length = 200 author_name_max_length = 50 @property def attributes(self) -> Set[str]: return super().attributes.union( { "alt_text", "video_url", "thumbnail_url", "title", "title_url", "description", "provider_icon_url", "provider_name", "author_name", } ) def __init__( self, *, block_id: Optional[str] = None, alt_text: Optional[str] = None, video_url: Optional[str] = None, thumbnail_url: Optional[str] = None, title: Optional[Union[str, dict, PlainTextObject]] = None, title_url: Optional[str] = None, description: Optional[Union[str, dict, PlainTextObject]] = None, provider_icon_url: Optional[str] = None, provider_name: Optional[str] = None, author_name: Optional[str] = None, **others: dict, ): """A video block is designed to embed videos in all app surfaces (e.g. link unfurls, messages, modals, App Home) — anywhere you can put blocks! To use the video block within your app, you must have the links.embed:write scope. https://api.slack.com/reference/block-kit/blocks#video Args: block_id: A string acting as a unique identifier for a block. If not specified, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id. alt_text (required): A tooltip for the video. Required for accessibility video_url (required): The URL to be embedded. Must match any existing unfurl domains within the app and point to a HTTPS URL. thumbnail_url (required): The thumbnail image URL title (required): Video title in plain text format. Must be less than 200 characters. title_url: Hyperlink for the title text. Must correspond to the non-embeddable URL for the video. Must go to an HTTPS URL. description: Description for video in plain text format. provider_icon_url: Icon for the video provider - ex. Youtube icon provider_name: The originating application or domain of the video ex. Youtube author_name: Author name to be displayed. Must be less than 50 characters. """ super().__init__(type=self.type, block_id=block_id) show_unknown_key_warning(self, others) self.alt_text = alt_text self.video_url = video_url self.thumbnail_url = thumbnail_url self.title = TextObject.parse(title, default_type=PlainTextObject.type) self.title_url = title_url self.description = TextObject.parse(description, default_type=PlainTextObject.type) self.provider_icon_url = provider_icon_url self.provider_name = provider_name self.author_name = author_name @JsonValidator("alt_text attribute must be specified") def _validate_alt_text(self): return self.alt_text is not None @JsonValidator("video_url attribute must be specified") def _validate_video_url(self): return self.video_url is not None @JsonValidator("thumbnail_url attribute must be specified") def _validate_thumbnail_url(self): return self.thumbnail_url is not None @JsonValidator("title attribute must be specified") def _validate_title(self): return self.title is not None @JsonValidator(f"title attribute cannot exceed {title_max_length} characters") def _validate_title_length(self): return self.title is None or len(self.title.text) < self.title_max_length @JsonValidator(f"author_name attribute cannot exceed {author_name_max_length} characters") def _validate_author_name_length(self): return self.author_name is None or len(self.author_name) < self.author_name_max_length
Ancestors
Class variables
var title_max_length
var type
Instance variables
prop attributes : Set[str]
-
set() -> new empty set object set(iterable) -> new set object
Build an unordered collection of unique elements.
Expand source code
@property def attributes(self) -> Set[str]: return super().attributes.union( { "alt_text", "video_url", "thumbnail_url", "title", "title_url", "description", "provider_icon_url", "provider_name", "author_name", } )
Inherited members