implemented file configuration for commands and controllers

config/commands.yaml

@@ -1,7 +1,4 @@
-
-controllers:
-    engines_ctrl:
-        target: digilib.pin.EnginesController
-        left: 17,
 commands:
-    turn: engines_ctrl.turn
+    turn:
+        controller: engines_ctrl
+        function: turn

config/controllers.yaml

@@ -0,0 +1,37 @@
+controllers:
+    engines_ctrl:
+        target: digilib.pin.EnginesController
+        left: [4,17]
+        right: [27,22]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#

gui.py

@@ -87,12 +87,8 @@ group_af_family.add_argument(
 )
 args = parser.parse_args()
 if args.debug:
-    with open("config/logging.yaml") as f:
-        data = f.read()
-    config = yaml.safe_load(data)
-    logging.config.dictConfig(config)
-#
-print(args)
+    digilib.misc.load_files("config/logging.yaml",logging.config.dictConfig)
+
 win = beewatch.gui.BeeWindow(
     host=args.host,
     port=args.port,

lib/beewatch/__init__.py

@@ -27,61 +27,79 @@ import blinker
 import curio
 
 import digilib.network
-# import beewatch.server
 
 log = logging.getLogger(__name__+"")
-log = logging.getLogger(__name__+".psm")
-
-# class PinScriptManager(object):
-#     scripts = []
-#     signals = [
-#     ]
-#     handlers = {
-#     }
-#     def __init__(self):
-#         super(PinScriptManager,self).__init__()
-#     def load_script(self,script):
-#         if script in self.scripts:
-#             lpsm.warn("script '{}' is already loaded!")
-#         self.scripts.add(script)
-#         script.on_load()
-#     # def import_script(self,script)
-#     def unload_script(self,script):
-#         if script in self.scripts:
-#             raise ValueError("script '{}' is not loaded")
-#         script.on_unload()
-#         self.scripts.remove(script)
-
-
-    # def connect(self,signal,func):
-    #     if not signal in self.signals:
-    #         raise ValueError("There is no signal named '{}'".format(signal))
-    #     self.handlers[signal].append(func)
-    # def disconnect(self,signal,func):
-    #     if not signal in self.signals:
-    #         raise NameError("There is no signal named '{}'".format(signal))
-    #     self.handlers[signal].append(func)
-
-
-
-
-# class PinScript(object):
-#     """docstring for Script."""
-#     def __init__(self):
-#         super(PinScript, self).__init__()
-#     def on_load(self):
-#         pass
-#     def on_unload(self):
-#         pass
 
-#
-# class TestPS(PinScript):
-#     def __init__(self):
+_controllers = {}
+_commands = {}
+
+
+class Configure(object):
+    warnings = True
+    """
+    Configure BeeWatch from a dict
+    This class is inspired by logging.config
+    (https://github.com/python/cpython/blob/3.6/Lib/logging/config.py)
+    """
+
+    def __init__(self,config):
+        super(Configure,self).__init__()
+        self.configure(config)
+
+    def configure(self,config):
+        retconf = {
+            "controllers":{},
+            "commands":{},
+        }
+        # Configure the Controllers first
+        for name,properties in config.get("controllers",{}).items():
+            target = properties.pop("target")
+            if not callable(target):
+                target = self.str_to_callable(target)
+            ctrl = target(**properties)
+            if name in _controllers.keys() and self.warnings:
+                log.warn("overwriting controller "+name)
+            _controllers[name] = ctrl
+            retconf["controllers"][name] = ctrl
+
+        # Next configure the commands
+        for name,properties in config.get("commands",{}).items():
+            function = properties.pop("function")
+            ctrl = properties.pop("controller")
+            if not callable(ctrl):
+                if ctrl not in _controllers.keys():
+                    raise ValueError("No controller found with name " + ctrl)
+                ctrl = _controllers[ctrl]
+            if not hasattr(ctrl,function):
+                raise ValueError(
+                    "{} doesn't have attribute {}".format(ctrl,function))
+            function = getattr(ctrl,function)
+            if name in _commands.keys() and self.warnings:
+                log.warn("overwriting command "+name)
+            _commands[name] = function
+            retconf["commands"][name] = function
+
+    def str_to_callable(self,dotted_str):
+        parts = dotted_str.split(".")
+        next_to_import = parts.pop(0)
+        converted = __import__(next_to_import)
+        for p in parts:
+            next_to_import += "." + p
+            if not hasattr(converted,p):
+                converted = __import__(next_to_import)
+            converted = getattr(converted,p)
+        return converted
+
+
+
+
+
+
+
+
+
+
 
-#
-# if __name__ == "__main__":
-#     psm = PinScriptManager()
-#
 
 
 

lib/beewatch/config/__init__.py → lib/beewatch/config_/__init__.py

@@ -16,29 +16,57 @@
 # You should have received a copy of the GNU General Public License
 # along with BeeWatch.  If not, see <http://www.gnu.org/licenses/>.
 
+import logging
+import beewatch
+
+log = logging.getLogger(__name__+"")
+
 
 class Configure(object):
+    warnings = True
     """
     Configure BeeWatch from a dict
     This class is inspired by logging.config
     (https://github.com/python/cpython/blob/3.6/Lib/logging/config.py)
     """
+
     def __init__(self,config):
         super(Configure,self).__init__()
         self.configure(config)
-        self.config = {}
+
     def configure(self,config):
-        for name,properties in config.pop("controllers").items():
-            print(name)
+        retconf = {
+            "controllers":{},
+            "commands":{},
+        }
+        # Configure the Controllers first
+        for name,properties in config.get("controllers",{}).items():
             target = properties.pop("target")
             if not callable(target):
                 target = self.str_to_callable(target)
-                print(target)
-            self.retconf["controllers"][name] = target(**properties)
-        for name,function in config.pop("commands").items():
-            if not callable(function):
-                function = self.str_to_callable()
-            self.retconf[commands][name] = function
+            ctrl = target(**properties)
+            if name in _controllers.keys() and self.warnings:
+                log.warn("overwriting controller "+name)
+            _controllers[name] = ctrl
+            retconf["controllers"][name] = ctrl
+        # Next configure the commands
+        for name,properties in config.get("commands",{}).items():
+            function = properties.pop("function")
+            ctrl = properties.pop("controller")
+            if not callable(ctrl):
+                if ctrl not in _controllers.keys():
+                    raise ValueError("No controller found with name " + ctrl)
+                ctrl = _controllers[ctrl]
+            if not hasattr(ctrl,function):
+                raise ValueError(
+                    "{} doesn't have attribute {}".format(ctrl,function)
+                )
+            function = getattr(ctrl,function)
+            if name in _commands.keys() and self.warnings:
+                log.warn("overwriting command "+name)
+            _commands[name] = function
+            retconf["commands"][name] = function
+
     def str_to_callable(self,dotted_str):
         parts = dotted_str.split(".")
         next_to_import = parts.pop(0)
@@ -48,10 +76,8 @@ class Configure(object):
         for p in parts:
             next_to_import += "." + p
             if not hasattr(converted,p):
-                print("importing " + next_to_import)
                 converted = __import__(next_to_import)
             converted = getattr(converted,p)
-        print("converted",converted)
         return converted
 
 

lib/beewatch/pinapi/__init__.py

@@ -29,7 +29,7 @@ lpin = logging.getLogger(__name__+".pin")
 # log = logging.getLogger(__name__+"")
 
 print("*"*20)
-print("USE TRIO WHEN CODING THE PIN STUFF")
+print("USE CURIO WHEN CODING THE PIN STUFF")
 print("this message is printed by {}".format(__file__))
 print("*"*20)
 

lib/beewatch/server/__init__.py

@@ -31,15 +31,13 @@ import traceback
 
 import digilib.pin
 import digilib.network
+import beewatch
 import beewatch.pinapi
 
 log = logging.getLogger(__name__+"")
 lapi = logging.getLogger(__name__+".api")
 lchat = logging.getLogger(__name__+".chat")
 
-def log_something():
-    lapi.info("logging works")
-
 class BeeWatchServer(digilib.network.Server):
     """docstring for Server."""
     def __init__(self,*args,**kwargs):
@@ -52,15 +50,16 @@ class BeeWatchServer(digilib.network.Server):
 class ConnHandlerBeeWatch(digilib.network.ConnHandlerBase):
     def __init__(self, socket, addr, server):
         super(ConnHandlerBeeWatch, self).__init__(socket, addr, server)
-        self.engine_controller = digilib.pin.EnginesController(
-            left=[4,17],
-            right=[27,22],
-        )
+        self.engines_ctrl = beewatch._controllers["engines_ctrl"]
+        # digilib.pin.EnginesController(
+        #     left=[4,17],
+        #     right=[27,22],
+        # )
         self.text_to_func = {
-            "turn":self.engine_controller.turn
+            "turn":self.engines_ctrl.turn
         }
     def call(self,func_name,args,respond_method,kwargs):
-        ttf = self.text_to_func
+        ttf = beewatch._commands
         if func_name in ttf.keys():
             try:
                 task = curio.run(

server.py

@@ -33,8 +33,12 @@ import time
 import yaml
 
 import beewatch
-# import beewatch.server as beeserver
+import beewatch
 import beewatch.server
+# import beewatch.server as beeserver
+import digilib.misc
+
+log = logging.getLogger(__name__+"")
 
 parser = argparse.ArgumentParser(
     # usage="use this to play",
@@ -85,50 +89,39 @@ group_af_family.add_argument(
 )
 
 args = parser.parse_args()
-print(args)
+
 if args.debug:
-    with open("config/logging.yaml") as f:
-        data = f.read()
-    config = yaml.safe_load(data)
-    logging.config.dictConfig(config)
+    digilib.misc.load_files("config/logging.yaml",logging.config.dictConfig)
 
 if args.af_family == "AF_UNIX":
     port = None
 elif args.af_family == "AF_INET":
     port = args.port
 
+config_files = [
+    "config/controllers.yaml",
+    "config/commands.yaml",
+]
+
+digilib.misc.load_files(config_files,beewatch.Configure)
+
 bee_server = beewatch.server.BeeWatchServer(
     host=args.host,
     port=args.port,
     af_family=args.af_family,
 )
-# bee_api = beeserver.BeeAPI()
 
-# s = mylibnetwork.Server(
-#     host=args.host,
-#     port=port,
-#     handler=beeserver.ConnHandlerBeeWatch,
-#     handler_kwargs={"bee_api":bee_api}
-#     )
-
-bee_server.run()
 try:
-    while True:
-        try:
-            if bee_server.is_alive():
-                bee_server.join(1)
-            else:
-                break
-        except Exception as e:
-            log.warn("an error occured, aborting")
-            log.error(e, exc_info=True)
-            bee_server.stop()
-            break
+    bee_server.run()
+except Exception as e:
+    log.warn("an error occured, aborting")
+    log.error(e, exc_info=True)
 except KeyboardInterrupt:
     print("\r    ", end="\r")
-    logging.warn("keyboardinterrupt! aborting!")
-    bee_server.stop()
-
+    logging.warn("KeyboardInterrupt! aborting!")
+finally:
+    # bee_server.stop()
+    pass
 
 
 
@@ -138,124 +131,3 @@ log = logging.getLogger(__name__+".server")
 logc = logging.getLogger(__name__+".chat")
 
 Notify.init("Bee Watch Server")
-#
-# class ConnHandlerBeeWatch(mylibnetwork.ConnHandlerBase):
-#     def __init__(self, socket, addr, server, action=None):
-#         self.status = "init"
-#         self.super_class = super(ConnHandlerBeeWatch, self)
-#         self.super_class.__init__(socket, addr, server)
-#         logc.info('hey')
-#         self.server = server
-#         self.address = addr
-#         self.action=action
-#         self.command_to_function={
-#             "set_speed":self.action.c.movement_control.set_speed,
-#             "mod_speed":self.action.c.movement_control.change_speed,
-#             "get_speed":self.speedcheck,
-#             "print":self.echo,
-#             "None":None,
-#         }
-#     def welcome_client(self):
-#         self.send("this is the server speaking, hello new client!")
-#     def handle(self, data_decoded):
-#         data_decoded=data_decoded.strip()
-#         logc.info("Client:"+data_decoded)
-#         if data_decoded.find(" ") != -1:
-#             cmd=data_decoded.split()[0]
-#             args=data_decoded.split()[1:]
-#         else:
-#             cmd=data_decoded
-#             args=()
-#             kwargs={}
-#         if cmd in self.command_to_function.keys():
-#             try:
-#                 # self.respond(str(args))
-#                 self.command_to_function[cmd](respond_method=self.respond,*args)
-#             except:
-#                 tb = traceback.format_exc()
-#                 print(tb)
-#                 self.respond(tb)
-#                 # for line in tb.split('\n'):
-#                 #     self.respond(line)
-#                 #     # print(line)
-#                 #     # time.sleep(0.001)
-#                 #     time.sleep(0.1)
-#                 #     # if line != "\n"
-#         else:
-#             self.respond("Unknown command")
-#         # Notify.Notification.new(
-#         #     self.address[0]+" ("+self.server.host+":"+str(self.server.port)+")",
-#         #     data_decoded
-#         #     ).show()
-#     def echo(self,*args,**kwargs):
-#         logc.info(str(args))
-#         logc.info(str(kwargs))
-#     def speedcheck(self,respond_method):
-#         left_speed=str(self.action.c.movement_control.get_speed("left"))
-#         right_speed=str(self.action.c.movement_control.get_speed("right"))
-#         result = "left: "+left_speed+", right: "+right_speed
-#         logc.info(result)
-#         self.respond(result)
-#     def respond(self,text,*args):
-#         self.send(text)
-#
-# # logging.basicConfig(
-# #         format = myLogger.fmt + " {process:^^20}",
-# #         datefmt = myLogger.datefmt,
-# #         style = "{",
-# #         level = logging.DEBUG,
-# #         handlers = [
-# #             myLogger.logHandler_console,
-# #         ]
-# #     )
-# # logger_server = logging.getLogger("server")
-# # logger_server.propagate = False
-# # logHandler_server_file = logging.handlers.WatchedFileHandler(filename="logs/server.log")
-# # logHandler_server_file.setFormatter(myLogger.logFormatter)
-# # logHandler_server_file.setLevel(level=logging.DEBUG)
-# # logger_server.addHandler(myLogger.logHandler_console)
-# # logger_server.addHandler(logHandler_server_file)
-# # logger_beewatch = logging.getLogger("BeeWatch")
-# # logger_beewatch.propagate = False
-# # logHandler_beewatch_file = logging.handlers.WatchedFileHandler(filename="logs/beeserver.log")
-# # logHandler_beewatch_file.setFormatter(myLogger.logFormatter)
-# # logHandler_beewatch_file.setLevel(level=logging.DEBUG)
-# # logger_beewatch.addHandler(myLogger.logHandler_console)
-# # logger_beewatch.addHandler(logHandler_beewatch_file)
-#
-#
-# action=beeserver.BoatAction()
-# boat_movement=beeserver.BoatMovement(action.boat_api)
-# action.add_component("movement_control",boat_movement)
-# # engine_left=beeserver.Engine(logger_beewatch,action,{"name":"engine_left"})
-# # engine_right=beeserver.Engine(logger_beewatch,action,{"name":"engine_right"})
-# # action.add_component("engine_left",engine_left)
-# # action.add_component("engine_right",engine_right)
-# argv_dict = dict(zip(range(0,len(sys.argv)),sys.argv))
-# port = argv_dict.get(2,None)
-# if port != None:
-#     port = int(port)
-# s = mylibnetwork.Server(
-#     host=sys.argv[1],
-#     port=port,
-#     handler=ConnHandlerBeeWatch,
-#     handler_kwargs={"action":action}
-#     )
-# bee_server.run()
-# while True:
-#     try:
-#         # print("".join(myLogger.list_stream))
-#         if bee_server.is_alive():
-#             bee_server.join(1)
-#         else:
-#             break
-#     except KeyboardInterrupt:
-#         print("\r    ", end="\r")
-#         logging.warn("keyboardinterrupt! aborting!")
-#         bee_server.stop()
-#         break
-#     except Exception as e:
-#         log.warn("an error occured, aborting")
-#         log.error(e, exc_info=True)
-#         bee_server.stop()
-#         break

test_config.py

@@ -18,12 +18,19 @@
 
 from pprint import pprint
 import yaml
-import beewatch.config
+import beewatch
+import digilib.misc
+
+config_files = [
+    "config/controllers.yaml",
+    "config/commands.yaml",
+]
+
+digilib.misc.load_files(config_files,beewatch.Configure)
+
+pprint(beewatch._controllers)
+pprint(beewatch._commands)
 
-with open("config/commands.yaml") as f:
-    data = f.read()
-config = yaml.safe_load(data)
-pprint(beewatch.config.Configure(config))