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

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

@@ -0,0 +1,196 @@
+#!/usr/bin/env python
+from typing import Union, List
+
+from requests import HTTPError
+
+from .globals import LIBRARY_ENDPOINT, ORCABUS_ULID_REGEX_MATCH
+from .models import Library, Subject
+from . import get_metadata_request_response_results, get_item_objs_from_item_id_list
+from .errors import LibraryNotFoundError
+
+
+def get_library_from_library_id(library_id: str) -> Library:
+    """
+    Get library from the library id
+    :param library_id:
+    :return:
+    """
+    # Get library id
+    # We have an internal id, convert to int
+    params = {
+        "library_id": library_id
+    }
+
+    # Get library
+    try:
+        query_results = get_metadata_request_response_results(LIBRARY_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError) as e:
+        raise LibraryNotFoundError(
+            library_id=library_id,
+        )
+
+
+def get_libraries_list_from_library_id_list(library_id_list: List[str], accept_missing: bool = False) -> List[Library]:
+    # We have an internal id, convert to int
+    return list(map(
+        lambda library_iter_: Library(**library_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=library_id_list,
+            item_identifier="libraryId",
+            endpoint=LIBRARY_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_library_orcabus_id_from_library_id(library_id: str) -> str:
+    """
+    Get library from the library id
+    :param library_id:
+    :return:
+    """
+    # Get library id
+    return get_library_from_library_id(library_id)['orcabusId']
+
+
+def get_library_id_from_library_orcabus_id(library_id: str) -> str:
+    """
+    Get library from the library id
+    :param library_id:
+    :return:
+    """
+    # Get library id
+    return get_library_from_library_orcabus_id(library_id)['libraryId']
+
+
+def coerce_library_id_or_orcabus_id_to_library_orcabus_id(id_: str) -> str:
+    if ORCABUS_ULID_REGEX_MATCH.match(id_):
+        return id_
+    else :
+        return get_library_orcabus_id_from_library_id(id_)
+
+
+def get_library_from_library_orcabus_id(library_orcabus_id: str) -> Library:
+    """
+    Get library from the library id
+    :param library_orcabus_id:
+    :return:
+    """
+    # Get library id
+    # We have an internal id, convert to int
+    params = {
+        "orcabus_id": library_orcabus_id
+    }
+
+    # Get library
+    try:
+        query_list = get_metadata_request_response_results(LIBRARY_ENDPOINT, params)
+        assert len(query_list) == 1
+        return query_list[0]
+    except (HTTPError, AssertionError) as e:
+        raise LibraryNotFoundError(
+            library_orcabus_id=library_orcabus_id,
+        )
+
+
+def get_libraries_from_library_orcabus_id_list(library_orcabus_id_list: List[str], accept_missing: bool = False) -> List[Library]:
+    # We have an internal id, convert to int
+    return list(map(
+        lambda library_iter_: Library(**library_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=library_orcabus_id_list,
+            item_identifier="orcabusId",
+            endpoint=LIBRARY_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_subject_from_library_id(library_id: str) -> Subject:
+    """
+    Given a library id, collect the subject id
+    :param library_id:
+    :return:
+    """
+    from .subject_helpers import get_subject_from_subject_orcabus_id
+
+    # Get the subject linked to this library id
+    subject_orcabus_id = get_library_from_library_id(library_id)["subject"]["orcabusId"]
+
+    return get_subject_from_subject_orcabus_id(subject_orcabus_id)
+
+
+def get_library_type(library_id: str) -> Union[str | None]:
+    """
+    Given a library id, collect the library id type
+    :param library_id:
+    :return:
+    """
+    library = get_library_from_library_id(library_id)
+
+    return library.get("type")
+
+
+def get_library_assay_type(library_id: str) -> Union[str | None]:
+    """
+    Given a library id, collect the library assay type
+    :param library_id:
+    :return:
+    """
+    library = get_library_from_library_id(library_id)
+
+    return library.get("assay")
+
+
+def get_library_phenotype(library_id: str) -> Union[str | None]:
+    """
+    Given a library id, collect the library phenotype
+    :param library_id:
+    :return:
+    """
+    library = get_library_from_library_id(library_id)
+
+    return library.get("phenotype")
+
+
+def get_library_workflow(library_id: str) -> Union[str | None]:
+    """
+    Given a library id, collect the library workflow
+    :param library_id:
+    :return:
+    """
+    library = get_library_from_library_id(library_id)
+
+    return library.get("workflow")
+
+
+# def get_library_project_owner(library_id: str) -> Union[str | None]:
+#     """
+#     Given a library id, collect the library project owner
+#     :param library_id:
+#     :return:
+#     """
+#     library = get_library_from_library_id(library_id)
+#
+#     return library.get("projectOwner")
+#
+#
+# def get_library_project_name(library_id: str) -> Union[str | None]:
+#     """
+#     Given a library id, collect the library workflow
+#     :param library_id:
+#     :return:
+#     """
+#     library = get_library_from_library_id(library_id)
+#
+#     return library.get("projectName")
+
+
+def get_all_libraries() -> List[Library]:
+    """
+    Collect all libraries from the database
+    :return:
+    """
+    return get_metadata_request_response_results(LIBRARY_ENDPOINT)

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

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+"""
+Custom helpers, for use in generating a 'lims row' given a library id
+"""
+from .models import LimsRow
+
+
+def generate_lims_row(library_id: str, instrument_run_id: str) -> LimsRow:
+    """
+    Generate a 'lims row' given a library id, we return the following:
+    """
+    from .library_helpers import get_library_from_library_id
+    from .subject_helpers import get_subject_from_subject_orcabus_id
+    from .individual_helpers import get_individual_from_individual_orcabus_id
+    from .project_helpers import get_project_from_project_orcabus_id
+    from .sample_helpers import get_sample_from_sample_orcabus_id
+
+    library_obj = get_library_from_library_id(library_id)
+    sample_obj = get_sample_from_sample_orcabus_id(library_obj['sample']['orcabusId'])
+    subject_obj = get_subject_from_subject_orcabus_id(library_obj['subject']['orcabusId'])
+    individual_obj = get_individual_from_individual_orcabus_id(subject_obj['individualSet'][0]['orcabusId'])
+    project_obj = get_project_from_project_orcabus_id(library_obj['projectSet'][0]['orcabusId'])
+
+    return {
+        'externalSubjectId': subject_obj['subjectId'],
+        'externalSampleId': sample_obj['externalSampleId'],
+        'individualId': individual_obj['individualId'],
+        'sampleId': sample_obj['sampleId'],
+        'libraryId': library_obj['libraryId'],
+        'instrumentRunId': instrument_run_id,
+        'projectName': project_obj['projectId'],
+        'sampleType': library_obj['type'],
+        'assay': library_obj['assay'],
+        'phenotype': library_obj['phenotype'],
+    }

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

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+
+from typing import (
+    TypedDict,
+    Optional, List
+)
+
+
+# Base Objects
+class MetadataBase(TypedDict):
+    orcabusId: str
+
+
+class LibraryBase(MetadataBase):
+    libraryId: str
+
+
+class SampleBase(MetadataBase):
+    sampleId: str
+
+
+class SubjectBase(MetadataBase):
+    subjectId: str
+
+
+class IndividualBase(MetadataBase):
+    individualId: str
+
+
+class ProjectBase(MetadataBase):
+    projectId: str
+
+
+class ContactBase(MetadataBase):
+    contactId: str
+
+
+# Detailed Objects - Often outputs of API calls from other metadata endpoints
+class LibraryDetail(LibraryBase):
+    phenotype: Optional[str]
+    workflow: Optional[str]
+    quality: Optional[str]
+    type: Optional[str]
+    assay: Optional[str]
+    coverage: Optional[float]
+    overrideCycles: Optional[str]
+
+
+class SampleDetail(SampleBase):
+    externalSampleId: Optional[str]
+    source: Optional[str]
+
+
+class SubjectDetail(SubjectBase):
+    pass
+
+
+class IndividualDetail(IndividualBase):
+    source: Optional[str]
+
+
+class ProjectDetail(ProjectBase):
+    name: Optional[str]
+    description: Optional[str]
+
+
+class ContactDetail(ContactBase):
+    name: Optional[str]
+    email: Optional[str]
+    description: Optional[str]
+
+
+# Add complete objects
+# These contain the sets of other metadata objects
+class Library(LibraryDetail):
+    sample: Optional[SampleDetail]
+    subject: Optional[SubjectDetail]
+    projectSet: Optional[List[ProjectDetail]]
+
+
+class Sample(SampleDetail):
+    librarySet: Optional[List[LibraryDetail]]
+
+
+class Subject(SubjectDetail):
+    librarySet: Optional[List[LibraryDetail]]
+    individualSet: Optional[List[IndividualDetail]]
+
+
+class Individual(IndividualDetail):
+    subjectSet: Optional[List[SubjectDetail]]
+
+
+class Project(ProjectDetail):
+    contactSet: Optional[List[ContactDetail]]
+
+
+class Contact(ContactDetail):
+    projectSet: Optional[List[ProjectDetail]]
+
+
+class LimsRow(TypedDict):
+    externalSubjectId: Optional[str]
+    externalSampleId: Optional[str]
+    individualId: Optional[str]
+    sampleId: Optional[str]
+    libraryId: Optional[str]
+    instrumentRunId: Optional[str]
+    projectName: Optional[str]
+    sampleType: Optional[str]
+    assay: Optional[str]
+    phenotype: Optional[str]

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

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+
+"""
+Helpers for using the project 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 .errors import ProjectNotFoundError
+from .globals import PROJECT_ENDPOINT, LIBRARY_ENDPOINT, ORCABUS_ULID_REGEX_MATCH
+from .models import Project, Library
+
+
+
+def get_project_from_project_id(project_id: str) -> Project:
+    """
+    Get project from the project id
+    :param project_id:
+    :return:
+    """
+    # We have an internal id, convert to int
+    params = {
+        "projectId": project_id
+    }
+
+    # Get project
+    try:
+        query_results = get_metadata_request_response_results(PROJECT_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError) as e:
+        raise ProjectNotFoundError(
+            project_id=project_id,
+        )
+
+
+def get_projects_list_from_project_id_list(project_id_list: List[str], accept_missing: bool = False) -> List[Project]:
+    """
+    Get project from the project id
+    :param project_id:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda project_iter_: Project(**project_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=project_id_list,
+            item_identifier="projectId",
+            endpoint=PROJECT_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_project_orcabus_id_from_project_id(project_id: str) -> str:
+    return get_project_from_project_id(project_id)["orcabusId"]
+
+
+def coerce_project_id_or_orcabus_id_to_project_orcabus_id(id_: str) -> str:
+    if ORCABUS_ULID_REGEX_MATCH.match(id_):
+        return id_
+    else :
+        return get_project_orcabus_id_from_project_id(id_)
+
+
+def get_project_from_project_orcabus_id(project_orcabus_id: str) -> Project:
+    """
+    Get project from the project id
+    :param project_orcabus_id:
+    :return:
+    """
+    params = {
+        "orcabusId": project_orcabus_id.split(".")[1]
+    }
+
+    # Get project
+    try:
+        query_results = get_metadata_request_response_results(PROJECT_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError) as e:
+        raise ProjectNotFoundError(
+            project_id=project_orcabus_id,
+        )
+
+
+def get_projects_list_from_project_orcabus_id_list(project_orcabus_id_list: List[str], accept_missing: bool = False) -> List[Project]:
+    """
+    Get project from the project id
+    :param project_id:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda project_iter_: Project(**project_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=project_orcabus_id_list,
+            item_identifier="orcabusId",
+            endpoint=PROJECT_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_all_projects() -> List[Project]:
+    """
+    Get all projects
+    :return:
+    """
+    return get_metadata_request_response_results(PROJECT_ENDPOINT)
+
+
+def list_libraries_in_project(project_orcabus_id: str) -> List[Library]:
+    """
+    List all libraries in a project
+    Use the projectSet__orcabusId query
+
+    :return:
+    """
+    params = {
+        "projectSet__orcabusId": project_orcabus_id
+    }
+
+    return get_metadata_request_response_results(LIBRARY_ENDPOINT, params)

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

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+
+
+# !/usr/bin/env python3
+
+
+"""
+Helper functions for a subject
+"""
+
+# Standard imports
+from typing import List
+from requests.exceptions import HTTPError
+
+# Local imports
+from . import get_metadata_request_response_results, get_item_objs_from_item_id_list
+from .errors import SampleNotFoundError
+from .globals import SAMPLE_ENDPOINT, ORCABUS_ULID_REGEX_MATCH
+from .models import Sample, LibraryDetail
+
+
+
+def get_sample_from_sample_id(sample_id: str) -> Sample:
+    """
+    Get sample from the sample id
+    :param sample_id:
+    :return:
+    """
+    # We have an internal id
+    params = {
+        "sampleId": sample_id
+    }
+
+    # Get sample
+    try:
+        query_results = get_metadata_request_response_results(SAMPLE_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError):
+        raise SampleNotFoundError(
+            sample_id=sample_id
+        )
+
+
+def get_samples_list_from_sample_id_list(sample_id_list: List[str], accept_missing: bool = False) -> List[Sample]:
+    """
+    Get sample from the sample id
+    :param sample_id:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda sample_iter_: Sample(**sample_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=sample_id_list,
+            item_identifier="sampleId",
+            endpoint=SAMPLE_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def get_sample_orcabus_id_from_sample_id(sample_id: str) -> str:
+    return get_sample_from_sample_id(sample_id)["orcabusId"]
+
+
+def get_sample_from_sample_orcabus_id(sample_orcabus_id: str) -> Sample:
+    """
+    Get sample from the sample id
+    :param sample_orcabus_id:
+    :return:
+    """
+    # We have an internal id
+    params = {
+        "orcabusId": sample_orcabus_id
+    }
+
+    # Get sample
+    try:
+        query_results = get_metadata_request_response_results(SAMPLE_ENDPOINT, params)
+        assert len(query_results) == 1
+        return query_results[0]
+    except (HTTPError, AssertionError):
+        raise SampleNotFoundError(
+            sample_orcabus_id=sample_orcabus_id
+        )
+
+
+def get_samples_list_from_sample_orcabus_id_list(sample_orcabus_id_list: List[str], accept_missing: bool = False) -> List[Project]:
+    """
+    Get sample from the sample id
+    :param sample_id:
+    :return:
+    """
+    # We have an internal id, convert to int
+    return list(map(
+        lambda sample_iter_: Sample(**sample_iter_),
+        get_item_objs_from_item_id_list(
+            item_id_list=sample_orcabus_id_list,
+            item_identifier="orcabusId",
+            endpoint=SAMPLE_ENDPOINT,
+            accept_missing=accept_missing
+        )
+    ))
+
+
+def coerce_sample_id_or_orcabus_id_to_sample_orcabus_id(id_: str) -> str:
+    if ORCABUS_ULID_REGEX_MATCH.match(id_):
+        return id_
+    else :
+        return get_sample_orcabus_id_from_sample_id(id_)
+
+
+def list_libraries_in_sample(sample_orcabus_id: str) -> List[LibraryDetail]:
+    """
+    Given a sample id, return the list of library objects in the sample
+    :param sample_orcabus_id:
+    :return:
+    """
+    # Get ID For Subject
+    sample = get_sample_from_sample_orcabus_id(sample_orcabus_id)
+
+    # Get the sample
+    return sample.get("librarySet", [])
+
+
+def get_all_samples():
+    """
+    Get all samples from the sample database
+    :return:
+    """
+    return get_metadata_request_response_results(SAMPLE_ENDPOINT)