genelastic 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

genelastic/api/extends/example.py

@@ -1,7 +1,6 @@
-# pylint: disable=missing-module-docstring
-from flask import jsonify, Response
+from flask import Response, jsonify
 
 
 def ping_2() -> Response:
     """Test route to verify that the server is online."""
-    return jsonify({'message': 'pong_2'})
+    return jsonify({"message": "pong_2"})

genelastic/api/routes.py

@@ -1,45 +1,56 @@
-# pylint: disable=missing-module-docstring
+from importlib.metadata import version
 from pathlib import Path
-from flask import jsonify, current_app, Response
+from typing import Any
+
+from flask import Response, current_app, jsonify
 
 
 def ping() -> Response:
     """Test route to verify that the server is online."""
-    return jsonify({'message': 'pong'})
+    return jsonify({"message": "pong"})
 
 
 def list_indices() -> Response:
     """Route to list Elasticsearch indexes."""
-    return current_app.elastic_query_conn.get_indices()  # type: ignore
+    return current_app.elastic_query_conn.get_indices()  # type: ignore[attr-defined, no-any-return]
 
 
 def retrieve_document(index_id: str, document_id: str) -> Response:
     """Route to retrieve a document by its ID."""
-    document = (current_app.elastic_query_conn  # type: ignore
-                .get_document_by_id(index_id, document_id))
+    document = current_app.elastic_query_conn.get_document_by_id(  # type: ignore[attr-defined]
+        index_id, document_id
+    )
     return jsonify(document)
 
 
 def list_wet_processes() -> Response:
     """Route to list wet processes."""
-    wet_processes_index = f"{current_app.config['GENAPI_ES_INDEX_PREFIX']}-wet_processes"
-    result = (current_app.elastic_query_conn  # type: ignore
-              .get_field_values(wet_processes_index, "proc_id"))
+    wet_processes_index = (
+        f"{current_app.config['GENAPI_ES_INDEX_PREFIX']}-wet_processes"
+    )
+    result = current_app.elastic_query_conn.get_field_values(  # type: ignore[attr-defined]
+        wet_processes_index, "proc_id"
+    )
     return jsonify(list(result))
 
 
 def list_bi_processes() -> Response:
     """Route to list bi processes."""
-    bi_processes_index = f"{current_app.config['GENAPI_ES_INDEX_PREFIX']}-bi_processes"
-    result = (current_app.elastic_query_conn  # type: ignore
-              .get_field_values(bi_processes_index, "name"))
+    bi_processes_index = (
+        f"{current_app.config['GENAPI_ES_INDEX_PREFIX']}-bi_processes"
+    )
+    result = current_app.elastic_query_conn.get_field_values(  # type: ignore[attr-defined]
+        bi_processes_index, "proc_id"
+    )
     return jsonify(list(result))
 
 
 def list_analyses() -> Response:
     """Route to list analyses."""
     analyses_index = f"{current_app.config['GENAPI_ES_INDEX_PREFIX']}-analyses"
-    result = current_app.elastic_query_conn.get_field_values(analyses_index, "path")  # type: ignore
+    result = current_app.elastic_query_conn.get_field_values(  # type: ignore[attr-defined]
+        analyses_index, "path"
+    )
     filenames = [Path(path).name for path in result]
     return jsonify(filenames)
 
@@ -55,11 +66,10 @@ def list_analyses_wet_processes(proc_id: str) -> Response:
             }
         }
     }
-    result = []
-    response = (current_app.elastic_query_conn  # type: ignore
-                .client.search(index=analyses_index, body=search_query))
-    for hit in response['hits']['hits']:
-        result.append(hit['_source']['path'])
+    response = current_app.elastic_query_conn.client.search(  # type: ignore[attr-defined]
+        index=analyses_index, body=search_query
+    )
+    result = [hit["_source"]["path"] for hit in response["hits"]["hits"]]
 
     return jsonify(result)
 
@@ -75,10 +85,137 @@ def list_analyses_bi_processes(proc_id: str) -> Response:
             }
         }
     }
-    result = []
-    response = (current_app.elastic_query_conn  # type: ignore
-                .client.search(index=analyses_index, body=search_query))
-    for hit in response['hits']['hits']:
-        result.append(hit['_source']['path'])
+    response = current_app.elastic_query_conn.client.search(  # type: ignore[attr-defined]
+        index=analyses_index, body=search_query
+    )
+    result = [hit["_source"]["path"] for hit in response["hits"]["hits"]]
 
     return jsonify(result)
