esgvoc 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

esgvoc/cli/offline.py

@@ -0,0 +1,269 @@
+"""
+Offline mode management CLI commands.
+
+This module provides CLI commands for managing offline mode settings
+for universe and project components.
+"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from esgvoc.core.service import config_manager
+
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command()
+def show(
+    component: str = typer.Argument(
+        None,
+        help="Component to show offline status for (universe or project name). Shows all if not specified."
+    ),
+    config: str = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration name to use"
+    )
+):
+    """Show offline mode status for components."""
+    try:
+        if config:
+            settings = config_manager.get_config(config)
+        else:
+            settings = config_manager.get_active_config()
+
+        if component:
+            # Show specific component
+            if component == "universe":
+                if settings.universe.offline_mode:
+                    console.print(f"[green]Universe is in offline mode[/green]")
+                else:
+                    console.print(f"[yellow]Universe is in online mode[/yellow]")
+            elif component in settings.projects:
+                project = settings.projects[component]
+                if project.offline_mode:
+                    console.print(f"[green]Project '{component}' is in offline mode[/green]")
+                else:
+                    console.print(f"[yellow]Project '{component}' is in online mode[/yellow]")
+            else:
+                console.print(f"[red]Component '{component}' not found[/red]")
+                raise typer.Exit(1)
+        else:
+            # Show all components
+            table = Table(title="Offline Mode Status")
+            table.add_column("Component", style="cyan")
+            table.add_column("Type", style="magenta")
+            table.add_column("Offline Mode", style="bold")
+
+            # Universe
+            status = "[green]✓ Enabled[/green]" if settings.universe.offline_mode else "[yellow]✗ Disabled[/yellow]"
+            table.add_row("Universe", "Universe", status)
+
+            # Projects
+            for project_name, project in settings.projects.items():
+                status = "[green]✓ Enabled[/green]" if project.offline_mode else "[yellow]✗ Disabled[/yellow]"
+                table.add_row(project_name, "Project", status)
+
+            console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def enable(
+    component: str = typer.Argument(
+        None,
+        help="Component to enable offline mode for (universe or project name). If not specified, enables for all components."
+    ),
+    config: str = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration name to use"
+    )
+):
+    """Enable offline mode for a component or all components if none specified."""
+    try:
+        if config:
+            settings = config_manager.get_config(config)
+        else:
+            settings = config_manager.get_active_config()
+
+        if component is None:
+            # Enable for all components
+            settings.universe.offline_mode = True
+            for project in settings.projects.values():
+                project.offline_mode = True
+            console.print(f"[green]✓ Enabled offline mode for all components[/green]")
+        elif component == "universe":
+            settings.universe.offline_mode = True
+            console.print(f"[green]✓ Enabled offline mode for universe[/green]")
+        elif component in settings.projects:
+            settings.projects[component].offline_mode = True
+            console.print(f"[green]✓ Enabled offline mode for project '{component}'[/green]")
+        else:
+            console.print(f"[red]Component '{component}' not found[/red]")
+            raise typer.Exit(1)
+
+        # Save the updated settings
+        if config:
+            # Use the correct format for saving
+            data = {
+                "universe": settings.universe.model_dump(),
+                "projects": [p.model_dump() for p in settings.projects.values()],
+            }
+            config_manager.save_config(data, config)
+        else:
+            config_manager.save_active_config(settings)
+        console.print(f"[blue]Configuration saved[/blue]")
+
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def disable(
+    component: str = typer.Argument(
+        None,
+        help="Component to disable offline mode for (universe or project name). If not specified, disables for all components."
+    ),
+    config: str = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration name to use"
+    )
+):
+    """Disable offline mode for a component or all components if none specified."""
+    try:
+        if config:
+            settings = config_manager.get_config(config)
+        else:
+            settings = config_manager.get_active_config()
+
+        if component is None:
+            # Disable for all components
+            settings.universe.offline_mode = False
+            for project in settings.projects.values():
+                project.offline_mode = False
+            console.print(f"[yellow]✓ Disabled offline mode for all components[/yellow]")
+        elif component == "universe":
+            settings.universe.offline_mode = False
+            console.print(f"[yellow]✓ Disabled offline mode for universe[/yellow]")
+        elif component in settings.projects:
+            settings.projects[component].offline_mode = False
+            console.print(f"[yellow]✓ Disabled offline mode for project '{component}'[/yellow]")
+        else:
+            console.print(f"[red]Component '{component}' not found[/red]")
+            raise typer.Exit(1)
+
+        # Save the updated settings
+        if config:
+            # Use the correct format for saving
+            data = {
+                "universe": settings.universe.model_dump(),
+                "projects": [p.model_dump() for p in settings.projects.values()],
+            }
+            config_manager.save_config(data, config)
+        else:
+            config_manager.save_active_config(settings)
+        console.print(f"[blue]Configuration saved[/blue]")
+
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def enable_all(
+    config: str = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration name to use"
+    )
+):
+    """Enable offline mode for all components."""
+    try:
+        if config:
+            settings = config_manager.get_config(config)
+        else:
+            settings = config_manager.get_active_config()
+
+        # Enable for universe
+        settings.universe.offline_mode = True
+
+        # Enable for all projects
+        for project in settings.projects.values():
+            project.offline_mode = True
+
+        # Save the updated settings
+        if config:
+            # Use the correct format for saving
+            data = {
+                "universe": settings.universe.model_dump(),
+                "projects": [p.model_dump() for p in settings.projects.values()],
+            }
+            config_manager.save_config(data, config)
+        else:
+            config_manager.save_active_config(settings)
+
+        console.print(f"[green]✓ Enabled offline mode for all components[/green]")
+        console.print(f"[blue]Configuration saved[/blue]")
+
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def disable_all(
+    config: str = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration name to use"
+    )
+):
+    """Disable offline mode for all components."""
+    try:
+        if config:
+            settings = config_manager.get_config(config)
+        else:
+            settings = config_manager.get_active_config()
+
+        # Disable for universe
+        settings.universe.offline_mode = False
+
+        # Disable for all projects
+        for project in settings.projects.values():
+            project.offline_mode = False
+
+        # Save the updated settings
+        if config:
+            # Use the correct format for saving
+            data = {
+                "universe": settings.universe.model_dump(),
+                "projects": [p.model_dump() for p in settings.projects.values()],
+            }
+            config_manager.save_config(data, config)
+        else:
+            config_manager.save_active_config(settings)
+
+        console.print(f"[yellow]✓ Disabled offline mode for all components[/yellow]")
+        console.print(f"[blue]Configuration saved[/blue]")
+
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

esgvoc/cli/status.py

@@ -22,26 +22,58 @@ def status():
     """
     assert service.current_state is not None
     service.current_state.get_state_summary()
