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

esgvoc/cli/valid.py

@@ -38,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)

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

@@ -76,7 +76,7 @@ def ingest_collection(collection_dir_path: Path,
             try:
                 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={"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,7 +9,7 @@ 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
 
@@ -63,7 +63,7 @@ def ingest_data_descriptor(data_descriptor_path: Path,
         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":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}).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")
+
+
+    
+
+

esgvoc/core/service/configuration/setting.py

@@ -0,0 +1,88 @@
+from typing import ClassVar, Dict, Optional
+import toml
+from pydantic import BaseModel, Field
+
+
+class ProjectSettings(BaseModel):
+    project_name: str
+    github_repo: str
+    branch: Optional[str] = "main"
+    local_path: Optional[str] = None
+    db_path: Optional[str] = None
+
+
+class UniverseSettings(BaseModel):
+    github_repo: str
+    branch: Optional[str] = None
+    local_path: Optional[str] = None
+    db_path: Optional[str] = None
+
+
+class ServiceSettings(BaseModel):
+    universe: UniverseSettings
+    projects: Dict[str, ProjectSettings] = Field(default_factory=dict)
+
+    # 🔹 Define default settings
+    DEFAULT_SETTINGS : ClassVar[dict]= {
+        "universe": {
+            "github_repo": "https://github.com/WCRP-CMIP/WCRP-universe",
+            "branch": "esgvoc",
+            "local_path": "repos/WCRP-universe",
+            "db_path": "dbs/universe.sqlite",
+        },
+        "projects": [
+            {
+                "project_name": "cmip6",
+                "github_repo": "https://github.com/WCRP-CMIP/CMIP6_CVs",
+                "branch": "esgvoc",
+                "local_path": "repos/CMIP6_CVs",
+                "db_path": "dbs/cmip6.sqlite",
+            },
+            {
+                "project_name": "cmip6plus",
+                "github_repo": "https://github.com/WCRP-CMIP/CMIP6Plus_CVs",
+                "branch": "esgvoc",
+                "local_path": "repos/CMIP6Plus_CVs",
+                "db_path": "dbs/cmip6plus.sqlite",
+            },
+        ],
+    }
+
+    @classmethod
+    def load_from_file(cls, file_path: str) -> "ServiceSettings":
+        """Load configuration from a TOML file, falling back to defaults if necessary."""
+        try:
+            data = toml.load(file_path)
+        except FileNotFoundError:
+            data = cls.DEFAULT_SETTINGS  # Use defaults if the file is missing
+
+        projects = {p["project_name"]: ProjectSettings(**p) for p in data.pop("projects", [])}
+        return cls(universe=UniverseSettings(**data["universe"]), projects=projects)
+
+    @classmethod
+    def load_default(cls) -> "ServiceSettings":
+        """Load default settings."""
+        return cls.load_from_dict(cls.DEFAULT_SETTINGS)
+
+    @classmethod
+    def load_from_dict(cls, config_data: dict) -> "ServiceSettings":
+        """Load configuration from a dictionary."""
+        projects = {p["project_name"]: ProjectSettings(**p) for p in config_data.get("projects", [])}
+        return cls(universe=UniverseSettings(**config_data["universe"]), projects=projects)
+
+    def save_to_file(self, file_path: str):
+        """Save the configuration to a TOML file."""
+        data = {
+            "universe": self.universe.model_dump(),
+            "projects": [p.model_dump() for p in self.projects.values()],
+        }
+        with open(file_path, "w") as f:
+            toml.dump(data, f)
+            
+    def dump(self)->dict:
+        data = {
+            "universe": self.universe.model_dump(),
+            "projects": [p.model_dump() for p in self.projects.values()],
+        }
+        return data
+