+
+
+def list_snv_documents() -> Response:
+    """Route to list all documents containing a mutation at a single position (SNV)."""
+    index_pattern = "genelastic-file-*"
+    target_value = "SNV"
+
+    search_query = {
+        "aggs": {
+            "snv_docs": {
+                "composite": {
+                    "sources": [
+                        {"alt_value": {"terms": {"field": "alt.keyword"}}}
+                    ],
+                    "size": 1000,
+                }
+            }
+        },
+        "query": {"term": {"alt.keyword": target_value}},
+        "size": 0,
+    }
+
+    all_documents = []
+    buckets = current_app.elastic_query_conn.run_composite_aggregation(  # type: ignore[attr-defined]
+        index_pattern, search_query
+    )
+
+    for bucket in buckets:
+        alt_value = bucket["key"]["alt_value"]
+
+        search_query_docs = {
+            "query": {"term": {"alt.keyword": alt_value}},
+            "size": 1000,
+        }
+
+        response = current_app.elastic_query_conn.client.search(  # type: ignore[attr-defined]
+            index=index_pattern, body=search_query_docs
+        )
+
+        all_documents.extend(response["hits"]["hits"])
+
+    return jsonify(all_documents)
+
+
+def build_snv_search_query(
+    target_alt: str, target_svtype: str
+) -> dict[str, Any]:
+    """Helper function to build the search query for SNV documents with specified alt and SVTYPE."""
+    return {
+        "query": {
+            "bool": {
+                "must": [
+                    {"term": {"alt.keyword": target_alt}},
+                    {"term": {"info.SVTYPE.keyword": target_svtype}},
+                ]
+            }
+        },
+        "size": 1000,
+    }
+
+
+def build_snv_mutation_search_query(
+    target_svtypes: list[str],
+) -> dict[str, Any]:
+    """Helper function to build the search query for SNV mutations with specified SVTYPE values."""
+    return {
+        "query": {
+            "bool": {
+                "must": [
+                    {"term": {"alt.keyword": "SNV"}},
+                    {"terms": {"info.SVTYPE.keyword": target_svtypes}},
+                ]
+            }
+        },
+        "size": 1000,
+    }
+
+
+def list_snv_insertion_documents() -> Response:
+    """Route to list all documents containing an insertion (INS) at a single position (SNV)."""
+    index_pattern = "genelastic-file-*"
+    search_query = build_snv_search_query(target_alt="SNV", target_svtype="INS")
+
+    response = current_app.elastic_query_conn.client.search(  # type: ignore[attr-defined]
+        index=index_pattern, body=search_query
+    )
+
+    all_documents = [hit["_source"] for hit in response["hits"]["hits"]]
+
+    return jsonify(all_documents)
+
+
+def list_snv_deletion_documents() -> Response:
+    """Route to list all documents containing a deletion (DEL) at a single position (SNV)."""
+    index_pattern = "genelastic-file-*"
+    search_query = build_snv_search_query(target_alt="SNV", target_svtype="DEL")
+
+    response = current_app.elastic_query_conn.client.search(  # type: ignore[attr-defined]
+        index=index_pattern, body=search_query
+    )
+
+    all_documents = [hit["_source"] for hit in response["hits"]["hits"]]
+
+    return jsonify(all_documents)
+
+
+def list_snv_mutation_documents() -> Response:
+    """Route to list all documents containing a mutation at a single position (SNV)."""
+    index_pattern = "genelastic-file-*"
+    target_svtypes = ["INS", "DEL"]
+
+    search_query = build_snv_mutation_search_query(
+        target_svtypes=target_svtypes
+    )
+
+    response = current_app.elastic_query_conn.client.search(  # type: ignore[attr-defined]
+        index=index_pattern, body=search_query
+    )
+
+    all_documents = [hit["_source"] for hit in response["hits"]["hits"]]
+
+    return jsonify(all_documents)
+
+
+def get_genelastic_version() -> Response:
+    """Retourne la version du package genelastic."""
+    top_level_package = __package__.split(".")[0]
+    return jsonify({"version": version(top_level_package)})

genelastic/api/server.py

@@ -1,15 +1,16 @@
-# pylint: disable=missing-module-docstring
-from typing import Any
 from pathlib import Path
+from typing import Any
+
+import connexion
 import yaml
-import connexion  # type: ignore
+
 from genelastic.common import ElasticQueryConn
 
 
-def load_yaml(file_path: Path) -> Any:
+def load_yaml(file_path: Path) -> Any:  # noqa: ANN401
     """Load a YAML file and return its content."""
     content = None
