add comparisons to automatabpp

Decided to add comparisons within the module itself

Author: grimar2008

README.md

@@ -88,7 +88,6 @@ I also recommend using **Python 3.4+** although I haven't even tried it yet on t
 ### Directories
 
 * **./automatabpp** - our module source code. This directory contains the python code for this project.
-* **./comparisons** - a small module which offers some lambda comparison functions you can use with this project.
 * **./graphs** - yEd graphs are stored in this directory by default
 * **./README** - I've really took my time to write all of this so I would appreciate you checking it out
 

README/FSM.md

@@ -4,8 +4,8 @@ I won't cover too much how the code is written but rather how to use it.
 
 Once we `import automatabpp` into our python script we can use the following 4 classes.
 
-| [OPERATION](#operation) | [BEHAVIOUR](#behaviour) | [EXECUTION](#execution) | [INTERFACE](#interface) |
-| --- | --- | --- | --- |
+| [OPERATION](#operation) | [BEHAVIOUR](#behaviour) | [EXECUTION](#execution) | [INTERFACE](#interface) | [COMPARISONS](#comparisons) |
+| --- | --- | --- | --- | --- |
 
 
 ### OPERATION
@@ -45,6 +45,21 @@ INTERFACE.run_command_if_lambda_on_result_true(lambda_function, command)
 # When the function decorated with this function is called, the command will be run if the lambda on result is True
 ```
 
+### COMPARISONS
+A helper class with lots of comparison `lambda` type functions. Can only return `True` or `False` .
+```python
+COMPARISONS.less_than(num)
+COMPARISONS.between(num1, num2)
+COMPARISONS.more_than(num)
+COMPARISONS.equal(num)
+COMPARISONS.not_equal(num)
+COMPARISONS.contains(string)
+COMPARISONS.one_of(items)
+COMPARISONS.none_of(items)
+COMPARISONS.always_true()
+COMPARISONS.on_result_true()
+COMPARISONS.on_result_false()
+```
 
 | [Back to Main][prev] | ----- | [Tutorial][next] |
 | --- | --- | --- |

README/examples/example4.md

@@ -56,7 +56,7 @@ _embedded/fan.graphml_
 
 <img src="../images/examples/example4/machine_fan.png" width="640" height="140" />
 
-These graphs will only serve as an endpoint for our execution functions. One thing to notice is that you can only turn on the device once. There is no possibility of turning the device again while it is already turned on.
+These graphs will only serve as an endpoint for our execution functions. One thing to notice is that you can only turn on the device once. There is no possibility of turning the device on again while it is already in that state.
 <br>Since the default state for LED light is to always be on we will set it to be on while starting.
 
 Now let's draw the behaviour of our components.
@@ -87,7 +87,6 @@ You can check the code in the [example4.py][pycode] script.
 - First let's take care of importing everything we will need:
     ```python
     from automatabpp import *
-    from comparisons import COMPARISONS # a helper class for comparison lambda functions
     import math, time                   # we'll use this to simulate our readings
     ```
 
@@ -166,9 +165,15 @@ You can check the code in the [example4.py][pycode] script.
       temp = round(simulate_temperature_reading(i), 2)          # simulate reading the temperature sensor
       print("\t\t|\t{}V\t|\t{}°C".format(volt, temp))
       OPERATION.run_fsm()                                       # run commands left in the CommandQueue
-      time.sleep(1)
+      time.sleep(2)
   ```
 
+Run the script and check how our simulated device behaves. Is the behaviour the same as in the requirements?
+
+```console
+user@computer:~$ python example4.py
+```
+
 The rest of the code doesn't ever need to care about the behaviour of our components. The only thing that we need to do is read the sensor from time to time and run the commands left in the CommandQueue and the automatabpp will take care of everything else.
 <br>Our code has just gotten a lot simpler after this and we can take care of whichever other things we want to do in the application.
 

README/other.md

@@ -11,5 +11,6 @@ Just keeping a list of things that I could add to the module.
 * add encryption support
 * add compression support
 * add more graph file extensions support
+* add more comparisons
 
 [Back to Main](../README.md)

automatabpp/__init__.py

@@ -1,12 +1,13 @@
-__all__ = ["logger", "BEHAVIOUR", "EXECUTION", "OPERATION", "INTERFACE"]
+__all__ = ["BEHAVIOUR", "EXECUTION", "OPERATION", "INTERFACE", "COMPARISONS"]
 
 import logging
-logger = logging.getLogger(__name__)
+automata_bpp_logger = logging.getLogger(__name__)
 
 from . machines.machines import Machines
 from . xml.xmlread import read_graphml
 from . commandqueue.commandqueue import CommandQueue
 from . constants import GRAPHS_DIRECTORY, START_COMMAND_NAME, STOP_COMMAND_NAME
+from . comparisons.comparisons import COMPARISONS
 
 from functools import wraps
 
@@ -25,7 +26,7 @@ def load_behaviour_from_graph(graph_file_path: str, machine_name: str):
         if graph_file_path[-8:] == ".graphml":
             read_graphml("{}/{}".format(GRAPHS_DIRECTORY, graph_file_path), machine_name)
         else:
-            logger.warning("Unknown format for reading the graph file: {}".format(graph_file_path))
+            automata_bpp_logger.warning("Unknown format for reading the graph file: {}".format(graph_file_path))
 
 
 class EXECUTION:

automatabpp/commandqueue/commandqueue.py

@@ -1,4 +1,4 @@
-from automatabpp import logger
+from automatabpp import automata_bpp_logger
 from automatabpp.metaclasses.singleton import Singleton
 
 
@@ -19,7 +19,7 @@ def GetNextCommand(self):
     def PushCommandsToQueue(self, commands: str):
         for cmd in commands.split(CommandQueue.SEPARATOR):
             if len(cmd) > 0:
-                logger.debug("++++++> {} pushed to CommandQueue <++++++".format(cmd))
+                automata_bpp_logger.debug("++++++> {} pushed to CommandQueue <++++++".format(cmd))
                 self.__list_of_cmds_to_execute.append(cmd)
 
     def EmptyAllCommands(self):

comparisons/__init__.py renamed to automatabpp/comparisons/comparisons.py

@@ -25,11 +25,11 @@ def contains(string: str):
         return lambda x: x.count(string) > 0
 
     @staticmethod
-    def one_of(items: str):
+    def one_of(items):
         return lambda x: x in items
 
     @staticmethod
-    def none_of(items: str):
+    def none_of(items):
         return lambda x: x not in items
 
     @staticmethod

automatabpp/machine/machine.py

@@ -1,4 +1,4 @@
-from automatabpp import logger
+from automatabpp import automata_bpp_logger
 from automatabpp.state.state import State
 from automatabpp.constants import START_STATE_NAME
 
@@ -28,7 +28,7 @@ def SetExecuteStateFunction(self, state_name: str, callback: callable):
     def ExecuteTransition(self, command: str):
         st_after_name = self.curr_state.GetNextStateWithTransition(command)
         if st_after_name is not None:
-            logger.debug("{}: state change {}->{}".format(self.machine_name, self.curr_state.GetName(), st_after_name))
+            automata_bpp_logger.debug("{}: state change {}->{}".format(self.machine_name, self.curr_state.GetName(), st_after_name))
             self.curr_state = self.GetStateWithName(st_after_name)
             self.curr_state.ExecuteState(command)
             return True

automatabpp/machines/machines.py

@@ -1,4 +1,4 @@
-from automatabpp import logger
+from automatabpp import automata_bpp_logger
 from automatabpp.metaclasses.singleton import Singleton
 from automatabpp.machine.machine import Machine
 from automatabpp.commandqueue.commandqueue import CommandQueue
@@ -27,7 +27,7 @@ def ExecuteAllCommands(self):                   # Should be used as default
             self.ExecuteNextCommand()
 
     def ExecuteCommand(self, command: str):         # Not recommended if states can execute commands
-        logger.debug("Executing command [{}]".format(command))
+        automata_bpp_logger.debug("Executing command [{}]".format(command))
         for machine in self.__list_of_machines:
             machine.ExecuteTransition(command)
 

automatabpp/state/state.py

@@ -1,11 +1,11 @@
-from automatabpp import logger
+from automatabpp import automata_bpp_logger
 from automatabpp.commandqueue.commandqueue import CommandQueue
 
 
 class State(object):
 
     def __not_defined(self, **_):
-        logger.debug("Machine:State [{}:{}] Execution not defined".format(self.machine_name, self.state_name))
+        automata_bpp_logger.debug("Machine:State [{}:{}] Execution not defined".format(self.machine_name, self.state_name))
 
     def __init__(self, state_name: str, machine_name: str):
         self.machine_name = machine_name