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

esgvoc/apps/drs/validator.py

@@ -0,0 +1,330 @@
+from typing import cast
+
+import esgvoc.api.projects as projects
+import esgvoc.apps.drs.constants as constants
+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:
+    """
+    Generic DRS application class.
+    """
+
+    def __init__(self, project_id: str, pedantic: bool = False) -> None:
+        self.project_id: str = project_id
+        """The project id."""
+        self.pedantic: bool = pedantic
+        """Same as the option of GCC: turn warnings into errors. Default False."""
+        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:
+                    self.directory_specs: DrsSpecification = specs
+                    """The DRS directory specs of the project."""
+                case DrsType.FILE_NAME:
+                    self.file_name_specs: DrsSpecification = specs
+                    """The DRS file name specs of the project."""
+                case DrsType.DATASET_ID:
+                    self.dataset_id_specs: DrsSpecification = specs
+                    """The DRS dataset id specs of the project."""
+                case _:
+                    raise RuntimeError(f'unsupported DRS specs type {specs.type}')
+
+    def _get_full_file_name_extension(self) -> str:
+        """
+        Returns the full file name extension (the separator plus the extension) of the DRS file
+        name specs of the project.
+
+        :returns: The full file name extension.
+        :rtype: str
+        """
+        specs: DrsSpecification = self.file_name_specs
+        if specs.properties:
+            full_extension = specs.properties[constants.FILE_NAME_EXTENSION_SEPARATOR_KEY] + \
+                             specs.properties[constants.FILE_NAME_EXTENSION_KEY]
+        else:
+            raise RuntimeError('missing properties in the DRS file name specifications of the ' +
+                               f'project {self.project_id}')
+        return full_extension
+
+
+class DrsValidator(DrsApplication):
+    """
+    Valid a DRS directory, dataset id and file name expression against a project.
+    """
+
+    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.
+
+        :param drs_expression: A DRS dataset id expression.
+        :type drs_expression: str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        return self._validate(drs_expression, self.dataset_id_specs)
+
+    def validate_file_name(self, drs_expression: str) -> DrsValidationReport:
+        """
+        Validate a file name expression.
+
+        :param drs_expression: A DRS file name expression.
+        :type drs_expression: str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        full_extension = self._get_full_file_name_extension()
+        if drs_expression.endswith(full_extension):
+            drs_expression = drs_expression.replace(full_extension, '')
+            result = self._validate(drs_expression, self.file_name_specs)
+        else:
+            issue = FileNameExtensionIssue(expected_extension=full_extension)
+            result = self._create_report(self.file_name_specs.type, drs_expression,
+                                         [issue], [])
+        return result
+
+    def validate(self, drs_expression: str, drs_type: DrsType|str) -> DrsValidationReport:
+        """
+        Validate a DRS expression.
+
+        :param drs_expression: A DRS expression.
+        :type drs_expression: str
+        :param drs_type: The type of the given DRS expression (directory, file_name or dataset_id)
+        :type drs_type: DrsType|str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        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,  # terms
+                                           list[DrsIssue],  # Errors
+                                           list[DrsIssue]]: # Warnings
+        errors: list[DrsIssue] = list()
+        warnings: list[DrsIssue] = list()
+        cursor_offset = 0
+        # Spaces at the beginning/end of expression:
+        start_with_space = drs_expression[0].isspace()
+        end_with_space = drs_expression[-1].isspace()
+        if start_with_space or end_with_space:
+            issue: ParsingIssue = Space()
+            if self.pedantic:
+                errors.append(issue)
+            else:
+                warnings.append(issue)
+            if start_with_space:
+                previous_len = len(drs_expression)
+                drs_expression = drs_expression.lstrip()
+                cursor_offset = previous_len - len(drs_expression)
+            if end_with_space:
+                drs_expression = drs_expression.rstrip()
+        terms = drs_expression.split(separator)
+        if len(terms) < 2:
+            errors.append(Unparsable(expected_drs_type=drs_type))
+            return None, errors, warnings # Early exit
+        max_term_index = len(terms)
+        cursor_position = initial_cursor_position = len(drs_expression) + 1
+        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_term_index = len(terms)
+            column = cursor_position+cursor_offset
+            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_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 terms[index]
+            if term.isspace():
+                column = cursor_position + cursor_offset - len_term
+                issue = BlankTerm(column=column)
+                errors.append(issue)
+                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 terms, sorted_errors, sorted_warnings # type: ignore
+
+    @staticmethod
+    def _sort_parser_issues(issues: list[ParsingIssue]) -> list[ParsingIssue]:
+        return sorted(issues, key=lambda issue: issue.column if issue.column else 0)
+
+    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(term,
+                                                                       self.project_id,
+                                                                       casted_part.collection_id)
+                except Exception as 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 != term
+            case _:
+                raise RuntimeError(f'unsupported DRS specs part type {part.kind}')
+
+    def _create_report(self,
+                       type: DrsType,
+                       drs_expression: str,
+                       errors: list[DrsIssue],
+                       warnings: list[DrsIssue]) -> DrsValidationReport:
+        return DrsValidationReport(project_id=self.project_id, type=type,
+                                   expression=drs_expression,
+                                   errors=cast(list[ValidationError], errors),
+                                   warnings=cast(list[ValidationWarning], warnings))
+
+    def _validate(self,
+                  drs_expression: str,
+                  specs: DrsSpecification) -> DrsValidationReport:
+        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.
+        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:
+            term = terms[term_index]
+            part = specs.parts[part_index]
+            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: 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
+                term_index += 1
+                part_index += 1
+            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 term_index == term_max_index:
+                break
+        # Cases:
+        # - 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 terms.
+            for index in range(part_index, part_max_index):
+                part = specs.parts[index]
+                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 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 = ExtraTerm(term=term, term_position=index, collection_id=str(part))
+                else:
+                    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)
+
+
+if __name__ == "__main__":
+    project_id = 'cmip6plus'
+    validator = DrsValidator(project_id)
+    drs_expressions = [
+".CMIP6Plus.CMIP.IPSL.  .MIROC6.amip..r2i2p1f2.ACmon.od550aer. ..gn",
+]
+    import time
+    for drs_expression in drs_expressions:
+        start_time = time.perf_counter_ns()
+        report = validator.validate_dataset_id(drs_expression)
+        stop_time = time.perf_counter_ns()
+        print(f'elapsed time: {(stop_time-start_time)/1000000} ms')
+        if report.nb_errors > 0:
+            print(f'error(s): {report.nb_errors}')
+            for error in report.errors:
+                print(error)
+        else:
+            print('error(s): 0')
+        if report.nb_warnings > 0:
+            print(f'warning(s): {report.nb_warnings}')
+            for warning in report.warnings:
+                print(warning)
+        else:
+            print('warning(s): 0')