-    with open(file_path, encoding='utf-8') as f:
+    with Path.open(file_path, encoding="utf-8") as f:
         try:
             content = yaml.safe_load(f)
         except yaml.YAMLError as exc:
@@ -17,50 +18,57 @@ def load_yaml(file_path: Path) -> Any:
     return content
 
 
-def aggregate_openapi_specs(main_spec_file: Path, additional_spec_path: Path) -> Any:
+def aggregate_openapi_specs(
+    main_spec_file: Path, additional_spec_path: Path
+) -> Any:  # noqa: ANN401
     """Aggregate OpenAPI specifications from a main file and a directory
-    of additional specifications."""
+    of additional specifications.
+    """
     main_spec = load_yaml(main_spec_file)
     try:
         entries = additional_spec_path.iterdir()
     except OSError as exc:
         raise SystemExit(exc) from exc
 
-    if not 'paths' in main_spec:
-        main_spec['paths'] = []
+    if "paths" not in main_spec:
+        main_spec["paths"] = []
 
     for entry in entries:
         if not entry.is_file():
             continue
 
-        if not entry.suffix in [".yml", ".yaml"]:
+        if entry.suffix not in [".yml", ".yaml"]:
             continue
 
         content = load_yaml(entry)
 
-        if 'paths' in content:
-            main_spec['paths'].update(content['paths'])
+        if "paths" in content:
+            main_spec["paths"].update(content["paths"])
 
     return main_spec
 
 
 # Initialiser l'application Connexion
 connexion_app = connexion.FlaskApp(__name__)
-connexion_app.app.config.from_object('src.genelastic.api.settings.Config')
+connexion_app.app.config.from_object("src.genelastic.api.settings.Config")
 
 # Initialiser le client Elasticsearch
-es_url = connexion_app.app.config['GENAPI_ES_URL']
-es_cert_fp = connexion_app.app.config['GENAPI_ES_CERT_FP']
-es_api_key = connexion_app.app.config['GENAPI_ES_ENCODED_API_KEY']
+es_url = connexion_app.app.config["GENAPI_ES_URL"]
+es_cert_fp = connexion_app.app.config["GENAPI_ES_CERT_FP"]
+es_api_key = connexion_app.app.config["GENAPI_ES_ENCODED_API_KEY"]
 
-connexion_app.app.elastic_query_conn = ElasticQueryConn(es_url, es_cert_fp, api_key=es_api_key)
+connexion_app.app.elastic_query_conn = ElasticQueryConn(
+    es_url, es_cert_fp, api_key=es_api_key
+)
 
-connexion_app.app.logger.debug("Successfully connected to Elasticsearch server: %s",
-                               connexion_app.app.elastic_query_conn.client.info())
+connexion_app.app.logger.debug(
+    "Successfully connected to Elasticsearch server: %s",
+    connexion_app.app.elastic_query_conn.client.info(),
+)
 
 # Chemins des fichiers YAML
-main_yaml_file = Path(__file__).parents[0] / 'specification.yml'
-additional_yaml_dir = Path(__file__).parents[0] / 'extends'
+main_yaml_file = Path(__file__).parents[0] / "specification.yml"
+additional_yaml_dir = Path(__file__).parents[0] / "extends"
 
 # Charger et combiner les fichiers YAML
 yaml_spec = aggregate_openapi_specs(main_yaml_file, additional_yaml_dir)
@@ -68,5 +76,5 @@ yaml_spec = aggregate_openapi_specs(main_yaml_file, additional_yaml_dir)
 # Ajouter la spécification vers OpenAPI
 connexion_app.add_api(yaml_spec)
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     connexion_app.run(debug=True)

genelastic/api/settings.py

@@ -1,11 +1,12 @@
-# pylint: disable=missing-module-docstring
 from environs import Env
 
 env = Env()
 env.read_env()
 
-# pylint: disable=missing-class-docstring,too-few-public-methods
+
 class Config:
+    """Flask config class."""
+
     # Charger toutes les variables d'environnement nécessaires
     GENAPI_ES_URL = env.url("GENAPI_ES_URL").geturl()
     GENAPI_ES_ENCODED_API_KEY = env.str("GENAPI_ES_ENCODED_API_KEY")

genelastic/common/__init__.py

@@ -1,12 +1,39 @@
 """Genelastic package for common code between API and import scripts."""
-from .elastic import ElasticQueryConn, ElasticImportConn
-from .types import (BundleDict, AnalysisMetaData, BioInfoProcessData, WetProcessesData,
-                    MetadataDocument, AnalysisDocument, BulkItems, ProcessDocument, Bucket)
-from .cli import add_verbose_control_args, add_es_connection_args
+
+from .cli import add_es_connection_args, add_verbose_control_args
+from .elastic import ElasticImportConn, ElasticQueryConn
 from .exceptions import DBIntegrityError
+from .types import (
+    AnalysisDocument,
+    AnalysisMetaData,
+    BioInfoProcessData,
+    Bucket,
+    BulkItems,
+    BundleDict,
+    MetadataDocument,
+    ProcessDocument,
+    RandomAnalysisData,
+    RandomBiProcessData,
+    RandomWetProcessData,
+    WetProcessesData,
+)
 
-__all__ = ['ElasticQueryConn', 'ElasticImportConn', 'BundleDict', 'AnalysisMetaData',
-           'BioInfoProcessData', 'WetProcessesData', 'MetadataDocument', 'AnalysisDocument',
-           'BulkItems', 'ProcessDocument', 'Bucket', 'add_verbose_control_args',
-           'add_es_connection_args', 'DBIntegrityError'
-           ]
+__all__ = [
+    "AnalysisDocument",
+    "AnalysisMetaData",
+    "BioInfoProcessData",
+    "Bucket",
+    "BulkItems",
+    "BundleDict",
+    "DBIntegrityError",
+    "ElasticImportConn",
+    "ElasticQueryConn",
+    "MetadataDocument",
+    "ProcessDocument",
+    "RandomAnalysisData",
+    "RandomBiProcessData",
+    "RandomWetProcessData",
+    "WetProcessesData",
+    "add_es_connection_args",
+    "add_verbose_control_args",
+]

genelastic/common/cli.py

@@ -1,35 +1,63 @@
 """Utility functions for CLI scripts."""
+
 import argparse
 
 
 def add_verbose_control_args(parser: argparse.ArgumentParser) -> None:
-    """
-    Add verbose control arguments to the parser.
+    """Add verbose control arguments to the parser.
     Arguments are added to the parser by using its reference.
     """