-    # display(service.state_service.table())
+
+    # Check for offline mode components and display summary
+    offline_components = []
+    if service.current_state.universe.offline_mode:
+        offline_components.append("universe")
+    for project_name, project in service.current_state.projects.items():
+        if project.offline_mode:
+            offline_components.append(project_name)
+
+    if offline_components:
+        console.print(f"[yellow]Offline mode enabled for: {', '.join(offline_components)}[/yellow]")
 
     table = Table(show_header=False, show_lines=True)
 
-    table.add_row("", "Remote github repo", "Local repository", "Cache Database", style="bright_green")
+    table.add_row("", "Remote github repo", "Local repository", "Cache Database", "Offline Mode", style="bright_green")
+
+    # Universe row
+    universe_offline_status = "✓" if service.current_state.universe.offline_mode else "✗"
     table.add_row(
         "Universe path",
         service.current_state.universe.github_repo,
         service.current_state.universe.local_path,
         service.current_state.universe.db_path,
+        universe_offline_status,
         style="white",
     )
     table.add_row(
         "Version",
-        service.current_state.universe.github_version,
-        service.current_state.universe.local_version,
-        service.current_state.universe.db_version,
+        service.current_state.universe.github_version or "N/A",
+        service.current_state.universe.local_version or "N/A",
+        service.current_state.universe.db_version or "N/A",
+        "",
         style="bright_blue",
     )