esgvoc/cli/drs.py

@@ -0,0 +1,248 @@
+import shlex
+import sys
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+import esgvoc.api as ev
+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()
+
+
+
+# Predefined list of projects and DRS types
+# projects = ["cmip5", "cmip6","cmip6plus", "cmip7"]
+projects = ev.get_all_projects()
+drs_types = ["filename", "directory", "dataset"]
+
+def display(table):
+    """
+    Function to display a rich table in the console.
+
+    :param table: The table to be displayed
+    """
+    console = Console(record=True, width=200)
+    console.print(table)
+
+
+@app.command()
+def drsvalid(
+    drs_entries: Optional[List[str]] = typer.Argument(None, help="List of DRS validation inputs in the form <project> <drstype> <string>"),
+    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]:
+    """
+    Validates DRS strings for a specific project and type.
+
+    Args:
+        drs_entries (Optional[List[str]]): A list of DRS validation inputs in the form <project> <drstype> <string>.
+        file (Optional[typer.FileText]): File containing DRS validation inputs, one per line.
+        verbose (bool): If true, prints detailed validation results.
+
+    Usage Examples:
+        # Validate multiple filenames for CMIP6
+        drsvalid cmip6 filename file1.nc file2.nc file3.nc
+
+        # Validate using a file
+        drsvalid --file drs_input.txt
+    """
+    current_project = None
+    current_drs_type = None
+    reports = []
+
+    entries = drs_entries or []
+
+    if not sys.stdin.isatty():  # Check if input is being piped via stdin
+        entries.extend(el for line in sys.stdin for el in shlex.split(line))
+
+
+    if file:
+        entries.extend(el for line in file for el in line.strip().split(" "))
+
+    i = 0
+    while i < len(entries):
+        if entries[i] in [""," "]:
+            i+=1
+            continue
+
+        if entries[i] in projects:
+            current_project = entries[i]
+            i += 1
+            continue
+        if entries[i] in drs_types:
+            current_drs_type = entries[i]
+            i += 1
+            continue
+
+        if current_project is None:
+            raise typer.BadParameter(f"Invalid project: {entries[i]}")
+
+        if current_drs_type is None:
+            raise typer.BadParameter(f"Invalid drs_type: {entries[i]}")
+
+        string = entries[i]
+        i += 1
+        validator = DrsValidator(current_project, pedantic=pedantic)
+        report = None
+        match current_drs_type:
+            case "filename":
+                report = validator.validate_file_name(string)
+            case "directory":
+                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 _:
+                raise RuntimeError("drstype is not known")
+        reports.append(report)
+
+    if verbose:
+        table = Table(title="Validation result")
+        table.add_column("entry", style="cyan")
+        table.add_column("project & drs_type", style="cyan")
+        table.add_column("warnings", style="magenta")
+        table.add_column("errors", style="red")
+        table.add_column("valid")
+
+        for report in reports:
+            entry = str(report.expression)
+            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"
+
+            table.add_row("-"*4,"-"*4,"-"*4,"-"*4,"-"*4)
+            table.add_row(entry,proj_and_type, warnings, errors, valid)
+
+        console.print(table)
+    elif output:
+        with open(output, "w") as f:
+            for report in reports:
+                f.write(str(report) + "\n")
+        console.print(f"DRS validation entries saved to [green]{output}[/green]")
+
+
+    else:
+        for report in reports:
+            console.print(str(report))
+
+    return reports
+
+
+@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_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[DrsGenerationReport]:
+    """
+    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_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.
+
+    Usage Examples:
+        # Generate multiple filenames for CMIP6
+        drsgen cmip6 filename var1=tas var2=pr
+
+        # Generate using a file
+        drsgen --file drs_input.txt
+    """
+    current_project = None
+    current_drs_type = None
+    generated_reports = []
+
+    entries = drs_entries or []
+
+    if not sys.stdin.isatty():  # Check if input is being piped via stdin
+        entries.extend(el for line in sys.stdin for el in shlex.split(line))
+
+    if file:
+        entries.extend(el for line in file for el in shlex.split(line))
+
+    i = 0
+    while i < len(entries):
+        if entries[i] in [""," "]:
+            i+=1
+            continue
+        if entries[i] in projects:
+            current_project = entries[i]
+            i += 1
+            continue
+        if entries[i] in drs_types:
+            current_drs_type = entries[i]
+            i += 1
+            continue
+
+        if current_project is None:
+            raise typer.BadParameter(f"Invalid project: {entries[i]}")
+
+        if current_drs_type is None:
+            raise typer.BadParameter(f"Invalid drs_type: {entries[i]}")
+
+        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_terms(bag_of_terms)
+            case "directory":
+                report = generator.generate_directory_from_bag_of_terms(bag_of_terms)
+            case "dataset":
+                report = generator.generate_dataset_id_from_bag_of_terms(bag_of_terms)
+            case _:
+                raise RuntimeError("drstype is not known")
+        generated_reports.append(report)
+
+    if verbose:
+        table = Table(title="Generation result")
+        table.add_column("deduced mapping entry", style="cyan")
+        table.add_column("warnings", style="magenta")
+        table.add_column("errors", style="red")
+        table.add_column("result", style="green", width=10)
+        for report in generated_reports:
+            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.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:
+                table.columns[3].width = len(result)+1
+        console.print(table)
+
+    elif output:
+        with open(output, "w") as f:
+            for report in generated_reports:
+                f.write(str(report) + "\n")
+        console.print(f"Generated entries saved to [green]{output}[/green]")
+
+    else:
+        for report in generated_reports:
+            console.print(str(report))
+
+    return generated_reports
+if __name__ == "__main__":
+    app()

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"^(\w*-?\w*)*:(\w*-?\w*)*:(\w*-?\w*)*$", 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()