Adding new configpyros class, renaming previous configpyros class to obsconfig_class

Alexis Koralewski
1 parent d42ec18b
Showing 14 changed files with 1293 additions and 1088 deletions Show diff stats
config/pyros/__init__.py
config/pyros/config_pyros.py
config/pyros/config_pyros.yml
config/pyros/schema_pyros_config.yml
pyros.py
src/core/pyros_django/agent/Agent.py
src/core/pyros_django/dashboard/views.py
src/core/pyros_django/misc/static/media/logo_pyros.png
src/core/pyros_django/misc/templates/base.html
src/core/pyros_django/obsconfig/configpyros.py -> src/core/pyros_django/obsconfig/obsconfig_class.py
src/core/pyros_django/obsconfig/templates/obsconfig/obs_astronomer_config.html
src/core/pyros_django/obsconfig/tests.py
src/core/pyros_django/obsconfig/views.py
src/core/pyros_django/pyros/settings.py
@@ -0,0 +1,75 @@
+import yaml,os,time
+import pykwalify.core
+from pykwalify.errors import SchemaError
+
+class configpyros:
+    def check_and_return_config(self,yaml_file:str,schema_file:str)->dict:
+        """
+        Check if yaml_file is valid for the schema_file and return an dictionary of the config file
+
+        Args:
+            yaml_file (str): Path to the config_file to be validated
+            schema_file (str): Path to the schema file 
+
+        Returns:
+            dict: dictionary of the config file (with values)
+        """
+        # disable pykwalify error to clean the output
+        #####logging.disable(logging.ERROR)
+        try:
+            can_yaml_file_be_read = False
+            while can_yaml_file_be_read != True:
+                if os.access(yaml_file, os.R_OK):
+                    can_yaml_file_be_read = True
+                else:
+                    print(f"{yaml_file} can't be accessed, waiting for availability")
+                    time.sleep(0.5)
+
+            c = pykwalify.core.Core(source_file=yaml_file, schema_files=[self.config_path+"/"+schema_file])
+            return c.validate(raise_exception=True)
+        except SchemaError:
+            for error in c.errors:
+                print("Error :",str(error).split(". Path")[0])
+                print("Path to error :",error.path)
+            return None
+        except IOError:
+            print("Error when reading the observatory config file")
+
+
+    def read_and_check_config_file(self,yaml_file:str)->dict:
+            """
+            Read the schema key of the config file to retrieve schema name and proceed to the checking of that config file
+            Call check_and_return_config function and print its return.
+
+            Args:
+                yaml_file (str): path to the config file
+            Returns:
+                dict: Dictionary of the config file (with values)
+            """
+            try:
+                can_config_file_be_read = False
+                while can_config_file_be_read != True:
+                    
+                    if os.access(yaml_file, os.R_OK):
+                        can_config_file_be_read = True
+                    else:
+                        print(f"{yaml_file} can't be accessed, waiting for availability")
+                        time.sleep(0.5)
+                with open(yaml_file, 'r') as stream:
+                    print(f"Reading {yaml_file}")
+                    config_file = yaml.safe_load(stream)
+                result = self.check_and_return_config(yaml_file,config_file["schema"])
+                if result == None:
+                    print("Error when reading and validating config file, please check the errors right above")
+                    exit(1)
+                return result
+
+            except yaml.YAMLError as exc:
+                print(exc)
+            except Exception as e:
+                print(e)
+                return None
+
+    def __init__(self,pyros_config_file):
+        self.config_path = os.path.abspath(os.path.join(os.environ.get("DJANGO_PATH"),"../../../config/pyros//"))
+        self.pyros_config = self.read_and_check_config_file(pyros_config_file)
@@ -0,0 +1,12 @@
+schema: schema_pyros_config.yml
+general:
+  logo: logo_pyros.png
+  color_theme: sienna
+  nb_element_per_page: 8
+USR: 
+  nb_element_per_page: 10
+SCP: ~
+OCF: ~
+
+
+  
 \ No newline at end of file
@@ -0,0 +1,24 @@
+type: map
+mapping:
+  schema:
+    type: str
+    required: True
+  general: 
+    type: map
+    required: True
+    mapping:
+      logo:
+        type: str
+        required: True
+      color_theme:
+        type: str
+        required: True
+      nb_element_per_page:
+        type: int
+        required: True
+  USR:
+    type: any
+  SCP:
+    type: any
+  OCF:
+    type: any
 \ No newline at end of file
@@ -21,6 +21,7 @@ import sys
 import time
 import re
 import glob
+from config.pyros.config_pyros import configpyros
 from git import Repo
 #import logging
  
@@ -569,6 +570,8 @@ def test(app):
     print("Running tests")
     os.environ["PATH_TO_OBSCONF_FOLDER"] = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"obsconfig/fixtures/")
     os.environ["unit_name"] = ""
+    configfile = 'config_pyros.yml'
+    os.environ["pyros_config_file"] = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"../../../config/pyros/", configfile)
     #start_dir = os.getcwd()
     if app == None:
         #apps = ['obsconfig','scientific_program','common', 'scheduler', 'routine_manager', 'user_manager', 'alert_manager.tests.TestStrategyChange']
@@ -663,7 +666,6 @@ def initdb():
     return True
  
  
-
 @pyros_launcher.command(help="Launch an agent")
 #@global_test_options
 @click.argument('agent')
@@ -677,8 +679,15 @@ def start(agent:str, configfile:str, observatory:str, unit:str):
     log.debug("Running start command")
     if configfile: 
         log.debug("With config file"+ configfile)
+        os.environ["pyros_config_file"] = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"../../../config/pyros/", configfile)
     else: 
-        configfile = ''
+        configfile = 'config_pyros.yml'
+        os.environ["pyros_config_file"] = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"../../../config/pyros/", configfile)
+        
+    logo_name = configpyros(os.environ["pyros_config_file"]).pyros_config["general"]["logo"]
+    logo_path = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"../../../config/pyros/", logo_name)
+    media_path = os.path.join(os.path.abspath(PYROS_DJANGO_BASE_DIR),"misc/static/media",logo_name)
+    shutil.copy(logo_path,media_path)
     #if test_mode(): print("in test mode")
     #if verbose_mode(): print("in verbose mode")
     if observatory == None or len(observatory) == 0:
