nmdc-runtime 2.8.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

nmdc_runtime/api/models/util.py

@@ -0,0 +1,253 @@
+from typing import TypeVar, List, Optional, Generic, Annotated
+
+from pydantic import model_validator, Field, BaseModel
+
+ResultT = TypeVar("ResultT")
+
+
+class ListResponse(BaseModel, Generic[ResultT]):
+    resources: List[ResultT]
+    next_page_token: Optional[str] = None
+
+
+class ListRequest(BaseModel):
+    r"""
+    An encapsulation of a set of parameters accepted by API endpoints related to listing things.
+
+    Note: This class was documented after the `FindRequest` class was documented. You can refer to the documentation of
+          the latter class for additional context about the usage of Pydantic's `Field` constructor in this class.
+    """
+
+    filter: Optional[str] = Field(
+        default=None,
+        title="Filter",
+        description="""The criteria by which you want to filter the resources, in the same format as the [`query`
+                    parameter](https://www.mongodb.com/docs/manual/reference/method/db.collection.find/#std-label-method-find-query)
+                    of MongoDB's `db.collection.find()` method.\n\n_Example:_
+                    `{"lat_lon.latitude": {"$gt": 45.0}, "ecosystem_category": "Plants"}`""",
+        examples=[
+            r'{"ecosystem_type": "Freshwater"}',
+            r'{"lat_lon.latitude": {"$gt": 45.0}, "ecosystem_category": "Plants"}',
+        ],
+    )
+    # TODO: Document why the optional type here is `int` as opposed to `PerPageRange` (`FindRequest` uses the latter).
+    max_page_size: Optional[int] = Field(
+        default=20,
+        title="Resources per page",
+        description="How many resources you want _each page_ to contain, formatted as a positive integer.",
+        examples=[20],
+    )
+    page_token: Optional[str] = Field(
+        default=None,
+        title="Next page token",
+        description="""A bookmark you can use to fetch the _next_ page of resources. You can get this from the
+                    `next_page_token` field in a previous response from this endpoint.\n\n_Example_: 
+                    `nmdc:sys0zr0fbt71`""",
+        examples=[
+            "nmdc:sys0zr0fbt71",
+        ],
+    )
+    # TODO: Document the endpoint's behavior when a projection includes a _nested_ field identifier (i.e. `foo.bar`),
+    #       and ensure the endpoint doesn't break when the projection includes field descriptors that contain commas.
+    projection: Optional[str] = Field(
+        default=None,
+        title="Projection",
+        description="""Comma-delimited list of the names of the fields you want the resources in the response to
+                    include. Note: In addition to those fields, the response will also include the `id`
+                    field.\n\n_Example_: `name, ecosystem_type`""",
+        examples=[
+            "name, ecosystem_type",
+        ],
+    )
+
+
+PerPageRange = Annotated[int, Field(gt=0, le=2_000)]
+
+
+class FindRequest(BaseModel):
+    r"""
+    An encapsulation of a set of parameters accepted by API endpoints related to finding things.
+
+    Notes:
+    - The "Query Parameter Models" section of the FastAPI docs says that this way of encapsulating
+      a set of query parameter definitions in a Pydantic model — so that Swagger UI displays a given
+      parameter's _description_ — was introduced in FastAPI 0.115.0.
+      Reference: https://fastapi.tiangolo.com/tutorial/query-param-models/
+    - While Swagger UI does show the parameter's _description_, specifically, it does not currently show the
+      parameter's _title_ or example value(s). The approach shown in the "Classes as Dependencies" section
+      of the FastAPI docs (i.e. https://fastapi.tiangolo.com/tutorial/dependencies/classes-as-dependencies/)
+      does result in Swagger UI showing those additional things, but the approach involves not inheriting
+      from Pydantic's `BaseModel` class and involves defining an `__init__` method for the class. That is
+      further than I want to take these classes from their existing selves at this point. To compensate
+      for that, I have included examples _within_ some of the descriptions.
+      Reference: https://github.com/fastapi/fastapi/issues/318#issuecomment-507043221
+    - The "Fields" section of the Pydantic docs says:
+      > "The `Field` function is used to customize and add metadata to fields of models."
+      References: https://docs.pydantic.dev/latest/concepts/fields/
+    """
+
+    filter: Optional[str] = Field(
+        default=None,
+        title="Filter",
+        description="""The criteria by which you want to filter the resources, formatted as a comma-separated list of
+                    `attribute:value` pairs. The `value` can include a comparison operator (e.g. `>=`). If the attribute
+                    is of type _string_ and you append `.search` to its name, the server will perform a full-text
+                    search.\n\n_Example:_ `ecosystem_category:Plants, lat_lon.latitude:>35.0`""",
+        examples=[
+            "ecosystem_category:Plants",
+            "ecosystem_category:Plants, lat_lon.latitude:>35.0",
+        ],
+    )
+    search: Optional[str] = Field(
+        default=None,
+        title="Search",
+        description="N/A _(not implemented yet)_",
+    )
+    sort: Optional[str] = Field(
+        default=None,
+        title="Sort",
+        description="""How you want the resources to be ordered in the response, formatted as a comma-separated list of
+                    `attribute:value` pairs. Each `attribute` is the name of a field you want the resources to be
+                    ordered by, and each `value` is the direction you want the values in that field to be ordered
+                    (i.e. `asc` or no value for _ascending_ order, and `desc` for _descending_ order).\n\n_Example:_
+                    `depth.has_numeric_value:desc, ecosystem_type`""",
+        examples=[
+            "depth.has_numeric_value:desc",
+            "depth.has_numeric_value:desc, ecosystem_type",
+        ],
+    )
+    page: Optional[int] = Field(
+        default=None,
+        title="Page number",
+        description="""_Which page_ of resources you want to retrieve, when using page number-based pagination.
+                    This is the page number formatted as an integer ≥ 1.""",
+        examples=[1],
+    )
+    per_page: Optional[PerPageRange] = Field(
+        default=25,
+        title="Resources per page",
+        description="How many resources you want _each page_ to contain, formatted as a positive integer ≤ 2000.",
+        examples=[25],
+    )
+    cursor: Optional[str] = Field(
+        default=None,
+        title="Cursor",
+        description="""A bookmark you can use to fetch the _next_ page of resources, when using cursor-based pagination.
+                    To use cursor-based pagination, set the `cursor` parameter to `*`. The response's `meta` object will
+                    include a `next_cursor` field, whose value can be used as the `cursor` parameter in a subsequent
+                    request.\n\n_Example_: `nmdc:sys0zr0fbt71`""",
+        examples=[
+            "*",
+            "nmdc:sys0zr0fbt71",
+        ],
+    )
+    group_by: Optional[str] = Field(
+        default=None,
+        title="Group by",
+        description="N/A _(not implemented yet)_",
+    )
+    fields: Optional[str] = Field(
+        default=None,
+        title="Fields",
+        description="""The fields you want the resources to include in the response, formatted as a comma-separated list
+                    of field names. This can be used to reduce the size and complexity of the response.\n\n_Example:_
+                    `name, ess_dive_datasets`""",
+        examples=[
+            "name",
+            "name, ess_dive_datasets",
+        ],
+    )
+
+    # Reference: https://docs.pydantic.dev/latest/concepts/validators/#model-validators
+    @model_validator(mode="before")
+    def set_page_if_cursor_unset(cls, values):
+        page, cursor = values.get("page"), values.get("cursor")
+        if page is not None and cursor is not None:
+            raise ValueError("cannot use cursor- and page-based pagination together")
+        if page is None and cursor is None:
+            values["page"] = 1
+        return values
+
+
+class FindResponse(BaseModel):
+    meta: dict
+    results: List[dict]
+    group_by: List[dict]
+
+
+class DeleteResponse(BaseModel):
+    r"""
+    Response model for "delete" operations. It summarizes the result of the
+    operation and it lists identifiers of the documents that were deleted.
+    """
+
+    message: str = Field(
+        description="Success message describing the deletion operation"
+    )
+    deleted_workflow_execution_ids: List[str] = Field(
+        # Note: `default_factory=list` sets this to an empty list by default.
+        default_factory=list,
+        description="The `id`s of the `WorkflowExecution`s that were deleted",
+    )
+    deleted_data_object_ids: List[str] = Field(
+        default_factory=list,
+        description="The `id`s of the `DataObject`s that were deleted",
+    )
+    deleted_functional_annotation_agg_oids: List[str] = Field(
+        default_factory=list,
+        description="The internal MongoDB `ObjectId`s of the `FunctionalAnnotationAggMember`s that were deleted",
+    )
+    deleted_job_ids: List[str] = Field(
+        default_factory=list,
+        description="The `id`s of the `jobs` documents that were deleted",
+    )
+
+
+# Note: For MongoDB, a single collection can have no more than 64 indexes
+# Note: Each collection has a unique index set on "id" elsewhere.
+entity_attributes_to_index = {
+    "biosample_set": {
+        "alternative_identifiers",
+        "env_broad_scale.has_raw_value",
+        "env_local_scale.has_raw_value",
+        "env_medium.has_raw_value",
+        "collection_date.has_raw_value",
+        "ecosystem",
+        "ecosystem_category",
+        "ecosystem_type",
+        "ecosystem_subtype",
+        "specific_ecosystem",
+        # Note: if `lat_lon` was GeoJSON, i.e. {type,coordinates}, MongoDB has a "2dsphere" index
+        "lat_lon.latitude",
+        "lat_lon.longitude",
+    },
+    "study_set": {
+        "has_credit_associations.applied_roles",
+        "has_credit_associations.applies_to_person.name",
+        "has_credit_associations.applies_to_person.orcid",
+    },
+    "data_object_set": {
+        "data_object_type",
+        "file_size_bytes",
+        "md5_checksum",
+        "url",
+    },
+    # TODO: Refrain from ensuring indexes exist in the `omics_processing_set` collection,
+    #       since that collection was deleted as part of the "Berkeley schema" refactor.
+    #       Reference: https://microbiomedata.github.io/nmdc-schema/v10-vs-v11-retrospective/#slots-removed-from-database
+    "omics_processing_set": {
+        "has_input",
+        "has_output",
+        "instrument_name",
+        "alternative_identifiers",
+    },
+    "functional_annotation_agg": {"was_generated_by"},
+    "workflow_execution_set": {
+        "has_input",
+        "has_output",
+    },
+    # Note: The `jobs` collection is not described by the NMDC schema.
+    "jobs": {
+        "config.activity_id",
+    },
+}