-    parser.add_argument('-q', '--quiet', dest='verbose', action='store_const',
-                        const=0, default=1,
-                        help='Set verbosity to 0 (quiet mode).')
-    parser.add_argument('-v', '--verbose', dest='verbose', action='count',
-                        default=1,
-                        help=('Verbose level. -v for information, -vv for debug,' +
-                              ' -vvv for trace.'))
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        dest="verbose",
+        action="store_const",
+        const=0,
+        default=1,
+        help="Set verbosity to 0 (quiet mode).",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        dest="verbose",
+        action="count",
+        default=1,
+        help=(
+            "Verbose level. -v for information, -vv for debug, -vvv for trace."
+        ),
+    )
 
 
 def add_es_connection_args(parser: argparse.ArgumentParser) -> None:
-    """
-    Add arguments to the parser needed to gather ElasticSearch server connection parameters.
+    """Add arguments to the parser needed to gather ElasticSearch server connection parameters.
     Arguments are added to the parser by using its reference.
     """
-    parser.add_argument('--es-host', dest='es_host', default='localhost',
-                        help='Address of Elasticsearch host.')
-    parser.add_argument('--es-port', type=int, default=9200, dest='es_port',
-                        help='Elasticsearch port.')
-    parser.add_argument('--es-usr', dest='es_usr', default='elastic',
-                        help='Elasticsearch user.')
-    parser.add_argument('--es-pwd', dest='es_pwd', required=True,
-                        help='Elasticsearch password.')
-    parser.add_argument('--es-cert-fp', dest='es_cert_fp',
-                        help='Elasticsearch sha256 certificate fingerprint.')
-    parser.add_argument('--es-index-prefix', dest='es_index_prefix',
-                        help='Add the given prefix to each index created during import.')
+    parser.add_argument(
+        "--es-host",
+        dest="es_host",
+        default="localhost",
+        help="Address of Elasticsearch host.",
+    )
+    parser.add_argument(
+        "--es-port",
+        type=int,
+        default=9200,
+        dest="es_port",
+        help="Elasticsearch port.",
+    )
+    parser.add_argument(
+        "--es-usr", dest="es_usr", default="elastic", help="Elasticsearch user."
+    )
+    parser.add_argument(
+        "--es-pwd", dest="es_pwd", required=True, help="Elasticsearch password."
+    )
+    parser.add_argument(
+        "--es-cert-fp",
+        dest="es_cert_fp",
+        help="Elasticsearch sha256 certificate fingerprint.",
+    )
+    parser.add_argument(
+        "--es-index-prefix",
+        dest="es_index_prefix",
+        help="Add the given prefix to each index created during import.",
+    )