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

esgvoc/apps/drs/validator.py

@@ -1,26 +1,18 @@
 from typing import cast
-from esgvoc.api.project_specs import (ProjectSpecs,
-                               DrsType,
-                               DrsPart,
-                               DrsSpecification,
-                               DrsPartKind,
-                               DrsCollection,
-                               DrsConstant)
+
 import esgvoc.api.projects as projects
 import esgvoc.apps.drs.constants as constants
-from esgvoc.apps.drs.report import (DrsValidationReport,
-                                    DrsIssue,
-                                    ParserIssue,
-                                    ValidationIssue,
-                                    Space,
-                                    Unparsable,
-                                    ExtraSeparator,
-                                    ExtraChar,
-                                    BlankToken,
-                                    InvalidToken,
-                                    ExtraToken,
-                                    MissingToken,
-                                    FileNameExtensionIssue)
+from esgvoc.api import APIException
+from esgvoc.api.project_specs import (DrsCollection, DrsConstant, DrsPart,
+                                      DrsPartKind, DrsSpecification, DrsType,
+                                      ProjectSpecs)
+from esgvoc.apps.drs.report import (BlankTerm, ComplianceIssue, DrsIssue,
+                                    DrsValidationReport, ExtraChar,
+                                    ExtraSeparator, ExtraTerm,
+                                    FileNameExtensionIssue, InvalidTerm,
+                                    MissingTerm, ParsingIssue, Space,
+                                    Unparsable, ValidationError,
+                                    ValidationWarning)
 
 
 class DrsApplication:
@@ -33,7 +25,9 @@ class DrsApplication:
         """The project id."""
         self.pedantic: bool = pedantic
         """Same as the option of GCC: turn warnings into errors. Default False."""
-        project_specs: ProjectSpecs = projects.get_project_specs(project_id)
+        project_specs: ProjectSpecs|None = projects.find_project(project_id)
+        if not project_specs:
+            raise APIException(f'unable to find project {project_id}')
         for specs in project_specs.drs_specs:
             match specs.type:
                 case DrsType.DIRECTORY:
@@ -46,7 +40,7 @@ class DrsApplication:
                     self.dataset_id_specs: DrsSpecification = specs
                     """The DRS dataset id specs of the project."""
                 case _:
-                    raise ValueError(f'unsupported DRS specs type {specs.type}')
+                    raise RuntimeError(f'unsupported DRS specs type {specs.type}')
 
     def _get_full_file_name_extension(self) -> str:
         """
@@ -61,38 +55,33 @@ class DrsApplication:
             full_extension = specs.properties[constants.FILE_NAME_EXTENSION_SEPARATOR_KEY] + \
                              specs.properties[constants.FILE_NAME_EXTENSION_KEY]
         else:
-            raise ValueError('missing properties in the DRS file name specifications of the ' +
-                             f'project {self.project_id}')
+            raise RuntimeError('missing properties in the DRS file name specifications of the ' +
+                               f'project {self.project_id}')
         return full_extension
-    
-    def _get_specs(self, drs_type: DrsType|str) -> DrsSpecification:
-        match drs_type:
-            case DrsType.DIRECTORY:
-                specs = self.directory_specs
-            case DrsType.FILE_NAME:
-                specs = self.file_name_specs
-            case DrsType.DATASET_ID:
-                specs = self.dataset_id_specs
-            case _:
-                raise ValueError(f'unsupported DRS type {drs_type}')
-        return specs
-    
+
+
 class DrsValidator(DrsApplication):
     """
     Valid a DRS directory, dataset id and file name expression against a project.
     """
-   
-    def validate_directory(self, drs_expression: str) -> DrsValidationReport:
+
+    def validate_directory(self, drs_expression: str,
+                           prefix: str|None = None) -> DrsValidationReport:
         """
         Validate a DRS directory expression.
 
         :param drs_expression: A DRS directory expression.
         :type drs_expression: str
+        :param prefix: A directory prefix to be removed from the directory expression.
+        :type prefix: str|None
         :returns: A validation report.
         :rtype: DrsValidationReport
         """
+        if prefix:
+            # Remove prefix if present. Always returns a copy.
+            drs_expression = drs_expression.removeprefix(prefix)
         return self._validate(drs_expression, self.directory_specs)
-    
+
     def validate_dataset_id(self, drs_expression: str) -> DrsValidationReport:
         """
         Validate a DRS dataset id expression.