nmdc_runtime/api/models/workflow.py

@@ -0,0 +1,15 @@
+import datetime
+from typing import Optional, List
+
+from pydantic import BaseModel
+
+
+class WorkflowBase(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    capability_ids: Optional[List[str]] = None
+
+
+class Workflow(WorkflowBase):
+    id: str
+    created_at: Optional[datetime.datetime] = None

nmdc_runtime/api/openapi.py

@@ -0,0 +1,242 @@
+r"""
+This module contains the definitions of constants and functions related to
+generating the API's OpenAPI schema (a.k.a. Swagger schema).
+
+References:
+- FastAPI Documentation: https://fastapi.tiangolo.com/tutorial/metadata/
+
+Notes:
+- The tag descriptions in this file were cut/pasted from `nmdc_runtime/api/main.py`.
+  Now that they are in a separate module, we will be able to edit them more easily.
+"""
+
+from html import escape
+from typing import List, Dict
+
+# Mapping from tag names to their (Markdown-formatted) descriptions.
+tag_descriptions: Dict[str, str] = {}
+
+tag_descriptions[
+    "sites"
+] = r"""
+A site corresponds to a physical place that may participate in job execution.
+
+A site may register data objects and capabilities with NMDC. It may claim jobs to execute, and it may
+update job operations with execution info.
+
+A site must be able to service requests for any data objects it has registered.
+
+A site may expose a "put object" custom method for authorized users. This method facilitates an
+operation to upload an object to the site and have the site register that object with the runtime
+system.
+"""
+
+tag_descriptions[
+    "workflows"
+] = r"""
+A workflow is a template for creating jobs.
+
+Workflow jobs are typically created by the system via trigger associations between
+workflows and object types. A workflow may also require certain capabilities of sites
+in order for those sites to claim workflow jobs.
+"""
+
+tag_descriptions[
+    "users"
+] = r"""
+Endpoints for user identification.
+
+Currently, accounts for use with the Runtime API are created manually by system administrators.
+"""
+
+tag_descriptions[
+    "capabilities"
+] = r"""
+A workflow may require an executing site to have particular capabilities.
+
+These capabilities go beyond the simple ability to access the data object resources registered with
+the runtime system. Sites register their capabilities, and sites are only able to claim workflow
+jobs if they are known to have the capabilities required by the workflow.
+"""
+
+tag_descriptions[
+    "object types"
+] = r"""
+An object type is an object annotation that is useful for triggering workflows.
+
+A data object may be annotated with one or more types, which in turn can be associated with
+workflows through trigger resources.
+
+The data-object type system may be used to trigger workflow jobs on a subset of data objects when a
+new version of a workflow is deployed. This could be done by minting a special object type for the
+occasion, annotating the subset of data objects with that type, and registering the association of
+object type to workflow via a trigger resource.
+"""
+
+tag_descriptions[
+    "triggers"
+] = r"""
+A trigger is an association between a workflow and a data object type.
+
+When a data object is annotated with a type, perhaps shortly after object registration, the NMDC
+Runtime will check, via trigger associations, for potential new jobs to create for any workflows.
+"""
+
+tag_descriptions[
+    "jobs"
+] = r"""
+A job is a resource that isolates workflow configuration from execution.
+
+Rather than directly creating a workflow operation by supplying a workflow ID along with
+configuration, NMDC creates a job that pairs a workflow with configuration. Then, a site can claim a
+job ID, allowing the site to execute the intended workflow without additional configuration.
+
+A job can have multiple executions, and a workflow's executions are precisely the executions of all
+jobs created for that workflow.
+
+A site that already has a compatible job execution result can preempt the unnecessary creation of a
+job by pre-claiming it. This will return like a claim, and now the site can register known data
+object inputs for the job without the risk of the runtime system creating a claimable job of the
+pre-claimed type.
+"""
+
+tag_descriptions[
+    "objects"
+] = r"""
+A [Data Repository Service (DRS)
+object](https://ga4gh.github.io/data-repository-service-schemas/preview/release/drs-1.1.0/docs/#_drs_datatypes)
+represents content necessary for a workflow job to execute, and/or output from a job execution.
+
+An object may be a *blob*, analogous to a file, or a *bundle*, analogous to a folder. Sites register
+objects, and sites must ensure that these objects are accessible to the NMDC data broker.
+
+An object may be associated with one or more object types, useful for triggering workflows.
+"""
+
+tag_descriptions[
+    "operations"
+] = r"""
+An operation is a resource for tracking the execution of a job.
+
+When a job is claimed by a site for execution, an operation resource is created.
+
+An operation is akin to a "promise" or "future" in that it should eventually resolve to either a
+successful result, i.e. an execution resource, or to an error.
+
+An operation is parameterized to return a result type, and a metadata type for storing progress
+information, that are both particular to the job type.
+
+Operations may be paused, resumed, and/or cancelled.
+
+Operations may expire, i.e. not be stored indefinitely. In this case, it is recommended that
+execution resources have longer lifetimes / not expire, so that information about successful results
+of operations are available.
+"""
+
+tag_descriptions[
+    "queries"
+] = r"""
+A query is an operation (find, update, etc.) against the metadata store.
+
+Metadata -- for studies, biosamples, omics processing, etc. -- is used by sites to execute jobs,
+as the parameterization of job executions may depend not only on the content of data objects, but
+also on objects' associated metadata.
+
+Also, the function of many workflows is to extract or produce new metadata. Such metadata products
+should be registered as data objects, and they may also be supplied by sites to the runtime system
+as an update query (if the latter is not done, the runtime system will sense the new metadata and
+issue an update query).
+"""
+
+tag_descriptions[
+    "metadata"
+] = r"""
+The [metadata endpoints](https://api.microbiomedata.org/docs#/metadata) can be used to get and filter
+metadata from collection set types (including 
+[studies](https://w3id.org/nmdc/Study/), 
+[biosamples](https://w3id.org/nmdc/Biosample/), 
+[planned processes](https://w3id.org/nmdc/PlannedProcess/), and 
+[data objects](https://w3id.org/nmdc/DataObject/) 
+as discussed in the __find__ section).
+<br/>
+ 
+The __metadata__ endpoints allow users to retrieve metadata from the data portal using the various
+GET endpoints  that are slightly different than the __find__ endpoints, but some can be used similarly.
+As with the __find__ endpoints,  parameters for the __metadata__ endpoints that do not have a
+red ___* required___ next to them are optional. <br/>
+
+Unlike the compact syntax used in the __find__  endpoints, the syntax for the filter parameter of
+the metadata endpoints
+uses [MongoDB-like language querying](https://www.mongodb.com/docs/manual/tutorial/query-documents/).
+"""
+
+tag_descriptions[
+    "find"
+] = r"""
+The [find endpoints](https://api.microbiomedata.org/docs#/find) are provided with NMDC metadata entities
+already specified - where metadata about [studies](https://w3id.org/nmdc/Study),
+[biosamples](https://w3id.org/nmdc/Biosample), [data objects](https://w3id.org/nmdc/DataObject/),
+and [planned processes](https://w3id.org/nmdc/PlannedProcess/) can be retrieved using GET requests.
+<br/>
+
+Each endpoint is unique and requires the applicable attribute names to be known in order to structure a query
+in a meaningful way.  Parameters that do not have a red ___* required___ label next to them are optional.
+"""
+
+tag_descriptions[
+    "runs"
+] = r"""
+**WORK IN PROGRESS**
+
+Run simple jobs.
+
+For off-site job runs, keep the Runtime appraised of run events.
+"""
+
+# Remove leading and trailing whitespace from each description.
+for name, description in tag_descriptions.items():
+    tag_descriptions[name] = description.strip()
+
+ordered_tag_descriptors: List[Dict[str, str]] = [
+    {"name": "sites", "description": tag_descriptions["sites"]},
+    {"name": "users", "description": tag_descriptions["users"]},
+    {"name": "workflows", "description": tag_descriptions["workflows"]},
+    {"name": "capabilities", "description": tag_descriptions["capabilities"]},
+    {"name": "object types", "description": tag_descriptions["object types"]},
+    {"name": "triggers", "description": tag_descriptions["triggers"]},
+    {"name": "jobs", "description": tag_descriptions["jobs"]},
+    {"name": "objects", "description": tag_descriptions["objects"]},
+    {"name": "operations", "description": tag_descriptions["operations"]},
+    {"name": "queries", "description": tag_descriptions["queries"]},
+    {"name": "metadata", "description": tag_descriptions["metadata"]},
+    {"name": "find", "description": tag_descriptions["find"]},
+    {"name": "runs", "description": tag_descriptions["runs"]},
+]
+
+
+def make_api_description(schema_version: str, orcid_login_url: str) -> str:
+    r"""
+    Returns an API description into which the specified schema version and
+    ORCID login URL have been incorporated.
+
+    Args:
+        schema_version (str): The version of `nmdc-schema` the Runtime is using.
+        orcid_login_url (str): The URL at which a user could login via ORCID.
+
+    Returns:
+        str: The Markdown-formatted API description.
+    """
+    result = f"""
+The NMDC Runtime API, via on-demand functions and via schedule-based and sensor-based automation, 
+supports validation and submission of metadata, as well as orchestration of workflow executions.
+
+[NMDC Schema](https://microbiomedata.github.io/nmdc-schema/) version: `{schema_version}`
+
+[Documentation](https://docs.microbiomedata.org/runtime/)
+
+<img src="/static/ORCIDiD_icon128x128.png" height="18" width="18"/>
+<a href="{escape(orcid_login_url)}" title="Login with ORCID">
+    Login with ORCID
+</a>
+""".strip()
+    return result

nmdc_runtime/config.py

@@ -1,5 +1,56 @@
-DATABASE_CLASS_NAME = "Database"
+"""
+This module acts as a unified interface between the codebase and the environment.
+We will eventually move all of the Runtime's environment variables reads into this
+module, instead of leaving them sprinkled throughout the codebase.
 
-# Feature flag that can be used to enable/disable the `/nmdcschema/related_ids`
-# endpoint and the tests that target it.
-IS_RELATED_IDS_ENDPOINT_ENABLED = False
+TODO: Move all environment variable reads into this module and update references accordingly.
+"""
+
+from typing import Set
+import os
+
+
+def is_env_var_true(name: str, default: str = "false") -> bool:
+    r"""
+    Checks whether the value of the specified environment variable
+    meets our criteria for true-ness.
+
+    Reference: https://docs.python.org/3/library/os.html#os.environ
+
+    Run doctests via: $ python -m doctest nmdc_runtime/config.py
+
+    >>> import os
+    >>> name = "EXAMPLE_ENV_VAR"
+    >>> os.unsetenv(name)  # Undefined
+    >>> is_env_var_true(name)
+    False
+    >>> is_env_var_true(name, "true")  # Undefined, overridden default
+    True
+    >>> os.environ[name] = "false"  # Defined as false
+    >>> is_env_var_true(name)
+    False
+    >>> os.environ[name] = "true"  # Defined as true
+    >>> is_env_var_true(name)
+    True
+    >>> os.environ[name] = "TRUE"  # Case-insensitive
+    >>> is_env_var_true(name)
+    True
+    >>> os.environ[name] = "potato"  # Non-boolean string
+    >>> is_env_var_true(name)
+    False
+    """
+    lowercase_true_strings: Set[str] = {"true"}
+    return os.environ.get(name, default).lower() in lowercase_true_strings
+
+
+# Feature flag to enable/disable the `/nmdcschema/linked_instances` endpoint and the tests that target it.
+IS_LINKED_INSTANCES_ENDPOINT_ENABLED: bool = is_env_var_true(
+    "IS_LINKED_INSTANCES_ENDPOINT_ENABLED", default="true"
+)
+
+# Feature flag that can be used to enable/disable the `/scalar` endpoint.
+IS_SCALAR_ENABLED: bool = is_env_var_true("IS_SCALAR_ENABLED", default="true")
+
+# Feature flag that can be used to enable/disable performance profiling,
+# which can be activated via the `?profile=true` URL query parameter.
+IS_PROFILING_ENABLED: bool = is_env_var_true("IS_PROFILING_ENABLED", default="false")

nmdc_runtime/core/db/Database.py

@@ -1,6 +1,4 @@
-from contextlib import contextmanager, AbstractContextManager
-from typing import Callable
-import logging
+from contextlib import contextmanager
 
 from motor import motor_asyncio
 

nmdc_runtime/infrastructure/database/models/user.py

@@ -1,10 +1 @@
 from __future__ import annotations
-
-from abc import abstractmethod
-from typing import List
-
-from nmdc_runtime.domain.users.userSchema import (
-    UserAuth,
-    UserUpdate,
-    UserOut,
-)

nmdc_runtime/lib/extract_nmdc_data.py

@@ -3,14 +3,6 @@
 
 ## system level modules
 import pandas as pds
-import jq
-import jsonasobj
-import json
-import zipfile
-import yaml
-from yaml import CLoader as Loader, CDumper as Dumper
-from dotted_dict import DottedDict
-from collections import namedtuple
 
 
 def extract_table(merged_df, table_name):

nmdc_runtime/lib/nmdc_dataframes.py

@@ -3,13 +3,9 @@
 
 ## system level modules
 import pandas as pds
-import jsonasobj
-import json
 import zipfile
 import yaml
-from pandas.core.dtypes.missing import notnull
-from yaml import CLoader as Loader, CDumper as Dumper
-from dotted_dict import DottedDict
+from yaml import CLoader as Loader
 from collections import namedtuple
 
 
@@ -309,10 +305,10 @@ def make_study_dataframe(study_table, contact_table, proposals_table, result_col
 
     ## make sure the contact ids are strings with the ".0" removed from the end (i.e., the strings aren't floats)
     study_table["contact_id"] = (
-        study_table["contact_id"].astype(str).replace("\.0", "", regex=True)
+        study_table["contact_id"].astype(str).replace(r"\.0", "", regex=True)
     )
     contact_table_splice["contact_id"] = (
-        contact_table_splice["contact_id"].astype(str).replace("\.0", "", regex=True)
+        contact_table_splice["contact_id"].astype(str).replace(r"\.0", "", regex=True)
     )
     # print(study_table[['contact_id', 'principal_investigator_name']].head())
 

nmdc_runtime/lib/nmdc_etl_class.py

@@ -8,14 +8,8 @@ import nmdc_runtime.lib.load_nmdc_data as lx
 import nmdc_runtime.lib.nmdc_dataframes as nmdc_dfs
 from nmdc_schema import nmdc
 import pandas as pds
-import jq
-import jsonasobj
-import json
-import zipfile
 import yaml
-from yaml import CLoader as Loader, CDumper as Dumper
-from dotted_dict import DottedDict
-from collections import namedtuple
+from yaml import CLoader as Loader
 
 
 class NMDC_ETL:

nmdc_runtime/minter/adapters/repository.py

@@ -2,9 +2,8 @@ import abc
 import re
 from typing import Union
 
-from fastapi import HTTPException
 from pymongo import ReturnDocument
-from toolz import merge, dissoc
+from toolz import merge
 from pymongo.database import Database as MongoDatabase
 
 

nmdc_runtime/minter/config.py

@@ -23,9 +23,11 @@ def typecodes() -> List[dict]:
           that class _today_; regardless of what it may have used in the past.
 
     >>> typecode_descriptors = typecodes()
+
     # Test #1: We get the typecode we expect, for a class whose pattern contains only one typecode.
     >>> any((td["name"] == "sty" and td["schema_class"] == "nmdc:Study") for td in typecode_descriptors)
     True
+
     # Tests #2 and #3: We get only the typecode we expect, for a class whose pattern contains multiple typecodes.
     >>> any((td["name"] == "dgms" and td["schema_class"] == "nmdc:MassSpectrometry") for td in typecode_descriptors)
     True