def __init__(self, config: JsonDict = None, communicator: python_communicator.PythonCommunicator = None, logger=None, autocheckports=AUTOCHECKPORTS, port_check_time=PORTCHECKTIME, permanently_ignored_ports=None, datalogger: DataLogger = None, start_in_background=False): self.ignored_ports = set() self.deadports = set() self.connected_ports = set() self.available_ports = set() self.identified_ports = set() self.datalogger = DataLogger() if datalogger is None else datalogger self.config = JsonDict("portdata.json") if config is None else config if permanently_ignored_ports is None: permanently_ignored_ports = [] self.port_check_time = port_check_time self.autocheckports = autocheckports self.permanently_ignored_ports = set(permanently_ignored_ports) self.set_communicator(python_communicator.PythonCommunicator( ) if communicator is None else communicator) self.logger = logging.getLogger( "SerialReader") if logger is None else logger if start_in_background: self.run_in_background()
def setUp(self): self.temp_dir = tempfile.mkdtemp() self.temp_file = os.path.join(self.temp_dir, "d") with open(self.temp_file, "wb+") as f: f.write(b'{"test":"file"}') with open(self.temp_file, "r") as f: print(f.read(), self.temp_file) self.d = JsonDict(self.temp_file, backup=False)
def test_empty_key(self): dic = { "data": { "": { "inempty": ["test"], } } } self.d.data = dic ds = JsonDict(self.d.file) print(ds)
def __init__(self, serial_reader=None, config=None): """ :type serial_reader: SerialReader """ super().__init__() self._on_stop_functions = [] self.data_logger = DataLogger() self._data = dict() self.running = False self.pause = False self._ws_targets = set() self.logger = logging.getLogger(self.__class__.__name__) self.logger.info("start API {}".format(self.__class__.__name__)) self._serial_reader = None self.config = ( JsonDict( os.path.join( os.path.expanduser("~"), ".{}".format(self.__class__.__name__), "portdata.json", ) ) if config is None else config ) self.possible_boards = [[] for board in self.required_boards] if ( self.config.get("api_name", default=self.__class__.__name__) != self.__class__.__name__ ): self.config.data = {} self.config.put("api_name", value=self.__class__.__name__) self.config.put( "linked_boards", value=[None for board in self.required_boards] ) self.linked_boards = [None for board in self.required_boards] if len( self.config.get( "linked_boards", default=[b.id if b is not None else None for b in self.linked_boards], ) ) != len(self.linked_boards): self.config.put( "linked_boards", value=[None for board in self.required_boards] ) for board in self.required_boards: parseboards.add_board(board) self.serial_reader = serial_reader
def __init__( self, name="arduinocontrollerapi", python_communicator: PythonCommunicator = None, websocket_server: SocketServer = None, config=None, datalogger: DataLogger = None, logger=None, data_dir=None, ): self._python_communicator = None self.board_data = {} self.websocket_server = None if websocket_server is not None: self.set_websocket_server(websocket_server) self.name = name self.data = {} self.dataupdate = 1 self.lastupdate = 0 self.lastsend = dict() self.connected_ports = set() self.ignored_ports = set() self.available_ports = set() self.identified_ports = set() self.logger = logging.getLogger( self.name) if logger is None else -logger self.data_dir = (os.path.join(tempfile.gettempdir(), self.name + "_API") if data_dir is None else data_dir) os.makedirs(self.data_dir, exist_ok=True) self.config = (JsonDict(file=os.path.join(self.data_dir, "config.json"), createfile=True) if config is None else config) self.config.autosave = True self.sensor_ports = set([]) self.set_communicator(PythonCommunicator( ) if python_communicator is None else python_communicator) self.datalogger = (DataLogger( autosave_path=self.data_dir) if datalogger is None else datalogger) self.running = False self.run_thread = None
def __init__(self, interpreter, on_connect=None, config=None, **kwargs): super().__init__(**kwargs) self._interpreter = None self.interpreter = interpreter if config: self.config = config else: self.config = JsonDict() self.send_queue = [] self.connection_checks = [] self.connected = False if not hasattr(self, "logger"): self.logger = logging.getLogger(self.__class__.__name__) if not hasattr(self, "on_connect") or on_connect is not None: self.on_connect = on_connect
def plug_in(appconfig, config=None): # plugin app global CONFIG if CONFIG is None: if config is not None: CONFIG = config.getsubdict(preamble=["plug_in_django_server"]) else: CONFIG = JsonDict( os.path.join( os.path.join(os.path.expanduser("~"), ".plug_in_django_server"), "plug_in_django_server_config.json", )) if config is not None: appconfig.config = config.getsubdict(preamble=[appconfig.name]) else: if appconfig.config is None: appconfig.config = CONFIG.getsubdict(preamble=[appconfig.name]) logger.info("plug in {} with the config-path:'{}'".format( appconfig.name, appconfig.config.file)) if not hasattr(appconfig, "baseurl"): setattr(appconfig, "baseurl", getattr(appconfig, "name")) apps = CONFIG.get("django_settings", "apps", "additional", default={}) if getattr(appconfig, "data_dir", False) is True: appconfig.data_dir = os.path.join(os.path.dirname(CONFIG.file), "{}_data".format(appconfig.name)) appconfig.data_dir_url = ("/" + appconfig.baseurl + ("/" if len(appconfig.baseurl) > 0 else "") + "{}_data".format(appconfig.name)) else: appconfig.data_dir = False apps[appconfig.name] = { "name": appconfig.name, "baseurl": getattr(appconfig, "baseurl"), "data_dir": appconfig.data_dir, } if appconfig.data_dir is not False: os.makedirs(appconfig.data_dir, exist_ok=True) CONFIG.put("django_settings", "apps", "additional", value=apps) CONFIG.save()
def __init__( self, auto_check_ports=AUTO_CHECK_PORTS, port_check_time=PORT_CHECK_TIME, start_in_background=False, config: JsonDict = None, logger=None, permanently_ignored_ports=None, # datalogger: DataLogger = None, ): self.data_targets = set() self.ignored_ports = set() self.dead_ports = set() self.connected_ports = set() self.available_ports = set() self.identified_ports = set() self.running = False self.read_thread = None # self.datalogger = DataLogger() if datalogger is None else datalogger self.config = ( JsonDict( os.path.join( os.path.expanduser("~"), ".arduino_controller", "portdata.json" ) ) if config is None else config ) if permanently_ignored_ports is None: permanently_ignored_ports = [] self.port_check_time = port_check_time self.auto_check_ports = auto_check_ports self.permanently_ignored_ports = set(permanently_ignored_ports) # self.set_communicator(python_communicator.PythonCommunicator() if communicator is None else communicator) self.logger = logging.getLogger("SerialReader") if logger is None else logger if start_in_background: self.run_in_background()
import os import time from json_dict import JsonDict from arduino_controller.controller import ArduinoController if __name__ == "__main__": import argparse p = argparse.ArgumentParser() p.add_argument('-c', '--config', dest="config", default=os.path.join(os.path.expanduser("~"), ".ArduinoController", "controller_config.json")) kwargs = vars(p.parse_args()) kwargs['config'] = JsonDict(kwargs['config']) logging_fmt = ( "%(asctime)s %(filename)s %(lineno)d %(name)s %(levelname)-8s %(message)s" ) logging.basicConfig(level=logging.DEBUG, format=logging_fmt, datefmt="(%H:%M:%S)") try: import coloredlogs coloredlogs.install(level="DEBUG", fmt=logging_fmt) except: pass ac = ArduinoController(**kwargs, start_in_background=True) while ac._running:
def main(): os.makedirs(BASE_DIR, exist_ok=True) config = JsonDict(os.path.join(BASE_DIR, SNAKE_NAME + "_config.json")) logging_fmt = ( "%(asctime)s %(filename)s %(lineno)d %(name)s %(levelname)-8s %(message)s" ) logging.basicConfig( level=config.get( "basic", "logging", "level", default=logging.DEBUG if DEBUGGING else logging.INFO, ), format=logging_fmt, datefmt="(%H:%M:%S)", ) rotating_handler = RotatingFileHandler( os.path.join(BASE_DIR, "log.log"), maxBytes=config.get("basic", "logging", "max_bytes", default=2 ** 19), backupCount=config.get("basic", "logging", "backup_count", default=10), ) rotating_handler.setFormatter(logging.Formatter(logging_fmt)) logging.getLogger("").addHandler(rotating_handler) logger = logging.getLogger(BASENAME) coloredlogs.install(level="DEBUG", fmt=logging_fmt) logger.info("Use basedir: " + os.path.abspath(BASE_DIR)) # board_collection. # plugin to django plug_in_django_manage.plug_in(DjangoArduinoControllerConfig, config) plug_in_django_manage.CONFIG.put("django_settings", "apps", "channels", value=True) # set site parameters plug_in_django_manage.CONFIG.put("public", "site", "title", value=BASENAME) plug_in_django_manage.CONFIG.put("django_settings", "DEBUG", value=DEBUGGING) plug_in_django_manage.CONFIG.put("django_settings", "BASE_DIR", value=BASE_DIR) # login required plug_in_django_manage.CONFIG.put( "django_settings", "manual", "add_to_list", "MIDDLEWARE", value=[ # "global_login_required.GlobalLoginRequiredMiddleware" ], ) # if login is required accounds neet to be public plug_in_django_manage.CONFIG.put( "django_settings", "manual", "add_to_list", "PUBLIC_PATHS", value=[r"^/accounts/.*"], ) plug_in_django_manage.run( sys.argv[0], "runserver", "--noreload", "0.0.0.0:" + str( plug_in_django_manage.CONFIG.get("django_settings", "port", default=8000) ), )
import datetime from django.utils.timezone import make_aware from json_dict import JsonDict import random # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! if os.path.exists("/django_settings.json"): config = JsonDict("/django_settings.json") else: config = JsonDict("django_settings.json") SECRET_KEY = config.get( 'base_settings', 'SECRET_KEY', default="".join([ random.choice("abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)") for i in range(50) ])) #'l5!r&kcwz5r+#%**eq8j*6p-6@nw&0h)1uf&9c^27sw)9_s^-=' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = config.get('base_settings', 'DEBUG', default=False)
def main(): # main data dir os.makedirs(BASE_DIR, exist_ok=True) config = JsonDict(os.path.join(BASE_DIR, SNAKE_NAME + "_config.json")) # create basic logger logging_fmt = "%(asctime)s %(filename)s %(lineno)d %(name)s %(levelname)-8s %(message)s" logging.basicConfig( level=config.get("basic", "logging", "level", default=logging.DEBUG), format=logging_fmt, datefmt="(%H:%M:%S)", ) rotating_handler = RotatingFileHandler(os.path.join(BASE_DIR, 'log.log'), maxBytes=config.get("basic", "logging", "max_bytes", default=2**19), backupCount=config.get( "basic", "logging", "backup_count", default=10)) rotating_handler.setFormatter(logging.Formatter(logging_fmt)) logging.getLogger('').addHandler(rotating_handler) # logger.addHandler(logging.StreamHandler()) logger = logging.getLogger(BASENAME) coloredlogs.install(level='DEBUG', fmt=logging_fmt) logger.info("Use basedir: " + os.path.abspath(BASE_DIR)) # set server logger. from multi_purpose_arduino_controller.controll_server import manage as controll_server_manage # controll_server_manage.logger = logger # set_server_config controll_server_manage.CONFIG = config.getsubdict( preamble=['controll_server']) controll_server_manage.CONFIG.put("public", "site", "title", value=BASENAME) if config.get("basic", "mode", default=DEFAULT_MODE) == DEVELOPMENT_MODE: controll_server_manage.CONFIG.put("django_settings", "debug", value=True) else: controll_server_manage.CONFIG.put("django_settings", "debug", value=False) apps = [ "custom_accounts_django", "multi_purpose_arduino_controller.controll_server.board_controller", "django_websocket_server", "column_switcher.django_app" ] # apps.append("serverapps.board_creator") controll_server_manage.CONFIG.put("django_settings", "apps", "additional", value=apps) # create pending migrations if in development mode if config.get("basic", "mode", default=DEFAULT_MODE) == DEVELOPMENT_MODE: controll_server_manage.run(sys.argv[0], "makemigrations") controll_server_manage.run(sys.argv[0], "migrate") from django.contrib.auth.models import User superusers = User.objects.filter(is_superuser=True) if len(superusers) == 0: print("No Superuser specified") unsername = input("Enter Username: "******"Mail: ") pass1 = input("Password: "******"django_settings", "static_files", "dirs", value=[ os.path.abspath( os.path.join(os.path.dirname(__file__), "apis", "static")), # socketserver_instance.get_www_data_path(), # socketserver.TEMPDIR ], ) python_communicator = PythonCommunicator() # websocket server socketserver_instance = websocket_server.connect_to_first_free_port( data_dir=BASE_DIR, logger=logging.getLogger("websocket_server"), start_in_background=True, startport=config.get("websocket", "startport", default=9001), disable_encryption=config.get("websocket", "security", "disable_encryption", default=False)) # parse for boards parse_path_for_boards(os.path.join(os.path.dirname(__file__), "boards")) board_controller_api = BoardControllerAPI( python_communicator=python_communicator, websocket_server=socketserver_instance, data_dir=os.path.join(BASE_DIR, "BoardControllerAPI")) column_switcher_api = ColumnSwitcherAPI( python_communicator=python_communicator, websocket_server=socketserver_instance, data_dir=os.path.join(BASE_DIR, "ColumnSwitcherAPI")) # SerialReader sr = serialreader.SerialReader(communicator=python_communicator, start_in_background=True, config=config.getsubdict(["portdata"])) # starts django controll_server_manage.run( sys.argv[0], "runserver", "--noreload", "0.0.0.0:" + str( config.get( "controll_server", "django_settings", "port", default=8000)))
def test_double_open_file(self): d2 = JsonDict(self.d.file, backup=False) d2.put("second_entry", value=1) assert len(d2.data.keys()) == len(self.d.data.keys())
import logging import os import threading import time from arduino_controller import serialreader from arduino_controller.parseboards import parse_path_for_boards, BOARDS from arduinocontrollserver.arduinocontrollserver import ArduinoControllServer from json_dict import JsonDict from websocket_communication_server.socketserver import connect_to_first_free_port from column_automation import ColumnAutomate if __name__ == "__main__": logging.basicConfig(level=logging.INFO) serialportconfig = JsonDict("portdata.json") serialportconfig.autosave = True socketserver = connect_to_first_free_port() threading.Thread(target=socketserver.run_forever).start( ) # runs server forever in background server = ArduinoControllServer( port=80, socketport=socketserver.port, www_data=os.path.join(os.path.dirname(__file__), "www-data"), ) threading.Thread( target=server.start).start() # runs server forever in background server.deploy(socketserver.get_www_data_path(), "websocketserver")
def __init__(self, port=None, auto_port=True, interpreter=None, **kwargs): SerialCommunicator.__init__( self, port=port, auto_port=auto_port, interpreter=interpreter, **kwargs ) if not hasattr(self, "config"): self.config = JsonDict()
from django.conf import settings from json_dict import JsonDict preamble = "" #if manage.py is called directly if len(__name__.split(".")) == 2: from manage import logger, CONFIG else: from ..manage import logger, CONFIG preamble = __name__.replace(".controll_server.settings", ".") BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) if CONFIG is None: CONFIG = JsonDict(os.path.join(BASE_DIR, "serverconfig.json")) SECRET_KEY = CONFIG.get( "django_settings", "security", "key", default="".join(random.SystemRandom().choice( "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)") for i in range(50)), ) DEBUG = CONFIG.get("django_settings", "debug", default=False) ALLOWED_HOSTS = CONFIG.get("django_settings", "security", "allowed_hosts",
def db(self, tablename): """Return a JsonDict for a specific 'tablename' i.e. a single json file.""" assert tablename in DB_NAMES return JsonDict(__path__=self._db_json_path(tablename))
def __init__(self): self.to_migrate = False if not os.path.exists(self.BASE_DIR): self.to_migrate = True os.makedirs(self.BASE_DIR, exist_ok=True) self.config = JsonDict( os.path.join(self.BASE_DIR, self.SNAKE_NAME + "_config.json")) logging.basicConfig( level=self.config.get( "basic", "logging", "level", default=logging.DEBUG if self.DEBUGGING else logging.INFO, ), format=self.logging_fmt, datefmt="(%H:%M:%S)", ) rotating_handler = RotatingFileHandler( os.path.join(self.BASE_DIR, "log.log"), maxBytes=self.config.get("basic", "logging", "max_bytes", default=2**19), backupCount=self.config.get("basic", "logging", "backup_count", default=10), ) rotating_handler.setFormatter(logging.Formatter(self.logging_fmt)) logging.getLogger("").addHandler(rotating_handler) logger = logging.getLogger(self.BASENAME) coloredlogs.install(level="DEBUG", fmt=self.logging_fmt) logger.info("Use basedir: " + os.path.abspath(self.BASE_DIR)) # plugin to django plug_in_django_manage.plug_in(DjangoArduinoControllerConfig, self.config) plug_in_django_manage.CONFIG.put("django_settings", "apps", "channels", value=True) # set site parameters plug_in_django_manage.CONFIG.put("public", "site", "title", value=self.BASENAME) plug_in_django_manage.CONFIG.put("django_settings", "DEBUG", value=self.DEBUGGING) plug_in_django_manage.CONFIG.put("django_settings", "BASE_DIR", value=self.BASE_DIR) if self.login_required: # login required plug_in_django_manage.CONFIG.put( "django_settings", "manual", "add_to_list", "MIDDLEWARE", value=[ # "global_login_required.GlobalLoginRequiredMiddleware" ], ) # if login is required accounds neet to be public plug_in_django_manage.CONFIG.put( "django_settings", "manual", "add_to_list", "PUBLIC_PATHS", value=[r"^/accounts/.*"], ) for app_config in self.app_configs: plug_in_django_manage.plug_in(app_config, self.config)