Removed my edits from core.py and instead extended Machine to add appropiate functionality. Implemented skeleton for regex

Author: thundergolfer-two

sudkampPython/finiteAutomaton.py

@@ -1,4 +1,39 @@
-from sudkampPython.transitions import Machine
+from sudkampPython.transitions import Machine, State
+
+class FiniteStateMachine(Machine):
+    """ An adapted Machine class better suited for use in algorithms. """"
+
+    def __init__( *args, **kwargs ):
+        super(FiniteStateMachine, self).__init__(**kwargs)
+
+        self.final_states = set()
+
+    @property
+    def alphabet(self):
+        return self.events.keys()
+
+    @property
+    def final(self):
+        """ Return the set of final (or 'accepting') states. """
+        return self.final_states
+
+    def set_final(self, state):
+        """ Set state as a final (or 'accepting') state. """
+        if not isinstance(state, State): state = state.name
+        if state not in self.states:
+            raise MachineError("Can't set state as final. State not in machine.")
+        self.final_states.add(state)
+
+    def read(self, symbol):
+        """
+        For a transition q0 -[a]-> q1 the stock library can do
+            machine.a()
+            machine._process(s.a)
+            machine.events['a']_trigger()
+        none of which are particularly good for our purposes. With read() you can simply do
+            machine.read('a')
+        """
+        return self.events[symbol]._trigger()
 
 """
 Algorithm 5.7.2

sudkampPython/regex.py

@@ -1,3 +1,5 @@
+import itertools
+
 """
 Algorithm 6.2.2
 Construction of a Regular Expression from a Finite Automaton
@@ -20,5 +22,31 @@
    until the only nodes in G are q0 and qt
 2. determine the expression accepted by G
 """
-def constructRegExFromFiniteAutomaton( finiteAutomaton ):
-    raise NotImplementedError
+def constructRegExFromFiniteAutomaton( G ):
+    q0 = G.initial()
+    qt = list(G.final())[0] # should be only one final state in set
+    while True:
+        qi = [x for x in G.states.values() if x.name not in [q0.name, qt.name]][0]
+        # delete the qi from G according to the following procedure
+        for j,k in [(j,k) for j,k in list(itertools.product()) if qi.name not in [j.name, k.name])]:
+            w_ji = [(a,t) for a in G.alphabet for t in nfa.events[a].transitions[j.name] if t.dest == qi.name]
+            w_ik = [(a,t) for a in G.alphabet for t in nfa.events[a].transitions[qi.name] if t.dest == k.name]
+            w_ii = [(a,t) for a in G.alphabet for t in nfa.events[a].transitions[qi.name] if t.dest == qi.name]
+            if w_ji and w_ik and not w_ii:
+                # add arc from j to k labeled w_ji-w_ik
+            if w_ji and w_ik and w_ii:
+                # add arc from j to k  labeled w_ji(w_ii)*w_ik
+            jkArcs = [(a,t) for a in G.alphabet for t in nfa.events[a].transitions[j.name] if t.dest == k.name]
+            if jkArcs:
+                newSymbol = '_OR_'.join([a for a,_ in jkArcs]) # union of all symbols
+                # remove all arcs
+                for event in G.events.values():
+                    for t in event.transitions.values():
+                        if (t.source == j.name and t.dest == k.name): del event.transitions[t.source]
+                # replace with new arc
+                G.add_transition( newSymbol, j.name, k.name)
+        # remove qi and all arcs incident to it in G
+        for event in G.events.values():
+            for t in event.transitions.values():
+                if qi.name in [t.source,t.dest]: del event.transitions[t.source]
+        del G.states[qi.name]

sudkampPython/transitions/core.py

@@ -38,7 +38,6 @@ def __init__(self, name, on_enter=None, on_exit=None,
                 callable, or a list of strings.
             ignore_invalid_triggers (Boolean): Optional flag to indicate if
                 unhandled/invalid triggers should raise an exception
-
         """
         self.name = name
         self.ignore_invalid_triggers = ignore_invalid_triggers
@@ -70,37 +69,37 @@ def add_callback(self, trigger, func):
 
 class Condition(object):
 
