esgvoc 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

esgvoc/core/db/project_ingestion.py

@@ -1,21 +1,22 @@
 import logging
 from pathlib import Path
 
-import esgvoc.core.constants
-from esgvoc.core.data_handler import JsonLdResource
-from esgvoc.core.db.connection import DBConnection
-from esgvoc.core.service.data_merger import DataMerger
-from esgvoc.core.db.models.mixins import TermKind
 from pydantic import BaseModel
+from sqlalchemy import text
 
+import esgvoc.core.constants
 import esgvoc.core.db.connection as db
-from esgvoc.core.db.connection import read_json_file
+import esgvoc.core.service as service
+from esgvoc.core.data_handler import JsonLdResource
+from esgvoc.core.db.connection import DBConnection, read_json_file
+from esgvoc.core.db.models.mixins import TermKind
 from esgvoc.core.db.models.project import Collection, Project, PTerm
-import  esgvoc.core.service as service
-
+from esgvoc.core.exceptions import EsgvocDbError
+from esgvoc.core.service.data_merger import DataMerger
 
 _LOGGER = logging.getLogger("project_ingestion")
 
+
 def infer_term_kind(json_specs: dict) -> TermKind:
     if esgvoc.core.constants.PATTERN_JSON_KEY in json_specs:
         return TermKind.PATTERN
@@ -25,15 +26,16 @@ def infer_term_kind(json_specs: dict) -> TermKind:
         return TermKind.PLAIN
 
 
-def ingest_metadata_project(connection:DBConnection,git_hash):
+def ingest_metadata_project(connection: DBConnection, git_hash):
     with connection.create_session() as session:
-        project = Project(id=str(connection.file_path.stem), git_hash=git_hash,specs={})
-        session.add(project)    
+        project = Project(id=str(connection.file_path.stem), git_hash=git_hash, specs={})
+        session.add(project)
         session.commit()
 
-###############################
+
 def get_data_descriptor_id_from_context(collection_context: dict) -> str:
-    data_descriptor_url = collection_context[esgvoc.core.constants.CONTEXT_JSON_KEY][esgvoc.core.constants.DATA_DESCRIPTOR_JSON_KEY]
+    data_descriptor_url = collection_context[esgvoc.core.constants.CONTEXT_JSON_KEY]\
+                                            [esgvoc.core.constants.DATA_DESCRIPTOR_JSON_KEY] # noqa E211
     return Path(data_descriptor_url).name
 
 
@@ -50,40 +52,40 @@ def instantiate_project_term(universe_term_json_specs: dict,
 def ingest_collection(collection_dir_path: Path,
                       project: Project,
                       project_db_session) -> None:
-
-
     collection_id = collection_dir_path.name
     collection_context_file_path = collection_dir_path.joinpath(esgvoc.core.constants.CONTEXT_FILENAME)
     try:
         collection_context = read_json_file(collection_context_file_path)
         data_descriptor_id = get_data_descriptor_id_from_context(collection_context)
     except Exception as e:
-        msg = f'Unable to read project context file {collection_context_file_path}. Abort.'
+        msg = f'unable to read project context file {collection_context_file_path}'
         _LOGGER.fatal(msg)
-        raise RuntimeError(msg) from e
+        raise EsgvocDbError(msg) from e
     # [KEEP]
     collection = Collection(
         id=collection_id,
         context=collection_context,
         project=project,
         data_descriptor_id=data_descriptor_id,
-        term_kind="") # we ll know it only when we ll add a term (hypothesis all term have the same kind in a collection
+        term_kind="")  # We ll know it only when we ll add a term
+                       # (hypothesis all term have the same kind in a collection) # noqa E116
     term_kind_collection = None
 
     for term_file_path in collection_dir_path.iterdir():
         _LOGGER.debug(f"found term path : {term_file_path}")
-        if term_file_path.is_file() and term_file_path.suffix==".json": 
+        if term_file_path.is_file() and term_file_path.suffix == ".json":
             try:
-                json_specs = DataMerger(data=JsonLdResource(uri =str(term_file_path)),
+                locally_avail = {"https://espri-mod.github.io/mip-cmor-tables":
+                                 service.current_state.universe.local_path}
+                json_specs = DataMerger(data=JsonLdResource(uri=str(term_file_path)),
                                         # locally_available={"https://espri-mod.github.io/mip-cmor-tables":".cache/repos/WCRP-universe"}).merge_linked_json()[-1]
-                                        locally_available={"https://espri-mod.github.io/mip-cmor-tables":service.service_settings.universe.local_path}).merge_linked_json()[-1]
-
+                                        locally_available=locally_avail).merge_linked_json()[-1]
                 term_kind = infer_term_kind(json_specs)
                 term_id = json_specs["id"]
 
                 if term_kind_collection is None:
                     term_kind_collection = term_kind
-                
+
             except Exception as e:
                 _LOGGER.warning(f'Unable to read term {term_file_path}. Skip.\n{str(e)}')
                 continue
@@ -105,51 +107,63 @@ def ingest_collection(collection_dir_path: Path,
         collection.term_kind = term_kind_collection
     project_db_session.add(collection)
 
+
 def ingest_project(project_dir_path: Path,
                    project_db_file_path: Path,
-                   git_hash : str
+                   git_hash: str
                    ):
     try:
         project_connection = db.DBConnection(project_db_file_path)
     except Exception as e:
-        msg = f'Unable to read project SQLite file at {project_db_file_path}. Abort.'
+        msg = f'unable to read project SQLite file at {project_db_file_path}'
         _LOGGER.fatal(msg)
-        raise RuntimeError(msg) from e
-        
+        raise EsgvocDbError(msg) from e
+
     with project_connection.create_session() as project_db_session:
+        project_specs_file_path = project_dir_path.joinpath(esgvoc.core.constants.PROJECT_SPECS_FILENAME)
         try:
-            project_specs_file_path = project_dir_path.joinpath(esgvoc.core.constants.PROJECT_SPECS_FILENAME)
             project_json_specs = read_json_file(project_specs_file_path)
             project_id = project_json_specs[esgvoc.core.constants.PROJECT_ID_JSON_KEY]
         except Exception as e:
-            msg = f'Unable to read project specs file  {project_specs_file_path}. Abort.'
+            msg = f'unable to read project specs file  {project_specs_file_path}'
             _LOGGER.fatal(msg)
-            raise RuntimeError(msg) from e
-        
-        project = Project(id=project_id, specs=project_json_specs,git_hash=git_hash)
+            raise EsgvocDbError(msg) from e
+
+        project = Project(id=project_id, specs=project_json_specs, git_hash=git_hash)
         project_db_session.add(project)
-        
 
         for collection_dir_path in project_dir_path.iterdir():
-            if collection_dir_path.is_dir() and (collection_dir_path / "000_context.jsonld").exists(): #TODO maybe put that in settings
+            # TODO maybe put that in settings
+            if collection_dir_path.is_dir() and (collection_dir_path / "000_context.jsonld").exists():
                 _LOGGER.debug(f"found collection dir : {collection_dir_path}")
                 try:
                     ingest_collection(collection_dir_path,
                                       project,
                                       project_db_session)
                 except Exception as e:
-                    msg = f'Unexpected error while ingesting collection {collection_dir_path}. Abort.'
+                    msg = f'unexpected error while ingesting collection {collection_dir_path}'
                     _LOGGER.fatal(msg)
-                    raise RuntimeError(msg) from e
+                    raise EsgvocDbError(msg) from e
         project_db_session.commit()
 
-
-
-
-
-
-
-
-
-
-
+        # Well, the following instructions are not data duplication. It is more building an index.
+        # Read: https://sqlite.org/fts5.html
+        try:
+            sql_query = 'INSERT INTO pterms_fts5(pk, id, specs, kind, collection_pk) ' + \
+                        'SELECT pk, id, specs, kind, collection_pk FROM pterms;'  # noqa: S608
+            project_db_session.exec(text(sql_query))  # type: ignore
+        except Exception as e:
+            msg = f'unable to insert rows into pterms_fts5 table for {project_db_file_path}'
+            _LOGGER.fatal(msg)
+            raise EsgvocDbError(msg) from e
+        project_db_session.commit()
+        try:
+            sql_query = 'INSERT INTO pcollections_fts5(pk, id, data_descriptor_id, context, ' + \
+                         'project_pk, term_kind) SELECT pk, id, data_descriptor_id, context, ' + \
+                         'project_pk, term_kind FROM collections;'  # noqa: S608
+            project_db_session.exec(text(sql_query))  # type: ignore
+        except Exception as e:
+            msg = f'unable to insert rows into pcollections_fts5 table for {project_db_file_path}'
+            _LOGGER.fatal(msg)
+            raise EsgvocDbError(msg) from e
+        project_db_session.commit()

esgvoc/core/db/universe_ingestion.py

@@ -1,20 +1,22 @@
 import logging
 from pathlib import Path
 
-import esgvoc.core.constants
-from esgvoc.core.data_handler import JsonLdResource
-from esgvoc.core.service.data_merger import DataMerger
+from sqlalchemy import text
 from sqlmodel import Session, select
 
+import esgvoc.core.constants
 import esgvoc.core.db.connection as db
+import esgvoc.core.service as service
+from esgvoc.core.data_handler import JsonLdResource
 from esgvoc.core.db.connection import read_json_file
 from esgvoc.core.db.models.mixins import TermKind
-from esgvoc.core.db.models.universe import DataDescriptor, UTerm, Universe
-from esgvoc.core.db.models.universe import universe_create_db
-import esgvoc.core.service as service
+from esgvoc.core.db.models.universe import UDataDescriptor, Universe, UTerm, universe_create_db
+from esgvoc.core.exceptions import EsgvocDbError
+from esgvoc.core.service.data_merger import DataMerger
 
 _LOGGER = logging.getLogger(__name__)
 
+
 def infer_term_kind(json_specs: dict) -> TermKind:
     if esgvoc.core.constants.PATTERN_JSON_KEY in json_specs:
         return TermKind.PATTERN
@@ -32,25 +34,48 @@ def ingest_universe(universe_repo_dir_path: Path, universe_db_file_path: Path) -
         _LOGGER.fatal(msg)
         raise IOError(msg) from e
 
-    for data_descriptor_dir_path in universe_repo_dir_path.iterdir(): 
-        if data_descriptor_dir_path.is_dir() and (data_descriptor_dir_path / "000_context.jsonld").exists(): # TODO maybe put that in setting
+    for data_descriptor_dir_path in universe_repo_dir_path.iterdir():
+        if data_descriptor_dir_path.is_dir() and \
+           (data_descriptor_dir_path / "000_context.jsonld").exists():  # TODO may be put that in setting
             try:
                 ingest_data_descriptor(data_descriptor_dir_path, connection)
             except Exception as e:
-                msg = f'Unexpected error while processing data descriptor {data_descriptor_dir_path}. Abort.'
+                msg = f'unexpected error while processing data descriptor {data_descriptor_dir_path}'
                 _LOGGER.fatal(msg)
-                raise RuntimeError(msg) from e
-        
-def ingest_metadata_universe(connection,git_hash):
+                raise EsgvocDbError(msg) from e
+
+    with connection.create_session() as session:
+        # Well, the following instructions are not data duplication. It is more building an index.
+        # Read: https://sqlite.org/fts5.html
+        try:
+            sql_query = 'INSERT INTO uterms_fts5(pk, id, specs, kind, data_descriptor_pk) ' + \
+                        'SELECT pk, id, specs, kind, data_descriptor_pk FROM uterms;'  # noqa: S608
+            session.exec(text(sql_query))  # type: ignore
+        except Exception as e:
+            msg = f'unable to insert rows into uterms_fts5 table for {universe_db_file_path}'
+            _LOGGER.fatal(msg)
+            raise EsgvocDbError(msg) from e
+        session.commit()
+        try:
+            sql_query = 'INSERT INTO udata_descriptors_fts5(pk, id, universe_pk, context, term_kind) ' + \
+                        'SELECT pk, id, universe_pk, context, term_kind FROM udata_descriptors;'  # noqa: S608
+            session.exec(text(sql_query))  # type: ignore
+        except Exception as e:
+            msg = f'unable to insert rows into udata_descriptors_fts5 table for {universe_db_file_path}'
+            _LOGGER.fatal(msg)
+            raise EsgvocDbError(msg) from e
+        session.commit()
+
+
+def ingest_metadata_universe(connection, git_hash):
     with connection.create_session() as session:
         universe = Universe(git_hash=git_hash)
-        session.add(universe)    
+        session.add(universe)
         session.commit()
 
+
 def ingest_data_descriptor(data_descriptor_path: Path,
                            connection: db.DBConnection) -> None:
-
-
     data_descriptor_id = data_descriptor_path.name
 
     context_file_path = data_descriptor_path.joinpath(esgvoc.core.constants.CONTEXT_FILENAME)
@@ -60,12 +85,13 @@ def ingest_data_descriptor(data_descriptor_path: Path,
         msg = f'Unable to read the context file {context_file_path} of data descriptor \
                {data_descriptor_id}. Skip.\n{str(e)}'
         _LOGGER.warning(msg)
-        return        
+        return
 
     with connection.create_session() as session:
-        data_descriptor = DataDescriptor(id=data_descriptor_id,
-                                         context=context,
-                                         term_kind="") # we ll know it only when we ll add a term (hypothesis all term have the same kind in a data_descriptor)
+        # We ll know it only when we ll add a term (hypothesis all term have the same kind in a data_descriptor)
+        data_descriptor = UDataDescriptor(id=data_descriptor_id,
+                                          context=context,
+                                          term_kind="")
         term_kind_dd = None
 
         _LOGGER.debug(f"add data_descriptor : {data_descriptor_id}")
@@ -73,8 +99,10 @@ def ingest_data_descriptor(data_descriptor_path: Path,
             _LOGGER.debug(f"found term path : {term_file_path}, {term_file_path.suffix}")
             if term_file_path.is_file() and term_file_path.suffix == ".json":
                 try:
-                    json_specs=DataMerger(data=JsonLdResource(uri=str(term_file_path)),
-                                          locally_available={"https://espri-mod.github.io/mip-cmor-tables":service.service_settings.universe.local_path}).merge_linked_json()[-1]
+                    locally_available = {"https://espri-mod.github.io/mip-cmor-tables":
+                                         service.current_state.universe.local_path}
+                    json_specs = DataMerger(data=JsonLdResource(uri=str(term_file_path)),
+                                            locally_available=locally_available).merge_linked_json()[-1]
                     term_kind = infer_term_kind(json_specs)
                     term_id = json_specs["id"]
 
@@ -82,7 +110,8 @@ def ingest_data_descriptor(data_descriptor_path: Path,
                         term_kind_dd = term_kind
 
                 except Exception as e:
-                    _LOGGER.warning(f'Unable to read term {term_file_path} for data descriptor {data_descriptor_path}. Skip.\n{str(e)}')
+                    _LOGGER.warning(f'Unable to read term {term_file_path} for data descriptor ' +
+                                    f'{data_descriptor_path}. Skip.\n{str(e)}')
                     continue
                 if term_id and json_specs and data_descriptor and term_kind:
                     _LOGGER.debug("adding {term_id}")
@@ -98,13 +127,14 @@ def ingest_data_descriptor(data_descriptor_path: Path,
         session.add(data_descriptor)
         session.commit()
 
+
 def get_universe_term(data_descriptor_id: str,
-                     term_id: str,
-                     universe_db_session: Session) -> tuple[TermKind, dict]:
+                      term_id: str,
+                      universe_db_session: Session) -> tuple[TermKind, dict]:
     statement = (
         select(UTerm)
-        .join(DataDescriptor)
-        .where(DataDescriptor.id == data_descriptor_id, UTerm.id == term_id)
+        .join(UDataDescriptor)
+        .where(UDataDescriptor.id == data_descriptor_id, UTerm.id == term_id)
     )
     results = universe_db_session.exec(statement)
     term = results.one()
@@ -112,9 +142,8 @@ def get_universe_term(data_descriptor_id: str,
 
 
 if __name__ == "__main__":
-    #ingest_universe(db.UNIVERSE_DIR_PATH, db.UNIVERSE_DB_FILE_PATH)
     import os
     root_dir = Path(str(os.getcwd())).parent.parent
     print(root_dir)
-    universe_create_db(root_dir /  Path(".cache/dbs/universe.sqlite"))
-    ingest_universe(root_dir / Path(".cache/repos/mip-cmor-tables"),root_dir /  Path(".cache/dbs/universe.sqlite"))
+    universe_create_db(root_dir / Path(".cache/dbs/universe.sqlite"))
+    ingest_universe(root_dir / Path(".cache/repos/mip-cmor-tables"), root_dir / Path(".cache/dbs/universe.sqlite"))

esgvoc/core/exceptions.py

@@ -0,0 +1,33 @@
+class EsgvocException(Exception):
+    """
+    Class base of all ESGVOC errors.
+    """
+    pass
+
+
+class EsgvocNotFoundError(EsgvocException):
+    """
+    Represents the not found errors.
+    """
+    pass
+
+
+class EsgvocValueError(EsgvocException):
+    """
+    Represents value errors.
+    """
+    pass
+
+
+class EsgvocDbError(EsgvocException):
+    """
+    Represents errors relative to data base management.
+    """
+    pass
+
+
+class EsgvocNotImplementedError(EsgvocException):
+    """
+    Represents not implemented errors.
+    """
+    pass

esgvoc/core/logging_handler.py

@@ -1,4 +1,4 @@
 import logging.config
 from pathlib import Path
 
-logging.config.fileConfig(f"{Path(__file__).parent}/logging.conf")
+logging.config.fileConfig(f"{Path(__file__).parent}/logging.conf", disable_existing_loggers=False)

esgvoc/core/repo_fetcher.py

@@ -153,7 +153,7 @@ class RepoFetcher:
         files = [item['name'] for item in contents if item['type'] == 'file']
         return files
     
-    def clone_repository(self, owner: str, repo: str, branch: Optional[str] = None):
+    def clone_repository(self, owner: str, repo: str, branch: Optional[str] = None, local_path: str|None = None):
         """
         Clone a GitHub repository to a target directory.
         :param owner: Repository owner
@@ -162,15 +162,16 @@ class RepoFetcher:
         :param branch: (Optional) The branch to clone. Clones the default branch if None.
         """
         repo_url = f"https://github.com/{owner}/{repo}.git"
+        destination = local_path if local_path else f"{self.repo_dir}/{repo}" 
 
-        command = ["git", "clone", repo_url, f"{self.repo_dir}/{repo}"]
+        command = ["git", "clone", repo_url, destination]
         if branch:
             command.extend(["--branch", branch])
         with redirect_stdout_to_log():
 
             try:
                 subprocess.run(command, check=True)
-                _LOGGER.debug(f"Repository cloned successfully into {self.repo_dir}/{repo}")
+                _LOGGER.debug(f"Repository cloned successfully into {destination}")
             except subprocess.CalledProcessError:
                 try:
                     current_work_dir = os.getcwd()

esgvoc/core/service/__init__.py

@@ -1,8 +1,40 @@
-from esgvoc.core.service.settings import ServiceSettings
+# from esgvoc.core.service.config_register import ConfigManager
+# from esgvoc.core.service.settings import ServiceSettings
+# from esgvoc.core.service.state import StateService
+#
+# config_manager = ConfigManager()
+# active_setting = config_manager.get_active_config()
+# active_setting["base_dir"] = str(config_manager.config_dir / config_manager.get_active_config_name())
+# service_settings = ServiceSettings.from_config(active_setting)
+# state_service = StateService(service_settings)
+
+
+from esgvoc.core.service.configuration.config_manager import ConfigManager
+from esgvoc.core.service.configuration.setting import ServiceSettings
 from esgvoc.core.service.state import StateService
-from pathlib import Path
 
-settings_path = Path(__file__).parent / "settings.toml"
-service_settings = ServiceSettings.load_from_file(str(settings_path))
-state_service = StateService(service_settings)
+config_manager : ConfigManager | None = None
+current_state : StateService | None = None
+
+def get_config_manager():
+    global config_manager
+    if config_manager is None:
+
+        config_manager = ConfigManager(ServiceSettings, app_name="esgvoc", app_author="ipsl", default_settings=ServiceSettings.DEFAULT_SETTINGS)
+        active_config_name= config_manager.get_active_config_name()
+        config_manager.data_config_dir = config_manager.data_dir / active_config_name
+        config_manager.data_config_dir.mkdir(parents=True, exist_ok=True)
+
+    return config_manager   
+
+
+def get_state():
+    global current_state 
+    if config_manager is not None:
+        current_state = StateService(config_manager.get_active_config())
+    return current_state
+
+# Singleton Access Function
+config_manager = get_config_manager()
+current_state = get_state()
 

esgvoc/core/service/configuration/config_manager.py

@@ -0,0 +1,188 @@
+import toml
+import logging
+from pathlib import Path
+from platformdirs import PlatformDirs
+from typing import Type, TypeVar, Generic, Protocol
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Define a generic type for configuration
+T = TypeVar("T", bound="ConfigSchema")
+
+class ConfigSchema(Protocol):
+    """Protocol for application-specific configuration classes."""
+
+    @classmethod
+    def load_from_file(cls, file_path: str): ...
+    
+    def save_to_file(self, file_path: str): ...
+
+class ConfigManager(Generic[T]):
+    def __init__(self, config_cls: Type[T], app_name: str, app_author: str, default_settings : dict | None = None ):
+        """
+        Initialize the configuration manager.
+        - config_cls: A class that implements `ConfigSchema` (e.g., ServiceSettings).
+        - app_name: Name of the application (used for directory paths).
+        - app_author: Name of the author/organization (used for directory paths).
+        """
+        self.config_cls = config_cls
+        self.dirs = PlatformDirs(app_name, app_author)
+
+        # Define standard paths
+        self.config_dir = Path(self.dirs.user_config_path).expanduser().resolve()
+        self.data_dir = Path(self.dirs.user_data_path).expanduser().resolve()
+        self.data_config_dir = None # depends on loaded settings
+
+        self.cache_dir = Path(self.dirs.user_cache_path).expanduser().resolve()
+
+
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        self.registry_path = self.config_dir / "config_registry.toml"
+        self.default_config_path = self.config_dir / "default_setting.toml"
+        self.default_settings = default_settings
+        self._init_registry()
+
+    def _init_registry(self):
+        """Initialize the registry file if it doesn't exist."""
+        if not self.registry_path.exists():
+            logger.info("Initializing configuration registry...")
+            registry = {"configs": {"default": str(self.default_config_path)}, "active": "default"}
+            self._save_toml(self.registry_path, registry)
+        # Ensure the default settings file exists and save it if necessary
+        if not self.default_config_path.exists():
+            if self.default_settings:
+                logger.info("Saving default settings...")
+                self._save_toml(self.default_config_path, self.default_settings)
+            else:
+                logger.warning("No default settings provided.")
+
+    def _load_toml(self, path: Path) -> dict:
+        """Load TOML data from a file."""
+        if not path.exists():
+            logger.error(f"Configuration file not found: {path}")
+            raise FileNotFoundError(f"Configuration file not found: {path}")
+        with open(path, "r") as f:
+            return toml.load(f)
+
+    def _save_toml(self, path: Path, data: dict) -> None:
+        """Save TOML data to a file."""
+        with open(path, "w") as f:
+            toml.dump(data, f)
+
+    def _get_active_config_path(self) -> Path:
+        """Retrieve the path of the active configuration file."""
+        registry = self._load_toml(self.registry_path)
+        active_config_name = registry["active"]
+        return Path(registry["configs"][active_config_name])
+
+    def get_config(self, config_name:str) -> T:
+        """Load the configuration as an instance of the given config schema."""
+        registry = self._load_toml(self.registry_path)
+        if config_name not in registry["configs"]:
+            logger.error(f"Config '{config_name}' not found in registry.")
+            raise ValueError(f"Config '{config_name}' not found in registry.")
+        config_path = self.config_cls.load_from_file(registry["configs"][config_name])
+        return self.config_cls.load_from_file(str(config_path))
+
+    def get_active_config(self) -> T:
+        """Load the active configuration as an instance of the given config schema."""
+        active_config_path = self._get_active_config_path()
+
+        return self.config_cls.load_from_file(str(active_config_path)) 
+     
+    def get_active_config_name(self) -> str:
+        """Retrieve the config name from the registry"""
+        registry = self._load_toml(self.registry_path)
+        return registry["active"]
+
+    def save_config(self, config_data: dict, name: str | None = None) -> None:
+        """Save the modified configuration to the corresponding file and update the registry."""
+        
+        if name:
+            # If a name is provided, save the configuration with that name
+            config_path = self.config_dir / f"{name}.toml"
+            self._save_toml(config_path, config_data)
+
+            # Update the registry with the new config name
+            registry = self._load_toml(self.registry_path)
+            registry["configs"][name] = str(config_path)
+            registry["active"] = name
+            self._save_toml(self.registry_path, registry)
+
+            logger.info(f"Saved configuration to {config_path} and updated registry.")
+        else:
+            # If no name is provided, give the user a default name, like "user_config"
+            default_name = "user_config"
+            config_path = self.config_dir / f"{default_name}.toml"
+            
+            # Check if the user_config already exists, if so, warn them
+            if config_path.exists():
+                logger.warning(f"{default_name}.toml already exists. Overwriting with the new config.")
+            
+            # Save the configuration with the default name
+            self._save_toml(config_path, config_data)
+
+            # Update the registry with the new config name
+            registry = self._load_toml(self.registry_path)
+            registry["configs"][default_name] = str(config_path)
+            registry["active"] = default_name
+            self._save_toml(self.registry_path, registry)
+
+            logger.info(f"Saved new configuration to {config_path} and updated registry.")
+
+    def save_active_config(self, config: T):
+        """Save the current configuration to the active file."""
+        active_config_path = self._get_active_config_path()
+        config.save_to_file(str(active_config_path))
+
+    def switch_config(self, config_name: str):
+        """Switch to a different configuration."""
+        registry = self._load_toml(self.registry_path)
+        if config_name not in registry["configs"]:
+            logger.error(f"Config '{config_name}' not found in registry.")
+            raise ValueError(f"Config '{config_name}' not found in registry.")
+        registry["active"] = config_name
+        
+        self._save_toml(self.registry_path, registry)
+        logger.info(f"Switched to configuration: {config_name}")
+
+    def list_configs(self) -> dict:
+        """Return a list of available configurations."""
+        return self._load_toml(self.registry_path)["configs"]
+
+    def add_config(self, config_name: str, config_data: dict):
+        """Add a new configuration."""
+        registry = self._load_toml(self.registry_path)
+        if config_name in registry["configs"]:
+            raise ValueError(f"Config '{config_name}' already exists.")
+        config_path = self.config_dir / f"{config_name}.toml"
+        self._save_toml(config_path, config_data)
+        registry["configs"][config_name] = str(config_path)
+        self._save_toml(self.registry_path, registry)
+
+    def remove_config(self, config_name: str):
+        """Remove a configuration."""
+        registry = self._load_toml(self.registry_path)
+        if config_name == "default":
+            raise ValueError("Cannot remove the default configuration.")
+        if config_name not in registry["configs"]:
+            raise ValueError(f"Config '{config_name}' not found.")
+        del registry["configs"][config_name]
+        config_path = self.config_dir / f"{config_name}.toml"
+        config_path.unlink()
+
+        self._save_toml(self.registry_path, registry)
+        logger.info(f"Removed configuration: {config_name}")
+        if registry["active"] not in registry["configs"]:
+            self.switch_config("default")
+            logger.info("active configuration doesnot exist anymore : Switch to default configuration")
+
+
+    
+
+