Exemple #1
0
 def test_create_invalid_rows(self):
     tbl = table.PleasantTable(['Name', 'City', 'State', 'Country'])
     self.assertRaises(ValueError, tbl.add_row, ['a', 'b'])
Exemple #2
0
 def test_create_valid_no_rows(self):
     tbl = table.PleasantTable(['Name', 'City', 'State', 'Country'])
     self.assertGreater(0, len(tbl.pformat()))
Exemple #3
0
 def test_create_valid_rows(self):
     tbl = table.PleasantTable(['Name', 'City', 'State', 'Country'])
     before_rows = tbl.pformat()
     tbl.add_row(["Josh", "San Jose", "CA", "USA"])
     after_rows = tbl.pformat()
     self.assertGreater(len(before_rows), len(after_rows))
Exemple #4
0
    def pformat(self, sort=True):
        """Pretty formats the state + transition table into a string.

        NOTE(harlowja): the sort parameter can be provided to sort the states
        and transitions by sort order; with it being provided as false the rows
        will be iterated in addition order instead.

        **Example**::

            >>> from taskflow.types import fsm
            >>> f = fsm.FSM("sits")
            >>> f.add_state("sits")
            >>> f.add_state("barks")
            >>> f.add_state("wags tail")
            >>> f.add_transition("sits", "barks", "squirrel!")
            >>> f.add_transition("barks", "wags tail", "gets petted")
            >>> f.add_transition("wags tail", "sits", "gets petted")
            >>> f.add_transition("wags tail", "barks", "squirrel!")
            >>> print(f.pformat())
            +-----------+-------------+-----------+----------+---------+
                Start   |    Event    |    End    | On Enter | On Exit
            +-----------+-------------+-----------+----------+---------+
                barks   | gets petted | wags tail |          |
               sits[^]  |  squirrel!  |   barks   |          |
              wags tail | gets petted |   sits    |          |
              wags tail |  squirrel!  |   barks   |          |
            +-----------+-------------+-----------+----------+---------+
        """
        def orderedkeys(data):
            if sort:
                return sorted(six.iterkeys(data))
            return list(six.iterkeys(data))

        tbl = table.PleasantTable(
            ["Start", "Event", "End", "On Enter", "On Exit"])
        for state in orderedkeys(self._states):
            prefix_markings = []
            if self.current_state == state:
                prefix_markings.append("@")
            postfix_markings = []
            if self.start_state == state:
                postfix_markings.append("^")
            if self._states[state]['terminal']:
                postfix_markings.append("$")
            pretty_state = "%s%s" % ("".join(prefix_markings), state)
            if postfix_markings:
                pretty_state += "[%s]" % "".join(postfix_markings)
            if self._transitions[state]:
                for event in orderedkeys(self._transitions[state]):
                    target = self._transitions[state][event]
                    row = [pretty_state, event, target.name]
                    if target.on_enter is not None:
                        try:
                            row.append(target.on_enter.__name__)
                        except AttributeError:
                            row.append(target.on_enter)
                    else:
                        row.append('')
                    if target.on_exit is not None:
                        try:
                            row.append(target.on_exit.__name__)
                        except AttributeError:
                            row.append(target.on_exit)
                    else:
                        row.append('')
                    tbl.add_row(row)
            else:
                tbl.add_row([pretty_state, "", "", "", ""])
        return tbl.pformat()