esgvoc 0.4.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

esgvoc/cli/find.py

@@ -0,0 +1,138 @@
+import re
+from typing import Any
+
+import typer
+from pydantic import BaseModel
+from requests import logging
+from rich.console import Console
+from rich.json import JSON
+from rich.table import Table
+
+from esgvoc.api.projects import (
+    find_collections_in_project,
+    find_items_in_project,
+    find_terms_in_all_projects,
+    find_terms_in_collection,
+    find_terms_in_project,
+    get_all_projects,
+)
+from esgvoc.api.universe import (
+    find_data_descriptors_in_universe,
+    find_items_in_universe,
+    find_terms_in_data_descriptor,
+    find_terms_in_universe,
+)
+
+app = typer.Typer()
+console = Console()
+
+_LOGGER = logging.getLogger(__name__)
+
+
+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):
+        raise typer.BadParameter(f"Invalid key format: {key}. Must be XXXX:YYYY:ZZZZ.")
+    return key.split(":")
+
+
+def handle_universe(expression: str, data_descriptor_id: str | None, term_id: str | None, options=None):
+    _LOGGER.debug(f"Handling universe with data_descriptor_id={data_descriptor_id}, term_id={term_id}")
+
+    if data_descriptor_id:
+        return find_terms_in_data_descriptor(expression, data_descriptor_id)
+        # BaseModel|dict[str: BaseModel]|None:
+
+    else:
+        return find_terms_in_universe(expression)
+        # dict[str, dict]:
+
+
+def handle_project(expression: str, project_id: str, collection_id: str | None, term_id: str | None, options=None):
+    _LOGGER.debug(f"Handling project {project_id} with Y={collection_id}, Z={term_id}, options = {options}")
+
+    if project_id == "all":
+        return find_terms_in_all_projects(expression)
+
+    elif collection_id:
+        return find_terms_in_collection(expression, project_id, collection_id)
+        # dict[str, BaseModel]|None:
+
+    else:
+        res = find_terms_in_project(expression, project_id)
+        if res is None:
+            return None
+        else:
+            return res
+        # dict[str, dict]:
+
+
+def handle_unknown(x: str | None, y: str | None, z: str | None):
+    print(f"Something wrong in X,Y or Z : X={x}, Y={y}, Z={z}")
+
+
+def display(data: Any):
+    if isinstance(data, BaseModel):
+        # Pydantic Model
+        console.print(JSON.from_data(data.model_dump()))
+    elif isinstance(data, dict):
+        # Dictionary as JSON
+        console.print(data.keys())
+    elif isinstance(data, list):
+        # List as Table
+        table = Table(title="List")
+        table.add_column("Index")
+        table.add_column("Item")
+        for i, item in enumerate(data):
+            table.add_row(str(i), str(item))
+        console.print(table)
+    else:
+        # Fallback to simple print
+        console.print(data)
+
+
+@app.command()
+def find(expression: str, keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZZZ format")):
+    """
+    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
+        `find <expression> <project>:<collection>:<term>`\n
+    \n
+    Arguments:\n
+        <expression>\t The full text search expression.
+        <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:
+    \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()
+    _LOGGER.debug(f"Processed expression: {expression}")
+
+    # Validate and process each key
+    for key in keys:
+        validated_key = validate_key_format(key)
+        _LOGGER.debug(f"Processed key: {validated_key}")
+        where, what, who = validated_key
+        what = what if what != "" else None
+        who = who if who != "" else None
+        if where == "" or where == "universe":
+            res = handle_universe(expression, what, who)
+        elif where in known_projects:
+            res = handle_project(expression, where, what, who, None)
+        else:
+            res = handle_unknown(where, what, who)
+
+        display(res)

esgvoc/cli/get.py

@@ -1,35 +1,40 @@
+import logging
+import re
+from typing import Any, List, Optional
 
-from typing import Any
-from esgvoc.api.projects import get_all_collections_in_project, get_all_projects, \
-    get_all_terms_in_collection, get_term_in_project, get_term_in_collection
-from esgvoc.api.universe import find_terms_in_data_descriptor, find_terms_in_universe, \
-    get_all_data_descriptors_in_universe, get_all_terms_in_data_descriptor, get_term_in_data_descriptor, \
-    get_term_in_universe
-from pydantic import BaseModel
-from requests import logging
-from rich.table import Table
 import typer
-import re
-from rich.json import JSON
+from pydantic import BaseModel
 from rich.console import Console
+from rich.json import JSON
+from rich.table import Table
+
+from esgvoc.api.projects import (get_all_collections_in_project,
+                                 get_all_projects, get_all_terms_in_collection,
+                                 get_term_in_collection, get_term_in_project)
+from esgvoc.api.universe import (find_terms_in_data_descriptor,
+                                 find_terms_in_universe,
+                                 get_all_data_descriptors_in_universe,
+                                 get_all_terms_in_data_descriptor,
+                                 get_term_in_data_descriptor,
+                                 get_term_in_universe)
 
 app = typer.Typer()
 console = Console()
 
 _LOGGER = logging.getLogger(__name__)
 
+
 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(":")
 
 
-def handle_universe(data_descriptor_id:str|None,term_id:str|None, options=None):
-    _LOGGER.debug(f"Handling universe with data_descriptor_id={data_descriptor_id}, term_id={term_id}") 
-
+def handle_universe(data_descriptor_id: str | None, term_id: str | None, options=None):
+    _LOGGER.debug(f"Handling universe with data_descriptor_id={data_descriptor_id}, term_id={term_id}")
     if data_descriptor_id and term_id:
         return get_term_in_data_descriptor(data_descriptor_id, term_id, options)
         # BaseModel|dict[str: BaseModel]|None:
@@ -38,29 +43,28 @@ def handle_universe(data_descriptor_id:str|None,term_id:str|None, options=None):
         return get_term_in_universe(term_id, options)
         # dict[str, BaseModel] | dict[str, dict[str, BaseModel]] | None:
 
-
     elif data_descriptor_id:
-        return get_all_terms_in_data_descriptor(data_descriptor_id)
+        return get_all_terms_in_data_descriptor(data_descriptor_id, options)
         # dict[str, BaseModel]|None:
 
     else:
         return get_all_data_descriptors_in_universe()
         # dict[str, dict]:
 
-def handle_project(project_id:str,collection_id:str|None,term_id:str|None,options=None):
+
+def handle_project(project_id: str, collection_id: str | None, term_id: str | None, options=None):
     _LOGGER.debug(f"Handling project {project_id} with Y={collection_id}, Z={term_id}, options = {options}")
-    
+
     if project_id and collection_id and term_id:
         return get_term_in_collection(project_id, collection_id, term_id, options)
         # BaseModel|dict[str: BaseModel]|None:
 
     elif term_id:
-        return get_term_in_project(project_id, term_id,options)
+        return get_term_in_project(project_id, term_id, options)
         # dict[str, BaseModel] | dict[str, dict[str, BaseModel]] | None:
 
-
     elif collection_id:
-        return get_all_terms_in_collection(project_id, collection_id)
+        return get_all_terms_in_collection(project_id, collection_id, options)
         # dict[str, BaseModel]|None:
 
     else:
@@ -72,12 +76,11 @@ def handle_project(project_id:str,collection_id:str|None,term_id:str|None,option
         # dict[str, dict]:
 
 
-def handle_unknown(x:str|None,y:str|None,z:str|None):
+def handle_unknown(x: str | None, y: str | None, z: str | None):
     print(f"Something wrong in X,Y or Z : X={x}, Y={y}, Z={z}")
 
 
-def display(data:Any):
-
+def display(data: Any):
     if isinstance(data, BaseModel):
         # Pydantic Model
         console.print(JSON.from_data(data.model_dump()))
@@ -96,8 +99,12 @@ def display(data:Any):
         # Fallback to simple print
         console.print(data)
 
+
 @app.command()
-def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZZZ format")):
+def get(
+    keys: List[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZZZ format"),
+    select: Optional[List[str]] = typer.Option(None, "--select", help="keys selected for the result"),
+):
     """
     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,
@@ -113,7 +120,7 @@ def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZ
         <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, the term with the identifier "ipsl", you would use: \n 
+        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
@@ -124,23 +131,21 @@ def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZ
         - 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()
 
     # Validate and process each key
     for key in keys:
         validated_key = validate_key_format(key)
         _LOGGER.debug(f"Processed key: {validated_key}")
-        where,what,who = validated_key
-        what = what if what!="" else None
-        who = who if who!="" else None
-        if where == "" or where=="universe": 
-            res = handle_universe(what,who)
+        where, what, who = validated_key
+        what = what if what != "" else None
+        who = who if who != "" else None
+        if where == "" or where == "universe":
+            res = handle_universe(what, who, select)
         elif where in known_projects:
-            res = handle_project(where,what,who,None)
+            res = handle_project(where, what, who, select)
         else:
-            res = handle_unknown(where,what,who)
-        
-        display(res)
-
+            res = handle_unknown(where, what, who)
 
+        display(res)

esgvoc/cli/main.py

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

esgvoc/cli/status.py

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

esgvoc/cli/valid.py

@@ -1,26 +1,21 @@
 
+import re
 from typing import List
-from esgvoc.api.projects import (
-    valid_term, 
-    valid_term_in_collection, 
-    valid_term_in_project, 
-    valid_term_in_all_projects
-)
-from requests import logging
-from rich.table import Table
+
 import typer
-import re
 from rich.console import Console
+from rich.table import Table
+
+from esgvoc.api.projects import valid_term, valid_term_in_all_projects, valid_term_in_collection, valid_term_in_project
 
 app = typer.Typer()
 console = Console()
 
-_LOGGER = logging.getLogger(__name__)
 
 @app.command()
 def valid(
     strings_targets: List[str] = typer.Argument(
-        ..., 
+        ...,
         help=(
             "Pairs of strings to validate against a key in the form '<StringToValidate> <Project:Collection:Term>'.\n"
             "Multiple pairs can be provided. The key '<Project:Collection:Term>' consists of three parts:\n"
@@ -51,7 +46,7 @@ def valid(
             \t\t- A string to validate.\n
             \t\t- A key in the form '<Project:Collection:Term>'.\n
     Usage :\n
-        \tValid one:\n 
+        \tValid one:\n
         \tesgvocab valid IPSL cmip6plus:institution_id:ipsl\n
         \tesgvocab valid IPSL cmip6plus:institution_id:\n
         \tesgvocab valid IPSL cmip6plus::\n
@@ -67,7 +62,7 @@ def valid(
         \tesgvocab valid IPSL :: IPS :: \n
         \t\tresult will be [True, False]\n
         \n
-        \tesgvocab valid --verbose IPS :: IPSL ::\n 
+        \tesgvocab valid --verbose IPS :: IPSL ::\n
         \tresult will be \n
         \t\t┏━━━━━━━━┳━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n
         \t\t┃ String ┃ Key ┃ Result     ┃ Errors                      ┃\n
@@ -83,7 +78,7 @@ def valid(
 
     # 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)
@@ -109,7 +104,7 @@ def valid(
         except Exception as e:
             validation_result=False
             exception_message = repr(e)
-        
+
         # Handle validation result
 
         if validation_result:

esgvoc/core/db/models/project.py

@@ -10,18 +10,18 @@ import esgvoc.core.db.connection as db
 from esgvoc.core.db.models.mixins import IdMixin, PkMixin, TermKind
 from esgvoc.core.exceptions import EsgvocDbError
 
-_LOGGER = logging.getLogger("project_db_creation")
+_LOGGER = logging.getLogger(__name__)
 
 
 class Project(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "projects"
     specs: dict = Field(sa_column=sa.Column(JSON))
     git_hash: str
-    collections: list["Collection"] = Relationship(back_populates="project")
+    collections: list["PCollection"] = Relationship(back_populates="project")
 
 
-class Collection(SQLModel, PkMixin, IdMixin, table=True):
-    __tablename__ = "collections"
+class PCollection(SQLModel, PkMixin, IdMixin, table=True):
+    __tablename__ = "pcollections"
     data_descriptor_id: str = Field(index=True)
     context: dict = Field(sa_column=sa.Column(JSON))
     project_pk: int | None = Field(default=None, foreign_key="projects.pk")
@@ -44,8 +44,8 @@ class PTerm(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "pterms"
     specs: dict = Field(sa_column=sa.Column(JSON))
     kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
-    collection_pk: int | None = Field(default=None, foreign_key="collections.pk")
-    collection: Collection = Relationship(back_populates="terms")
+    collection_pk: int | None = Field(default=None, foreign_key="pcollections.pk")
+    collection: PCollection = Relationship(back_populates="terms")
     __table_args__ = (sa.Index("drs_name_index", specs.sa_column["drs_name"]), )  # type: ignore
 
 
@@ -55,7 +55,7 @@ class PTermFTS5(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "pterms_fts5"
     specs: dict = Field(sa_column=sa.Column(JSON))
     kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
-    collection_pk: int | None = Field(default=None, foreign_key="collections.pk")
+    collection_pk: int | None = Field(default=None, foreign_key="pcollections.pk")
 
 
 def project_create_db(db_file_path: Path):
@@ -68,7 +68,7 @@ def project_create_db(db_file_path: Path):
     try:
         # Do not include pterms_fts5 table: it is build from a raw SQL query.
         tables_to_be_created = [SQLModel.metadata.tables['projects'],
-                                SQLModel.metadata.tables['collections'],
+                                SQLModel.metadata.tables['pcollections'],
                                 SQLModel.metadata.tables['pterms']]
         SQLModel.metadata.create_all(connection.get_engine(), tables=tables_to_be_created)
     except Exception as e:
@@ -77,8 +77,8 @@ def project_create_db(db_file_path: Path):
         raise EsgvocDbError(msg) from e
     try:
         with connection.create_session() as session:
-            sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS pterms_fts5 USING ' + \
-                        'fts5(pk, id, specs, kind, collection_pk, content=pterms, content_rowid=pk);'
+            sql_query = "CREATE VIRTUAL TABLE IF NOT EXISTS pterms_fts5 USING " + \
+                        "fts5(pk, id, specs, kind, collection_pk, content=pterms, content_rowid=pk, prefix=3);"
             session.exec(text(sql_query))  # type: ignore
             session.commit()
     except Exception as e:
@@ -89,7 +89,7 @@ def project_create_db(db_file_path: Path):
         with connection.create_session() as session:
             sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS pcollections_fts5 USING ' + \
                         'fts5(pk, id, data_descriptor_id, context, project_pk, ' + \
-                        'term_kind, content=collections, content_rowid=pk);'
+                        'term_kind, content=pcollections, content_rowid=pk, prefix=3);'
             session.exec(text(sql_query))  # type: ignore
             session.commit()
     except Exception as e:

esgvoc/core/db/models/universe.py

@@ -10,7 +10,7 @@ import esgvoc.core.db.connection as db
 from esgvoc.core.db.models.mixins import IdMixin, PkMixin, TermKind
 from esgvoc.core.exceptions import EsgvocDbError
 
-_LOGGER = logging.getLogger("universe_db_creation")
+_LOGGER = logging.getLogger(__name__)
 
 
 class Universe(SQLModel, PkMixin, table=True):
@@ -74,7 +74,7 @@ def universe_create_db(db_file_path: Path) -> None:
     try:
         with connection.create_session() as session:
             sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS uterms_fts5 USING ' + \
-                        'fts5(pk, id, specs, kind, data_descriptor_pk, content=uterms, content_rowid=pk);'
+                        'fts5(pk, id, specs, kind, data_descriptor_pk, content=uterms, content_rowid=pk, prefix=3);'
             session.exec(text(sql_query))  # type: ignore
             session.commit()
     except Exception as e:
@@ -85,7 +85,7 @@ def universe_create_db(db_file_path: Path) -> None:
         with connection.create_session() as session:
             sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS udata_descriptors_fts5 USING ' + \
                         'fts5(pk, id, universe_pk, context, ' + \
-                        'term_kind, content=udata_descriptors, content_rowid=pk);'
+                        'term_kind, content=udata_descriptors, content_rowid=pk, prefix=3);'
             session.exec(text(sql_query))  # type: ignore
             session.commit()
     except Exception as e: