Initialize the types of labelings on states and edges.

Label types by example

Use a dict for each label type you want to define, like this:

>>> types = [
        {'name': 'drink',
         'values': {'tea', 'coffee'},
         'setter': True,
         'default': 'tea'},
    ]

This will create a label type named 'drink' that can take the values 'tea' and 'coffee'.

Assuming this label type applies to nodes, you can now label a new node as:

>>> g = LabeledDiGraph(types)
>>> g.add_node(1, drink='coffee')

If you omit the label when adding a new node, it gets the default value:

>>> g.add_node(2)
>>> g.node[2]
{'drink': 'tea'}

The main difference with vanilla networkx is that the dict above includes type checking:

>>> type(g.node[2])
tulip.transys.mathset.TypedDict

The 'setter' key with value True creates also a field g.drink. Be careful to avoid name conflicts with existing networkx MultiDiGraph attributes.

This allows us to add more values after creating the graph:

>>> g.drink
{'coffee', 'tea'}
>>> g.drink.add('water')
{'coffee', 'tea', 'water'}

Finally, the graph will prevent us from accidentally using an untyped label name, by raising an AttributeError:

>>> g.add_node(3, day='Jan')
AttributeError: ...

To add untyped labels, do so explicitly:

>>> g.add_node(3, day='Jan', check=False)
>>> g.node[3]
{'day': 'Jan', 'drink': 'tea'}

Details on label types

Each label type is defined by a dict that must have the keys 'name' and 'values':

• 'name': with str value
• 'values' : B implements __contains__ used to check label validity.

  If you want the codomain B to be extensible even after initialization, it must implement method add.

and optionally the keys:

• 'setter': C with 3 possibilities:
  • if absent, then no setter attribute is created
  • otherwise an attribute self.A is created, pointing at:
    • the given co-domain B if C is True
    • C, otherwise.
• 'default': d is a value in B to be returned for node and edge labels not yet explicitly specified by the user.

Parameters:

• node_label_types - applies to nodes, as described above.
• edge_label_types - applies to edges, as described above.
• deterministic - if True, then edge-label-deterministic

Overrides: object.__init__

(inherited documentation)

Get informal string representation.

Overrides: object.__str__

Add new outputs.

Parameters:

• new_outputs (dict) - dict of pairs {port_name : port_type} where:
  • port_name: str
  • port_type: Iterable | check class
• masks (dict of functions keys are port_names (see arg: new_outputs) each function returns bool) - custom mask functions, for each sublabel based on its current value each such function returns:
  • True, if the sublabel should be shown
  • False, otherwise (to hide it)

Return next state and output, when reacting to given inputs.

The machine must be deterministic. (for each state and input at most a single transition enabled, this notion does not coincide with output-determinism)

Not exactly a wrapper of Transitions.find, because it matches only that part of an edge label that corresponds to the inputs.

Parameters:

• from_state (element of self.states) - transition starts from this state.
• inputs ({'port_name':port_value, ...}) - dict assigning a valid value to each input port.

Returns: (outputs, next_state) where outputs: {'port_name':port_value, ...}

output values and next state.

Guided or interactive run.

Parameters:

• input_sequences - if None, then call interactive_run, otherwise call guided_run.

Returns:

output of guided_run, otherwise None.