@@ -709,8 +718,8 @@ def start(agent:str, configfile:str, observatory:str, unit:str):
     '''
  
     # add path to pyros_django folder as the config class is supposed to work within this folder
-    #cmd_test_obs_config = f"-c \"from src.core.pyros_django.obsconfig.configpyros import ConfigPyros\nConfigPyros('{os.path.join(PYROS_DJANGO_BASE_DIR,os.environ.get('PATH_TO_OBSCONF_FILE'))}')\""
-    cmd_test_obs_config = f"-c \"from src.core.pyros_django.obsconfig.configpyros import ConfigPyros\nConfigPyros('{obs_config_file_path}')\""
+    #cmd_test_obs_config = f"-c \"from src.core.pyros_django.obsconfig.obsconfig_class import OBSConfig\nOBSConfig('{os.path.join(PYROS_DJANGO_BASE_DIR,os.environ.get('PATH_TO_OBSCONF_FILE'))}')\""
+    cmd_test_obs_config = f"-c \"from src.core.pyros_django.obsconfig.obsconfig_class import OBSConfig\nOBSConfig('{obs_config_file_path}')\""
     if not execProcessFromVenv(cmd_test_obs_config):
         # Observatory configuration has an issue
         exit(1) 
@@ -128,7 +128,7 @@ from common.models import AgentSurvey, AgentCmd, AgentLogs
  
 #from config.configpyros import ConfigPyros
 from config.old_config.configpyros import ConfigPyros as ConfigPyrosOld
-from src.core.pyros_django.obsconfig.configpyros import ConfigPyros
+from src.core.pyros_django.obsconfig.obsconfig_class import OBSConfig
  
 #from dashboard.views import get_sunelev
 #from devices.TelescopeRemoteControlDefault import TelescopeRemoteControlDefault
@@ -460,7 +460,7 @@ class Agent:
         obs_config_file_path = os.environ["PATH_TO_OBSCONF_FILE"]
         path_to_obs_config_folder = os.environ["PATH_TO_OBSCONF_FOLDER"]
         unit = os.environ["unit_name"]
-        oc = ConfigPyros(obs_config_file_path)
+        oc = OBSConfig(obs_config_file_path)
         self.set_config(oc, obs_config_file_path, path_to_obs_config_folder, unit)
  
         #self.name = name
@@ -545,7 +545,7 @@ class Agent:
  
  
  
-    def set_config(self, oc: ConfigPyros, obs_config_file_path: str, path_to_obs_config_folder: str, unit: str):
+    def set_config(self, oc: OBSConfig, obs_config_file_path: str, path_to_obs_config_folder: str, unit: str):
         self._oc = {
             'config' : oc,
             'env' : [
@@ -25,10 +25,10 @@ from devices.CameraVISRemoteControlDefault import CameraVISRemoteControlDefault
 from devices.CameraNIRRemoteControlDefault import CameraNIRRemoteControlDefault
 from devices import PLC
 import time,os
-from obsconfig.configpyros import ConfigPyros
+from src.core.pyros_django.obsconfig.obsconfig_class import OBSConfig
 from django.conf import settings as pyros_settings
-
 sys.path.append("../../..")
+from config.pyros.config_pyros import configpyros
 #import utils.celme as celme
 import vendor.guitastro as guitastro
  
@@ -41,11 +41,13 @@ MAX_LOGS_LINES = 100
 log = l.setupLogger("dashboard", "dashboard")
  
 def index(request):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     observatory_name = config.get_obs_name()
     unit_name = config.unit_name
     request.session["obsname"] = observatory_name+" "+unit_name
-    
+    request.session["pyros_config"] = pyros_settings.CONFIG_PYROS
+    logo = pyros_settings.CONFIG_PYROS.get("general").get("logo")
+    request.session["logo"] = "media/"+logo
     message = ""
     if request.user.is_authenticated:
         if SP_Period_Guest.objects.filter(email=request.user.email):
@@ -40,6 +40,13 @@
  
 <body>
 <style>
+:root{
+  --main-bg-color: {{ request.session.pyros_config.general.color_theme }}
+}
+.bg-gradient-primary{
+  background-color: var(--main-bg-color);
+  background-image: None;
+}
 /*
 #page-wrapper {
   width: 80vw;
@@ -125,6 +132,12 @@ a {
   margin-right:1vw;
 }
  
+#logo_icon{
+  height: 4.5vh;
+  width: 4.5vw;  
+  float:left;
+  margin-right:1vw;
+}
 .dropdown_user_actions {
   overflow: hidden;
   min-width:8.5vw;
@@ -241,7 +254,11 @@ footer{
         <div class="sidebar-brand d-flex align-items-center justify-content-center">
             <a class="navbar-brand" href={% url "index" %} style="color: black;">
             <img class="sidebar-brand-icon" src="{% static 'media/home.png'  %}" id="home_icon"></a>
-            <div class="sidebar-brand-text mx-3">PyROS</div>
+            {% if request.session.logo %}
+              <img class="sidebar-brand-icon" src="{% static request.session.logo  %}" id="logo_icon"></a>
+            {% else %}
+              <div class="sidebar-brand-text mx-3">PyROS</div>
+            {% endif %}
  
         </div>
             {% comment %} OLD SIDE MENU
@@ -253,7 +270,7 @@ footer{
               <li class="nav-item"><a class="nav-link" href="{% url "current_schedule" %}">Schedule</a></li>
             {# TODO: TBD #}
             {% if USER_LEVEL|ifinlist:"Admin,Operator,Unit-PI,Management board member,Observer,TAC" %}
-              <li class="nav-item"><a class="nav-link" href="{% url "requests_list" %}">Request</a></li>
+              <li class="nav-item"><a class="nav-link" href="{% url "sequences_list" %}">Request</a></li>
               <li class="nav-item"><a class="nav-link" href="#">Images</a></li>
             {% endif %}
  
-#!/usr/bin/env python3
-import pykwalify.core
-import sys
-import yaml, logging, os, pickle, time
-from datetime import datetime
-from pykwalify.errors import PyKwalifyException,SchemaError
-from pathlib import Path
-
-class ConfigPyros:
-    # (AKo) : Config file path is checked on the settings file, if the file isn't valid (i.e not found) the error will be launched by the settings file when starting the application 
-    devices_links = {}
-    current_file = None
-    #COMPONENT_PATH = os.path.join(os.environ["DJANGO_PATH"],"../../../config/components/")
-    #GENERIC_DEVICES_PATH = os.path.join(os.environ["DJANGO_PATH"],"../../../config/devices/")
-    pickle_file = "obsconfig.p"
-    obs_config = None
-    devices = None
-    computers = None
-    agents = None 
-    obs_config_file_content = None
-    #obs_config_path = os.environ.get("PATH_TO_OBSCONF_FOLDER",os.path.join(os.environ["DJANGO_PATH"],"../../../privatedev/config/default/"))
-    errors = None
-
-    def verify_if_pickle_needs_to_be_updated(self, observatory_config_file)->bool:
-        """
-
-        Args:
-            observatory_config_file ([type]): [description]
-
-        Returns:
-            bool: [description]
-        """
-        self.CONFIG_PATH = os.path.dirname(observatory_config_file)+"/"
-        self.obs_config_path = self.CONFIG_PATH
-        #self.CONFIG_PATH = self.obs_config_path
-        if os.path.isfile(self.CONFIG_PATH+self.pickle_file) == False:
-            return True
-        else:
-            pickle_file_mtime = os.path.getmtime(self.CONFIG_PATH+self.pickle_file)
-            obs_config_mtime = os.path.getmtime(observatory_config_file)
-
-            obs_config = self.read_and_check_config_file(observatory_config_file)
-            if obs_config_mtime > pickle_file_mtime:
-                # create obs file (yaml) from pickle["obsconfig"] with date of pickle within history folder-> nom ficher + année + mois + jour + datetime (avec secondes) -> YYYY/MM/DD H:m:s
-                pickle_datetime = datetime.utcfromtimestamp(pickle_file_mtime).strftime("%Y%m%d_%H%M%S")
-                # Create history folder if doesn't exist
-                Path(self.obs_config_path+"/history/").mkdir(parents=True, exist_ok=True)
-                file_name = f"{self.obs_config_path}/history/observatory_{pickle_datetime}.yml"
-                config_file = open(observatory_config_file,"r")
-
-                with open(file_name, 'w') as f:
-                    f.write(config_file.read())
-                return True
-            if obs_config == None:
-                print(f"Error when trying to read config file (path of config file : {observatory_config_file}")
-                return -1
-            self.obs_config = obs_config
-            # check last date of modification for devices files
-            for device in self.obs_config["OBSERVATORY"]["DEVICES"]:
-                device_file = self.CONFIG_PATH+device["DEVICE"]["file"]
-                device_file_mtime = os.path.getmtime(device_file)
-                if device_file_mtime > pickle_file_mtime:
-                    return True
-
-            for computer in self.obs_config["OBSERVATORY"]["COMPUTERS"]:
-                computer_file = self.CONFIG_PATH+computer["COMPUTER"]["file"]
-                computer_file_mtime = os.path.getmtime(computer_file)
-                if computer_file_mtime > pickle_file_mtime:
-                    return True
-        return False
-
-    def load(self, observatory_config_file):
-        pickle_needs_to_be_updated = self.verify_if_pickle_needs_to_be_updated(observatory_config_file)
-        # check if we already read and load devices configuration and if pickle needs to be updated
-        if pickle_needs_to_be_updated == False and self.devices != None:
-            return None
-        else:
-            if os.path.isfile(self.CONFIG_PATH+self.pickle_file) and pickle_needs_to_be_updated == False:
-                print("Reading pickle file")
-                try:
-                    can_pickle_file_be_read = False
-                    while can_pickle_file_be_read != True:
-                        if os.access(self.CONFIG_PATH+self.pickle_file, os.R_OK):
-                            pickle_dict = pickle.load(open(self.CONFIG_PATH+self.pickle_file,"rb"))
-                            can_pickle_file_be_read = True
-                        else:
-                            time.sleep(0.5)
-                except IOError:
-                    print("Error when reading the pickle file")
-                try:
-                    self.obs_config = pickle_dict["obs_config"]
-                    self.computers = pickle_dict["computers"]
-                    self.devices = pickle_dict["devices"]
-                    self.devices_links = pickle_dict["devices_links"]
-                    self.obs_config_file_content = pickle_dict["obs_config_file_content"]
-                    self.raw_config =  pickle_dict["raw_config"] 
-                except:
-                    # we rewrite the pickle file, the content will be the same otherwise we would be in the else case
-                    print("Rewritting the pickle file (an error occured while reading it, the content will be the same as it was")
-                    pickle_dict = {}
-                    
-                    self.obs_config = self.read_and_check_config_file(observatory_config_file) 
-                    obs_file = open(observatory_config_file,"r")
-                    pickle_dict["raw_config"] = obs_file.read()
-                    obs_file.close()
-                    self.raw_config =  pickle_dict["raw_config"] 
-                    pickle_dict["obs_config"] = self.obs_config
-                    pickle_dict["devices"] = self.get_devices()
-                    pickle_dict["computers"] = self.get_computers()
-                    pickle_dict["devices_links"] = self.devices_links
-                    pickle_dict["obs_config_file_content"] = self.read_and_check_config_file(observatory_config_file) 
-                    print("Writing pickle file")
-                    pickle.dump(pickle_dict,open(self.CONFIG_PATH+self.pickle_file,"wb"))    
-            else:
-                print("Pickle file needs to be created or updated")
-                pickle_dict = {}
-
-                self.obs_config = self.read_and_check_config_file(observatory_config_file) 
-                pickle_dict["obs_config"] = self.obs_config
-                pickle_dict["devices"] = self.get_devices()
-                pickle_dict["computers"] = self.get_computers()
-                pickle_dict["devices_links"] = self.devices_links
-                pickle_dict["obs_config_file_content"] = self.read_and_check_config_file(observatory_config_file) 
-                print("Writing pickle file")
-                pickle.dump(pickle_dict,open(self.CONFIG_PATH+self.pickle_file,"wb"))
-
-    def check_and_return_config(self,yaml_file:str,schema_file:str)->dict:
-        """
-        Check if yaml_file is valid for the schema_file and return an dictionary of the config file
-
-        Args:
-            yaml_file (str): Path to the config_file to be validated
-            schema_file (str): Path to the schema file 
-
-        Returns:
-            dict: dictionary of the config file (with values)
-        """
-        # disable pykwalify error to clean the output
-        #####logging.disable(logging.ERROR)
-        try:
-            can_yaml_file_be_read = False
-            while can_yaml_file_be_read != True:
-                if os.access(yaml_file, os.R_OK):
-                    can_yaml_file_be_read = True
-                else:
-                    print(f"{yaml_file} can't be accessed, waiting for availability")
-                    time.sleep(0.5)
-
-            c = pykwalify.core.Core(source_file=yaml_file, schema_files=[self.SCHEMA_PATH+schema_file])
-            return c.validate(raise_exception=True)
-        except SchemaError:
-            for error in c.errors:
-                print("Error :",str(error).split(". Path")[0])
-                print("Path to error :",error.path)
-                self.errors = c.errors
-            return None
-        except IOError:
-            print("Error when reading the observatory config file")
-
-    @staticmethod
-    def check_config(yaml_file:str,schema_file:str)->any:
-        """
-        Check if yaml_file is valid for the schema_file and return a boolean or list of errors according the schema
-
-        Args:
-            yaml_file (str): Path to the config_file to be validated
-            schema_file (str): Path to the schema file 
-
-        Returns:
-            any: boolean (True) if the configuration is valid according the schema or a list of error otherwise
-        """
-        # disable pykwalify error to clean the output
-        ####logging.disable(logging.ERROR)
-        try:
-            can_yaml_file_be_read = False
-            while can_yaml_file_be_read != True:
-                if os.access(yaml_file, os.R_OK):
-                    can_yaml_file_be_read = True
-                else:
-                    print(f"{yaml_file} can't be accessed, waiting for availability")
-                    time.sleep(0.5)
-        
-            c = pykwalify.core.Core(source_file=yaml_file, schema_files=[schema_file])
-            c.validate(raise_exception=True)
-            return True
-        except SchemaError:
-            for error in c.errors:
-                print("Error :",str(error).split(". Path")[0])
-                print("Path to error :",error.path)
-                
-            return c.errors
-        except IOError:
-            print("Error when reading the observatory config file")
-            
-    def read_and_check_config_file(self,yaml_file:str)->dict:
-        """
-        Read the schema key of the config file to retrieve schema name and proceed to the checking of that config file
-        Call check_and_return_config function and print its return.
-
-        Args:
-            yaml_file (str): path to the config file
-        Returns:
-            dict: Dictionary of the config file (with values)
-        """
-        self.current_file = yaml_file
-        try:
-            can_config_file_be_read = False
-            while can_config_file_be_read != True:
-                
-                if os.access(yaml_file, os.R_OK):
-                    can_config_file_be_read = True
-                else:
-                    print(f"{yaml_file} can't be accessed, waiting for availability")
-                    time.sleep(0.5)
-            with open(yaml_file, 'r') as stream:
-                print(f"Reading {yaml_file}")
-                config_file = yaml.safe_load(stream)
-
-            self.DJANGO_PATH = os.environ.get("DJANGO_PATH",os.path.abspath(os.path.dirname(yaml_file)))
-            self.SCHEMA_PATH = os.path.join(self.DJANGO_PATH,"../../../config/schemas/")
-            self.CONFIG_PATH = self.obs_config_path
-            self.COMPONENT_PATH = os.path.join(self.DJANGO_PATH,"../../../config/components/")
-            self.GENERIC_DEVICES_PATH = os.path.join(self.DJANGO_PATH,"../../../config/devices/")
-            result = self.check_and_return_config(yaml_file,config_file["schema"])
-            if result == None:
-                print("Error when reading and validating config file, please check the errors right above")
-                exit(1)
-            return result
-
-        except yaml.YAMLError as exc:
-            print(exc)
-        except Exception as e:
-            print(e)
-            return None
-    
-    def read_generic_component_and_return_attributes(self,component_name:str)->dict:
-        file_path = self.COMPONENT_PATH + component_name + ".yml"
-        try:
-            with open(file_path, 'r') as stream:
-                config_file = yaml.safe_load(stream)  
-                
-                attributes = {}
-                for attribute in config_file:
-                
-                    attribute = attribute["attribute"]
-                    attributes[attribute.pop("key")] = attribute
-                return attributes
-        except yaml.YAMLError as exc:
-            print(exc)
-        except Exception as e:
-            print(e)
-            return None
-    
-    def read_capability_of_device(self,capability:dict)->dict:
-        """
-        Read capability of device and inherit attributes from generic component then overwrite attributes defined in device config
-
-        Args:
-            capability (dict): dictionary containing a capabilitiy (keys : component and attributes)
-
-        Returns:
-            dict: dictionary of capability inherited by generic component and overwritten his attributes by current attributes of capability
-        """
-        
-        component_attributes = self.read_generic_component_and_return_attributes(capability["component"])
-        
-        attributes = {}
-        # get all attributes of device's capability
-        for attribute in capability["attributes"]:
-            attribute = attribute["attribute"]
-        
-            attributes[attribute.pop("key")] = attribute
-        
-        # for each attributes of generic component attributes
-        for attribute_name in attributes.keys():
-            # merge attributes of general component with specified component in device config file
-            new_attributes = {**component_attributes[attribute_name],**attributes[attribute_name]}
-            if "is_enum" in component_attributes[attribute_name].keys():
-                # make an intersection of both list of values
-                new_attributes["value"] = list(set(attributes[attribute_name]["value"]) & set(component_attributes[attribute_name]["value"]))
-                if len(new_attributes["value"]) == 0:
-                    print(f"Value of lastly read device's attribute '{attribute_name}' isn't one of the values of component configuration for this device (component configuration value(s): {component_attributes[attribute_name]['value']}) (actual value : {attributes[attribute_name]['value']})")
-                    exit(1)
-            component_attributes[attribute_name] = new_attributes
-        
-        # return inherited and overwritten attributes of capability
-        capability["attributes"] = component_attributes
-        return capability
-
-    def get_devices_names_and_file(self) -> dict:
-        """
-        Return a dictionary giving the device file name by the device name 
-        Returns:
-            dict: key is device name, value is file name
-        """
-        devices_names_and_files = {}
-        for device in self.obs_config["OBSERVATORY"]["DEVICES"]:
-            device = device["DEVICE"]
-            
-            devices_names_and_files[device["name"]] = device["file"]
-        return devices_names_and_files
-
-    def read_device_config_file(self,config_file_name:str,is_generic=False)->dict:
-        """
-        Read the device config file, inherit generic device config if "generic" key is present in "DEVICE".
-        Associate capabilities of attached_devices if this device has attached_devices.
-        Inherit capabilities from generic component and overwritte attributes defined in the device config
-        Args:
-            config_file_name (str): file name to be read
-            is_generic (bool, optional): tells if we're reading a generic configuration (is_generic =True) or not (is_generic = False). Defaults to False.
-
-        Returns:
-            dict: formatted device configuration (attributes, capabilities...)
-        """
-        self.current_file = config_file_name
-        devices_name_and_file = self.get_devices_names_and_file()
-        if not is_generic:
-            # check if device config file is listed in observatory configuration
-            current_device_name = [device for device,file_name in devices_name_and_file.items() if file_name in config_file_name[len(self.CONFIG_PATH):] ]
-            if len(current_device_name) <= 0:
-                print(f"Current file '{config_file_name[len(self.CONFIG_PATH):]}' isn't listed in observatory configuration")
-                print("The devices names and files are: ")
-                for device_name,file_name in devices_name_and_file.items():
-                    print(f"device name: '{device_name}', device filename: '{file_name}'")
-                exit(1)
-        print(f"Reading {config_file_name}")
-        try:
-            with open(config_file_name, 'r') as stream:
-                config_file = yaml.safe_load(stream)
-                # if we're reading a generic device configuration, the path to get the schema is different than usual
-                self.SCHEMA_PATH =os.path.join(self.DJANGO_PATH,"../../../config/schemas/")
-                
-                # read and verify that the device configuration match the schema
-                result = self.check_and_return_config(config_file_name,config_file["schema"])
-                # if the configuration didn't match the schema or had an error when reading the file
-                if result == None:
-                    print("Error when reading and validating config file, please check the errors right above")
-                    exit(1)
-                else:
-                    # the configuration is valid
-                    # storing DEVICE key in device (DEVICE can contains : attributes of device, capabilities, attached devices)
-                    device = result["DEVICE"]
-                    generic_device_config = None
-                    # if the device is associated to an generic configuration, we'll read that generic configuration to inherit his attributes
-                    if "generic" in device:
-                        # storing the whole current config
-                        current_config = result
-                        # read and get the generic device config
-                        generic_device_config = self.read_device_config_file(self.GENERIC_DEVICES_PATH+device["generic"],is_generic=True)
-                        # merge whole device config but we need to merge capabilities differently after
-                        new_config = {**generic_device_config["DEVICE"],**current_config["DEVICE"]}
-                        result["DEVICE"] = new_config
-
-                    # device has capabilities
-                    if "CAPABILITIES" in device:
-                        capabilities = []
-                        # if the device is associated to a generic device we need to associate his capabilities with the generic capabilities and overwrite them
-                        if generic_device_config != None:
-                            # we're making a copy of generic device config so we can remove items during loop
-                            copy_generic_device_config = generic_device_config.copy()
-                            # We have to extend capabilities of generic device configuration
-                            for capability in current_config["DEVICE"]["CAPABILITIES"]:
-                                is_capability_in_generic_config = False
-                                current_config_capability = capability["CAPABILITY"]
-                                current_config_component = current_config_capability["component"]
-                                # find if this component was defined in generic_device_config
-                                for index,generic_config_capability in enumerate(generic_device_config["DEVICE"]["CAPABILITIES"]):
-                                    # if the current capability is the capability of the component we're looking for
-                                    if current_config_component == generic_config_capability["component"]:
-                                        is_capability_in_generic_config = True
-                                        # we're merging their attributes
-                                        new_attributes = generic_config_capability["attributes"].copy()
-                                        attributes = {}
-                                        current_config_attributes = current_config_capability["attributes"]                                        
-                                        generic_config_attributes = generic_config_capability["attributes"]
-                                        for attribute in current_config_attributes:
-                                            attribute = attribute["attribute"]
-                                            attributes[attribute.pop("key")] = attribute
-                                        # for each attributes of device component attributes
-                                        for attribute_name in attributes.keys():
-                                            # merge attributes of general component with specified component in device config file
-                                            new_attributes[attribute_name] = {**generic_config_attributes[attribute_name],**attributes[attribute_name]}
-                                            if "is_enum" in generic_config_attributes[attribute_name].keys():
-                                                # make an intersection of both list of values
-                                                new_attributes[attribute_name]["value"] = list(set(attributes[attribute_name]["value"]) & set(generic_config_attributes[attribute_name]["value"]))
-                                                if len(new_attributes[attribute_name]["value"]) == 0:
-                                                    print(f"Value of device '{config_file_name}' for attribute '{attribute_name}' isn't one of the values of generic configuration for this device (generic value(s): {generic_config_attributes[attribute_name]['value']}) (actual value : {attributes[attribute_name]['value']})")
-                                                    exit(1)
-                                        # removing this capability from generic device configuration
-                                        generic_device_config["DEVICE"]["CAPABILITIES"].pop(index)
-                                        capabilities.append({"component": current_config_component,"attributes":new_attributes}) 
-                                        break
-                                if is_capability_in_generic_config == False:
-                                    current_config_capability = self.read_capability_of_device(current_config_capability)
-                                    # the component defined in the current_config isn't defined in generic config (should not happen but we'll deal with that case anyway) : we're simply adding this capability
-                                    capabilities.append(current_config_capability)
-                            # looping through generic device config's capabilities in order to add them to current device configuration
-                            for generic_config_capability in generic_device_config["DEVICE"]["CAPABILITIES"]:
-                                capabilities.append(generic_config_capability)
-                        else:
-                            # device not associated to a generic device configuration
-                            for capability in device["CAPABILITIES"]:
-                                capability = capability["CAPABILITY"]
-                                capabilities.append(self.read_capability_of_device(capability))
-                        device["CAPABILITIES"] = capabilities
-                        # associate capabilities to final device configuration (stored in result variable)
-                        result["DEVICE"]["CAPABILITIES"] = device["CAPABILITIES"]
-                    if "ATTACHED_DEVICES" in device.keys():
-                        # device has attached devices, we need to read their configuration in order to get their capabilities and add them to the current device
-                        devices_name_and_file = self.get_devices_names_and_file()
-                        active_devices = self.get_active_devices()
-                        for attached_device in device["ATTACHED_DEVICES"]:
-                            is_attached_device_link_to_agent = False
-                            # we're looking for if the attached device is associated to an agent (i.e. the device is considered as 'active'). However an attached_device shoudn't be active
-                            for active_device in active_devices:
-                                if devices_name_and_file[active_device] == attached_device["file"]:
-                                    # the attached device is an active device (so it's linked to an agent)
-                                    is_attached_device_link_to_agent = True
-                                    break
-                            if self.CONFIG_PATH+attached_device["file"] != config_file_name and not is_attached_device_link_to_agent:
-                            # if the attached device isn't the device itself and not active
-                                
-                                # get configuration of attached device
-                                config_of_attached_device = self.read_device_config_file(self.CONFIG_PATH+attached_device["file"])
-                                capabilities_of_attached_device = None
-                                if "CAPABILITIES" in config_of_attached_device["DEVICE"].keys():
-                                    capabilities_of_attached_device = config_of_attached_device["DEVICE"]["CAPABILITIES"]
-                                if capabilities_of_attached_device != None:
-                                    # get name of device corresponding to the config file name
-                                    parent_device_name = [device for device,file_name in devices_name_and_file.items() if file_name == config_file_name[len(self.CONFIG_PATH):]]
-                                    attached_device_name = [device for device,file_name in devices_name_and_file.items() if file_name == attached_device["file"]]
-                                    if len(parent_device_name) > 0 :
-                                        parent_device_name = parent_device_name[0]
-                                    else:
-                                        print(f"Attached device filename '{config_file_name[len(self.CONFIG_PATH):]}' is not listed in observatory devices files names")
-                                        print("The devices names and files are: ")
-                                        for device_name,file_name in devices_name_and_file.items():
-                                            print(f"device name: '{device_name}', device filename: '{file_name}'")
-                                        exit(1)
-                                    if len(attached_device_name) > 0 :
-                                        attached_device_name = attached_device_name[0]
-                                    else:
-                                        
-                                        print(f"Attached device filename '{attached_device['file']}' is not listed in observatory devices files names")
-                                        print("The devices names and files are: ")
-                                        for device_name,file_name in devices_name_and_file.items():
-                                            print(f"device name: '{device_name}', device filename: '{file_name}'")
-                                        exit(1)
-                                    # associate attached device to his 'parent' device (parent device is the currently read device)
-                                    self.devices_links[attached_device_name] = parent_device_name
-                                    for capability in capabilities_of_attached_device:
-                                        # add capabilities of attached device to current device
-                                        result["DEVICE"]["CAPABILITIES"].append(capability)
-                return result
-        except yaml.YAMLError as exc:
-            print(exc)
-        except Exception as e:
-            print(e)
-            exit(1)
-            #return None
-
-    def __init__(self, observatory_config_file:str, unit_name:str="") -> None:
-        """
-        Initiate class with the config file
-        set content attribute to a dictionary containing all values from the config file
-
-        Args:
-            config_file_name (str): path to the config file
-        """
-        self.load(observatory_config_file)
-        if unit_name == "":
-            # By default we will use the first unit
-            self.unit_name = self.get_units_name()[0]
-        else:
-            self.unit_name = unit_name
-
-    def get_obs_name(self) -> str:
-        """
-        Return name of the observatory
-
-        Returns:
-            str: Name of the observatory
-        """
-        return self.obs_config["OBSERVATORY"]["name"]
-
-    def get_channels(self, unit_name: str) -> dict:
-        
-        """
-        return dictionary of channels
-
-        Args:
-            unit_name (str): Name of the unit
-        Returns:
-            dict: [description]
-        """
-        unit = self.get_unit_by_name(unit_name)
-        channels = {}
-        
-        for channel_id in range(len(unit["TOPOLOGY"]["CHANNELS"])):
-            channel = unit["TOPOLOGY"]["CHANNELS"][channel_id]["CHANNEL"]
-            channels[channel["name"]] = channel
-        return channels
-    
-    def get_computers(self) -> dict:
-        """
-        return dictionary of computers
-
-        Returns:
-            dict: [description]
-        """
-        if self.computers != None:
-            return self.computers
-        else:
-            computers = {}
-            for computer_id in range(len(self.obs_config["OBSERVATORY"]["COMPUTERS"])):
-                computer = self.obs_config["OBSERVATORY"]["COMPUTERS"][computer_id]["COMPUTER"]
-                if( "file" in computer.keys() ):
-                    computer["computer_config"]= self.read_and_check_config_file(self.CONFIG_PATH+computer["file"])["COMPUTER"]
-                computers[computer["name"]] = computer
-            return computers
-
-    def get_devices(self) -> dict:
-        """
-        return dictionary of devices
-
-        Returns:
-            dict: [description]
-        """
-        if self.devices != None:
-            return self.devices
-
-        else:
-            devices = {}
-            for device_id in range(len(self.obs_config["OBSERVATORY"]["DEVICES"])):
-                device = self.obs_config["OBSERVATORY"]["DEVICES"][device_id]["DEVICE"]
-                if( "file" in device.keys() ):
-                    device["device_config"] = self.read_device_config_file(self.CONFIG_PATH+device["file"])["DEVICE"]
-                devices[device["name"]] = device
-            return devices
-
-    def get_devices_names(self)->list:
-        """Return the list of devices names of an observatory
-
-        Returns:
-            list: list of names of devices
-        """
-        devices_names = []
-        for device in self.obs_config["OBSERVATORY"]["DEVICES"]:
-            devices_names.append(device["DEVICE"]["name"])
-        return devices_names
-
-    def get_agents(self,unit_name)->dict:
-        """
-        return dictionary of agents 
-
-        Args:
-            unit_name (str): name of the unit
-
-        Returns:
-            dict: dictionary of agents. For each agents tell the name, computer, device, protocole, etc...
-        """
-        unit = self.get_unit_by_name(unit_name)
-        if self.agents != None:
-            return self.agents
-        else:
-            agents = {}
-            
-            
-            for agent_id in range(len(unit["AGENTS"])):
-                # Agents is a list containing dictionary that have only one key
-                key = list(unit["AGENTS"][agent_id].keys())[0]
-                agent = unit["AGENTS"][agent_id][key]
-                agents[agent["name"]] = agent
-            return agents
-
-    def get_layouts(self, unit_name: str) -> dict:
-        """
-        Return dictionary of layouts
-
-        Args:
-            unit_name (str): name of the unit
-        Returns:
-            dict: dictionary of layouts
-        """
-        unit = self.get_unit_by_name(unit_name)
-        info = {}
-        info["layouts"] = {}
-        for layout_id in range(len(unit["TOPOLOGY"]["LAYOUTS"])):
-            layout = unit["TOPOLOGY"]["LAYOUTS"][layout_id]["LAYOUT"]
-            info["layouts"][layout["name"]] = layout
-        return info
-
-    def get_albums(self,unit_name : str) -> dict:
-        """
-        Return dictionary of layouts
-
-        Args:
-            unit_name (str): name of the unit
-        Returns:
-            dict: dictionary of layouts
-        """
-        unit = self.get_unit_by_name(unit_name)
-        info = {}
-        info["albums"] = {}
-        for album_id in range(len(unit["TOPOLOGY"]["ALBUMS"])):
-            album = unit["TOPOLOGY"]["ALBUMS"][album_id]["ALBUM"]
-            info["albums"][album["name"]] = album
-        return info
-
-    def get_channel_information(self, unit_name: str, channel_name: str) -> dict:
-        """
-        Return information of the given channel name of a unit
-
-        Args:
-            unit_name (str): Name of the unit 
-            channel_name (str): name of the channel
-
-        Returns:
-            dict: dictionary containing all values that define this channel
-        """
-        channels = self.get_channels(unit_name)
-        return channels[channel_name]
-
-    def get_topology(self, unit_name:str)->dict:
-        """
-        Return dictionary of the topology of the observatory
-
-        Args:
-            unit_name (str): Name of the unit
-        Returns:
-            dict: dictionary representing the topology of an unit (security, mount, channels, layouts, albums)
-        """
-        unit = self.get_unit_by_name(unit_name)
-        topology = {}
-        for key in unit["TOPOLOGY"].keys():
-            branch = unit["TOPOLOGY"][key]
-            if key == "CHANNELS":
-                topology[key] = self.get_channels(unit_name)
-            elif key == "LAYOUTS":
-                topology[key] = self.get_layouts(unit_name)
-            elif key == "ALBUMS":
-                topology[key] = self.get_albums(unit_name)
-            else:
-                topology[key] = branch
-        return topology
-
-    def get_active_agents(self, unit_name: str) -> list:
-        """
-        Return the list of active agents (i.e. agents that have an association with a device)
-
-        Args:
-            unit_name (str): Name of the unit
-
-        Returns:
-            list: kist of the name of active agents
-        """
-        return list(self.get_agents(unit_name).keys())
-
-    def get_units(self)->dict:
-        """
-        Return all units sort by name defined in the config file
-
-        Returns:
-            dict: dictionary giving for a unit_name, his content (name,database,topology,agents,...)
-        """
-        result = {}
-        units = self.obs_config["OBSERVATORY"]["UNITS"]
-        for unit in units:
-            unit = unit["UNIT"]
-            result[unit["name"]] = unit
-        return result
-
-    def get_components_agents(self, unit_name: str) -> dict:
-        """
-        Return dictionary of component_agents of the given unit
-
-        Args:
-            unit_name (str): Name of the unit
-
-        Returns:
-            dict: dictionary sort by component name giving the associated agent (agent name)
-        """
-        components_agents = {}
-        topology = self.get_topology(unit_name)
-        for element in topology:
-            if element in ("SECURITY","MOUNT","CHANNELS"):
-                if(element != "CHANNELS"):
-                    for component_agent in topology[element]["COMPONENT_AGENTS"]:
-                        component_name = list(component_agent.keys())[0]
-                        components_agents[component_name] = component_agent[component_name]
-                else:
-                    for channel in topology[element]:
-                        for component_agent in topology[element][channel]["COMPONENT_AGENTS"]:
-                            component_name = list(component_agent.keys())[0]
-                            components_agents[component_name] = component_agent[component_name]
-        return components_agents
-
-    def get_units_name(self)->list:
-        """
-        Return list of units names 
-
-        Returns:
-            [list]: names of units
-        """
-        return list(self.get_units().keys())
-
-    def get_unit_by_name(self, name: str) -> dict:
-        """
-        Return dictionary containing definition of the unit that matches the given name
-
-        Args:
-            name (str): name of the unit
-
-        Returns:
-            dict: dictonary representing the unit
-        """
-        return self.get_units()[name]
-    
-    def get_agents_per_computer(self, unit_name: str) -> dict:
-        """
-        Return dictionary that give for each computer, what are the associated agents to it as a list
-
-        Args:
-            unit_name (str): Name of the unit
-
-        Returns:
-            dict:  dictionary that give for each computer, what are the associated agents to it as a list
-
-        """
-        agents_per_computer = {}
-        agents = self.get_agents(unit_name)
-        for agent in agents:
-            computer_name = agents[agent]["computer"]
-            if(agents[agent]["computer"] not in agents_per_computer.keys()):
-                agents_per_computer[computer_name] = [agent]
-            else:
-                agents_per_computer[computer_name].append(agent)
-        return agents_per_computer
-
-
-    def get_agents_per_device(self,unit_name:str)->dict:
-        """
-        Return dictionary that give for each device, what are the associated agents to it as a list
-
-        Args:
-            unit_name (str): Name of the unit
-
-        Returns:
-            dict:  dictionary that give for each device, what are the associated agents to it as a list
-
-        """
-        agents_per_device = {}
-        agents = self.get_agents(unit_name)
-        for agent in agents:
-            if("device" in agents[agent].keys()):
-                device_name = agents[agent]["device"]
-                if device_name in self.get_devices_names():
-                    if(agents[agent]["device"] not in agents_per_device.keys()):
-                        agents_per_device[device_name] = [agent]
-                    else:
-                        agents_per_device[device_name].append(agent)
-                else:
-                    print(f"Error: device name '{device_name}' for agent '{agent}' is not known in the configuration file. The device name must match one of the names defined in the DEVICES section")
-                    exit(1)
-        return agents_per_device
-
-    def get_active_devices(self)->list:
-        """
-        Return a list of active device names
-
-        Returns:
-            list: list of active device names
-        """
-        active_devices = []
-        for unit_name in self.get_units():
-            for device in self.get_agents_per_device(unit_name):
-                active_devices.append(device)
-        return active_devices
-
-    def get_active_computers(self)->list:
-        """
-        Return a list of active computer names
-
-        Returns:
-            list: list of active computer names
-        """
-        active_computers = []
-        for unit_name in self.get_units():
-            unit = self.get_unit_by_name(unit_name)
-            for computer in self.get_agents_per_computer(unit_name):
-                active_computers.append(computer)
-        return active_computers
-
-    def get_agent_information(self,unit_name:str,agent_name:str)->dict:
-        """
-        Give the dictionary of attributes of the agent for an unit.
-
-        Args:
-            unit (dict): dictonary representing the unit
-            agent_name (str): agent name
-
-        Returns:
-            dict: dictionary containing attributes of the agent
-        """
-        return self.get_agents(unit_name)[agent_name]
-
-    def get_device_information(self,device_name:str)->dict:
-        """
-        Give the dictionary of the attributes of the device 
-
-        Args:
-            device_name (str): device name
-
-        Returns:
-            dict: dictionary containing attributes of the device
-        """
-        return self.get_devices()[device_name]
-
-    def get_database_for_unit(self, unit_name: str) -> dict:
-        """
-        Return dictionary of attributes of the database for an unit
-
-        Args:
-            unit_name (str): unit name
-
-        Returns:
-            dict: dictionary of attributes of the database for an unit
-        """
-        return self.get_unit_by_name(unit_name)["DATABASE"]
-
-    def get_device_for_agent(self, unit_name: str, agent_name: str) -> str:
-        """
-        Return device name associated to the agent
-
-        Args:
-            unit (dict): dictonary representing the unit
-            agent_name (str): agent name
-
-        Returns:
-            str: device name associated to this agent
-        """
-        agents_per_device = self.get_agents_per_device(unit_name)
-        for device in agents_per_device:
-            if agent_name in agents_per_device[device]:
-                return self.get_device_information(device)
-
-    def get_unit_of_computer(self, computer_name: str) -> str:
-        """
-        Return the name of the unit where the computer is used
-
-        Args:
-            computer_name (str): computer name
-
-        Returns:
-            str: unit name
-        """
-        for unit_name in self.get_units():
-            if(computer_name in self.get_agents_per_computer(unit_name)):
-                return unit_name
-
-    def get_unit_of_device(self, device_name:str)->str:
-        """
-        Return the name of the unit where the device is used
-
-        Args:
-            device_name (str): device name
-
-        Returns:
-            str: unit name
-        """
-        for unit_name in self.get_units():
-            if(device_name in self.get_agents_per_device(unit_name)):
-                return unit_name
-
-    def get_device_power(self,device_name:str)->dict:
-        """
-        Return dictionary that contains informations about power if this information is present in the device config file
-
-        Return None if this information isn't stored in device's config file
-        Args:
-            device_name (str): name of the device
-
-        Returns:
-            dict: informations about power of device
-        """
-        return self.get_devices()[device_name]["device_config"].get("power")
-
-
-    def get_device_capabilities(self, device_name:str)->list:
-        """
-        Return dictionary that contains informations about capabilities if this information is present in the device config file
-
-        Return empty list if this information isn't stored in device's config file
-        Args:
-            device_name (str): name of the device
-
-        Returns:
-            list: list of capabilities of device
-        """
-        list_of_capabilities = []
-        capabilities = self.get_devices()[device_name]["device_config"].get("CAPABILITIES")
-        return capabilities
-
-    def get_device_connector(self,device_name:str)->dict:
-        """
-        Return dictionary that contains informations about connector if this information is present in the device config file
-
-        Return None if this information isn't stored in device's config file
-        Args:
-            device_name (str): name of the device
-
-        Returns:
-            dict: informations about connector of device
-        """
-        return self.get_devices()[device_name]["device_config"].get("connector")
-
-    def get_computer_power(self, computer_name: str) -> dict:
-        """
-        Return dictionary that contains informations about power if this information is present in the device config file
-
-        Return None if this information isn't stored in device's config file
-        Args:
-            device_name (str): name of the device
-
-        Returns:
-            dict: informations about connector of device
-        """
-        return self.get_computers()[computer_name]["computer_config"].get("power")
-
-    def getDeviceControllerNameForAgent(self,unit_name:str,agent_name:str)->tuple:
-        agent = self.get_agent_information(unit_name,agent_name)
-        return (agent["device"],"DeviceController"+agent["device"])
-
-    def getDeviceConfigForDeviceController(self,device_name:str)->dict:
-        return self.get_devices()[device_name]["device_config"]
-
-    def getCommParamsForAgentDevice(self,unit_name:str,agent_name:str)->tuple:
-        agent = self.get_agent_information(unit_name,agent_name)
-        device_config = self.getDeviceConfigForDeviceController(agent["device"])
-        comm_access = agent.get("comm_access",None)
-        comm = device_config["comm"]
-        return (comm_access,comm)
-
-    def getChannelCapabilities(self,unit_name:str,channel_name:str)->list:
-        channel = self.get_channel_information(unit_name,channel_name)
-        result = []
-        for component_agent in channel["COMPONENT_AGENTS"]:
-            component = list(component_agent.keys())[0]
-            agent = component_agent[component]
-            device = self.getDeviceControllerNameForAgent(unit_name,agent)[0]
-            device_capabilities = self.get_device_capabilities(device)
-            for capability in device_capabilities:
-                if capability["component"] == component:
-                    result.append(capability)
-        return result
-
-    def getEditableAttributesOfCapability(self,capability:dict)->dict:
-        editable_fields = {}
-        attributes = capability.get("attributes")
-        for attribute in attributes:
-            if attributes[attribute]["is_editable"]:
-                editable_fields[attribute] = attributes[attribute]
-        return editable_fields
-
-    def getUneditableAttributesOfCapability(self,capability:dict)->dict:
-        uneditable_fields = {}
-        attributes = capability.get("attributes")
-        for attribute in attributes:
-            if attributes[attribute]["is_editable"] == False:
-                uneditable_fields[attribute] = attributes[attribute]
-        return uneditable_fields
-
-    def getEditableAttributesOfChannel(self,unit_name:str,channel_name:str)->list:
-        capabilities = self.getChannelCapabilities(unit_name,channel_name)
-        # merged_result = {}
-        # for capability in capabilities:
-        #     merged_result[capability["component"]] = self.getEditableAttributesOfCapability(capability)
-        # return merged_result
-        merged_result = []
-        for capability in capabilities:
-            attributes = self.getEditableAttributesOfCapability(capability)
-            if len(attributes.keys()) > 0:
-                merged_result.append(attributes)
-        return merged_result
-
-    def getUneditableAttributesOfChannel(self,unit_name:str,channel_name:str)->list:
-        capabilities = self.getChannelCapabilities(unit_name,channel_name)
-        # merged_result = {}
-        # for capability in capabilities:
-        #     merged_result[capability["component"]] = self.getEditableAttributesOfCapability(capability)
-        # return merged_result
-        merged_result = []
-        for capability in capabilities:
-            attributes = self.getUneditableAttributesOfCapability(capability)
-            if len(attributes.keys()) > 0:
-                merged_result.append(attributes)
-        return merged_result
-
-
-    # def getLogicOfChannelGroups(self,unit_name):
-    #     return self.get_layouts(unit_name)["global_group_logic"]
-
-    
-    def getLayoutByName(self, unit_name:str, name_of_layout):
-        return self.get_layouts(unit_name)["layouts"][name_of_layout]
-
-    def getAlbumByName(self,unit_name : str, name_of_album):
-        return self.get_albums(unit_name)["albums"][name_of_album]
-
-    def getEditableAttributesOfMount(self,unit_name):
-        capabilities = self.get_device_capabilities(self.get_device_for_agent(unit_name,"mount")["name"])
-        merged_result = []
-        for capability in capabilities:
-            attributes = self.getEditableAttributesOfCapability(capability)
-            if len(attributes.keys()) > 0:
-                merged_result.append(attributes)
-        return merged_result
-    
-    
-    def getHorizonLine(self, unit_name):
-        horizon = self.get_unit_by_name(unit_name).get("horizon")
-        return horizon.get("line")
-
-def main():
-    # config = ConfigPyros("../../../../privatedev/config/guitalens/observatory_guitalens.yml")
-    # unit_name = config.get_units_name()[0]
-    # dc = config.getDeviceControllerNameForAgent(unit_name,"mount")[0]
-    #print(config.getDeviceConfigForDeviceController(dc))
-    #print(config.getCommParamsForAgentDevice(unit_name,"mount"))
-    # print(config.getChannelCapabilities(unit_name,"OpticalChannel_up"))
-    # print(config.get_channel_groups(unit_name))
-    # print(config.getEditableAttributesOfCapability(config.getChannelCapabilities(unit_name,"OpticalChannel_up")[0]))
-    # print(config.getEditableAttributesOfChannel(unit_name,"OpticalChannel_up"))
-    config = ConfigPyros("../../../../privatedev/config/tnc/observatory_tnc.yml")
-    unit_name = config.get_units_name()[0]
-    #dc = config.getDeviceControllerNameForAgent(unit_name,"mount")[0]
-    #print(config.getDeviceConfigForDeviceController(dc))
-    #print(config.getCommParamsForAgentDevice(unit_name,"mount"))
-    # print(config.getChannelCapabilities(unit_name,"OpticalChannel_down2"))
-    # print(config.get_channel_groups(unit_name))
-    # print(config.getEditableAttributesOfCapability(config.getChannelCapabilities(unit_name,"OpticalChannel_down2")[0]))
-    # print(config.getEditableAttributesOfChannel(unit_name,"OpticalChannel_down2"))
-    print(config.getEditableAttributesOfMount(unit_name))
-    #print(config.get_devices()["FLI-Kepler4040"]["device_config"])
-    #print(config.get_devices()["FLI-Kepler4040"]["device_config"]["CAPABILITIES"][1]["attributes"]["manufacturer"])
-    #print(config.get_devices()["FLI-Kepler4040"]["device_config"]["CAPABILITIES"])
-    #print(config.get_devices()["AstroMecCA-TM350"]["device_config"]["CAPABILITIES"])
-if __name__ == "__main__": 
-
+#!/usr/bin/env python3
+import pykwalify.core
+import sys
+import yaml, logging, os, pickle, time
+from datetime import datetime
+from pykwalify.errors import PyKwalifyException,SchemaError
+from pathlib import Path
+
+class OBSConfig:
+    # (AKo) : Config file path is checked on the settings file, if the file isn't valid (i.e not found) the error will be launched by the settings file when starting the application 
+    devices_links = {}
+    current_file = None
+    #COMPONENT_PATH = os.path.join(os.environ["DJANGO_PATH"],"../../../config/components/")
+    #GENERIC_DEVICES_PATH = os.path.join(os.environ["DJANGO_PATH"],"../../../config/devices/")
+    pickle_file = "obsconfig.p"
+    obs_config = None
+    devices = None
+    computers = None
+    agents = None 
+    obs_config_file_content = None
+    #obs_config_path = os.environ.get("PATH_TO_OBSCONF_FOLDER",os.path.join(os.environ["DJANGO_PATH"],"../../../privatedev/config/default/"))
+    errors = None
+
+    def verify_if_pickle_needs_to_be_updated(self, observatory_config_file)->bool:
+        """
+
+        Args:
+            observatory_config_file ([type]): [description]
+
+        Returns:
+            bool: [description]
+        """
+        self.CONFIG_PATH = os.path.dirname(observatory_config_file)+"/"
+        self.obs_config_path = self.CONFIG_PATH
+        #self.CONFIG_PATH = self.obs_config_path
+        if os.path.isfile(self.CONFIG_PATH+self.pickle_file) == False:
+            return True
+        else:
+            pickle_file_mtime = os.path.getmtime(self.CONFIG_PATH+self.pickle_file)
+            obs_config_mtime = os.path.getmtime(observatory_config_file)
+
+            obs_config = self.read_and_check_config_file(observatory_config_file)
+            if obs_config_mtime > pickle_file_mtime:
+                # create obs file (yaml) from pickle["obsconfig"] with date of pickle within history folder-> nom ficher + année + mois + jour + datetime (avec secondes) -> YYYY/MM/DD H:m:s
+                pickle_datetime = datetime.utcfromtimestamp(pickle_file_mtime).strftime("%Y%m%d_%H%M%S")
+                # Create history folder if doesn't exist
+                Path(self.obs_config_path+"/history/").mkdir(parents=True, exist_ok=True)
+                file_name = f"{self.obs_config_path}/history/observatory_{pickle_datetime}.yml"
+                config_file = open(observatory_config_file,"r")
+
+                with open(file_name, 'w') as f:
+                    f.write(config_file.read())
+                return True
+            if obs_config == None:
+                print(f"Error when trying to read config file (path of config file : {observatory_config_file}")
+                return -1
+            self.obs_config = obs_config
+            # check last date of modification for devices files
+            for device in self.obs_config["OBSERVATORY"]["DEVICES"]:
+                device_file = self.CONFIG_PATH+device["DEVICE"]["file"]
+                device_file_mtime = os.path.getmtime(device_file)
+                if device_file_mtime > pickle_file_mtime:
+                    return True
+
+            for computer in self.obs_config["OBSERVATORY"]["COMPUTERS"]:
+                computer_file = self.CONFIG_PATH+computer["COMPUTER"]["file"]
+                computer_file_mtime = os.path.getmtime(computer_file)
+                if computer_file_mtime > pickle_file_mtime:
+                    return True
+        return False
+
+    def load(self, observatory_config_file):
+        pickle_needs_to_be_updated = self.verify_if_pickle_needs_to_be_updated(observatory_config_file)
+        # check if we already read and load devices configuration and if pickle needs to be updated
+        if pickle_needs_to_be_updated == False and self.devices != None:
+            return None
+        else:
+            if os.path.isfile(self.CONFIG_PATH+self.pickle_file) and pickle_needs_to_be_updated == False:
+                print("Reading pickle file")
+                try:
+                    can_pickle_file_be_read = False
+                    while can_pickle_file_be_read != True:
+                        if os.access(self.CONFIG_PATH+self.pickle_file, os.R_OK):
+                            pickle_dict = pickle.load(open(self.CONFIG_PATH+self.pickle_file,"rb"))
+                            can_pickle_file_be_read = True
+                        else:
+                            time.sleep(0.5)
+                except IOError:
+                    print("Error when reading the pickle file")
+                try:
+                    self.obs_config = pickle_dict["obs_config"]
+                    self.computers = pickle_dict["computers"]
+                    self.devices = pickle_dict["devices"]
+                    self.devices_links = pickle_dict["devices_links"]
+                    self.obs_config_file_content = pickle_dict["obs_config_file_content"]
+                    self.raw_config =  pickle_dict["raw_config"] 
+                except:
+                    # we rewrite the pickle file, the content will be the same otherwise we would be in the else case
+                    print("Rewritting the pickle file (an error occured while reading it, the content will be the same as it was")
+                    pickle_dict = {}
+                    
+                    self.obs_config = self.read_and_check_config_file(observatory_config_file) 
+                    obs_file = open(observatory_config_file,"r")
+                    pickle_dict["raw_config"] = obs_file.read()
+                    obs_file.close()
+                    self.raw_config =  pickle_dict["raw_config"] 
+                    pickle_dict["obs_config"] = self.obs_config
+                    pickle_dict["devices"] = self.get_devices()
+                    pickle_dict["computers"] = self.get_computers()
+                    pickle_dict["devices_links"] = self.devices_links
+                    pickle_dict["obs_config_file_content"] = self.read_and_check_config_file(observatory_config_file) 
+                    print("Writing pickle file")
+                    pickle.dump(pickle_dict,open(self.CONFIG_PATH+self.pickle_file,"wb"))    
+            else:
+                print("Pickle file needs to be created or updated")
+                pickle_dict = {}
+
+                self.obs_config = self.read_and_check_config_file(observatory_config_file) 
+                pickle_dict["obs_config"] = self.obs_config
+                pickle_dict["devices"] = self.get_devices()
+                pickle_dict["computers"] = self.get_computers()
+                pickle_dict["devices_links"] = self.devices_links
+                pickle_dict["obs_config_file_content"] = self.read_and_check_config_file(observatory_config_file) 
+                print("Writing pickle file")
+                pickle.dump(pickle_dict,open(self.CONFIG_PATH+self.pickle_file,"wb"))
+
+    def check_and_return_config(self,yaml_file:str,schema_file:str)->dict:
+        """
+        Check if yaml_file is valid for the schema_file and return an dictionary of the config file
+
+        Args:
+            yaml_file (str): Path to the config_file to be validated
+            schema_file (str): Path to the schema file 
+
+        Returns:
+            dict: dictionary of the config file (with values)
+        """
+        # disable pykwalify error to clean the output
+        #####logging.disable(logging.ERROR)
+        try:
+            can_yaml_file_be_read = False
+            while can_yaml_file_be_read != True:
+                if os.access(yaml_file, os.R_OK):
+                    can_yaml_file_be_read = True
+                else:
+                    print(f"{yaml_file} can't be accessed, waiting for availability")
+                    time.sleep(0.5)
+
+            c = pykwalify.core.Core(source_file=yaml_file, schema_files=[self.SCHEMA_PATH+schema_file])
+            return c.validate(raise_exception=True)
+        except SchemaError:
+            for error in c.errors:
+                print("Error :",str(error).split(". Path")[0])
+                print("Path to error :",error.path)
+                self.errors = c.errors
+            return None
+        except IOError:
+            print("Error when reading the observatory config file")
+
+    @staticmethod
+    def check_config(yaml_file:str,schema_file:str)->any:
+        """
+        Check if yaml_file is valid for the schema_file and return a boolean or list of errors according the schema
+
+        Args:
+            yaml_file (str): Path to the config_file to be validated
+            schema_file (str): Path to the schema file 
+
+        Returns:
+            any: boolean (True) if the configuration is valid according the schema or a list of error otherwise
+        """
+        # disable pykwalify error to clean the output
+        ####logging.disable(logging.ERROR)
+        try:
+            can_yaml_file_be_read = False
+            while can_yaml_file_be_read != True:
+                if os.access(yaml_file, os.R_OK):
+                    can_yaml_file_be_read = True
+                else:
+                    print(f"{yaml_file} can't be accessed, waiting for availability")
+                    time.sleep(0.5)
+        
+            c = pykwalify.core.Core(source_file=yaml_file, schema_files=[schema_file])
+            c.validate(raise_exception=True)
+            return True
+        except SchemaError:
+            for error in c.errors:
+                print("Error :",str(error).split(". Path")[0])
+                print("Path to error :",error.path)
+                
+            return c.errors
+        except IOError:
+            print("Error when reading the observatory config file")
+            
+    def read_and_check_config_file(self,yaml_file:str)->dict:
+        """
+        Read the schema key of the config file to retrieve schema name and proceed to the checking of that config file
+        Call check_and_return_config function and print its return.
+
+        Args:
+            yaml_file (str): path to the config file
+        Returns:
+            dict: Dictionary of the config file (with values)
+        """
+        self.current_file = yaml_file
+        try:
+            can_config_file_be_read = False
+            while can_config_file_be_read != True:
+                
+                if os.access(yaml_file, os.R_OK):
+                    can_config_file_be_read = True
+                else:
+                    print(f"{yaml_file} can't be accessed, waiting for availability")
+                    time.sleep(0.5)
+            with open(yaml_file, 'r') as stream:
+                print(f"Reading {yaml_file}")
+                config_file = yaml.safe_load(stream)
+
+            self.DJANGO_PATH = os.environ.get("DJANGO_PATH",os.path.abspath(os.path.dirname(yaml_file)))
+            self.SCHEMA_PATH = os.path.join(self.DJANGO_PATH,"../../../config/schemas/")
+            self.CONFIG_PATH = self.obs_config_path
+            self.COMPONENT_PATH = os.path.join(self.DJANGO_PATH,"../../../config/components/")
+            self.GENERIC_DEVICES_PATH = os.path.join(self.DJANGO_PATH,"../../../config/devices/")
+            result = self.check_and_return_config(yaml_file,config_file["schema"])
+            if result == None:
+                print("Error when reading and validating config file, please check the errors right above")
+                exit(1)
+            return result
+
+        except yaml.YAMLError as exc:
+            print(exc)
+        except Exception as e:
+            print(e)
+            return None
+    
+    def read_generic_component_and_return_attributes(self,component_name:str)->dict:
+        file_path = self.COMPONENT_PATH + component_name + ".yml"
+        try:
+            with open(file_path, 'r') as stream:
+                config_file = yaml.safe_load(stream)  
+                
+                attributes = {}
+                for attribute in config_file:
+                
+                    attribute = attribute["attribute"]
+                    attributes[attribute.pop("key")] = attribute
+                return attributes
+        except yaml.YAMLError as exc:
+            print(exc)
+        except Exception as e:
+            print(e)
+            return None
+    
+    def read_capability_of_device(self,capability:dict)->dict:
+        """
+        Read capability of device and inherit attributes from generic component then overwrite attributes defined in device config
+
+        Args:
+            capability (dict): dictionary containing a capabilitiy (keys : component and attributes)
+
+        Returns:
+            dict: dictionary of capability inherited by generic component and overwritten his attributes by current attributes of capability
+        """
+        
+        component_attributes = self.read_generic_component_and_return_attributes(capability["component"])
+        
+        attributes = {}
+        # get all attributes of device's capability
+        for attribute in capability["attributes"]:
+            attribute = attribute["attribute"]
+        
+            attributes[attribute.pop("key")] = attribute
+        
+        # for each attributes of generic component attributes
+        for attribute_name in attributes.keys():
+            # merge attributes of general component with specified component in device config file
+            new_attributes = {**component_attributes[attribute_name],**attributes[attribute_name]}
+            if "is_enum" in component_attributes[attribute_name].keys():
+                # make an intersection of both list of values
+                new_attributes["value"] = list(set(attributes[attribute_name]["value"]) & set(component_attributes[attribute_name]["value"]))
+                if len(new_attributes["value"]) == 0:
+                    print(f"Value of lastly read device's attribute '{attribute_name}' isn't one of the values of component configuration for this device (component configuration value(s): {component_attributes[attribute_name]['value']}) (actual value : {attributes[attribute_name]['value']})")
+                    exit(1)
+            component_attributes[attribute_name] = new_attributes
+        
+        # return inherited and overwritten attributes of capability
+        capability["attributes"] = component_attributes
+        return capability
+
+    def get_devices_names_and_file(self) -> dict:
+        """
+        Return a dictionary giving the device file name by the device name 
+        Returns:
+            dict: key is device name, value is file name
+        """
+        devices_names_and_files = {}
+        for device in self.obs_config["OBSERVATORY"]["DEVICES"]:
+            device = device["DEVICE"]
+            
+            devices_names_and_files[device["name"]] = device["file"]
+        return devices_names_and_files
+
+    def read_device_config_file(self,config_file_name:str,is_generic=False)->dict:
+        """
+        Read the device config file, inherit generic device config if "generic" key is present in "DEVICE".
+        Associate capabilities of attached_devices if this device has attached_devices.
+        Inherit capabilities from generic component and overwritte attributes defined in the device config
+        Args:
+            config_file_name (str): file name to be read
+            is_generic (bool, optional): tells if we're reading a generic configuration (is_generic =True) or not (is_generic = False). Defaults to False.
+
+        Returns:
+            dict: formatted device configuration (attributes, capabilities...)
+        """
+        self.current_file = config_file_name
+        devices_name_and_file = self.get_devices_names_and_file()
+        if not is_generic:
+            # check if device config file is listed in observatory configuration
+            current_device_name = [device for device,file_name in devices_name_and_file.items() if file_name in config_file_name[len(self.CONFIG_PATH):] ]
+            if len(current_device_name) <= 0:
+                print(f"Current file '{config_file_name[len(self.CONFIG_PATH):]}' isn't listed in observatory configuration")
+                print("The devices names and files are: ")
+                for device_name,file_name in devices_name_and_file.items():
+                    print(f"device name: '{device_name}', device filename: '{file_name}'")
+                exit(1)
+        print(f"Reading {config_file_name}")
+        try:
+            with open(config_file_name, 'r') as stream:
+                config_file = yaml.safe_load(stream)
+                # if we're reading a generic device configuration, the path to get the schema is different than usual
+                self.SCHEMA_PATH =os.path.join(self.DJANGO_PATH,"../../../config/schemas/")
+                
+                # read and verify that the device configuration match the schema
+                result = self.check_and_return_config(config_file_name,config_file["schema"])
+                # if the configuration didn't match the schema or had an error when reading the file
+                if result == None:
+                    print("Error when reading and validating config file, please check the errors right above")
+                    exit(1)
+                else:
+                    # the configuration is valid
+                    # storing DEVICE key in device (DEVICE can contains : attributes of device, capabilities, attached devices)
+                    device = result["DEVICE"]
+                    generic_device_config = None
+                    # if the device is associated to an generic configuration, we'll read that generic configuration to inherit his attributes
+                    if "generic" in device:
+                        # storing the whole current config
+                        current_config = result
+                        # read and get the generic device config
+                        generic_device_config = self.read_device_config_file(self.GENERIC_DEVICES_PATH+device["generic"],is_generic=True)
+                        # merge whole device config but we need to merge capabilities differently after
+                        new_config = {**generic_device_config["DEVICE"],**current_config["DEVICE"]}
+                        result["DEVICE"] = new_config
+
+                    # device has capabilities
+                    if "CAPABILITIES" in device:
+                        capabilities = []
+                        # if the device is associated to a generic device we need to associate his capabilities with the generic capabilities and overwrite them
+                        if generic_device_config != None:
+                            # we're making a copy of generic device config so we can remove items during loop
+                            copy_generic_device_config = generic_device_config.copy()
+                            # We have to extend capabilities of generic device configuration
+                            for capability in current_config["DEVICE"]["CAPABILITIES"]:
+                                is_capability_in_generic_config = False
+                                current_config_capability = capability["CAPABILITY"]
+                                current_config_component = current_config_capability["component"]
+                                # find if this component was defined in generic_device_config
+                                for index,generic_config_capability in enumerate(generic_device_config["DEVICE"]["CAPABILITIES"]):
+                                    # if the current capability is the capability of the component we're looking for
+                                    if current_config_component == generic_config_capability["component"]:
+                                        is_capability_in_generic_config = True
+                                        # we're merging their attributes
+                                        new_attributes = generic_config_capability["attributes"].copy()
+                                        attributes = {}
+                                        current_config_attributes = current_config_capability["attributes"]                                        
+                                        generic_config_attributes = generic_config_capability["attributes"]
+                                        for attribute in current_config_attributes:
+                                            attribute = attribute["attribute"]
+                                            attributes[attribute.pop("key")] = attribute
+                                        # for each attributes of device component attributes
+                                        for attribute_name in attributes.keys():
+                                            # merge attributes of general component with specified component in device config file
+                                            new_attributes[attribute_name] = {**generic_config_attributes[attribute_name],**attributes[attribute_name]}
+                                            if "is_enum" in generic_config_attributes[attribute_name].keys():
+                                                # make an intersection of both list of values
+                                                new_attributes[attribute_name]["value"] = list(set(attributes[attribute_name]["value"]) & set(generic_config_attributes[attribute_name]["value"]))
+                                                if len(new_attributes[attribute_name]["value"]) == 0:
+                                                    print(f"Value of device '{config_file_name}' for attribute '{attribute_name}' isn't one of the values of generic configuration for this device (generic value(s): {generic_config_attributes[attribute_name]['value']}) (actual value : {attributes[attribute_name]['value']})")
+                                                    exit(1)
+                                        # removing this capability from generic device configuration
+                                        generic_device_config["DEVICE"]["CAPABILITIES"].pop(index)
+                                        capabilities.append({"component": current_config_component,"attributes":new_attributes}) 
+                                        break
+                                if is_capability_in_generic_config == False:
+                                    current_config_capability = self.read_capability_of_device(current_config_capability)
+                                    # the component defined in the current_config isn't defined in generic config (should not happen but we'll deal with that case anyway) : we're simply adding this capability
+                                    capabilities.append(current_config_capability)
+                            # looping through generic device config's capabilities in order to add them to current device configuration
+                            for generic_config_capability in generic_device_config["DEVICE"]["CAPABILITIES"]:
+                                capabilities.append(generic_config_capability)
+                        else:
+                            # device not associated to a generic device configuration
+                            for capability in device["CAPABILITIES"]:
+                                capability = capability["CAPABILITY"]
+                                capabilities.append(self.read_capability_of_device(capability))
+                        device["CAPABILITIES"] = capabilities
+                        # associate capabilities to final device configuration (stored in result variable)
+                        result["DEVICE"]["CAPABILITIES"] = device["CAPABILITIES"]
+                    if "ATTACHED_DEVICES" in device.keys():
+                        # device has attached devices, we need to read their configuration in order to get their capabilities and add them to the current device
+                        devices_name_and_file = self.get_devices_names_and_file()
+                        active_devices = self.get_active_devices()
+                        for attached_device in device["ATTACHED_DEVICES"]:
+                            is_attached_device_link_to_agent = False
+                            # we're looking for if the attached device is associated to an agent (i.e. the device is considered as 'active'). However an attached_device shoudn't be active
+                            for active_device in active_devices:
+                                if devices_name_and_file[active_device] == attached_device["file"]:
+                                    # the attached device is an active device (so it's linked to an agent)
+                                    is_attached_device_link_to_agent = True
+                                    break
+                            if self.CONFIG_PATH+attached_device["file"] != config_file_name and not is_attached_device_link_to_agent:
+                            # if the attached device isn't the device itself and not active
+                                
+                                # get configuration of attached device
+                                config_of_attached_device = self.read_device_config_file(self.CONFIG_PATH+attached_device["file"])
+                                capabilities_of_attached_device = None
+                                if "CAPABILITIES" in config_of_attached_device["DEVICE"].keys():
+                                    capabilities_of_attached_device = config_of_attached_device["DEVICE"]["CAPABILITIES"]
+                                if capabilities_of_attached_device != None:
+                                    # get name of device corresponding to the config file name
+                                    parent_device_name = [device for device,file_name in devices_name_and_file.items() if file_name == config_file_name[len(self.CONFIG_PATH):]]
+                                    attached_device_name = [device for device,file_name in devices_name_and_file.items() if file_name == attached_device["file"]]
+                                    if len(parent_device_name) > 0 :
+                                        parent_device_name = parent_device_name[0]
+                                    else:
+                                        print(f"Attached device filename '{config_file_name[len(self.CONFIG_PATH):]}' is not listed in observatory devices files names")
+                                        print("The devices names and files are: ")
+                                        for device_name,file_name in devices_name_and_file.items():
+                                            print(f"device name: '{device_name}', device filename: '{file_name}'")
+                                        exit(1)
+                                    if len(attached_device_name) > 0 :
+                                        attached_device_name = attached_device_name[0]
+                                    else:
+                                        
+                                        print(f"Attached device filename '{attached_device['file']}' is not listed in observatory devices files names")
+                                        print("The devices names and files are: ")
+                                        for device_name,file_name in devices_name_and_file.items():
+                                            print(f"device name: '{device_name}', device filename: '{file_name}'")
+                                        exit(1)
+                                    # associate attached device to his 'parent' device (parent device is the currently read device)
+                                    self.devices_links[attached_device_name] = parent_device_name
+                                    for capability in capabilities_of_attached_device:
+                                        # add capabilities of attached device to current device
+                                        result["DEVICE"]["CAPABILITIES"].append(capability)
+                return result
+        except yaml.YAMLError as exc:
+            print(exc)
+        except Exception as e:
+            print(e)
+            exit(1)
+            #return None
+
+    def __init__(self, observatory_config_file:str, unit_name:str="") -> None:
+        """
+        Initiate class with the config file
+        set content attribute to a dictionary containing all values from the config file
+
+        Args:
+            config_file_name (str): path to the config file
+        """
+        self.load(observatory_config_file)
+        if unit_name == "":
+            # By default we will use the first unit
+            self.unit_name = self.get_units_name()[0]
+        else:
+            self.unit_name = unit_name
+
+    def get_obs_name(self) -> str:
+        """
+        Return name of the observatory
+
+        Returns:
+            str: Name of the observatory
+        """
+        return self.obs_config["OBSERVATORY"]["name"]
+
+    def get_channels(self, unit_name: str) -> dict:
+        
+        """
+        return dictionary of channels
+
+        Args:
+            unit_name (str): Name of the unit
+        Returns:
+            dict: [description]
+        """
+        unit = self.get_unit_by_name(unit_name)
+        channels = {}
+        
+        for channel_id in range(len(unit["TOPOLOGY"]["CHANNELS"])):
+            channel = unit["TOPOLOGY"]["CHANNELS"][channel_id]["CHANNEL"]
+            channels[channel["name"]] = channel
+        return channels
+    
+    def get_computers(self) -> dict:
+        """
+        return dictionary of computers
+
+        Returns:
+            dict: [description]
+        """
+        if self.computers != None:
+            return self.computers
+        else:
+            computers = {}
+            for computer_id in range(len(self.obs_config["OBSERVATORY"]["COMPUTERS"])):
+                computer = self.obs_config["OBSERVATORY"]["COMPUTERS"][computer_id]["COMPUTER"]
+                if( "file" in computer.keys() ):
+                    computer["computer_config"]= self.read_and_check_config_file(self.CONFIG_PATH+computer["file"])["COMPUTER"]
+                computers[computer["name"]] = computer
+            return computers
+
+    def get_devices(self) -> dict:
+        """
+        return dictionary of devices
+
+        Returns:
+            dict: [description]
+        """
+        if self.devices != None:
+            return self.devices
+
+        else:
+            devices = {}
+            for device_id in range(len(self.obs_config["OBSERVATORY"]["DEVICES"])):
+                device = self.obs_config["OBSERVATORY"]["DEVICES"][device_id]["DEVICE"]
+                if( "file" in device.keys() ):
+                    device["device_config"] = self.read_device_config_file(self.CONFIG_PATH+device["file"])["DEVICE"]
+                devices[device["name"]] = device
+            return devices
+
+    def get_devices_names(self)->list:
+        """Return the list of devices names of an observatory
+
+        Returns:
+            list: list of names of devices
+        """
+        devices_names = []
+        for device in self.obs_config["OBSERVATORY"]["DEVICES"]:
+            devices_names.append(device["DEVICE"]["name"])
+        return devices_names
+
+    def get_agents(self,unit_name)->dict:
+        """
+        return dictionary of agents 
+
+        Args:
+            unit_name (str): name of the unit
+
+        Returns:
+            dict: dictionary of agents. For each agents tell the name, computer, device, protocole, etc...
+        """
+        unit = self.get_unit_by_name(unit_name)
+        if self.agents != None:
+            return self.agents
+        else:
+            agents = {}
+            
+            
+            for agent_id in range(len(unit["AGENTS"])):
+                # Agents is a list containing dictionary that have only one key
+                key = list(unit["AGENTS"][agent_id].keys())[0]
+                agent = unit["AGENTS"][agent_id][key]
+                agents[agent["name"]] = agent
+            return agents
+
+    def get_layouts(self, unit_name: str) -> dict:
+        """
+        Return dictionary of layouts
+
+        Args:
+            unit_name (str): name of the unit
+        Returns:
+            dict: dictionary of layouts
+        """
+        unit = self.get_unit_by_name(unit_name)
+        info = {}
+        info["layouts"] = {}
+        for layout_id in range(len(unit["TOPOLOGY"]["LAYOUTS"])):
+            layout = unit["TOPOLOGY"]["LAYOUTS"][layout_id]["LAYOUT"]
+            info["layouts"][layout["name"]] = layout
+        return info
+
+    def get_albums(self,unit_name : str) -> dict:
+        """
+        Return dictionary of layouts
+
+        Args:
+            unit_name (str): name of the unit
+        Returns:
+            dict: dictionary of layouts
+        """
+        unit = self.get_unit_by_name(unit_name)
+        info = {}
+        info["albums"] = {}
+        for album_id in range(len(unit["TOPOLOGY"]["ALBUMS"])):
+            album = unit["TOPOLOGY"]["ALBUMS"][album_id]["ALBUM"]
+            info["albums"][album["name"]] = album
+        return info
+
+    def get_channel_information(self, unit_name: str, channel_name: str) -> dict:
+        """
+        Return information of the given channel name of a unit
+
+        Args:
+            unit_name (str): Name of the unit 
+            channel_name (str): name of the channel
+
+        Returns:
+            dict: dictionary containing all values that define this channel
+        """
+        channels = self.get_channels(unit_name)
+        return channels[channel_name]
+
+    def get_topology(self, unit_name:str)->dict:
+        """
+        Return dictionary of the topology of the observatory
+
+        Args:
+            unit_name (str): Name of the unit
+        Returns:
+            dict: dictionary representing the topology of an unit (security, mount, channels, layouts, albums)
+        """
+        unit = self.get_unit_by_name(unit_name)
+        topology = {}
+        for key in unit["TOPOLOGY"].keys():
+            branch = unit["TOPOLOGY"][key]
+            if key == "CHANNELS":
+                topology[key] = self.get_channels(unit_name)
+            elif key == "LAYOUTS":
+                topology[key] = self.get_layouts(unit_name)
+            elif key == "ALBUMS":
+                topology[key] = self.get_albums(unit_name)
+            else:
+                topology[key] = branch
+        return topology
+
+    def get_active_agents(self, unit_name: str) -> list:
+        """
+        Return the list of active agents (i.e. agents that have an association with a device)
+
+        Args:
+            unit_name (str): Name of the unit
+
+        Returns:
+            list: kist of the name of active agents
+        """
+        return list(self.get_agents(unit_name).keys())
+
+    def get_units(self)->dict:
+        """
+        Return all units sort by name defined in the config file
+
+        Returns:
+            dict: dictionary giving for a unit_name, his content (name,database,topology,agents,...)
+        """
+        result = {}
+        units = self.obs_config["OBSERVATORY"]["UNITS"]
+        for unit in units:
+            unit = unit["UNIT"]
+            result[unit["name"]] = unit
+        return result
+
+    def get_components_agents(self, unit_name: str) -> dict:
+        """
+        Return dictionary of component_agents of the given unit
+
+        Args:
+            unit_name (str): Name of the unit
+
+        Returns:
+            dict: dictionary sort by component name giving the associated agent (agent name)
+        """
+        components_agents = {}
+        topology = self.get_topology(unit_name)
+        for element in topology:
+            if element in ("SECURITY","MOUNT","CHANNELS"):
+                if(element != "CHANNELS"):
+                    for component_agent in topology[element]["COMPONENT_AGENTS"]:
+                        component_name = list(component_agent.keys())[0]
+                        components_agents[component_name] = component_agent[component_name]
+                else:
+                    for channel in topology[element]:
+                        for component_agent in topology[element][channel]["COMPONENT_AGENTS"]:
+                            component_name = list(component_agent.keys())[0]
+                            components_agents[component_name] = component_agent[component_name]
+        return components_agents
+
+    def get_units_name(self)->list:
+        """
+        Return list of units names 
+
+        Returns:
+            [list]: names of units
+        """
+        return list(self.get_units().keys())
+
+    def get_unit_by_name(self, name: str) -> dict:
+        """
+        Return dictionary containing definition of the unit that matches the given name
+
+        Args:
+            name (str): name of the unit
+
+        Returns:
+            dict: dictonary representing the unit
+        """
+        return self.get_units()[name]
+    
+    def get_agents_per_computer(self, unit_name: str) -> dict:
+        """
+        Return dictionary that give for each computer, what are the associated agents to it as a list
+
+        Args:
+            unit_name (str): Name of the unit
+
+        Returns:
+            dict:  dictionary that give for each computer, what are the associated agents to it as a list
+
+        """
+        agents_per_computer = {}
+        agents = self.get_agents(unit_name)
+        for agent in agents:
+            computer_name = agents[agent]["computer"]
+            if(agents[agent]["computer"] not in agents_per_computer.keys()):
+                agents_per_computer[computer_name] = [agent]
+            else:
+                agents_per_computer[computer_name].append(agent)
+        return agents_per_computer
+
+
+    def get_agents_per_device(self,unit_name:str)->dict:
+        """
+        Return dictionary that give for each device, what are the associated agents to it as a list
+
+        Args:
+            unit_name (str): Name of the unit
+
+        Returns:
+            dict:  dictionary that give for each device, what are the associated agents to it as a list
+
+        """
+        agents_per_device = {}
+        agents = self.get_agents(unit_name)
+        for agent in agents:
+            if("device" in agents[agent].keys()):
+                device_name = agents[agent]["device"]
+                if device_name in self.get_devices_names():
+                    if(agents[agent]["device"] not in agents_per_device.keys()):
+                        agents_per_device[device_name] = [agent]
+                    else:
+                        agents_per_device[device_name].append(agent)
+                else:
+                    print(f"Error: device name '{device_name}' for agent '{agent}' is not known in the configuration file. The device name must match one of the names defined in the DEVICES section")
+                    exit(1)
+        return agents_per_device
+
+    def get_active_devices(self)->list:
+        """
+        Return a list of active device names
+
+        Returns:
+            list: list of active device names
+        """
+        active_devices = []
+        for unit_name in self.get_units():
+            for device in self.get_agents_per_device(unit_name):
+                active_devices.append(device)
+        return active_devices
+
+    def get_active_computers(self)->list:
+        """
+        Return a list of active computer names
+
+        Returns:
+            list: list of active computer names
+        """
+        active_computers = []
+        for unit_name in self.get_units():
+            unit = self.get_unit_by_name(unit_name)
+            for computer in self.get_agents_per_computer(unit_name):
+                active_computers.append(computer)
+        return active_computers
+
+    def get_agent_information(self,unit_name:str,agent_name:str)->dict:
+        """
+        Give the dictionary of attributes of the agent for an unit.
+
+        Args:
+            unit (dict): dictonary representing the unit
+            agent_name (str): agent name
+
+        Returns:
+            dict: dictionary containing attributes of the agent
+        """
+        return self.get_agents(unit_name)[agent_name]
+
+    def get_device_information(self,device_name:str)->dict:
+        """
+        Give the dictionary of the attributes of the device 
+
+        Args:
+            device_name (str): device name
+
+        Returns:
+            dict: dictionary containing attributes of the device
+        """
+        return self.get_devices()[device_name]
+
+    def get_database_for_unit(self, unit_name: str) -> dict:
+        """
+        Return dictionary of attributes of the database for an unit
+
+        Args:
+            unit_name (str): unit name
+
+        Returns:
+            dict: dictionary of attributes of the database for an unit
+        """
+        return self.get_unit_by_name(unit_name)["DATABASE"]
+
+    def get_device_for_agent(self, unit_name: str, agent_name: str) -> str:
+        """
+        Return device name associated to the agent
+
+        Args:
+            unit (dict): dictonary representing the unit
+            agent_name (str): agent name
+
+        Returns:
+            str: device name associated to this agent
+        """
+        agents_per_device = self.get_agents_per_device(unit_name)
+        for device in agents_per_device:
+            if agent_name in agents_per_device[device]:
+                return self.get_device_information(device)
+
+    def get_unit_of_computer(self, computer_name: str) -> str:
+        """
+        Return the name of the unit where the computer is used
+
+        Args:
+            computer_name (str): computer name
+
+        Returns:
+            str: unit name
+        """
+        for unit_name in self.get_units():
+            if(computer_name in self.get_agents_per_computer(unit_name)):
+                return unit_name
+
+    def get_unit_of_device(self, device_name:str)->str:
+        """
+        Return the name of the unit where the device is used
+
+        Args:
+            device_name (str): device name
+
+        Returns:
+            str: unit name
+        """
+        for unit_name in self.get_units():
+            if(device_name in self.get_agents_per_device(unit_name)):
+                return unit_name
+
+    def get_device_power(self,device_name:str)->dict:
+        """
+        Return dictionary that contains informations about power if this information is present in the device config file
+
+        Return None if this information isn't stored in device's config file
+        Args:
+            device_name (str): name of the device
+
+        Returns:
+            dict: informations about power of device
+        """
+        return self.get_devices()[device_name]["device_config"].get("power")
+
+
+    def get_device_capabilities(self, device_name:str)->list:
+        """
+        Return dictionary that contains informations about capabilities if this information is present in the device config file
+
+        Return empty list if this information isn't stored in device's config file
+        Args:
+            device_name (str): name of the device
+
+        Returns:
+            list: list of capabilities of device
+        """
+        list_of_capabilities = []
+        capabilities = self.get_devices()[device_name]["device_config"].get("CAPABILITIES")
+        return capabilities
+
+    def get_device_connector(self,device_name:str)->dict:
+        """
+        Return dictionary that contains informations about connector if this information is present in the device config file
+
+        Return None if this information isn't stored in device's config file
+        Args:
+            device_name (str): name of the device
+
+        Returns:
+            dict: informations about connector of device
+        """
+        return self.get_devices()[device_name]["device_config"].get("connector")
+
+    def get_computer_power(self, computer_name: str) -> dict:
+        """
+        Return dictionary that contains informations about power if this information is present in the device config file
+
+        Return None if this information isn't stored in device's config file
+        Args:
+            device_name (str): name of the device
+
+        Returns:
+            dict: informations about connector of device
+        """
+        return self.get_computers()[computer_name]["computer_config"].get("power")
+
+    def getDeviceControllerNameForAgent(self,unit_name:str,agent_name:str)->tuple:
+        agent = self.get_agent_information(unit_name,agent_name)
+        return (agent["device"],"DeviceController"+agent["device"])
+
+    def getDeviceConfigForDeviceController(self,device_name:str)->dict:
+        return self.get_devices()[device_name]["device_config"]
+
+    def getCommParamsForAgentDevice(self,unit_name:str,agent_name:str)->tuple:
+        agent = self.get_agent_information(unit_name,agent_name)
+        device_config = self.getDeviceConfigForDeviceController(agent["device"])
+        comm_access = agent.get("comm_access",None)
+        comm = device_config["comm"]
+        return (comm_access,comm)
+
+    def getChannelCapabilities(self,unit_name:str,channel_name:str)->list:
+        channel = self.get_channel_information(unit_name,channel_name)
+        result = []
+        for component_agent in channel["COMPONENT_AGENTS"]:
+            component = list(component_agent.keys())[0]
+            agent = component_agent[component]
+            device = self.getDeviceControllerNameForAgent(unit_name,agent)[0]
+            device_capabilities = self.get_device_capabilities(device)
+            for capability in device_capabilities:
+                if capability["component"] == component:
+                    result.append(capability)
+        return result
+
+    def getEditableAttributesOfCapability(self,capability:dict)->dict:
+        editable_fields = {}
+        attributes = capability.get("attributes")
+        for attribute in attributes:
+            if attributes[attribute]["is_editable"]:
+                editable_fields[attribute] = attributes[attribute]
+        return editable_fields
+
+    def getUneditableAttributesOfCapability(self,capability:dict)->dict:
+        uneditable_fields = {}
+        attributes = capability.get("attributes")
+        for attribute in attributes:
+            if attributes[attribute]["is_editable"] == False:
+                uneditable_fields[attribute] = attributes[attribute]
+        return uneditable_fields
+
+    def getEditableAttributesOfChannel(self,unit_name:str,channel_name:str)->list:
+        capabilities = self.getChannelCapabilities(unit_name,channel_name)
+        # merged_result = {}
+        # for capability in capabilities:
+        #     merged_result[capability["component"]] = self.getEditableAttributesOfCapability(capability)
+        # return merged_result
+        merged_result = []
+        for capability in capabilities:
+            attributes = self.getEditableAttributesOfCapability(capability)
+            if len(attributes.keys()) > 0:
+                merged_result.append(attributes)
+        return merged_result
+
+    def getUneditableAttributesOfChannel(self,unit_name:str,channel_name:str)->list:
+        capabilities = self.getChannelCapabilities(unit_name,channel_name)
+        # merged_result = {}
+        # for capability in capabilities:
+        #     merged_result[capability["component"]] = self.getEditableAttributesOfCapability(capability)
+        # return merged_result
+        merged_result = []
+        for capability in capabilities:
+            attributes = self.getUneditableAttributesOfCapability(capability)
+            if len(attributes.keys()) > 0:
+                merged_result.append(attributes)
+        return merged_result
+
+
+    # def getLogicOfChannelGroups(self,unit_name):
+    #     return self.get_layouts(unit_name)["global_group_logic"]
+
+    
+    def getLayoutByName(self, unit_name:str, name_of_layout):
+        return self.get_layouts(unit_name)["layouts"][name_of_layout]
+
+    def getAlbumByName(self,unit_name : str, name_of_album):
+        return self.get_albums(unit_name)["albums"][name_of_album]
+
+    def getEditableAttributesOfMount(self,unit_name):
+        capabilities = self.get_device_capabilities(self.get_device_for_agent(unit_name,"mount")["name"])
+        merged_result = []
+        for capability in capabilities:
+            attributes = self.getEditableAttributesOfCapability(capability)
+            if len(attributes.keys()) > 0:
+                merged_result.append(attributes)
+        return merged_result
+    
+    
+    def getHorizonLine(self, unit_name):
+        horizon = self.get_unit_by_name(unit_name).get("horizon")
+        return horizon.get("line")
+
+def main():
+    # config = ConfigPyros("../../../../privatedev/config/guitalens/observatory_guitalens.yml")
+    # unit_name = config.get_units_name()[0]
+    # dc = config.getDeviceControllerNameForAgent(unit_name,"mount")[0]
+    #print(config.getDeviceConfigForDeviceController(dc))
+    #print(config.getCommParamsForAgentDevice(unit_name,"mount"))
+    # print(config.getChannelCapabilities(unit_name,"OpticalChannel_up"))
+    # print(config.get_channel_groups(unit_name))
+    # print(config.getEditableAttributesOfCapability(config.getChannelCapabilities(unit_name,"OpticalChannel_up")[0]))
+    # print(config.getEditableAttributesOfChannel(unit_name,"OpticalChannel_up"))
+    config = OBSConfig("../../../../privatedev/config/tnc/observatory_tnc.yml")
+    unit_name = config.get_units_name()[0]
+    #dc = config.getDeviceControllerNameForAgent(unit_name,"mount")[0]
+    #print(config.getDeviceConfigForDeviceController(dc))
+    #print(config.getCommParamsForAgentDevice(unit_name,"mount"))
+    # print(config.getChannelCapabilities(unit_name,"OpticalChannel_down2"))
+    # print(config.get_channel_groups(unit_name))
+    # print(config.getEditableAttributesOfCapability(config.getChannelCapabilities(unit_name,"OpticalChannel_down2")[0]))
+    # print(config.getEditableAttributesOfChannel(unit_name,"OpticalChannel_down2"))
+    print(config.getEditableAttributesOfMount(unit_name))
+    #print(config.get_devices()["FLI-Kepler4040"]["device_config"])
+    #print(config.get_devices()["FLI-Kepler4040"]["device_config"]["CAPABILITIES"][1]["attributes"]["manufacturer"])
+    #print(config.get_devices()["FLI-Kepler4040"]["device_config"]["CAPABILITIES"])
+    #print(config.get_devices()["AstroMecCA-TM350"]["device_config"]["CAPABILITIES"])
+if __name__ == "__main__": 
+
     main()
 \ No newline at end of file
@@ -49,7 +49,53 @@
                                     </div>
                                 {% endfor %}
                             </div>        
-                        
+                        {% elif category == "ALBUMS" %}
+                          <li class="collapsible collapsible_category"> ALBUMS </li>
+      
+                          <div class="content">
+                            {% for album in category_content.values %}
+                              <h2 class="collapsible collapsible_name">Name : {{ album|get_item:"name" }}</h2>
+                              <div class="content">
+                                <table class="table table-bordered table-hover table-striped">
+                                  <thead>
+                                    <tr>
+                                      <th> Channels </th>
+                                    </tr>
+                                  </thead>
+                                  <tbody>
+                                    {% for channel in album|get_item:"CHANNELS"  %}
+                                    
+                                      <tr>
+                                        <td> {{ channel }} </td>
+                                      </tr>
+                                    {% endfor %}
+                                </table>
+                              </div>
+                            {% endfor %}
+                          </div>
+                        {% elif category == "LAYOUTS" %}
+                          <li class="collapsible collapsible_category"> LAYOUTS </li>
+                          <div class="content">
+                            {% for layout in category_content.values %}
+                              <h2 class="collapsible collapsible_name">Name : {{ layout|get_item:"name" }}</h2>
+                              <div class="content">
+                                <table class="table table-bordered table-hover table-striped">
+                                  <thead>
+                                    <tr>
+                                      <th> Albums </th>
+                                    </tr>
+                                  </thead>
+                                  <tbody>
+                                    {% for album in layout|get_item:"ALBUMS"  %}
+                                    
+                                      <tr>
+                                        <td> {{ album }} </td>
+                                      </tr>
+                                    {% endfor %}
+                                </table>
+                              </div>
+                            {% endfor %}
+                          </div>
                         {% else %}
  
                             <li class="collapsible collapsible_category">{{ category }} </li>
@@ -87,7 +133,9 @@
             </div>
         {% endfor %}
     </ul>
-</div>
+    
+    {{ albums }}
+    
 <script>
 var coll = document.getElementsByClassName("collapsible");
 var i;
 from django.test import TestCase
 from common.models import PyrosUser
-from .configpyros import ConfigPyros
+from .obsconfig_class import OBSConfig
 from django.urls import reverse
 import unittest,os
 class ObservatoryConfigurationTests(TestCase):
@@ -11,13 +11,13 @@ class ObservatoryConfigurationTests(TestCase):
             os.remove("obsconfig/fixtures/obsconfig.p")
  
         u1 = PyrosUser.objects.get(username="haribo")
-        config_ko = ConfigPyros("obsconfig/fixtures/observatory_configuration_ko.yml")
+        config_ko = OBSConfig("obsconfig/fixtures/observatory_configuration_ko.yml")
         if os.path.exists("obsconfig/fixtures/obsconfig.p"):
             os.remove("obsconfig/fixtures/obsconfig.p")
  
     def test_OCF_read_config_get_content(self):
         os.environ["PATH_TO_OBSCONF_FILE"] = "obsconfig/fixtures/observatory_configuration_ok_simple.yml"
-        config = ConfigPyros("obsconfig/fixtures/observatory_configuration_ok_simple.yml")
+        config = OBSConfig("obsconfig/fixtures/observatory_configuration_ok_simple.yml")
         # get_devices, and get_computers are already tested in load
         self.assertEqual(config.get_obs_name(),"observatory_test")
         self.assertEqual(len(config.get_units()),1)
@@ -35,7 +35,7 @@ class ObservatoryConfigurationTests(TestCase):
  
     def test_OCF_view_config_simple(self):
         os.environ["PATH_TO_OBSCONF_FILE"] = "obsconfig/fixtures/observatory_configuration_ok_simple.yml"
-        config = ConfigPyros("obsconfig/fixtures/observatory_configuration_ok_simple.yml")
+        config = OBSConfig("obsconfig/fixtures/observatory_configuration_ok_simple.yml")
         u1 = PyrosUser.objects.get(username="haribo")
         u1.set_password("password123")
         u1.save()
@@ -53,7 +53,7 @@ class ObservatoryConfigurationTests(TestCase):
  
     def test_OCF_view_config_complex(self):
         os.environ["PATH_TO_OBSCONF_FILE"] = "obsconfig/fixtures/observatory_configuration_ok_complex.yml"
-        config = ConfigPyros("obsconfig/fixtures/observatory_configuration_ok_complex.yml")
+        config = OBSConfig("obsconfig/fixtures/observatory_configuration_ok_complex.yml")
         u1 = PyrosUser.objects.get(username="haribo")
         u1.set_password("password123")
         u1.save()
 from django import conf
 from django.shortcuts import render
-from .configpyros import ConfigPyros
+from .obsconfig_class import OBSConfig
 from django.conf import settings
 from src.core.pyros_django.dashboard.decorator import level_required
 from django.contrib.auth.decorators import login_required
@@ -30,7 +30,7 @@ def get_nested_dictionaries_as_list(dic,result=[]):
 @login_required
 @level_required("Admin","Observer","Management","Operator","Unit-PI")
 def obs_global_config(request):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     units_names = list(config.get_units().keys())
     pickle_file_mtime = os.path.getmtime(config.CONFIG_PATH+config.pickle_file)
     pickle_datetime = datetime.utcfromtimestamp(pickle_file_mtime).strftime("%Y/%m/%d %H:%M:%S")
@@ -52,7 +52,7 @@ def obs_global_config(request):
 @login_required
 @level_required("Admin","Unit-PI","Operator")
 def obs_hardware_config(request):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     devices = config.get_devices()
     active_devices = config.get_active_devices()
     computers = config.get_computers()
@@ -71,7 +71,7 @@ def obs_hardware_config(request):
 @login_required
 @level_required("Admin","Unit-PI","Operator")
 def unit_hardware_configuration(request,unit_name):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     devices = config.get_devices()
  
     return render(request, 'obsconfig/unit_hardware_configuration.html', {'config':config})                              
@@ -79,7 +79,7 @@ def unit_hardware_configuration(request,unit_name):
 @login_required
 @level_required("Admin","Unit-PI","Operator")
 def computer_details(request,computer_name):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     computer_detail = yaml.dump(config.get_computers()[computer_name])
     """
     computer_detail = { re.sub("^_","",key):value for key,value in config.get_computers()[computer_name].items() }
@@ -101,7 +101,7 @@ def computer_details(request,computer_name):
 @login_required
 @level_required("Admin","Unit-PI","Unit-board","Operator","Observer")
 def device_details(request,device_name):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     # We're removing "_" at the beginning of each key :
     device = config.get_devices()[device_name]
     #device_detail  = yaml.dump(device)
@@ -156,16 +156,15 @@ def device_details(request,device_name):
 @login_required
 @level_required("Admin","Observer","Management","Operator","Unit-PI","TAC")
 def obs_astronomer_config(request):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     units = config.get_units()
     units_topologies = {}
     # for each unit
     for unit_name in units:
  
         units_topologies[unit_name] = config.get_topology(unit_name)
-        # removing channel_groups, not useful in this view
-        units_topologies[unit_name].pop("LAYOUTS")
-        units_topologies[unit_name].pop("ALBUMS")
+        layouts = units_topologies[unit_name].pop("LAYOUTS")["layouts"]
+        albums = units_topologies[unit_name].pop("ALBUMS")["albums"]
         # for each category (security, mount, channels)
         for category in units_topologies[unit_name]:
             if category != "CHANNELS":
@@ -187,14 +186,17 @@ def obs_astronomer_config(request):
                         device_of_agent = config.get_device_for_agent(unit_name,agent)
                         index = units_topologies[unit_name]["CHANNELS"][channel_name]["COMPONENT_AGENTS"].index(component_agent)
                         units_topologies[unit_name]["CHANNELS"][channel_name]["COMPONENT_AGENTS"][index][component_name] = device_of_agent
-
-    return render(request,"obsconfig/obs_astronomer_config.html", { "units_topologies" : units_topologies })
+        units_topologies[unit_name]["ALBUMS"] = albums
+        units_topologies[unit_name]["LAYOUTS"] = layouts
+    return render(request,"obsconfig/obs_astronomer_config.html", { 
+        "units_topologies" : units_topologies,
+    })
  
  
 @login_required
 @level_required("Admin")
 def obs_agents_config(request):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     units = config.get_units()
     units_topologies = {}
     active_agents_by_unit = {}
@@ -205,8 +207,9 @@ def obs_agents_config(request):
         active_agents_by_unit[unit_name] = config.get_active_agents(unit_name)
         # topology of the current unit
         units_topologies[unit_name] = config.get_topology(unit_name)
-        # removing channel_groups, not useful in this view
-        units_topologies[unit_name].pop("CHANNEL_GROUPS")
+        # removing albums and layouts, not useful in this view
+        units_topologies[unit_name].pop("LAYOUTS")
+        units_topologies[unit_name].pop("ALBUMS")
         for category in units_topologies[unit_name]:
             if category != "CHANNELS":
                 # Security and Mount are directly a dictionary containing the attributes of those categories
@@ -233,7 +236,7 @@ def obs_agents_config(request):
 @login_required
 @level_required("Admin","Operator","Unit-PI","Unit-board")
 def edit_config(request):
-    config = ConfigPyros(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
+    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
     return render(request,"obsconfig/edit_config.html",{"config_file":config.raw_config})
  
 @login_required
@@ -263,7 +266,7 @@ def verify_config(request):
             response_data["is_valid"] = False
             response_data["message"] = "Missing schema"
         schema_path = os.path.join(os.environ["DJANGO_PATH"],"../../../config/schemas/")
-        config = ConfigPyros.check_config(temp_config_file.name,schema_path+schema)
+        config = OBSConfig.check_config(temp_config_file.name,schema_path+schema)
         if type(config) == bool and config:
             response_data["is_valid"] = True
         else:    
@@ -44,10 +44,23 @@ MODULES_VERSIONS = {
  
  
  
-import os,re,platform, subprocess
+import os,re,platform, subprocess, sys
 from datetime import date, datetime
  
 import django
+# append previous parent folders to import configpyros
+sys.path.append("../../..")
+from config.pyros.config_pyros import configpyros
+
+PYROS_CONFIG_FILE = os.environ.get("pyros_config_file")
+if PYROS_CONFIG_FILE:
+    CONFIG_PYROS =  configpyros(os.environ["pyros_config_file"]).pyros_config
+    NB_ELEMENT_PER_PAGE = CONFIG_PYROS.get("general").get("nb_element_per_page")
+
+def read_version_number_from_file(version_file:str) -> str:
+    version = open(version_file,"r").readline()
+    return version
+
 # duplicate from the same function in pyros.py ...
 def set_environment_variables_if_not_configured(env_path: str,env_sample_path: str)->None:
     """
@@ -404,6 +417,8 @@ python_version = subprocess.run( &quot;python --version | cut -d &#39; &#39; -f 2 | cut -d &#39;.
 python_version = python_version.stdout
 day = "2022-01-06"
 django_version_major,django_version_minor = django.VERSION[:2][0],django.VERSION[:2][1] 
-pyros_version = "0.3.3.0"
+pyros_version = read_version_number_from_file("../../../VERSION")
+#TODO: create function to read VERSION file 
+
 #pyros_version = "0.2.12.0"
 VERSION_NUMBER = f"{pyros_version}_{django_version_major}.{django_version_minor}_{python_version}_{day}"