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

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:

esgvoc/core/db/project_ingestion.py

@@ -10,11 +10,11 @@ import esgvoc.core.service as service
 from esgvoc.core.data_handler import JsonLdResource
 from esgvoc.core.db.connection import DBConnection, read_json_file
 from esgvoc.core.db.models.mixins import TermKind
-from esgvoc.core.db.models.project import Collection, Project, PTerm
+from esgvoc.core.db.models.project import PCollection, Project, PTerm
 from esgvoc.core.exceptions import EsgvocDbError
 from esgvoc.core.service.data_merger import DataMerger
 
-_LOGGER = logging.getLogger("project_ingestion")
+_LOGGER = logging.getLogger(__name__)
 
 
 def infer_term_kind(json_specs: dict) -> TermKind:
@@ -34,52 +34,53 @@ def ingest_metadata_project(connection: DBConnection, git_hash):
 
 
 def get_data_descriptor_id_from_context(collection_context: dict) -> str:
-    data_descriptor_url = collection_context[esgvoc.core.constants.CONTEXT_JSON_KEY]\
-                                            [esgvoc.core.constants.DATA_DESCRIPTOR_JSON_KEY] # noqa E211
+    data_descriptor_url = collection_context[esgvoc.core.constants.CONTEXT_JSON_KEY][
+        esgvoc.core.constants.DATA_DESCRIPTOR_JSON_KEY
+    ]  # noqa E211
     return Path(data_descriptor_url).name
 
 
-def instantiate_project_term(universe_term_json_specs: dict,
-                             project_term_json_specs_update: dict,
-                             pydantic_class: type[BaseModel]) -> dict:
+def instantiate_project_term(
+    universe_term_json_specs: dict, project_term_json_specs_update: dict, pydantic_class: type[BaseModel]
+) -> dict:
     term_from_universe = pydantic_class(**universe_term_json_specs)
-    updated_term = term_from_universe.model_copy(
-        update=project_term_json_specs_update, deep=True
-    )
+    updated_term = term_from_universe.model_copy(update=project_term_json_specs_update, deep=True)
     return updated_term.model_dump()
 
 
-def ingest_collection(collection_dir_path: Path,
-                      project: Project,
-                      project_db_session) -> None:
+def ingest_collection(collection_dir_path: Path, project: Project, project_db_session) -> None:
     collection_id = collection_dir_path.name
     collection_context_file_path = collection_dir_path.joinpath(esgvoc.core.constants.CONTEXT_FILENAME)
     try:
         collection_context = read_json_file(collection_context_file_path)
         data_descriptor_id = get_data_descriptor_id_from_context(collection_context)
     except Exception as e:
-        msg = f'unable to read project context file {collection_context_file_path}'
+        msg = f"unable to read project context file {collection_context_file_path}"
         _LOGGER.fatal(msg)
         raise EsgvocDbError(msg) from e
     # [KEEP]
-    collection = Collection(
+    collection = PCollection(
         id=collection_id,
         context=collection_context,
         project=project,
         data_descriptor_id=data_descriptor_id,
-        term_kind="")  # We ll know it only when we ll add a term
-                       # (hypothesis all term have the same kind in a collection) # noqa E116
+        term_kind="",
+    )  # We ll know it only when we ll add a term
+    # (hypothesis all term have the same kind in a collection) # noqa E116
     term_kind_collection = None
 
     for term_file_path in collection_dir_path.iterdir():
         _LOGGER.debug(f"found term path : {term_file_path}")
         if term_file_path.is_file() and term_file_path.suffix == ".json":
             try:
-                locally_avail = {"https://espri-mod.github.io/mip-cmor-tables":
-                                 service.current_state.universe.local_path}
-                json_specs = DataMerger(data=JsonLdResource(uri=str(term_file_path)),
-                                        # locally_available={"https://espri-mod.github.io/mip-cmor-tables":".cache/repos/WCRP-universe"}).merge_linked_json()[-1]
-                                        locally_available=locally_avail).merge_linked_json()[-1]
+                locally_avail = {
+                    "https://espri-mod.github.io/mip-cmor-tables": service.current_state.universe.local_path
+                }
+                json_specs = DataMerger(
+                    data=JsonLdResource(uri=str(term_file_path)),
+                    # locally_available={"https://espri-mod.github.io/mip-cmor-tables":".cache/repos/WCRP-universe"}).merge_linked_json()[-1]
+                    locally_available=locally_avail,
+                ).merge_linked_json()[-1]
                 term_kind = infer_term_kind(json_specs)
                 term_id = json_specs["id"]
 
