esgvoc 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

esgvoc/cli/main.py

@@ -1,22 +1,21 @@
-
 import typer
-from esgvoc.cli.config import app as config_app
 from esgvoc.cli.get import app as get_app
 from esgvoc.cli.status import app as status_app
 from esgvoc.cli.valid import app as valid_app
 from esgvoc.cli.install import app as install_app
-    
-
+from esgvoc.cli.drs import app as drs_app   
 app = typer.Typer()
 
 # Register the subcommands
-app.add_typer(config_app)
 app.add_typer(get_app)
 app.add_typer(status_app)
 app.add_typer(valid_app)
 app.add_typer(install_app)
+app.add_typer(drs_app)
 
 def main():
     app()
+    
+
 if __name__ == "__main__":
     main()

esgvoc/cli/status.py

@@ -1,4 +1,5 @@
 from esgvoc.core import service
+from rich.table import Table
 import typer
 from rich.console import Console
 
@@ -19,8 +20,19 @@ def status():
     i.e summary of version of usable ressources (between remote/cached)  
     
     """
+    assert(service.current_state is not None)
+    service.current_state.get_state_summary()
+    #display(service.state_service.table())
 
-    service.state_service.get_state_summary()
-    display(service.state_service.table())
+
+    table = Table(show_header=False, show_lines=True)
+
+    table.add_row("","Remote github repo","Local repository","Cache Database", style = "bright_green")
+    table.add_row("Universe path",service.current_state.universe.github_repo,service.current_state.universe.local_path,service.current_state.universe.db_path, style = "white")
+    table.add_row("Version",service.current_state.universe.github_version,service.current_state.universe.local_version,service.current_state.universe.db_version, style="bright_blue")
+    for proj_name,proj in service.current_state.projects.items():
+        table.add_row(f"{proj_name} path",proj.github_repo,proj.local_path,proj.db_path, style="white")
+        table.add_row("Version",proj.github_version,proj.local_version,proj.db_version,style ="bright_blue")
+    display(table)
 
     

esgvoc/cli/valid.py

@@ -6,10 +6,8 @@ from esgvoc.api.projects import (
     valid_term_in_project, 
     valid_term_in_all_projects
 )
-from esgvoc.api import BasicValidationErrorVisitor
 from requests import logging
 from rich.table import Table
-from sqlmodel import except_
 import typer
 import re
 from rich.console import Console
@@ -40,52 +38,52 @@ def valid(
     verbose: bool = typer.Option(False, "-v", "--verbose", help="Provide detailed validation results")
 ):
     """