@@ -134,13 +123,20 @@ class DrsValidator(DrsApplication):
         :returns: A validation report.
         :rtype: DrsValidationReport
         """
-        specs = self._get_specs(drs_type)
-        return self._validate(drs_expression, specs)
-    
+        match drs_type:
+            case DrsType.DIRECTORY:
+                return self.validate_directory(drs_expression=drs_expression)
+            case DrsType.FILE_NAME:
+                return self.validate_file_name(drs_expression=drs_expression)
+            case DrsType.DATASET_ID:
+                return self.validate_dataset_id(drs_expression=drs_expression)
+            case _:
+                raise RuntimeError(f'unsupported drs type {drs_type}')
+
     def _parse(self,
                drs_expression: str,
                separator: str,
-               drs_type: DrsType) -> tuple[list[str]|None,  # Tokens
+               drs_type: DrsType) -> tuple[list[str]|None,  # terms
                                            list[DrsIssue],  # Errors
                                            list[DrsIssue]]: # Warnings
         errors: list[DrsIssue] = list()
@@ -150,7 +146,7 @@ class DrsValidator(DrsApplication):
         start_with_space = drs_expression[0].isspace()
         end_with_space = drs_expression[-1].isspace()
         if start_with_space or end_with_space:
-            issue: ParserIssue = Space()
+            issue: ParsingIssue = Space()
             if self.pedantic:
                 errors.append(issue)
             else:
@@ -161,78 +157,78 @@ class DrsValidator(DrsApplication):
                 cursor_offset = previous_len - len(drs_expression)
             if end_with_space:
                 drs_expression = drs_expression.rstrip()
-        tokens = drs_expression.split(separator)
-        if len(tokens) < 2:
+        terms = drs_expression.split(separator)
+        if len(terms) < 2:
             errors.append(Unparsable(expected_drs_type=drs_type))
             return None, errors, warnings # Early exit
-        max_token_index = len(tokens)
+        max_term_index = len(terms)
         cursor_position = initial_cursor_position = len(drs_expression) + 1
-        has_white_token = False
-        for index in range(max_token_index-1, -1, -1):
-            token = tokens[index]
-            if (is_white_token := token.isspace()) or (not token):
-                has_white_token = has_white_token or is_white_token
-                cursor_position -= len(token) + 1
-                del tokens[index]
+        has_white_term = False
+        for index in range(max_term_index-1, -1, -1):
+            term = terms[index]
+            if (is_white_term := term.isspace()) or (not term):
+                has_white_term = has_white_term or is_white_term
+                cursor_position -= len(term) + 1
+                del terms[index]
                 continue
             else:
                 break
         if cursor_position != initial_cursor_position:
-            max_token_index = len(tokens)
+            max_term_index = len(terms)
             column = cursor_position+cursor_offset
-            if (drs_type == DrsType.DIRECTORY) and (not has_white_token):
+            if (drs_type == DrsType.DIRECTORY) and (not has_white_term):
                 issue = ExtraSeparator(column=column)
                 warnings.append(issue)
             else:
                 issue = ExtraChar(column=column)
                 errors.append(issue)
-        for index in range(max_token_index-1, -1, -1):
-            token = tokens[index]
-            len_token = len(token)
-            if not token:
+        for index in range(max_term_index-1, -1, -1):
+            term = terms[index]
+            len_term = len(term)
+            if not term:
                 column = cursor_position + cursor_offset
                 issue = ExtraSeparator(column=column)
                 if (drs_type != DrsType.DIRECTORY) or self.pedantic or (index == 0):
                     errors.append(issue)
                 else:
                     warnings.append(issue)
-                del tokens[index]
-            if token.isspace():
-                column = cursor_position + cursor_offset - len_token
-                issue = BlankToken(column=column)
+                del terms[index]
+            if term.isspace():
+                column = cursor_position + cursor_offset - len_term
+                issue = BlankTerm(column=column)
                 errors.append(issue)
-                del tokens[index]
-            cursor_position -= len_token + 1
-        
-        # Mypy doesn't understand that ParserIssues are DrsIssues...
+                del terms[index]
+            cursor_position -= len_term + 1
+
+        # Mypy doesn't understand that ParsingIssues are DrsIssues...
         sorted_errors = DrsValidator._sort_parser_issues(errors) # type: ignore
         sorted_warnings = DrsValidator._sort_parser_issues(warnings) # type: ignore
-        return tokens, sorted_errors, sorted_warnings # type: ignore
-    
+        return terms, sorted_errors, sorted_warnings # type: ignore
+
     @staticmethod
-    def _sort_parser_issues(issues: list[ParserIssue]) -> list[ParserIssue]:
+    def _sort_parser_issues(issues: list[ParsingIssue]) -> list[ParsingIssue]:
         return sorted(issues, key=lambda issue: issue.column if issue.column else 0)
 
-    def _validate_token(self, token: str, part: DrsPart) -> bool:
+    def _validate_term(self, term: str, part: DrsPart) -> bool:
         match part.kind:
             case DrsPartKind.COLLECTION:
                 casted_part: DrsCollection = cast(DrsCollection, part)
                 try:
-                    matching_terms = projects.valid_term_in_collection(token,
+                    matching_terms = projects.valid_term_in_collection(term,
                                                                        self.project_id,
                                                                        casted_part.collection_id)
                 except Exception as e:
-                    msg = f'problem while validating token: {e}.Abort.'
-                    raise ValueError(msg) from e
+                    msg = f'problem while validating term: {e}.Abort.'
+                    raise APIException(msg) from e
                 if len(matching_terms) > 0:
                     return True
                 else:
                     return False
             case DrsPartKind.CONSTANT:
                 part_casted: DrsConstant = cast(DrsConstant, part)
-                return part_casted.value != token
+                return part_casted.value != term
             case _:
-                raise ValueError(f'unsupported DRS specs part type {part.kind}')
+                raise RuntimeError(f'unsupported DRS specs part type {part.kind}')
 
     def _create_report(self,
                        type: DrsType,
@@ -240,67 +236,69 @@ class DrsValidator(DrsApplication):
                        errors: list[DrsIssue],
                        warnings: list[DrsIssue]) -> DrsValidationReport:
         return DrsValidationReport(project_id=self.project_id, type=type,
-                                   expression=drs_expression, errors=errors, warnings=warnings)
+                                   expression=drs_expression,
+                                   errors=cast(list[ValidationError], errors),
+                                   warnings=cast(list[ValidationWarning], warnings))
 
     def _validate(self,
                   drs_expression: str,
                   specs: DrsSpecification) -> DrsValidationReport:
-        tokens, errors, warnings = self._parse(drs_expression, specs.separator, specs.type)
-        if not tokens:
+        terms, errors, warnings = self._parse(drs_expression, specs.separator, specs.type)
+        if not terms:
             return self._create_report(specs.type, drs_expression, errors, warnings) # Early exit.
-        token_index = 0
-        token_max_index = len(tokens)
+        term_index = 0
+        term_max_index = len(terms)
         part_index = 0
         part_max_index = len(specs.parts)
         matching_code_mapping = dict()
         while part_index < part_max_index:
-            token = tokens[token_index]
+            term = terms[term_index]
             part = specs.parts[part_index]
-            if self._validate_token(token, part):
-                token_index += 1
+            if self._validate_term(term, part):
+                term_index += 1
                 part_index += 1
                 matching_code_mapping[part.__str__()] = 0
             elif part.kind == DrsPartKind.CONSTANT or \
                  cast(DrsCollection, part).is_required:
-                issue: ValidationIssue = InvalidToken(token=token,
-                                                      token_position=token_index+1,
+                issue: ComplianceIssue = InvalidTerm(term=term,
+                                                      term_position=term_index+1,
                                                       collection_id_or_constant_value=str(part))
                 errors.append(issue)
                 matching_code_mapping[part.__str__()] = 1
-                token_index += 1
+                term_index += 1
                 part_index += 1
-            else: # The part is not required so try to match the token with the next part.
+            else: # The part is not required so try to match the term with the next part.
                 part_index += 1
                 matching_code_mapping[part.__str__()] = -1
-            if token_index == token_max_index:
+            if term_index == term_max_index:
                 break
         # Cases:
-        # - All tokens and collections have been processed.
-        # - Not enough token to process all collections.
-        # - Extra tokens left whereas all collections have been processed:
-        #   + The last collections are required => report extra tokens.
-        #   + The last collections are not required and these tokens were not validated by them.
+        # - All terms and collections have been processed.
+        # - Not enough term to process all collections.
+        # - Extra terms left whereas all collections have been processed:
+        #   + The last collections are required => report extra terms.
+        #   + The last collections are not required and these terms were not validated by them.
         #     => Should report error even if the collections are not required.
-        if part_index < part_max_index: # Missing tokens.
+        if part_index < part_max_index: # Missing terms.
             for index in range(part_index, part_max_index):
                 part = specs.parts[index]
-                issue = MissingToken(collection_id=str(part), collection_position=index+1)
+                issue = MissingTerm(collection_id=str(part), collection_position=index+1)
                 if part.kind == DrsPartKind.CONSTANT or \
                    cast(DrsCollection, part).is_required:
                     errors.append(issue)
                 else:
                     warnings.append(issue)
-        elif token_index < token_max_index: # Extra tokens.
-            part_index -= token_max_index - token_index
-            for index in range(token_index, token_max_index):
-                token = tokens[index]
+        elif term_index < term_max_index: # Extra terms.
+            part_index -= term_max_index - term_index
+            for index in range(term_index, term_max_index):
+                term = terms[index]
                 part = specs.parts[part_index]
                 if part.kind != DrsPartKind.CONSTANT           and \
                    (not cast(DrsCollection, part).is_required) and \
                     matching_code_mapping[part.__str__()] < 0:
-                    issue = ExtraToken(token=token, token_position=index, collection_id=str(part))
+                    issue = ExtraTerm(term=term, term_position=index, collection_id=str(part))
                 else:
-                    issue = ExtraToken(token=token, token_position=index, collection_id=None)
+                    issue = ExtraTerm(term=term, term_position=index, collection_id=None)
                 errors.append(issue)
                 part_index += 1
         return self._create_report(specs.type, drs_expression, errors, warnings)
@@ -329,4 +327,4 @@ if __name__ == "__main__":
             for warning in report.warnings:
                 print(warning)
         else:
-            print('warning(s): 0')
+            print('warning(s): 0')

esgvoc/cli/drs.py

@@ -1,13 +1,15 @@
-from esgvoc.apps.drs.generator import DrsGenerator
-from esgvoc.apps.drs.report import DrsValidationReport, DrsGeneratorReport
-from esgvoc.apps.drs.validator import DrsValidator
+import shlex
 import sys
+from typing import List, Optional
+
 import typer
 from rich.console import Console
 from rich.table import Table
-from typing import List, Optional
+
 import esgvoc.api as ev
-import shlex
+from esgvoc.apps.drs.generator import DrsGenerator
+from esgvoc.apps.drs.report import DrsGenerationReport, DrsValidationReport
+from esgvoc.apps.drs.validator import DrsValidator
 
 app = typer.Typer()
 console = Console()
@@ -35,6 +37,10 @@ def drsvalid(
     file: Optional[typer.FileText] = typer.Option(None, "--file", "-f", help="File containing DRS validation inputs, one per line in the form <project> <drstype> <string>"),
     verbose: bool = typer.Option(False, "-v", "--verbose", help="Provide detailed validation results"),
     output: Optional[str] = typer.Option(None, "-o", "--output", help="File to save the DRS entries validation"),
+    rm_prefix: Optional[str] = typer.Option(None,"-p","--prefix", help="Remove given prefix from all checked directory"),
+    pedantic: Optional[bool] = typer.Option(False,"-e","--enforce", help="Enable pedantic mode, enforcing strict compliance, mean that warnings are now errors.")
+
+
 
 ) -> List[DrsValidationReport]:
     """