+
+    # Projects rows
     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")
+        proj_offline_status = "✓" if proj.offline_mode else "✗"
+        table.add_row(
+            f"{proj_name} path",
+            proj.github_repo,
+            proj.local_path,
+            proj.db_path,
+            proj_offline_status,
+            style="white"
+        )
+        table.add_row(
+            "Version",
+            proj.github_version or "N/A",
+            proj.local_version or "N/A",
+            proj.db_version or "N/A",
+            "",
+            style="bright_blue"
+        )
     display(table)

esgvoc/core/db/project_ingestion.py

@@ -138,15 +138,19 @@ def ingest_project(project_dir_path: Path, project_db_file_path: Path, git_hash:
         project_specs_file_path = project_dir_path.joinpath(esgvoc.core.constants.PROJECT_SPECS_FILENAME)
         drs_specs_file_path = project_dir_path.joinpath(esgvoc.core.constants.DRS_SPECS_FILENAME)
         catalog_specs_file_path = project_dir_path.joinpath(esgvoc.core.constants.CATALOG_SPECS_FILENAME)
+        attr_specs_file_path = project_dir_path.joinpath(esgvoc.core.constants.ATTRIBUTES_SPECS_FILENAME)
         try:
             raw_project_specs = read_yaml_file(project_specs_file_path)
             project_id = raw_project_specs[esgvoc.core.constants.PROJECT_ID_JSON_KEY]
             raw_drs_specs = read_yaml_file(drs_specs_file_path)
             project_specs = raw_project_specs
-            project_specs['drs_specs'] = raw_drs_specs
+            project_specs["drs_specs"] = raw_drs_specs
             if catalog_specs_file_path.exists():
                 raw_catalog_specs = read_yaml_file(catalog_specs_file_path)
-                project_specs['catalog_specs'] = raw_catalog_specs
+                project_specs["catalog_specs"] = raw_catalog_specs
+            if attr_specs_file_path.exists():
+                raw_attr_specs = read_yaml_file(attr_specs_file_path)
+                project_specs["attr_specs"] = raw_attr_specs
         except Exception as e:
             msg = f"unable to read specs files in {project_dir_path}"
             _LOGGER.fatal(msg)

esgvoc/core/repo_fetcher.py

@@ -64,9 +64,10 @@ class RepoFetcher:
     DataFetcher is responsible for fetching data from external sources such as GitHub.
     """
 
-    def __init__(self, base_url: str = "https://api.github.com", local_path: str = ".cache/repos"):
+    def __init__(self, base_url: str = "https://api.github.com", local_path: str = ".cache/repos", offline_mode: bool = False):
         self.base_url = base_url
         self.repo_dir = local_path
+        self.offline_mode = offline_mode
 
     def fetch_repositories(self, user: str) -> List[GitHubRepository]:
         """
@@ -74,6 +75,9 @@ class RepoFetcher:
         :param user: GitHub username
         :return: List of GitHubRepository objects
         """
+        if self.offline_mode:
+            raise Exception("Cannot fetch repositories in offline mode")
+
         url = f"{self.base_url}/users/{user}/repos"
         response = requests.get(url)
 
@@ -93,6 +97,9 @@ class RepoFetcher:
         :param repo: Repository name
         :return: GitHubRepository object
         """
+        if self.offline_mode:
+            raise Exception("Cannot fetch repository details in offline mode")
+
         url = f"{self.base_url}/repos/{owner}/{repo}"
         response = requests.get(url)
 
@@ -113,6 +120,9 @@ class RepoFetcher:
         :param branch: Branch name
         :return: GitHubBranch object
         """
+        if self.offline_mode:
+            raise Exception("Cannot fetch branch details in offline mode")
+
         url = f"{self.base_url}/repos/{owner}/{repo}/branches/{branch}"
         response = requests.get(url)
 
@@ -133,6 +143,9 @@ class RepoFetcher:
         :param branch: Branch name (default: 'main').
         :return: List of directories in the repository.
         """
+        if self.offline_mode:
+            raise Exception("Cannot list directories in offline mode")
+
         url = f"https://api.github.com/repos/{owner}/{repo}/contents/?ref={branch}"
         response = requests.get(url)
         response.raise_for_status()  # Raise an error for bad responses
@@ -150,6 +163,9 @@ class RepoFetcher:
         :param branch: Branch name (default: 'main').
         :return: List of files in the specified directory.
         """
+        if self.offline_mode:
+            raise Exception("Cannot list files in offline mode")
+
         url = f"https://api.github.com/repos/{owner}/{repo}/contents/{directory}?ref={branch}"
         response = requests.get(url)
         response.raise_for_status()  # Raise an error for bad responses
@@ -157,18 +173,24 @@ 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, local_path: str | None = None):
+    def clone_repository(self, owner: str, repo: str, branch: Optional[str] = None, local_path: str | None = None, shallow: bool = True):
         """
         Clone a GitHub repository to a target directory.
         :param owner: Repository owner
         :param repo: Repository name
         :param target_dir: The directory where the repository should be cloned.
         :param branch: (Optional) The branch to clone. Clones the default branch if None.
+        :param shallow: (Optional) If True, performs a shallow clone with --depth 1. Default is True.
         """
+        if self.offline_mode:
+            raise Exception("Cannot clone repository in offline mode")
+
         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, destination]
+        if shallow:
+            command.extend(["--depth", "1"])
         if branch:
             command.extend(["--branch", branch])
         with redirect_stdout_to_log():
@@ -179,8 +201,63 @@ class RepoFetcher:
                 else:
                     current_work_dir = os.getcwd()
                     os.chdir(f"{destination}")
-                    command = ["git", "pull"]
-                    subprocess.run(command, check=True)
+
+                    # Clean up any conflicted state first
+                    try:
+                        subprocess.run(["git", "reset", "--hard"], capture_output=True, check=False)
+                        subprocess.run(["git", "clean", "-fd"], capture_output=True, check=False)
+                    except Exception:
+                        pass
+
+                    # Check if the requested branch exists locally
+                    try:
+                        result = subprocess.run(
+                            ["git", "rev-parse", "--verify", f"refs/heads/{branch}"],
+                            capture_output=True,
+                            check=False
+                        )
+                        branch_exists_locally = result.returncode == 0
+                    except Exception:
+                        branch_exists_locally = False
+
+                    if not branch_exists_locally and branch:
+                        # If branch doesn't exist locally, we need to fetch it
+                        # For shallow repos, we need to unshallow first or fetch the specific branch
+                        try:
+                            # Try to fetch the specific branch
+                            subprocess.run(["git", "fetch", "origin", f"{branch}:{branch}"], check=True)
+                            _LOGGER.debug(f"Fetched new branch {branch}")
+                        except subprocess.CalledProcessError:
+                            # If that fails, unshallow and try again
+                            subprocess.run(["git", "fetch", "--unshallow"], check=True)
+                            subprocess.run(["git", "fetch", "origin", f"{branch}:{branch}"], check=True)
+                            _LOGGER.debug(f"Unshallowed repo and fetched branch {branch}")
+
+                    # Switch to the requested branch if specified
+                    if branch:
+                        subprocess.run(["git", "checkout", branch], check=True)
+                        _LOGGER.debug(f"Switched to branch {branch}")
+
+                    # For shallow repos that switched branches, just ensure we have latest
+                    # to avoid merge conflicts from different commit histories
+                    if branch and not branch_exists_locally:
+                        # We already fetched the branch, no need for additional reset
+                        _LOGGER.debug(f"Switched to newly fetched branch {branch}")
+                    else:
+                        # Pull latest changes for normal updates
+                        try:
+                            subprocess.run(["git", "pull"], check=True)
+                        except subprocess.CalledProcessError:
+                            # If pull fails, try to fetch and reset
+                            subprocess.run(["git", "fetch"], check=True)
+                            # Check if remote tracking branch exists
+                            try:
+                                subprocess.run(["git", "rev-parse", f"origin/{branch}"], capture_output=True, check=True)
+                                subprocess.run(["git", "reset", "--hard", f"origin/{branch}"], check=True)
+                                _LOGGER.debug(f"Reset to origin/{branch} after pull failure")
+                            except subprocess.CalledProcessError:
+                                # Remote tracking branch doesn't exist, just continue
+                                _LOGGER.debug(f"No remote tracking branch for {branch}, continuing")
                     os.chdir(current_work_dir)
 
             except Exception as e:
@@ -188,11 +265,17 @@ class RepoFetcher:
 
     def get_github_version_with_api(self, owner: str, repo: str, branch: str = "main"):
         """Fetch the latest commit version (or any other versioning scheme) from GitHub."""
+        if self.offline_mode:
+            raise Exception("Cannot get GitHub version in offline mode")
         details = self.fetch_branch_details(owner, repo, branch)
         return details.commit.get("sha")
 
     def get_github_version(self, owner: str, repo: str, branch: str = "main"):
         """Fetch the latest commit version (or any other versioning scheme) from GitHub. with command git fetch"""
+        if self.offline_mode:
+            _LOGGER.debug("Cannot get GitHub version in offline mode")
+            return None
+
         repo_url = f"https://github.com/{owner}/{repo}.git"
         command = ["git", "ls-remote", repo_url, f"{self.repo_dir}/{repo}"]
         if branch:

esgvoc/core/service/__init__.py

@@ -20,7 +20,7 @@ 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)
+        config_manager = ConfigManager(ServiceSettings, app_name="esgvoc", app_author="ipsl", default_settings=ServiceSettings._get_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)
@@ -29,9 +29,10 @@ def get_config_manager():
 
 
 def get_state():
-    global current_state 
+    global current_state
     if config_manager is not None:
-        current_state = StateService(config_manager.get_active_config())
+        service_settings = config_manager.get_active_config()
+        current_state = StateService(service_settings)
     return current_state
 
 # Singleton Access Function

esgvoc/core/service/configuration/config_manager.py

@@ -11,16 +11,18 @@ 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 ):
+    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).
@@ -33,11 +35,10 @@ class ConfigManager(Generic[T]):
         # 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.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)
@@ -80,7 +81,7 @@ class ConfigManager(Generic[T]):
         active_config_name = registry["active"]
         return Path(registry["configs"][active_config_name])
 
-    def get_config(self, config_name:str) -> T:
+    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"]:
@@ -92,9 +93,14 @@ class ConfigManager(Generic[T]):
     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()
+        active_config_name = self.get_active_config_name()
+
+        settings = self.config_cls.load_from_file(str(active_config_path))
+        # Set the config name if the settings support it (duck typing)
+        if hasattr(settings, 'set_config_name'):
+            settings.set_config_name(active_config_name)
+        return settings
 
-        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)
@@ -102,7 +108,7 @@ class ConfigManager(Generic[T]):
 
     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"
@@ -119,11 +125,11 @@ class ConfigManager(Generic[T]):
             # 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)
 
@@ -147,7 +153,7 @@ class ConfigManager(Generic[T]):
             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}")
 
@@ -181,8 +187,3 @@ class ConfigManager(Generic[T]):
         if registry["active"] not in registry["configs"]:
             self.switch_config("default")
             logger.info("active configuration doesnot exist anymore : Switch to default configuration")
-
-
-    
-
-