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

genelastic/import_data/import_data.py

@@ -1,292 +0,0 @@
-# pylint: disable=missing-module-docstring
-# vi: se tw=80
-
-# Elasticsearch Python API:
-# https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/overview.html
-# https://elasticsearch-py.readthedocs.io/en/latest/api.html
-
-import argparse
-import csv
-import datetime
-import hashlib
-import logging
-import os
-import sys
-import time
-import vcf  # type: ignore
-
-from genelastic.common import (add_verbose_control_args, add_es_connection_args,
-                               ElasticImportConn, MetadataDocument, AnalysisDocument,
-                               BulkItems, ProcessDocument)
-
-from .import_bundle_factory import make_import_bundle_from_files
-from .bi_processes import BioInfoProcesses
-from .data_file import DataFile
-from .logger import configure_logging
-from .wet_processes import WetProcesses
-
-logger = logging.getLogger('genelastic')
-logging.getLogger('elastic_transport').setLevel(logging.WARNING)  # Disable excessive logging
-logging.getLogger('urllib3').setLevel(logging.WARNING)  # Disable excessive logging
-
-
-def read_args() -> argparse.Namespace:
-    # pylint: disable=R0801
-    """Read arguments from command line."""
-    parser = argparse.ArgumentParser(description='Genetics data importer.',
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-                                     allow_abbrev=False)
-    add_verbose_control_args(parser)
-    add_es_connection_args(parser)
-    parser.add_argument('-D', '--dry-run', dest='dryrun', action='count',
-                        default=0,
-                        help=('Dry-run level. -D for data files loading (VCF, coverage, etc)' +
-                              ' without connecting or importing to database. -DD for metadata' +
-                              ' YAML files loading only (no loading of data files).'))
-    parser.add_argument('--log-file', dest='log_file', help='Path to a log file.')
-    parser.add_argument('--no-list', dest='no_list',
-                        action='store_true',
-                        help='Do not print list of files to be imported.')
-    parser.add_argument('--no-confirm', dest='no_confirm',
-                        action='store_true',
-                        help='Do not ask confirmation before importing.')
-    parser.add_argument('files', type=str, nargs="+", default=None,
-                        help="Data files that describe what to import.")
-    args = parser.parse_args()
-    return args
-
-
-def import_cov_file(es_import_conn: ElasticImportConn | None,
-                    file_index: str, file: str, dryrun: int = 0) -> None:
-    """Import a coverage file to the Elasticsearch database."""
-    # Set field types
-    if dryrun == 0 and es_import_conn:
-        es_import_conn.client.indices.put_mapping(index=file_index,
-                                                  body={'properties': {'pos': {'type': 'integer'},
-                                                                       'depth': {'type': 'byte'}}})
-
-    # Open file
-    if dryrun > 1:
-        logger.info('Would load and import Coverage file %s '
-                    'into index %s.', file, file_index)
-    else:
-        logger.info('Load Coverage file %s.', file)
-        if dryrun == 1:
-            logger.info('Would import Coverage file %s into index %s.', file, file_index)
-        else:
-            logger.info('Import Coverage file %s into index %s.', file, file_index)
-        with open(file, newline='', encoding="utf-8") as f:
-
-            # Read file as CSV
-            reader = csv.reader(f, delimiter='\t', quotechar='"')
-
-            # Loop on al lines
-            for row in reader:
-
-                # Build document
-                # Position starts at 0 inside coverage file
-                doc: MetadataDocument = {
-                    'type': 'coverage',
-                    'chr': row[0],
-                    'pos': int(row[1]) + 1,
-                    'depth': int(row[2])
-                }
-
-                # Insert document
-                if dryrun == 0 and es_import_conn:
-                    es_import_conn.client.index(index=file_index, document=doc)
-
-
-# pylint: disable-next=too-many-arguments, too-many-positional-arguments
-def import_analysis_metadata(es_import_conn: ElasticImportConn | None,
-                             index_prefix: str,
-                             file_index: str,
-                             file: DataFile,
-                             analysis_type: str,
-                             dryrun: int = 0) -> None:
-    """Import analysis metadata into a dedicated index."""
-    doc: AnalysisDocument = {
-        "path": os.path.abspath(file.path),
-        "bundle_path": os.path.abspath(file.bundle_path) if file.bundle_path else None,
-        "metadata": file.metadata,
-        "file_index": file_index,
-        "type": analysis_type
-    }
-
-    bulk_items: BulkItems = [
-        {"_index": f"{index_prefix}-analyses", "_source": doc}
-    ]
-
-    if dryrun == 0 and es_import_conn:
-        es_import_conn.import_items(bulk_items,
-                                    start_time=time.perf_counter(),
-                                    total_items=len(bulk_items)
-                                    )
-
-
-def import_vcf_file(es_import_conn: ElasticImportConn | None,
-                    file_index: str,
-                    file: DataFile,
-                    dryrun: int = 0) -> None:
-    """Import a VCF file to the Elasticsearch database."""
-    logger.info("Import VCF file \"%s\".", file)
-
-    if dryrun > 1:
-        logger.info('Would load and import VCF file %s '
-                    'into index %s.', file.path, file_index)
-    else:
-        logger.info('Load VCF file %s.', file.path)
-        if dryrun == 1:
-            logger.info('Would import VCF file %s into index %s.', file.path, file_index)
-        else:
-            logger.info('Importing VCF file %s into index %s...', file.path, file_index)
-
-        try:
-            vcf_reader = vcf.Reader(filename=file.path)
-            n = 0
-            start = time.perf_counter()
-            bulk_sz = 256  # Bulk size
-            bulk_items: BulkItems = []
-            for record in vcf_reader:
-
-                # Correct values
-                if not record.CHROM.startswith('chr'):
-                    if record.CHROM.lower().startswith('chr'):
-                        record.CHROM = 'chr' + record.CHROM[3:]
-                    else:
-                        record.CHROM = 'chr' + record.CHROM
-
-                # Build document
-                alt = [x if x is None else x.type for x in record.ALT]
-                doc: MetadataDocument = {
-                    'type': 'vcf',
-                    'chr': record.CHROM,
-                    'pos': record.POS,
-                    'alt': alt,
-                    'info': record.INFO,
-                }
-
-                if dryrun == 0:
-
-                    # Append item to bulk
-                    bulk_items.append({"_index": file_index, "_source": doc})
-                    n += 1
-                    # resp = es.index(index=index, document=doc)
-
-                    # Insert bulk of items
-                    if len(bulk_items) >= bulk_sz and es_import_conn:
-                        es_import_conn.import_items(bulk_items, start_time=start,
-                                                    total_items=n)
-                        bulk_items = []
-
-            # Insert remaining items
-            if dryrun == 0 and es_import_conn:
-                es_import_conn.import_items(bulk_items, start_time=start, total_items=n)
-
-        except StopIteration:
-            logger.error('Skipping empty file : %s.', file.path)
-
-
-def import_processes(es_import_conn: ElasticImportConn | None, index: str,
-                     processes: WetProcesses | BioInfoProcesses, dryrun: int = 0) -> None:
-    """Import processes into their own index."""
-
-    bulk_items: BulkItems = []
-
-    for proc_id in processes.get_process_ids():
-        process = processes[proc_id]
-        process_type = process.__class__.__name__
-        doc: ProcessDocument = process.data | {'proc_id': proc_id, 'type': process_type}
-        bulk_items.append({"_index": index, "_source": doc})
-
-    if dryrun == 0 and es_import_conn:
-        es_import_conn.import_items(bulk_items,
-                                    start_time=time.perf_counter(),
-                                    total_items=len(bulk_items)
-                                    )
-
-
-def generate_unique_index(index_prefix: str, filepath: str) -> str:
-    """
-    Generate a unique index with the following format:
-    <index_prefix>_<current_date>_<md5_hashed_filepath>
-    """
-    current_date = datetime.datetime.today().strftime('%Y%m%d')
-    hashed_filepath = hashlib.md5(filepath.encode('utf-8'), usedforsecurity=False).hexdigest()
-    return f"{index_prefix}-file-{current_date}-{hashed_filepath}"
-
-
-def main() -> None:
-    """Entry point of the import script."""
-    # Read command line arguments
-    args = read_args()
-
-    # Configure logging
-    configure_logging(args.verbose, log_file=args.log_file)
-    logger.debug("Arguments: %s", args)
-    logger.debug("LOGGERS: %s", logging.root.manager.loggerDict)  # pylint: disable=no-member
-
-    # Open connection to ES
-    if args.dryrun == 0:
-        addr = f"https://{args.es_host}:{args.es_port}"
-        logger.info("Trying to connect to Elasticsearch at %s...", addr)
-        es_import_conn = ElasticImportConn(addr, args.es_cert_fp,
-                                           basic_auth=(args.es_usr, args.es_pwd))
-    else:
-        es_import_conn = None
-
-    # Create index
-    # es.indices.create(index=args.es_index_prefix)
-
-    # Load YAML import bundle
-    import_bundle = make_import_bundle_from_files(args.files, check=True)
-    all_bundled_files = import_bundle.get_files()
-
-    # CHECK
-    for f in all_bundled_files:
-        if not f.exists():
-            raise RuntimeError(f"Path {f.path} does not point to a valid file.")
-
-    # LIST
-    if not args.no_list:
-        for f in all_bundled_files:
-            logger.info("Will import %s.", f.path)
-
-    # Ask confirmation for importing
-    if not args.no_confirm:
-        answer: str = "maybe"
-        while answer not in ['', 'n', 'y']:
-            answer = input("Import (y/N)? ").lower()
-        if answer != 'y':
-            logger.info("Import canceled.")
-            sys.exit(0)
-
-    # IMPORT
-    # Loop on file categories
-    for cat in import_bundle.analyses.get_all_categories():
-        # Import all files in this category.
-        for f in import_bundle.get_files(cat):
-            logger.info("Import %s files from %s.", cat, f.path)
-            # First, generate a unique index name for each file.
-            file_index = generate_unique_index(args.es_index_prefix, f.path)
-            # Then, import the analysis metadata into a dedicated index.
-            import_analysis_metadata(es_import_conn, args.es_index_prefix,
-                                     file_index, f, cat, args.dryrun)
-            # Finally, import the file in its own index.
-            globals()[f'import_{cat}_file'](es_import_conn=es_import_conn,
-                                            file_index=file_index, file=f, dryrun=args.dryrun)
-
-    # Import processes
-    logger.info("Importing wet processes.")
-    logger.info("Wet processes IDs = %s", str(import_bundle.wet_processes.get_process_ids()))
-    import_processes(es_import_conn, f"{args.es_index_prefix}-wet_processes",
-                     import_bundle.wet_processes)
-
-    logger.info("Importing bio info processes.")
-    logger.info("Bio info processes IDs = %s", str(import_bundle.bi_processes.get_process_ids()))
-    import_processes(es_import_conn, f"{args.es_index_prefix}-bi_processes",
-                     import_bundle.bi_processes)
-
-
-if __name__ == '__main__':
-    main()