@@ -88,13 +94,17 @@ def drsvalid(
 
         string = entries[i]
         i += 1
-        validator = DrsValidator(current_project)
+        validator = DrsValidator(current_project, pedantic=pedantic)
         report = None
         match current_drs_type:
             case "filename":
                 report = validator.validate_file_name(string)
             case "directory":
-                report = validator.validate_directory(string)
+                if rm_prefix:
+                    prefix = rm_prefix+"/" if rm_prefix[-1]!="/" else ""
+                else:
+                    prefix=None
+                report = validator.validate_directory(string, prefix)
             case "dataset":
                 report = validator.validate_dataset_id(string)
             case _:
@@ -111,7 +121,7 @@ def drsvalid(
 
         for report in reports:
             entry = str(report.expression)
-            proj_and_type = str(report.project_id) + " " + report.type + " "  
+            proj_and_type = str(report.project_id) + " " + report.type + " "
             warnings = "\n".join(["⚠️ " + str(warning) for warning in report.warnings])
             errors = "\n".join(["⚠️ " + str(error) for error in report.errors])
             valid = "✅ Valid" if report else "❌ Invalid"
@@ -136,16 +146,16 @@ def drsvalid(
 
 @app.command()
 def drsgen(
-    drs_entries: Optional[List[str]] = typer.Argument(None, help="List of inputs to generate DRS in the form <project> <drstype> <bag_of_tokens>"),
-    file: Optional[typer.FileText] = typer.Option(None, "--file", "-f", help="File containing DRS generation inputs, one per line in the form <project> <drstype> <bag_of_tokens>"),
+    drs_entries: Optional[List[str]] = typer.Argument(None, help="List of inputs to generate DRS in the form <project> <drstype> <bag_of_terms>"),
+    file: Optional[typer.FileText] = typer.Option(None, "--file", "-f", help="File containing DRS generation inputs, one per line in the form <project> <drstype> <bag_of_terms>"),
     verbose: bool = typer.Option(False, "-v", "--verbose", help="Provide detailed generation results"),
     output: Optional[str] = typer.Option(None, "-o", "--output", help="File to save the generated DRS entries"),
-) -> List[DrsGeneratorReport]:
+) -> List[DrsGenerationReport]:
     """
-    Generates DRS strings for a specific project and type based on input bag of tokens.
+    Generates DRS strings for a specific project and type based on input bag of terms.
 
     Args:
-        drs_entries (Optional[List[str]]): A list of inputs in the form <project> <drstype> <bag_of_tokens>.
+        drs_entries (Optional[List[str]]): A list of inputs in the form <project> <drstype> <bag_of_terms>.
         file (Optional[typer.FileText]): File containing DRS generation inputs, one per line.
         verbose (bool): If true, prints detailed generation results.
         output (Optional[str]): File path to save the generated DRS entries.
@@ -189,19 +199,19 @@ def drsgen(
         if current_drs_type is None:
             raise typer.BadParameter(f"Invalid drs_type: {entries[i]}")
 
-        bag_of_tokens = entries[i]
-        bag_of_tokens = set(entries[i].split(" "))
+        bag_of_terms = entries[i]
+        bag_of_terms = set(entries[i].split(" "))
         i += 1
 
         generator = DrsGenerator(current_project)
         report = None
         match current_drs_type:
             case "filename":
-                report = generator.generate_file_name_from_bag_of_tokens(bag_of_tokens)
+                report = generator.generate_file_name_from_bag_of_terms(bag_of_terms)
             case "directory":
-                report = generator.generate_directory_from_bag_of_tokens(bag_of_tokens)
+                report = generator.generate_directory_from_bag_of_terms(bag_of_terms)
             case "dataset":
-                report = generator.generate_dataset_id_from_bag_of_tokens(bag_of_tokens)
+                report = generator.generate_dataset_id_from_bag_of_terms(bag_of_terms)
             case _:
                 raise RuntimeError("drstype is not known")
         generated_reports.append(report)
@@ -216,7 +226,7 @@ def drsgen(
             entry = str(report.mapping_used)
             warnings = "\n".join(["⚠️ " + str(warning) for warning in report.warnings])
             errors = "\n".join([f"🔍 {error}" for error in report.errors])
-            result = report.computed_drs_expression
+            result = report.generated_drs_expression
             table.add_row(entry, warnings, errors, result)
             table.add_row("----", "----", "----", "----")
             if table.columns[3].width is not None and len(result) > table.columns[3].width:

esgvoc/cli/get.py

@@ -19,7 +19,7 @@ def validate_key_format(key: str):
     """
     Validate if the key matches the XXXX:YYYY:ZZZZ format.
     """
-    if not re.match(r"^[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_]*$", key):
+    if not re.match(r"^[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_.]*$", key):
         raise typer.BadParameter(f"Invalid key format: {key}. Must be XXXX:YYYY:ZZZZ.")
     return key.split(":")
 
@@ -96,30 +96,31 @@ def display(data:Any):
 @app.command()
 def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZZZ format")):
     """
-    Retrieve a specific value from the database system.
-    This command allows you to fetch a value by specifying the universe/project, data_descriptor/collection, 
-    and term in a structured format.
-
-    Usage:
-        `get <project>:<collection>:<term>`
-
-    Arguments:
-        <project>        The name of the project to query. like `cmip6plus`
-        <collection>     The name of the collection in the specified database.
-        <term>           The name or term within the specified collection.
-
+    Retrieve a specific value from the database system.\n
+    This command allows you to fetch a value by specifying the universe/project, data_descriptor/collection,
+    and term in a structured format.\n
+    \n
+
+    Usage:\n
+        `get <project>:<collection>:<term>`\n
+    \n
+    Arguments:\n
+        <project>\tThe project id to query. like `cmip6plus`\n
+        <collection>\tThe collection id in the specified database.\n
+        <term>\t\tThe term id within the specified collection.\n
+    \n
     Example:
-        To retrieve the value from the "cmip6plus" project, under the "institution_id" column, 
-        in the term with the identifier "ipsl", you would use:
-            `get cmip6plus:institution_id:ipsl`
-        The default project is the universe CV : the argument would be like `universe:institution:ipsl` or `:institution:ipsl`
-        - to get list of available term from universe institution `:institution:` 
-
-    Notes:
-        - Ensure data exist in your system before using this command (use status command to see whats available).
-        - Use a colon (`:`) to separate the parts of the argument.  
-        - if more than one argument is given i.e get X:Y:Z A:B:C the 2 results are appended. 
-
+        To retrieve the value from the "cmip6plus" project, under the "institution_id" column, the term with the identifier "ipsl", you would use: \n 
+            `get cmip6plus:institution_id:ipsl`\n
+        The default project is the universe CV : the argument would be like `universe:institution:ipsl` or `:institution:ipsl` \n
+        - to get list of available term from universe institution `:institution:` \n
+        \n
+    \n
+    Notes:\n
+        - Ensure data exist in your system before using this command (use `esgvoc status` command to see whats available).\n
+        - Use a colon (`:`) to separate the parts of the argument.  \n
+        - if more than one argument is given i.e get X:Y:Z A:B:C the 2 results are appended. \n
+    \n
     """ 
     known_projects = get_all_projects()
 
@@ -133,7 +134,7 @@ def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZ
         if where == "" or where=="universe": 
             res = handle_universe(what,who)
         elif where in known_projects:
-            res = handle_project(where,what,who,{})
+            res = handle_project(where,what,who,None)
         else:
             res = handle_unknown(where,what,who)
         

esgvoc/cli/install.py

@@ -1,14 +1,17 @@
 import typer
-from esgvoc.core.service import esg_voc
+from esgvoc.core.service import current_state
 
 app = typer.Typer()
 
 @app.command()
 def install():
-    """
-    Command to clone and build necessary db with the latest available version
-    
-    """
-    esg_voc.install()
-    
-    
+    """Initialize default config and apply settings"""
+    try:
+        typer.echo("Initialized default configuration")
+        current_state.synchronize_all()
+    except Exception as e:
+        typer.echo(f"Error during installation: {str(e)}", err=True)
+        raise typer.Exit(1)
+
+if __name__ == "__main__":
+    app()

esgvoc/cli/main.py

@@ -1,5 +1,4 @@
 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
@@ -8,7 +7,6 @@ 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)

esgvoc/cli/status.py

@@ -20,17 +20,17 @@ def status():
     i.e summary of version of usable ressources (between remote/cached)  
     
     """
-
-    service.state_service.get_state_summary()
+    assert(service.current_state is not None)
+    service.current_state.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.state_service.universe.github_repo,service.state_service.universe.local_path,service.state_service.universe.db_path, style = "white")
-    table.add_row("Version",service.state_service.universe.github_version,service.state_service.universe.local_version,service.state_service.universe.db_version, style="bright_blue")
-    for proj_name,proj in service.state_service.projects.items():
+    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)