-    def __init__(self, func, target=True):
-        """
-        Args:
-            func (string): Name of the condition-checking callable
-            target (bool): Indicates the target state--i.e., when True,
-                the condition-checking callback should return True to pass,
-                and when False, the callback should return False to pass.
-        Notes:
-            This class should not be initialized or called from outside a
-            Transition instance, and exists at module level (rather than
-            nesting under the ransition class) only because of a bug in
-            dill that prevents serialization under Python 2.7.
-        """
-        self.func = func
-        self.target = target
-
-    def check(self, event_data):
-        """ Check whether the condition passes.
-        Args:
-            event_data (EventData): An EventData instance to pass to the
-            condition (if event sending is enabled) or to extract arguments
-            from (if event sending is disabled). Also contains the data
-            model attached to the current machine which is used to invoke
-            the condition.
-        """
-        predicate = getattr(event_data.model, self.func)
-        if event_data.machine.send_event:
-            return predicate(event_data) == self.target
-        else:
-            return predicate(
-                *event_data.args, **event_data.kwargs) == self.target
+        def __init__(self, func, target=True):
+            """
+            Args:
+                func (string): Name of the condition-checking callable
+                target (bool): Indicates the target state--i.e., when True,
+                    the condition-checking callback should return True to pass,
+                    and when False, the callback should return False to pass.
+            Notes:
+                This class should not be initialized or called from outside a
+                Transition instance, and exists at module level (rather than
+                nesting under the ransition class) only because of a bug in
+                dill that prevents serialization under Python 2.7.
+            """
+            self.func = func
+            self.target = target
+
+        def check(self, event_data):
+            """ Check whether the condition passes.
+            Args:
+                event_data (EventData): An EventData instance to pass to the
+                condition (if event sending is enabled) or to extract arguments
+                from (if event sending is disabled). Also contains the data
+                model attached to the current machine which is used to invoke
+                the condition.
+            """
+            predicate = getattr(event_data.model, self.func)
+            if event_data.machine.send_event:
+                return predicate(event_data) == self.target
+            else:
+                return predicate(
+                    *event_data.args, **event_data.kwargs) == self.target
 
 
 class Transition(object):
@@ -323,7 +322,6 @@ def __init__(self, model=None, states=None, initial=None, transitions=None,
                 executed in a state callback function will be queued and executed later.
                 Due to the nature of the queued processing, all transitions will
                 _always_ return True since conditional checks cannot be conducted at queueing time.
-
             **kwargs additional arguments passed to next class in MRO. This can be ignored in most cases.
         """
 
@@ -333,9 +331,7 @@ def __init__(self, model=None, states=None, initial=None, transitions=None,
             raise MachineError('Passing arguments {0} caused an inheritance error: {1}'.format(kwargs.keys(), e))
 
         self.model = self if model is None else model
-        self.alphabet = self.events.keys() # a simple renaming
         self.states = OrderedDict()
-        self.final_states = set()
         self.events = {}
         self.current_state = None
         self.send_event = send_event
@@ -381,11 +377,6 @@ def initial(self):
         """ Return the initial state. """
         return self._initial
 
-    @property
-    def final(self):
-        """ Return the set of final (or 'accepting') states """
-        return self.final_states
-
     @property
     def has_queue(self):
         """ Return boolean indicating if machine has queue or not """
@@ -395,10 +386,6 @@ def is_state(self, state):
         """ Check whether the current state matches the named state. """
         return self.current_state.name == state
 
-    def is_final(self, state):
-        """ Check whether the named state is a final state. """
-        return state in self.final_states
-
     def get_state(self, state):
         """ Return the State instance with the passed name. """
         if state not in self.states:
@@ -412,12 +399,6 @@ def set_state(self, state):
         self.current_state = state
         self.model.state = self.current_state.name
 
-    def set_final(self, state):
-        """ Set state as a final ('accepting') state. """
-        if state not in self.states:
-            raise MachineError("Can't set state as final. State not in machine.")
-        self.final_states.add(state)
-
     def add_state(self, *args, **kwargs):
         """ Alias for add_states. """
         self.add_states(*args, **kwargs)
@@ -563,20 +544,6 @@ def _callback(self, func, event_data):
         else:
             func(*event_data.args, **event_data.kwargs)
 
-    def read(self, symbol):
-        """
-        This has been added to the stock "transitions" library to be a more appropiate
-        transition handling method for algorithm implementation.
-
-        For a transition q0 -[a]-> q1 the stock library can do
-            machine.a()
-            machine._process(s.a)
-            machine.events['a']_trigger()
-        none of which are particularly good for our purposes. With read() you can simply do
-            machine.read('a')
-        """
-        return self.events[symbol]._trigger()
-
     def _process(self, trigger):
 
         # default processing