@@ -87,7 +88,7 @@ def ingest_collection(collection_dir_path: Path,
                     term_kind_collection = term_kind
 
             except Exception as e:
-                _LOGGER.warning(f'Unable to read term {term_file_path}. Skip.\n{str(e)}')
+                _LOGGER.warning(f"Unable to read term {term_file_path}. Skip.\n{str(e)}")
                 continue
             try:
                 term = PTerm(
@@ -108,14 +109,11 @@ def ingest_collection(collection_dir_path: Path,
     project_db_session.add(collection)
 
 
-def ingest_project(project_dir_path: Path,
-                   project_db_file_path: Path,
-                   git_hash: str
-                   ):
+def ingest_project(project_dir_path: Path, project_db_file_path: Path, git_hash: str):
     try:
         project_connection = db.DBConnection(project_db_file_path)
     except Exception as e:
-        msg = f'unable to read project SQLite file at {project_db_file_path}'
+        msg = f"unable to read project SQLite file at {project_db_file_path}"
         _LOGGER.fatal(msg)
         raise EsgvocDbError(msg) from e
 
@@ -125,7 +123,7 @@ def ingest_project(project_dir_path: Path,
             project_json_specs = read_json_file(project_specs_file_path)
             project_id = project_json_specs[esgvoc.core.constants.PROJECT_ID_JSON_KEY]
         except Exception as e:
-            msg = f'unable to read project specs file  {project_specs_file_path}'
+            msg = f"unable to read project specs file  {project_specs_file_path}"
             _LOGGER.fatal(msg)
             raise EsgvocDbError(msg) from e
 
@@ -137,11 +135,9 @@ def ingest_project(project_dir_path: Path,
             if collection_dir_path.is_dir() and (collection_dir_path / "000_context.jsonld").exists():
                 _LOGGER.debug(f"found collection dir : {collection_dir_path}")
                 try:
-                    ingest_collection(collection_dir_path,
-                                      project,
-                                      project_db_session)
+                    ingest_collection(collection_dir_path, project, project_db_session)
                 except Exception as e:
-                    msg = f'unexpected error while ingesting collection {collection_dir_path}'
+                    msg = f"unexpected error while ingesting collection {collection_dir_path}"
                     _LOGGER.fatal(msg)
                     raise EsgvocDbError(msg) from e
         project_db_session.commit()
@@ -149,21 +145,25 @@ def ingest_project(project_dir_path: Path,
         # Well, the following instructions are not data duplication. It is more building an index.
         # Read: https://sqlite.org/fts5.html
         try:
-            sql_query = 'INSERT INTO pterms_fts5(pk, id, specs, kind, collection_pk) ' + \
-                        'SELECT pk, id, specs, kind, collection_pk FROM pterms;'  # noqa: S608
+            sql_query = (
+                "INSERT INTO pterms_fts5(pk, id, specs, kind, collection_pk) "  # noqa: S608
+                + "SELECT pk, id, specs, kind, collection_pk FROM pterms;"
+            )
             project_db_session.exec(text(sql_query))  # type: ignore
         except Exception as e:
-            msg = f'unable to insert rows into pterms_fts5 table for {project_db_file_path}'
+            msg = f"unable to insert rows into pterms_fts5 table for {project_db_file_path}"
             _LOGGER.fatal(msg)
             raise EsgvocDbError(msg) from e
         project_db_session.commit()
         try:
-            sql_query = 'INSERT INTO pcollections_fts5(pk, id, data_descriptor_id, context, ' + \
-                         'project_pk, term_kind) SELECT pk, id, data_descriptor_id, context, ' + \
-                         'project_pk, term_kind FROM collections;'  # noqa: S608
+            sql_query = (
+                "INSERT INTO pcollections_fts5(pk, id, data_descriptor_id, context, "  # noqa: S608
+                + "project_pk, term_kind) SELECT pk, id, data_descriptor_id, context, "
+                + "project_pk, term_kind FROM pcollections;"
+            )
             project_db_session.exec(text(sql_query))  # type: ignore
         except Exception as e:
-            msg = f'unable to insert rows into pcollections_fts5 table for {project_db_file_path}'
+            msg = f"unable to insert rows into pcollections_fts5 table for {project_db_file_path}"
             _LOGGER.fatal(msg)
             raise EsgvocDbError(msg) from e
         project_db_session.commit()