errbot.flow module

class errbot.flow.BotFlow(bot)[source]

Bases: yapsy.IPlugin.IPlugin

Defines a Flow plugin ie. a plugin that will define new flows from its methods with the @botflow decorator.

__init__(bot)[source]
activate() → None[source]

Override if you want to do something at initialization phase (don't forget to super(Gnagna, self).activate())

deactivate() → None[source]

Override if you want to do something at tear down phase (don't forget to super(Gnagna, self).deactivate())

get_command(command_name: str)[source]

Helper to get a specific command.

errbot.flow.FLOW_END = <errbot.flow._FlowEnd object>

Flow marker indicating that the flow ends.

class errbot.flow.Flow(root: errbot.flow.FlowRoot, requestor: errbot.backends.base.Identifier, initial_context: typing.Mapping)[source]

Bases: object

This is a live Flow. It keeps context of the conversation (requestor and context). Context is just a python dictionary representing the state of the conversation.

__init__(root: errbot.flow.FlowRoot, requestor: errbot.backends.base.Identifier, initial_context: typing.Mapping)[source]
Parameters:
  • root (FlowRoot) -- the root of this flow.
  • requestor (Identifier) -- the user requesting this flow.
  • initial_context (Mapping) -- any data we already have that could help executing this flow automatically.
advance(next_step: errbot.flow.FlowNode, enforce_predicate=True)[source]

Move on along the flow. :type enforce_predicate: bool :type next_step: FlowNode :param next_step: Which node you want to move the flow forward to. :param enforce_predicate: Do you want to check if the predicate is verified for this step or not.

Usually, if it is a manual step, the predicate is irrelevant because the user will give the missing information as parameters to the command.
check_identifier(identifier: errbot.backends.base.Identifier)[source]
current_step

The current step this Flow is waiting on.

name

Helper property to get the name of the flow.

next_autosteps() → typing.List[source]

Get the next steps that can be automatically executed according to the set predicates.

next_steps() → typing.List[source]

Get all the possible next steps after this one (predicates statisfied or not).

root

The original flowroot of this flow.

class errbot.flow.FlowExecutor(bot)[source]

Bases: object

This is a instance that can monitor and execute flow instances.

__init__(bot)[source]
add_flow(flow: errbot.flow.FlowRoot)[source]

Register a flow with this executor.

check_inflight_already_running(user: errbot.backends.base.Identifier) → bool[source]
Check if user is already running a flow.
Return type:bool
Parameters:user (Identifier) -- the user
check_inflight_flow_triggered(cmd: str, user: errbot.backends.base.Identifier) → typing.Tuple[source]

Check if a command from a specific user was expected in one of the running flow. :rtype: Tuple :type user: Identifier :type cmd: str :param cmd: the command that has just been executed. :param user: the identifier of the person who started this flow :returns: The name of the flow it triggered or None if none were matching.

execute(flow: errbot.flow.Flow)[source]

This is where the flow execution happens from one of the thread of the pool.

start_flow(name: str, requestor: errbot.backends.base.Identifier, initial_context: typing.Mapping) → errbot.flow.Flow[source]

Starts the execution of a Flow.

stop_flow(name: str, requestor: errbot.backends.base.Identifier) → errbot.flow.Flow[source]

Stops a specific flow. It is a no op if the flow doesn't exist. Returns the stopped flow if found.

trigger(cmd: str, requestor: errbot.backends.base.Identifier, extra_context=None) → errbot.flow.Flow[source]

Trigger workflows that may have command cmd as a auto_trigger or an in flight flow waiting for command. This assume cmd has been correctly executed. :rtype: Flow :type requestor: Identifier :type cmd: str :param requestor: the identifier of the person who started this flow :param cmd: the command that has just been executed. :param extra_context: extra context from the current conversation :returns: The flow it triggered or None if none were matching.

class errbot.flow.FlowNode(command: str=None)[source]

Bases: object

This is a step in a Flow/conversation. It is linked to a specific botcmd and also a "predicate".

The predicate is a function that tells the flow executor if the flow can enter the step without the user intervention (automatically). The predicates defaults to False.

The predicate is a function that takes one parameter, the context of the conversation.

__init__(command: str=None)[source]

Creates a FlowNone, takes the command to which the Node is linked to. :type command: str :param command: the command this Node is linked to. Can only be None if this Node is a Root.

connect(node_or_command: typing.Union[_ForwardRef('FlowNode'), str], predicate: typing.Callable=<function FlowNode.<lambda>>)[source]

Construct the flow graph by connecting this node to another node or a command. The predicate is a function that tells the flow executor if the flow can enter the step without the user intervention (automatically). :type predicate: Callable :param node_or_command: the node or a string for a command you want to connect this Node to

(this node or command will be the follow up of this one)
Parameters:predicate -- function with one parameter, the context, to determine of the flow executor can continue automatically this flow with no user intervention.
Returns:the newly created node if you passed a command or the node you gave it to be easily chainable.
predicate_for_node(node: 'FlowNode')[source]

gets the predicate function for the specified child node. :param node: the child node :return: the predicate that allows the automatic execution of that node.

class errbot.flow.FlowRoot(name: str, description: str)[source]

Bases: errbot.flow.FlowNode

This represent the entry point of a flow description.

__init__(name: str, description: str)[source]
Parameters:
  • name (str) -- The name of the conversation/flow.
  • description (str) -- A human description of what this flow does.
connect(node_or_command: typing.Union[_ForwardRef('FlowNode'), str], predicate: typing.Callable=<function FlowRoot.<lambda>>, auto_trigger: bool=False, room_flow: bool=False)[source]
See:

FlowNode except fot auto_trigger

Parameters:
  • predicate (Callable) --
    see:FlowNode
  • node_or_command --
    see:FlowNode
  • auto_trigger (bool) -- Flag this root as autotriggering: it will start a flow if this command is executed in the chat.
  • room_flow (bool) -- Bind the flow to the room instead of a single person
exception errbot.flow.InvalidState[source]

Bases: Exception

Raised when the Flow Executor is asked to do something contrary to the contraints it has been given.