-    Validates one or more strings against specified Project:Collection:Term configurations.
-
-    Depending on the provided key structure, the function performs different validation operations:
-    - If all are None (e.g., "::"), validates the term across all projects (`valid_term_in_all_projects`).
-    - If Term is None (e.g., "Project:Collection:"), validates the term in the specified collection (`valid_term_in_collection`).
-    - If Term and Collection are None (e.g., "Project::"), validates the term in the specified project (`valid_term_in_project`).
-    - If all are specified (e.g., "Project:Collection:Term"), validates the term exactly (`valid_term`).
-
-    Parameters:
-        strings_targets (List[str]): A list of validation pairs, where each pair consists of:
-            - A string to validate.
-            - A key in the form '<Project:Collection:Term>'.
-    Usage :
-        Valid one: 
-        esgvocab valid IPSL cmip6plus:institution_id:ipsl
-        esgvocab valid IPSL cmip6plus:institution_id:
-        esgvocab valid IPSL cmip6plus::
-        esgvocab valid IPSL ::
-        
-        Unvalid one:
-        esgvocab valid IPSL_invalid cmip6plus:institution_id:ipsl
-        esgvocab valid IPSL cmip6plus:institution_id:isl <= term cant be found
-        esgvocab valid IPSL cmip6plus:institutin_id:ispl <= collection cant be found
-        esgvocab valid IPSL cmip6pls:institution_id:ispl <= project cant be found
-
-        Multiple validation for all known projects: 
-        esgvocab valid IPSL :: IPS :: 
-            result will be [True, False]
-        
-        esgvocab valid --verbose IPS :: IPSL :: 
-            result will be 
-            ┏━━━━━━━━┳━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
-            ┃ String ┃ Key ┃ Result     ┃ Errors                      ┃
-            ┡━━━━━━━━╇━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
-            │ IPS    │ ::  │ ❌ Invalid │ did not found matching term │
-            │ IPSL   │ ::  │ ✅ Valid   │ None                        │
-            └────────┴─────┴────────────┴─────────────────────────────┘
-    Returns:
-        List[bool]: Validation results for each pair in the input.
+    Validates one or more strings against specified Project:Collection:Term configurations.\n
+     \n
+    Depending on the provided key structure, the function performs different validation operations:\n
+    - If all are None (e.g., "::"), validates the term across all projects (`valid_term_in_all_projects`).\n
+    - If Term is None (e.g., "Project:Collection:"), validates the term in the specified collection (`valid_term_in_collection`).\n
+    - If Term and Collection are None (e.g., "Project::"), validates the term in the specified project (`valid_term_in_project`).\n
+    - If all are specified (e.g., "Project:Collection:Term"), validates the term exactly (`valid_term`).\n
+\n
+    Parameters:\n
+        \tstrings_targets (List[str]): A list of validation pairs, where each pair consists of:\n
+            \t\t- A string to validate.\n
+            \t\t- A key in the form '<Project:Collection:Term>'.\n
+    Usage :\n
+        \tValid one:\n 
+        \tesgvocab valid IPSL cmip6plus:institution_id:ipsl\n
+        \tesgvocab valid IPSL cmip6plus:institution_id:\n
+        \tesgvocab valid IPSL cmip6plus::\n
+        \tesgvocab valid IPSL ::\n
+        \n
+        \tUnvalid one:\n
+        \tesgvocab valid IPSL_invalid cmip6plus:institution_id:ipsl\n
+        \tesgvocab valid IPSL cmip6plus:institution_id:isl <= term cant be found\n
+        \tesgvocab valid IPSL cmip6plus:institutin_id:ispl <= collection cant be found\n
+        \tesgvocab valid IPSL cmip6pls:institution_id:ispl <= project cant be found\n
+        \n
+        \tMultiple validation for all known projects: \n
+        \tesgvocab valid IPSL :: IPS :: \n
+        \t\tresult will be [True, False]\n
+        \n
+        \tesgvocab valid --verbose IPS :: IPSL ::\n 
+        \tresult will be \n
+        \t\t┏━━━━━━━━┳━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n
+        \t\t┃ String ┃ Key ┃ Result     ┃ Errors                      ┃\n
+        \t\t┡━━━━━━━━╇━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n
+        \t\t│ IPS    │ ::  │ ❌ Invalid │ did not found matching term │\n
+        \t\t│ IPSL   │ ::  │ ✅ Valid   │ None                        │\n
+        \t\t└────────┴─────┴────────────┴─────────────────────────────┘\n
+    Returns:\n
+        \tList[bool]: Validation results for each pair in the input.\n
     """
     results = []
     detailed_results = []
 
     # Combine string and target into pairs
     pairs = [strings_targets[i] + " " + strings_targets[i + 1] for i in range(0, len(strings_targets), 2)]
-
+    
     # Validate each string against each target
     for validation in pairs:
         match = re.match(r"(.+)\s+([^:]*):([^:]*):([^:]*)", validation)
@@ -121,11 +119,9 @@ def valid(
             # Parse and collect errors for verbose mode
             if validation_result == []:
                 detailed_results.append({"validation":validation, "errors":["did not found matching term"]})
-
             results.append(False)
             if project and collection and term and exception_message is None:
-                visitor = BasicValidationErrorVisitor()
-                errors = [error.accept(visitor) for error in validation_result.errors]
+                errors = [str(error) for error in validation_result.errors]
                 detailed_results.append({"validation": validation, "errors": errors})
             if exception_message is not None:
                 detailed_results.append({"validation": validation, "errors": [exception_message]})

esgvoc/core/db/models/mixins.py

@@ -4,10 +4,17 @@ from sqlmodel import Field
 
 
 class TermKind(Enum):
+    """
+    The kinds of term.
+    """
     PLAIN = "plain"
+    """End written term."""
     PATTERN = "pattern"
+    """Regex based terms"""
     COMPOSITE = "composite"
+    """Term composed of terms."""
     MIXED = 'mixed'
+    """To be defined."""
 
 
 class PkMixin:

esgvoc/core/db/models/project.py

@@ -7,7 +7,6 @@ from sqlmodel import Column, Field, Relationship, SQLModel
 
 import esgvoc.core.db.connection as db
 from esgvoc.core.db.models.mixins import IdMixin, PkMixin, TermKind
-
 _LOGGER = logging.getLogger("project_db_creation")
 
 
@@ -34,13 +33,10 @@ class PTerm(SQLModel, PkMixin, IdMixin, table=True):
     kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
     collection_pk: int | None = Field(default=None, foreign_key="collections.pk")
     collection: Collection = Relationship(back_populates="terms")
+    __table_args__ = (sa.Index(
+             "drs_name_index", specs.sa_column["drs_name"]
 
-
-def create_drs_name_index():
-    PTerm.__table_args__ = sa.Index(
-        "drs_name_index", PTerm.__table__.c.specs["drs_name"]
-    )
-
+         ),)
 
 def project_create_db(db_file_path: Path):
     try:
@@ -53,7 +49,6 @@ def project_create_db(db_file_path: Path):
         tables_to_be_created = [SQLModel.metadata.tables['projects'],
                                 SQLModel.metadata.tables['collections'],
                                 SQLModel.metadata.tables['pterms']]
-        create_drs_name_index()
         SQLModel.metadata.create_all(connection.get_engine(), tables=tables_to_be_created)
     except Exception as e:
         msg = f'Unable to create tables in SQLite database at {db_file_path}. Abort.'

esgvoc/core/db/models/universe.py

@@ -14,10 +14,10 @@ _LOGGER = logging.getLogger("universe_db_creation")
 class Universe(SQLModel, PkMixin, table=True):
     __tablename__ = "universes"
     git_hash: str
-    data_descriptors: list["DataDescriptor"] = Relationship(back_populates="universe")
+    data_descriptors: list["UDataDescriptor"] = Relationship(back_populates="universe")
 
 
-class DataDescriptor(SQLModel, PkMixin, IdMixin, table=True):
+class UDataDescriptor(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "data_descriptors"
     context: dict = Field(sa_column=sa.Column(JSON))
     universe_pk: int | None = Field(default=None, foreign_key="universes.pk")
@@ -33,7 +33,7 @@ class UTerm(SQLModel, PkMixin, IdMixin, table=True):
     data_descriptor_pk: int | None = Field(
         default=None, foreign_key="data_descriptors.pk"
     )
-    data_descriptor: DataDescriptor = Relationship(back_populates="terms")
+    data_descriptor: UDataDescriptor = Relationship(back_populates="terms")
 
 
 def universe_create_db(db_file_path: Path) -> None:

esgvoc/core/db/project_ingestion.py

@@ -11,6 +11,7 @@ from pydantic import BaseModel
 import esgvoc.core.db.connection as db
 from esgvoc.core.db.connection import read_json_file
 from esgvoc.core.db.models.project import Collection, Project, PTerm
+import  esgvoc.core.service as service
 
 
 _LOGGER = logging.getLogger("project_ingestion")
@@ -74,7 +75,9 @@ def ingest_collection(collection_dir_path: Path,
         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":".cache/repos/mip-cmor-tables"}).merge_linked_json()[-1]
+                                        # 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.current_state.universe.local_path}).merge_linked_json()[-1]
+
                 term_kind = infer_term_kind(json_specs)
                 term_id = json_specs["id"]
 

esgvoc/core/db/universe_ingestion.py

@@ -9,8 +9,9 @@ from sqlmodel import Session, select
 import esgvoc.core.db.connection as db
 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 UDataDescriptor, UTerm, Universe
 from esgvoc.core.db.models.universe import universe_create_db
+import esgvoc.core.service as service
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -32,7 +33,7 @@ def ingest_universe(universe_repo_dir_path: Path, universe_db_file_path: Path) -
         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  
+        if data_descriptor_dir_path.is_dir() and (data_descriptor_dir_path / "000_context.jsonld").exists(): # TODO maybe put that in setting
             try:
                 ingest_data_descriptor(data_descriptor_dir_path, connection)
             except Exception as e:
@@ -61,9 +62,8 @@ def ingest_data_descriptor(data_descriptor_path: Path,
         _LOGGER.warning(msg)
         return        
 
-
     with connection.create_session() as session:
-        data_descriptor = DataDescriptor(id=data_descriptor_id,
+        data_descriptor = UDataDescriptor(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)
         term_kind_dd = None
@@ -72,9 +72,10 @@ def ingest_data_descriptor(data_descriptor_path: Path,
         for term_file_path in data_descriptor_path.iterdir():
             _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":".cache/repos/mip-cmor-tables"}).merge_linked_json()[-1]
+                                          locally_available={"https://espri-mod.github.io/mip-cmor-tables":service.current_state.universe.local_path}).merge_linked_json()[-1]
                     term_kind = infer_term_kind(json_specs)
                     term_id = json_specs["id"]
 
@@ -103,8 +104,8 @@ def get_universe_term(data_descriptor_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()

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")
+
+
+    
+
+