-

-controllers:

-    engines_ctrl:

-        target: digilib.pin.EnginesController

-        left: 17,

-    turn: engines_ctrl.turn

-    with open("config/logging.yaml") as f:

-        data = f.read()

-    config = yaml.safe_load(data)

-    logging.config.dictConfig(config)

-#

-print(args)

-# import beewatch.server

-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):

-#

-# if __name__ == "__main__":

-#     psm = PinScriptManager()

-#

-        self.config = {}

-        for name,properties in config.pop("controllers").items():

-            print(name)

-                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

-                print("importing " + next_to_import)

-        print("converted",converted)

-print("USE TRIO WHEN CODING THE PIN STUFF")

-def log_something():

-    lapi.info("logging works")

-

-        self.engine_controller = digilib.pin.EnginesController(

-            left=[4,17],

-            right=[27,22],

-        )

-            "turn":self.engine_controller.turn

-        ttf = self.text_to_func

-# import beewatch.server as beeserver

-print(args)

-    with open("config/logging.yaml") as f:

-        data = f.read()

-    config = yaml.safe_load(data)

-    logging.config.dictConfig(config)

-# bee_api = beeserver.BeeAPI()

-# s = mylibnetwork.Server(

-#     host=args.host,

-#     port=port,

-#     handler=beeserver.ConnHandlerBeeWatch,

-#     handler_kwargs={"bee_api":bee_api}

-#     )

-

-bee_server.run()

-    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

-    logging.warn("keyboardinterrupt! aborting!")

-    bee_server.stop()

-

-#

-# 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

-import beewatch.config

-with open("config/commands.yaml") as f:

-    data = f.read()

-config = yaml.safe_load(data)

-pprint(beewatch.config.Configure(config))