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

genelastic/api/cli_start_api.py

@@ -0,0 +1,18 @@
+from genelastic.common import parse_server_launch_args
+from genelastic.common.server import start_dev_server, start_prod_server
+
+
+def main() -> None:
+    app_module = "genelastic.api.server:app"
+    args = parse_server_launch_args("Start API server.", 8000)
+    if args.env == "dev":
+        start_dev_server(app_module, args)
+    elif args.env == "prod":
+        start_prod_server(app_module, args)
+    else:
+        msg = f"Environment '{args.env}' is not implemented."
+        raise NotImplementedError(msg)
+
+
+if __name__ == "__main__":
+    main()

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/extends/example.yml

@@ -0,0 +1,20 @@
+---
+paths:
+  /ping_2:
+    get:
+      operationId: genelastic.api.extends.example.ping_2
+      tags:
+        - Tests
+      summary: Vérification du statut du serveur
+      description: Route de test pour vérifier que le serveur est en ligne
+      responses:
+        200:
+          description: Le serveur est en ligne
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
+                    example: 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,17 @@
-# 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 connexion import FlaskApp
+
 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 file_path.open(encoding="utf-8") as f:
         try:
             content = yaml.safe_load(f)
         except yaml.YAMLError as exc:
@@ -17,56 +19,65 @@ 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')
+def create_app() -> FlaskApp:
+    # Initialiser l'application Connexion
+    connexion_app = connexion.FlaskApp(__name__)
+    connexion_app.app.config.from_object("genelastic.api.settings")
+
+    # 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"]
 
-# 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']
+    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"
 
-# Chemins des fichiers YAML
-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)
 
-# Charger et combiner les fichiers YAML
-yaml_spec = aggregate_openapi_specs(main_yaml_file, additional_yaml_dir)
+    # Ajouter la spécification vers OpenAPI
+    connexion_app.add_api(yaml_spec)
+    return connexion_app
 
-# Ajouter la spécification vers OpenAPI
-connexion_app.add_api(yaml_spec)
 
-if __name__ == '__main__':
-    connexion_app.run(debug=True)
+app = create_app()

genelastic/api/settings.py

@@ -1,13 +1,10 @@
-# 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:
-    # 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")
-    GENAPI_ES_INDEX_PREFIX = env.str("GENAPI_ES_INDEX_PREFIX")
-    GENAPI_ES_CERT_FP = env.str("GENAPI_ES_CERT_FP")
+# Load required environment variables.
+GENAPI_ES_URL = env.url("GENAPI_ES_URL").geturl()
+GENAPI_ES_ENCODED_API_KEY = env.str("GENAPI_ES_ENCODED_API_KEY")
+GENAPI_ES_INDEX_PREFIX = env.str("GENAPI_ES_INDEX_PREFIX")
+GENAPI_ES_CERT_FP = env.str("GENAPI_ES_CERT_FP")