genelastic/import_data/integrity.py

@@ -1,290 +0,0 @@
-# pylint: disable=missing-module-docstring
-import argparse
-import logging
-import typing
-from elasticsearch import NotFoundError
-
-from genelastic.common import (ElasticQueryConn, DBIntegrityError, Bucket,
-                               add_verbose_control_args, add_es_connection_args)
-
-from .logger import configure_logging
-
-logger = logging.getLogger('genelastic')
-logging.getLogger('elastic_transport').setLevel(logging.WARNING)  # Disable excessive logging
-
-
-def read_args() -> argparse.Namespace:
-    """Read arguments from command line."""
-    parser = argparse.ArgumentParser(description='Utility to check the integrity '
-                                                 'of the genelastic ElasticSearch database.',
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-                                     allow_abbrev=False)
-    add_verbose_control_args(parser)
-    add_es_connection_args(parser)
-    return parser.parse_args()
-
-
-def check_for_undefined_file_indices(es_query_conn: ElasticQueryConn, analyses_index: str) -> None:
-    """
-    Check for potentially undefined files indices in the analyses index.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :raises genelastic.common.DBIntegrityError:
-        Some files indices are used in the analyses index but are undefined.
-    """
-    logger.info("Checking for references to undefined file indices in the index '%s'...",
-                analyses_index)
-
-    undefined_indices = set()
-
-    query = {
-        "size": 0,
-        "aggs": {
-            "get_file_indices": {
-                "composite": {
-                    "sources": {"file_index": {"terms": {"field": "file_index.keyword"}}},
-                    "size": 1000,
-                }
-            }
-        }
-    }
-
-    buckets: typing.List[Bucket] = es_query_conn.run_composite_aggregation(analyses_index, query)
-
-    for bucket in buckets:
-        file_index = bucket['key']['file_index']
-
-        try:
-            es_query_conn.client.indices.get(index=file_index)
-            logger.debug("File index %s used in index '%s' is defined.",
-                         file_index, analyses_index)
-        except NotFoundError:
-            logger.debug("File index %s used in '%s' is undefined.",
-                         file_index, analyses_index)
-            undefined_indices.add(file_index)
-
-    if len(undefined_indices) > 0:
-        raise DBIntegrityError(f"Found the following undefined file indices defined "
-                               f"in the index '{analyses_index}': "
-                               f"{", ".join(undefined_indices)}")
-
-    logger.info("All defined file indices are referenced.")
-
-
-def get_undefined_processes(es_query_conn: ElasticQueryConn, analyses_index: str,
-                            process_index: str, field: str) -> typing.Set[str]:
-    """
-    Return a set of undefined processes IDs in an index.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :param process_index: Name of the index to check for undefined processes.
-    :param field: Field name used to retrieve the process ID.
-    :returns: A set of undefined processes IDs.
-    """
-    query = {
-        "size": 0,
-        "aggs": {
-            "get_analyses_processes": {
-                "composite": {
-                    "sources": {"process": {"terms": {"field": f"{field}.keyword"}}},
-                    "size": 1000,
-                }
-            }
-        }
-    }
-
-    buckets: typing.List[Bucket] = es_query_conn.run_composite_aggregation(analyses_index, query)
-
-    used_processes = set(map(lambda bucket: bucket["key"]["process"], buckets))
-    logger.debug("Used values for field '%s' in index '%s': %s",
-                 field, analyses_index, used_processes)
-
-    defined_processes = es_query_conn.get_field_values(process_index, "proc_id")
-    logger.debug("Defined values in index '%s': %s", process_index, defined_processes)
-
-    return used_processes.difference(defined_processes)
-
-
-def check_for_undefined_wet_processes(es_query_conn: ElasticQueryConn,
-                                      analyses_index: str, wet_process_index: str) -> None:
-    """
-    Check that each wet process used in the analyses index is defined.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :param wet_process_index: Name of the index where wet processes are stored.
-    :raises genelastic.common.DBIntegrityError:
-        Some wet processes used in the analyses index are undefined.
-    """
-    logger.info("Checking for undefined wet processes used in index '%s'...", analyses_index)
-    undefined_wet_processes = get_undefined_processes(es_query_conn,
-                                                      analyses_index, wet_process_index,
-                                                      "metadata.wet_process")
-
-    if len(undefined_wet_processes) > 0:
-        raise DBIntegrityError(f"Index '{analyses_index}' uses the following "
-                               f"undefined wet processes: {", ".join(undefined_wet_processes)}.")
-
-    logger.info("All wet processes used in index '%s' are defined.", wet_process_index)
-
-
-def check_for_undefined_bi_processes(es_query_conn: ElasticQueryConn,
-                                     analyses_index: str, bi_process_index: str) -> None:
-    """
-    Check that each bio info process used in the analyses index is defined.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :param bi_process_index: Name of the index where bio info processes are stored.
-    :raises genelastic.common.DBIntegrityError:
-        Some bio info processes used in the analyses index are undefined.
-    """
-    logger.info("Checking for undefined bio info processes used in index '%s'...",
-                analyses_index)
-    undefined_bi_processes = get_undefined_processes(es_query_conn, analyses_index,
-                                                     bi_process_index,
-                                                     "metadata.bi_process")
-
-    if len(undefined_bi_processes) > 0:
-        raise DBIntegrityError(f"Index '{analyses_index}' uses the following "
-                               f"undefined bio info processes: "
-                               f"{", ".join(undefined_bi_processes)}.")
-
-    logger.info("All bio info processes used in index '%s' are defined.", bi_process_index)
-
-
-def check_for_unused_file_indices(es_query_conn: ElasticQueryConn,
-                                  analyses_index: str, index_prefix: str) -> int:
-    """
-    Check that each of the file indices are used in at least one analysis.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :param index_prefix: Prefix given to all the indices of the ElasticSearch database.
-    :returns: 1 if some file indices exists but are unused in the analyses index,
-        and 0 otherwise.
-    """
-    json_indices = (es_query_conn.client.cat.
-                    indices(index=f"{index_prefix}-file-*", format="json").body)
-    found_file_indices = set(map(lambda x: x["index"], json_indices))
-
-    query = {
-        "size": 0,
-        "aggs": {
-            "get_file_indices": {
-                "composite": {
-                    "sources": {"file_index": {"terms": {"field": "file_index.keyword"}}},
-                    "size": 1000,
-                }
-            }
-        }
-    }
-
-    buckets: typing.List[Bucket] = es_query_conn.run_composite_aggregation(analyses_index, query)
-
-    used_files_indices = set(map(lambda bucket: bucket['key']['file_index'], buckets))
-    unused_files_indices = found_file_indices.difference(used_files_indices)
-
-    if len(unused_files_indices) > 0:
-        logger.warning("Found the following unused files indices: %s",
-                       ", ".join(unused_files_indices))
-        return 1
-
-    logger.info("All files indices are used.")
-    return 0
-
-
-def check_for_unused_wet_processes(es_query_conn: ElasticQueryConn, analyses_index: str,
-                                   wet_proc_index: str) -> int:
-    """
-    Check for defined wet processes that are not used in the analyses index.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :param wet_proc_index: Name of the index where wet processes are stored.
-    :returns: 1 if some wet process are defined but unused in the analyses index,
-        and 0 otherwise.
-    """
-    logger.info("Checking for unused wet processes in the index '%s'...", wet_proc_index)
-
-    defined_wet_procs = es_query_conn.get_field_values(wet_proc_index, "proc_id")
-    logger.debug("Found the following defined wet processes: %s", defined_wet_procs)
-
-    used_wet_procs = es_query_conn.get_field_values(analyses_index, "metadata.wet_process")
-    logger.debug("Following processes are used in the index '%s': %s",
-                 analyses_index, used_wet_procs)
-
-    unused_wet_procs = defined_wet_procs - used_wet_procs
-    if len(unused_wet_procs) > 0:
-        logger.warning("Found unused wet processes: %s", unused_wet_procs)
-        return 1
-
-    logger.info("No unused wet processes found.")
-    return 0
-
-
-def check_for_unused_bi_processes(es_query_conn: ElasticQueryConn, analyses_index: str,
-                                  bi_proc_index: str) -> int:
-    """
-    Check for defined bio info processes that are not used in the analyses index.
-
-    :param es_query_conn: Elasticsearch database instance.
-    :param analyses_index: Name of the index where analyses are stored.
-    :param bi_proc_index: Name of the index where bio info processes are stored.
-    :returns: 1 if some wet process are defined but unused in the analyses index,
-        and 0 otherwise.
-    """
-    logger.info("Checking for unused bio info processes in the index '%s'...", bi_proc_index)
-
-    defined_bi_procs = es_query_conn.get_field_values(bi_proc_index, "proc_id")
-    logger.debug("Found the following defined bio info processes: %s", defined_bi_procs)
-
-    used_bi_procs = es_query_conn.get_field_values(analyses_index, "metadata.bi_process")
-    logger.debug("Following processes are used in the index '%s': %s",
-                 analyses_index, used_bi_procs)
-
-    unused_bi_procs = defined_bi_procs - used_bi_procs
-    if len(unused_bi_procs) > 0:
-        logger.warning("Found unused bio info processes: %s", unused_bi_procs)
-        return 1
-
-    logger.info("No unused bio info processes found.")
-    return 0
-
-
-def main() -> None:
-    """Entry point of the integrity script."""
-    args = read_args()
-
-    configure_logging(args.verbose)
-    logger.debug("Arguments: %s", args)
-
-    analyses_index = f"{args.es_index_prefix}-analyses"
-    wet_processes_index = f"{args.es_index_prefix}-wet_processes"
-    bi_processes_index = f"{args.es_index_prefix}-bi_processes"
-
-    addr = f"https://{args.es_host}:{args.es_port}"
-    logger.info("Trying to connect to Elasticsearch at %s...", addr)
-    es_query_conn = ElasticQueryConn(addr, args.es_cert_fp,
-                                     basic_auth=(args.es_usr, args.es_pwd))
-
-    # Fatal errors
-    try:
-        es_query_conn.ensure_unique(wet_processes_index, "proc_id")
-        es_query_conn.ensure_unique(bi_processes_index, "proc_id")
-        check_for_undefined_file_indices(es_query_conn, analyses_index)
-        check_for_undefined_wet_processes(es_query_conn, analyses_index, wet_processes_index)
-        check_for_undefined_bi_processes(es_query_conn, analyses_index, bi_processes_index)
-    except DBIntegrityError as e:
-        raise SystemExit(e) from e
-
-    # Warnings
-    check_for_unused_wet_processes(es_query_conn, analyses_index, wet_processes_index)
-    check_for_unused_bi_processes(es_query_conn, analyses_index, bi_processes_index)
-    check_for_unused_file_indices(es_query_conn, analyses_index, args.es_index_prefix)
-
-
-if __name__ == '__main__':
-    main()

