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

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#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.
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

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

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

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

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

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: Union[Dict[str, Any], ForwardRef('RichTextBlock'), ForwardRef(None)] = 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__(  # type: ignore
        self,
        *,
        action_id: Optional[str] = None,
        placeholder: Optional[Union[str, dict, TextObject]] = None,
        # To avoid circular imports, the RichTextBlock type here is intentionally a string
        initial_value: Optional[Union[Dict[str, Any], "RichTextBlock"]] = None,  # noqa: F821
        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 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.
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 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.
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 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.
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 author_name_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",
            "video_url",
            "thumbnail_url",
            "title",
            "title_url",
            "description",
            "provider_icon_url",
            "provider_name",
            "author_name",
        }
    )

Inherited members