@orcabus/platform-cdk-constructs 0.0.6 → 0.0.7-alpha.3

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/metadata/__init__.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+from functools import reduce
+from itertools import batched
+from operator import concat
+# Standard imports
+from typing import Dict, List, Any
+from urllib.error import HTTPError
+
+# Util imports
+from ..utils.requests_helpers import (
+    get_request_response_results, get_url
+)
+
+# Local imports
+from .globals import METADATA_SUBDOMAIN_NAME
+
+
+def get_metadata_url(endpoint: str) -> str:
+    """
+    Get the URL for the Metadata endpoint
+    :param endpoint:
+    :return:
+    """
+    return get_url(
+        endpoint,
+        METADATA_SUBDOMAIN_NAME
+    )
+
+
+def get_metadata_request_response_results(
+        endpoint: str,
+        params: Dict = None,
+):
+    return get_request_response_results(get_metadata_url(endpoint), params=params)
+
+
+def get_item_objs_from_item_id_list(
+        item_id_list: List[str],
+        item_identifier: str,
+        endpoint: str,
+        accept_missing=False
+) -> List[Dict[str, Any]]:
+
+    # Get query list
+    try:
+        query_list = get_metadata_request_response_results(
+            endpoint,
+            {
+                item_identifier: item_id_list
+            }
+        )
+    except HTTPError as e:
+        raise HTTPError(f"Could not get item from item id list {item_id_list} from endpoint {endpoint}") from e
+
+    # Accept missing
+    if accept_missing:
+        return query_list
+
+    try:
+        assert len(query_list) == len(item_id_list)
+    except AssertionError:
+        # If we don't find all the items, we need to raise an error
+        item_ids_response = list(map(
+            lambda item_id_response_iter_: item_id_response_iter_[item_identifier],
+            query_list
+        ))
+        missing_items_list = list(set(item_id_list) - set(item_ids_response))
+        raise ValueError(f"Some items were not found in the response, {missing_items_list}")
+    return query_list
+
+
+def get_item_from_item_id_list_batched(
+        item_id_list: List[str],
+        item_identifier: str,
+        endpoint: str,
+        accept_missing: bool = False,
+        batch_size: int = 50
+) -> List[Dict[str: Any]]:
+    """
+    Get items from a list of item ids
+    We batch the requests to avoid hitting the API limits
+    :param item_id_list:
+    :param item_identifier:
+    :param endpoint:
+    :param accept_missing:
+    :param batch_size:
+    :return:
+    """
+    item_id_lists = batched(item_id_list, batch_size)
+
+    # Get the items from the list of item ids
+    try:
+        return list(reduce(
+            concat,
+            list(map(
+                lambda item_batch_: (
+                    get_item_objs_from_item_id_list(
+                        item_id_list=item_batch_,
+                        item_identifier=item_identifier,
+                        endpoint=endpoint,
+                        accept_missing=accept_missing
+                    )
+                ),
+                item_id_lists
+            ))
+        ))
+    except TypeError as e:
+        # TypeError: reduce() of empty sequence with no initial value
+        return []
+
+# Determine all the public classes and functions
+# that should be available for import
+
+from .contact_helpers import (
+    get_contact_from_contact_id,
+    get_contacts_list_from_contact_id_list,
+    get_contact_orcabus_id_from_contact_id,
+    get_contact_from_contact_orcabus_id,
+    get_contacts_list_from_contact_orcabus_id_list,
+    coerce_contact_id_or_orcabus_id_to_contact_orcabus_id,
+    get_all_contacts,
+)
+
+from .individual_helpers import (
+    get_individual_from_individual_id,
+    get_individuals_list_from_individual_id_list,
+    get_individual_orcabus_id_from_individual_id,
+    get_individual_from_individual_orcabus_id,
+    get_individuals_list_from_individual_orcabus_id_list,
+    coerce_individual_id_or_orcabus_id_to_individual_orcabus_id,
+    get_all_individuals,
+    list_libraries_in_individual,
+)
+
+from .library_helpers import (
+    get_library_from_library_id,
+    get_libraries_list_from_library_id_list,
+    get_library_orcabus_id_from_library_id,
+    get_library_id_from_library_orcabus_id,
+    coerce_library_id_or_orcabus_id_to_library_orcabus_id,
+    get_library_from_library_orcabus_id,
+    get_libraries_from_library_orcabus_id_list,
+    get_subject_from_library_id,
+    get_library_type,
+    get_library_assay_type,
+    get_library_phenotype,
+    get_library_workflow,
+    get_all_libraries
+)
+
+from .project_helpers import (
+    get_project_from_project_id,
+    get_projects_list_from_project_id_list,
+    get_project_orcabus_id_from_project_id,
+    coerce_project_id_or_orcabus_id_to_project_orcabus_id,
+    get_project_from_project_orcabus_id,
+    get_projects_list_from_project_orcabus_id_list,
+    get_all_projects,
+    list_libraries_in_project,
+)
+
+from .sample_helpers import (
+    get_sample_from_sample_id,
+    get_samples_list_from_sample_id_list,
+    get_sample_orcabus_id_from_sample_id,
+    get_sample_from_sample_orcabus_id,
+    get_samples_list_from_sample_orcabus_id_list,
+    coerce_sample_id_or_orcabus_id_to_sample_orcabus_id,
+    list_libraries_in_sample,
+    get_all_samples,
+)
+
+from .subject_helpers import (
+    get_subject_from_subject_id,
+    get_subjects_list_from_subject_id_list,
+    coerce_subject_id_or_orcabus_id_to_subject_orcabus_id,
+    get_subject_orcabus_id_from_subject_id,
+    get_subjects_list_from_subject_orcabus_id_list,
+    get_subject_from_subject_orcabus_id,
+    list_samples_in_subject,
+    list_libraries_in_subject,
+    get_all_subjects,
+)
+
+__all__ = [
+    # Contact Helpers
+    "get_contact_from_contact_id",
+    "get_contacts_list_from_contact_id_list",
+    "get_contact_orcabus_id_from_contact_id",
+    "get_contact_from_contact_orcabus_id",
+    "get_contacts_list_from_contact_orcabus_id_list",
+    "coerce_contact_id_or_orcabus_id_to_contact_orcabus_id",
+    "get_all_contacts",
+
+    # Individual Helpers
+    "get_individual_from_individual_id",
+    "get_individuals_list_from_individual_id_list",
+    "get_individual_orcabus_id_from_individual_id",
+    "get_individual_from_individual_orcabus_id",
+    "get_individuals_list_from_individual_orcabus_id_list",
+    "coerce_individual_id_or_orcabus_id_to_individual_orcabus_id",
+    "get_all_individuals",
+    "list_libraries_in_individual",
+
+    # Library Helpers
+    "get_library_from_library_id",
+    "get_libraries_list_from_library_id_list",
+    "get_library_orcabus_id_from_library_id",
+    "get_library_id_from_library_orcabus_id",
+    "coerce_library_id_or_orcabus_id_to_library_orcabus_id",
+    "get_library_from_library_orcabus_id",
+    "get_libraries_from_library_orcabus_id_list",
+    "get_subject_from_library_id",
+    "get_library_type",
+    "get_library_assay_type",
+    "get_library_phenotype",
+    "get_library_workflow",
+    "get_all_libraries",
+
+    # Project Helpers
+    "get_project_from_project_id",
+    "get_projects_list_from_project_id_list",
+    "get_project_orcabus_id_from_project_id",
+    "coerce_project_id_or_orcabus_id_to_project_orcabus_id",
+    "get_project_from_project_orcabus_id",
+    "get_projects_list_from_project_orcabus_id_list",
+    "get_all_projects",
+    "list_libraries_in_project",
+
+    # Sample Helpers
+    "get_sample_from_sample_id",
+    "get_samples_list_from_sample_id_list",
+    "get_sample_orcabus_id_from_sample_id",
+    "get_sample_from_sample_orcabus_id",
+    "get_samples_list_from_sample_orcabus_id_list",
+    "coerce_sample_id_or_orcabus_id_to_sample_orcabus_id",
+    "list_libraries_in_sample",
+    "get_all_samples",
+
+    # Subject Helpers
+    "get_subject_from_subject_id",
+    "get_subjects_list_from_subject_id_list",
+    "coerce_subject_id_or_orcabus_id_to_subject_orcabus_id",
+    "get_subject_orcabus_id_from_subject_id",
+    "get_subjects_list_from_subject_orcabus_id_list",
+    "get_subject_from_subject_orcabus_id",
+    "list_samples_in_subject",
+    "list_libraries_in_subject",
+    "get_all_subjects",
+]

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/metadata/contact_helpers.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+
+"""
+Helpers for using the contact API endpoint
+"""
+
+# Standard imports
+from typing import List
+from requests import HTTPError
+
+# Local imports
+from . import get_metadata_request_response_results, get_item_objs_from_item_id_list
+from .globals import CONTACT_ENDPOINT, ORCABUS_ULID_REGEX_MATCH
+from .models import Contact
+from .errors import ContactNotFoundError
+
+
+def get_contact_from_contact_id(contact_id: str) -> Contact:
+    """
+    Get contact from the contact id
+    :param contact_id:
+    :return:
+    """
+    # We have an internal id, convert to int
+    params = {
+        "contactId": contact_id
+    }
+
+    # Get contact
+    try:
+        query_list = get_metadata_request_response_results(CONTACT_ENDPOINT, params)
+        assert len(query_list) == 1
+        return query_list[0]
+    except (HTTPError, AssertionError):
+        raise ContactNotFoundError(
+            contact_id=contact_id,
+        )
+
+
+def get_contacts_list_from_contact_id_list(contact_id_list: List[str], accept_missing=False) -> List[Contact]:
+    """
+    Given a list of contact ids, return a list of Contact objects
+    :param contact_id_list:
+    :param accept_missing:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda contact_iter_: Contact(**contact_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=contact_id_list,
+            item_identifier="contactId",
+            endpoint=CONTACT_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_contact_orcabus_id_from_contact_id(contact_id: str) -> str:
+    return get_contact_from_contact_id(contact_id)['orcabusId']
+
+
+def get_contact_from_contact_orcabus_id(contact_orcabus_id: str) -> Contact:
+    """
+    Get contact from the contact id
+    :param contact_orcabus_id:
+    :return:
+    """
+    params = {
+        "orcabusId": contact_orcabus_id.split(".")[1]
+    }
+
+    # Get contact
+    try:
+        query_result = get_metadata_request_response_results(CONTACT_ENDPOINT, params)
+        assert len(query_result) == 1
+        return query_result[0]
+    except (HTTPError, AssertionError):
+        raise ContactNotFoundError(
+            contact_orcabus_id=contact_orcabus_id,
+        )
+
+
+def get_contacts_list_from_contact_orcabus_id_list(contact_orcabus_id_list: List[str], accept_missing=False) -> List[Contact]:
+    # We have an internal id, convert to int
+    return list(map(
+        lambda contact_iter_: Contact(**contact_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=contact_orcabus_id_list,
+            item_identifier="orcabusId",
+            endpoint=CONTACT_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def coerce_contact_id_or_orcabus_id_to_contact_orcabus_id(id_: str) -> str:
+    if ORCABUS_ULID_REGEX_MATCH.match(id_):
+        return id_
+    else :
+        return get_contact_orcabus_id_from_contact_id(id_)
+
+
+def get_all_contacts() -> List[Contact]:
+    """
+    Get all subjects
+    :return:
+    """
+    return get_metadata_request_response_results(CONTACT_ENDPOINT)

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/metadata/errors.py

@@ -0,0 +1,104 @@
+# SampleNotFoundError
+from typing import Optional
+
+
+class SampleNotFoundError(Exception):
+    def __init__(
+            self,
+            sample_id: Optional[str] = None,
+            sample_orcabus_id: Optional[str] = None
+    ):
+        self.sample_id = sample_id
+        self.sample_orcabus_id = sample_orcabus_id
+        if sample_id is not None:
+            self.message = f"Could not find sample with id '{sample_id}'"
+        elif sample_orcabus_id is not None:
+            self.message = f"Could not find sample with OrcaBus ID '{sample_orcabus_id}'"
+        else:
+            self.message = "Could not find sample"
+        super().__init__(self.message)
+
+
+class SubjectNotFoundError(Exception):
+    def __init__(
+            self,
+            subject_id: Optional[str] = None,
+            subject_orcabus_id: Optional[str] = None
+    ):
+        self.subject_id = subject_id
+        self.subject_orcabus_id = subject_orcabus_id
+        if subject_id is not None:
+            self.message = f"Could not find subject with id '{subject_id}'"
+        elif subject_orcabus_id is not None:
+            self.message = f"Could not find subject with OrcaBus ID '{subject_orcabus_id}'"
+        else:
+            self.message = "Could not find subject"
+        super().__init__(self.message)
+
+
+class ProjectNotFoundError(Exception):
+    def __init__(
+            self,
+            project_id: Optional[str] = None,
+            project_orcabus_id: Optional[str] = None
+    ):
+        self.project_id = project_id
+        self.project_orcabus_id = project_orcabus_id
+        if project_id is not None:
+            self.message = f"Could not find project with id '{project_id}'"
+        elif project_orcabus_id is not None:
+            self.message = f"Could not find project with OrcaBus ID '{project_orcabus_id}'"
+        else:
+            self.message = "Could not find project"
+        super().__init__(self.message)
+
+
+class IndividualNotFoundError(Exception):
+    def __init__(
+            self,
+            individual_id: Optional[str] = None,
+            individual_orcabus_id: Optional[str] = None
+    ):
+        self.individual_id = individual_id
+        self.individual_orcabus_id = individual_orcabus_id
+        if individual_id is not None:
+            self.message = f"Could not find individual with id '{individual_id}'"
+        elif individual_orcabus_id is not None:
+            self.message = f"Could not find individual with OrcaBus ID '{individual_orcabus_id}'"
+        else:
+            self.message = "Could not find individual"
+        super().__init__(self.message)
+
+
+class LibraryNotFoundError(Exception):
+    def __init__(
+            self,
+            library_id: Optional[str] = None,
+            library_orcabus_id: Optional[str] = None
+    ):
+        self.library_id = library_id
+        self.library_orcabus_id = library_orcabus_id
+        if library_id is not None:
+            self.message = f"Could not find library with id '{library_id}'"
+        elif library_orcabus_id is not None:
+            self.message = f"Could not find library with OrcaBus ID '{library_orcabus_id}'"
+        else:
+            self.message = "Could not find library"
+        super().__init__(self.message)
+
+
+class ContactNotFoundError(Exception):
+    def __init__(
+            self,
+            contact_id: Optional[str] = None,
+            contact_orcabus_id: Optional[str] = None
+    ):
+        self.contact_id = contact_id
+        self.contact_orcabus_id = contact_orcabus_id
+        if contact_id is not None:
+            self.message = f"Could not find contact with id '{contact_id}'"
+        elif contact_orcabus_id is not None:
+            self.message = f"Could not find contact with OrcaBus ID '{contact_orcabus_id}'"
+        else:
+            self.message = "Could not find contact"
+        super().__init__(self.message)

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/metadata/globals.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+import re
+
+# AWS PARAMETERS
+METADATA_SUBDOMAIN_NAME = "metadata"
+
+# API ENDPOINTS
+LIBRARY_ENDPOINT = "api/v1/library"
+SAMPLE_ENDPOINT = "api/v1/sample"
+SUBJECT_ENDPOINT = "api/v1/subject"
+PROJECT_ENDPOINT = "api/v1/project"
+INDIVIDUAL_ENDPOINT = "api/v1/individual"
+CONTACT_ENDPOINT = "api/v1/contact"
+
+ORCABUS_ULID_REGEX_MATCH = re.compile(r'^(?:[a-z0-9]{3}\.)?[A-Z0-9]{26}$')

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/metadata/individual_helpers.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+
+"""
+This module contains helper functions for the individual class.
+"""
+
+# Standard imports
+from typing import List
+from requests import HTTPError
+from functools import reduce
+from operator import concat
+
+# Local imports
+from . import get_metadata_request_response_results, get_item_objs_from_item_id_list
+from .models import Individual, LibraryDetail
+from .errors import IndividualNotFoundError
+from .globals import INDIVIDUAL_ENDPOINT, ORCABUS_ULID_REGEX_MATCH
+
+
+def get_individual_from_individual_id(individual_id: str) -> Individual:
+    """
+    Get individual from the individual id
+    :param individual_id:
+    :return:
+    """
+    # We have an internal id
+    params = {
+        "individual_id": individual_id
+    }
+
+    # Get individual
+    try:
+        query_results = get_metadata_request_response_results(INDIVIDUAL_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError):
+        raise IndividualNotFoundError(
+            individual_id=individual_id
+        )
+
+
+def get_individuals_list_from_individual_id_list(individual_id_list: List[str], accept_missing=False) -> List[Individual]:
+    """
+    Get individual from the individual id list
+    :param accept_missing:
+    :param individual_id_list:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda individual_iter_: Individual(**individual_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=individual_id_list,
+            item_identifier="individualId",
+            endpoint=INDIVIDUAL_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_individual_orcabus_id_from_individual_id(individual_id: str) -> str:
+    return get_individual_from_individual_id(individual_id)["orcabusId"]
+
+
+def get_individual_from_individual_orcabus_id(individual_orcabus_id: str) -> Individual:
+    """
+    Get individual from the individual id
+    :param individual_orcabus_id:
+    :return:
+    """
+    # We have an internal id
+    params = {
+        "orcabus_id": individual_orcabus_id
+    }
+
+    # Get individual
+    try:
+        query_results = get_metadata_request_response_results(INDIVIDUAL_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError):
+        raise IndividualNotFoundError(
+            individual_orcabus_id=individual_orcabus_id
+        )
+
+
+def get_individuals_list_from_individual_orcabus_id_list(individual_orcabus_id_list: List[str], accept_missing=False) -> List[Individual]:
+    """
+    Get individual from the individual id list
+    :param accept_missing:
+    :param individual_orcabus_id_list:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda individual_iter_: Individual(**individual_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=individual_orcabus_id_list,
+            item_identifier="orcabusId",
+            endpoint=INDIVIDUAL_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def coerce_individual_id_or_orcabus_id_to_individual_orcabus_id(id_: str) -> str:
+    if ORCABUS_ULID_REGEX_MATCH.match(id_):
+        return id_
+    else :
+        return get_individual_orcabus_id_from_individual_id(id_)
+
+
+def get_all_individuals():
+    """
+    Get all samples from the sample database
+    :return:
+    """
+    return get_metadata_request_response_results(INDIVIDUAL_ENDPOINT)
+
+
+def list_libraries_in_individual(individual_orcabus_id: str) -> List[LibraryDetail]:
+    """
+    Given an individual id, return all the libraries associated with the individual
+    First we need to collect all subjects associated with the individual
+    Then we need to collect all libraries associated with the subjects
+
+    :param individual_orcabus_id:
+    :return:
+    """
+    from .subject_helpers import list_libraries_in_subject
+    return list(reduce(
+        concat,
+        list(map(
+            # For each subject, get libraries in subject
+            lambda subject_iter_: list_libraries_in_subject(subject_iter_['orcabusId']),
+            # Get list of subject orcabus ids
+            get_individual_from_individual_orcabus_id(individual_orcabus_id)["subjectSet"]
+        ))
+    ))