genelastic/import_data/validate_data.py

@@ -1,43 +0,0 @@
-# pylint: disable=missing-module-docstring
-import argparse
-import logging
-
-from schema import SchemaError  # type: ignore
-
-from genelastic.common import add_verbose_control_args
-
-from .logger import configure_logging
-from .import_bundle_factory import make_import_bundle_from_files
-
-logger = logging.getLogger('genelastic')
-
-
-def read_args() -> argparse.Namespace:
-    """Read arguments from command line."""
-    parser = argparse.ArgumentParser(description="Ensure that YAML files "
-                                                 "follow the genelastic YAML bundle schema.",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-                                     allow_abbrev=False)
-    add_verbose_control_args(parser)
-    parser.add_argument('files', type=str, nargs="+", default=None,
-                        help="YAML files to validate.")
-    parser.add_argument('-c', '--check', action='store_true',
-                        help="In addition to validating the schema, "
-                             "check for undefined referenced processes.")
-    return parser.parse_args()
-
-
-def main() -> int:
-    """Entry point of the validate script."""
-    args = read_args()
-    configure_logging(args.verbose)
-
-    try:
-        make_import_bundle_from_files(args.files, check=args.check)
-    except (ValueError, RuntimeError, SchemaError) as e:
-        # Catch any exception that can be raised by 'make_import_bundle_from_files'.
-        logger.error(e)
-        return 1
-
-    logger.info("All YAML files respect the genelastic YAML bundle format.")
-    return 0

genelastic-0.6.1.dist-info/METADATA

@@ -1,41 +0,0 @@
-Metadata-Version: 2.1
-Name: genelastic
-Version: 0.6.1
-Summary: Generate and store genetic data into an Elasticsearch database.
-Author: CNRGH
-Author-email: Pierrick ROGER <pierrick.roger@cnrgh.fr>, Maxime BLANCHON <maxime.blanchon@cnrgh.fr>
-License: CeCILL
-Keywords: CNRGH,genelastic,generation,storage,elasticsearch,database
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: elasticsearch
-Requires-Dist: PyVCF3
-Requires-Dist: schema
-Requires-Dist: PyYAML
-Requires-Dist: biophony >=1.0.1
-Requires-Dist: colorlog
-Provides-Extra: api
-Requires-Dist: flask ; extra == 'api'
-Requires-Dist: elasticsearch ; extra == 'api'
-Requires-Dist: environs ; extra == 'api'
-Requires-Dist: connexion[flask,swagger-ui,uvicorn] ; extra == 'api'
-Provides-Extra: docs
-Requires-Dist: sphinx ; extra == 'docs'
-Requires-Dist: sphinx-autoapi ; extra == 'docs'
-Requires-Dist: furo ; extra == 'docs'
-Provides-Extra: tests
-Requires-Dist: pytest ; extra == 'tests'
-Requires-Dist: mypy ; extra == 'tests'
-Requires-Dist: pylint ; extra == 'tests'
-Requires-Dist: bandit ; extra == 'tests'
-Requires-Dist: coverage ; extra == 'tests'
-Requires-Dist: yamllint ; extra == 'tests'
-Requires-Dist: types-PyYAML ; extra == 'tests'
-
-# genelastic
-
-Storing of genetics data into an Elasticsearch database.