nmdc-runtime 2.6.0__py3-none-any.whl → 2.12.0__py3-none-any.whl

nmdc_runtime/api/models/job.py

@@ -0,0 +1,57 @@
+import datetime
+from typing import Optional, Dict, Any, List
+
+from pydantic import BaseModel, Field
+
+from nmdc_runtime.api.models.operation import Metadata as OperationMetadata
+from nmdc_runtime.api.models.workflow import Workflow
+
+
+class JobBase(BaseModel):
+    workflow: Workflow
+    name: Optional[str] = Field(
+        None, description="Name of the job", examples=["Some job"]
+    )
+    description: Optional[str] = Field(
+        None, description="Description of the job", examples=["Some description"]
+    )
+
+
+class JobClaim(BaseModel):
+    op_id: str
+    site_id: str
+    done: Optional[bool] = None
+    cancelled: Optional[bool] = None
+
+
+class Job(JobBase):
+    id: str
+    created_at: Optional[datetime.datetime] = None
+    config: Dict[str, Any]
+    claims: List[JobClaim] = []
+
+
+class JobIn(JobBase):
+    """Payload of an HTTP request to create a `Job`."""
+
+    # Consider forbidding extra fields (once the workflow automation developers have
+    # updated the client code accordingly).
+    # See: https://docs.pydantic.dev/latest/api/config/#pydantic.config.ConfigDict.extra
+    ##model_config = ConfigDict(extra="forbid")
+
+    config: Dict[str, Any] = Field(
+        ..., description="Configuration of the associated workflow", examples=[{}]
+    )
+    claims: List[JobClaim] = Field(
+        default_factory=list, description="Claims of the job", examples=[[]]
+    )
+
+
+class JobExecution(BaseModel):
+    id: str
+    job: Job
+
+
+class JobOperationMetadata(OperationMetadata):
+    job: Job
+    site_id: str

nmdc_runtime/api/models/lib/helpers.py

@@ -0,0 +1,78 @@
+from nmdc_runtime.api.models.query import (
+    DeleteCommand,
+    DeleteSpecs,
+    UpdateCommand,
+    UpdateSpecs,
+)
+
+
+def derive_delete_specs(delete_command: DeleteCommand) -> DeleteSpecs:
+    r"""
+    Derives a list of delete specifications from the given `DeleteCommand`.
+
+    Note: This algorithm was copied from the `_run_mdb_cmd`
+          function in `nmdc_runtime/api/endpoints/queries.py`.
+
+    To run doctests: $ python -m doctest nmdc_runtime/api/models/lib/helpers.py
+
+    >>> delete_command = DeleteCommand(**{
+    ...     "delete": "collection_name",
+    ...     "deletes": [
+    ...         {
+    ...             "q": {"color": "blue"},
+    ...             "limit": 0,
+    ...             "hint": {"potato": 1}
+    ...         },
+    ...         {
+    ...             "q": {"color": "green"},
+    ...             "limit": 1,
+    ...         }
+    ...     ],
+    ... })
+    >>> delete_specs = derive_delete_specs(delete_command)
+    >>> delete_specs[0]
+    {'filter': {'color': 'blue'}, 'limit': 0}
+    >>> delete_specs[1]
+    {'filter': {'color': 'green'}, 'limit': 1}
+    """
+
+    return [
+        {"filter": delete_statement.q, "limit": delete_statement.limit}
+        for delete_statement in delete_command.deletes
+    ]
+
+
+def derive_update_specs(update_command: UpdateCommand) -> UpdateSpecs:
+    r"""
+    Derives a list of update specifications from the given `UpdateCommand`.
+
+    Note: This algorithm was copied from the `_run_mdb_cmd`
+          function in `nmdc_runtime/api/endpoints/queries.py`.
+
+    >>> update_command = UpdateCommand(**{
+    ...     "update": "collection_name",
+    ...     "updates": [
+    ...         {
+    ...             "q": {"color": "blue"},
+    ...             "u": {"$set": {"color": "red"}},
+    ...             "upsert": False,
+    ...             "multi": True,
+    ...             "hint": {"potato": 1}
+    ...         },
+    ...         {
+    ...             "q": {"color": "green"},
+    ...             "u": {"$set": {"color": "yellow"}},
+    ...         }
+    ...     ],
+    ... })
+    >>> update_specs = derive_update_specs(update_command)
+    >>> update_specs[0]
+    {'filter': {'color': 'blue'}, 'limit': 0}
+    >>> update_specs[1]
+    {'filter': {'color': 'green'}, 'limit': 1}
+    """
+
+    return [
+        {"filter": update_statement.q, "limit": 0 if update_statement.multi else 1}
+        for update_statement in update_command.updates
+    ]

nmdc_runtime/api/models/metadata.py

@@ -0,0 +1,11 @@
+from pydantic import ConfigDict, BaseModel
+
+
+class ChangesheetIn(BaseModel):
+    name: str
+    content_type: str
+    text: str
+
+
+class Doc(BaseModel):
+    model_config = ConfigDict(extra="allow")

nmdc_runtime/api/models/nmdc_schema.py

@@ -0,0 +1,146 @@
+import inspect
+from enum import Enum
+from typing import List, Any, Dict, Optional
+
+from pydantic import BaseModel, Field, create_model
+from refscan.lib.helpers import get_collection_names_from_schema
+
+from nmdc_runtime.util import nmdc_schema_view
+
+
+class FileTypeEnum(str, Enum):
+    ft_icr_ms_analysis_results = "FT ICR-MS Analysis Results"
+    gc_ms_metabolomics_results = "GC-MS Metabolomics Results"
+    metaproteomics_workflow_statistics = "Metaproteomics Workflow Statistics"
+    protein_report = "Protein Report"
+    peptide_report = "Peptide Report"
+    unfiltered_metaproteomics_results = "Unfiltered Metaproteomics Results"
+    read_count_and_rpkm = "Read Count and RPKM"
+    qc_non_rrna_r2 = "QC non-rRNA R2"
+    qc_non_rrna_r1 = "QC non-rRNA R1"
+    metagenome_bins = "Metagenome Bins"
+    checkm_statistics = "CheckM Statistics"
+    gottcha2_krona_plot = "GOTTCHA2 Krona Plot"
+    kraken2_krona_plot = "Kraken2 Krona Plot"
+    centrifuge_krona_plot = "Centrifuge Krona Plot"
+    kraken2_classification_report = "Kraken2 Classification Report"
+    kraken2_taxonomic_classification = "Kraken2 Taxonomic Classification"
+    centrifuge_classification_report = "Centrifuge Classification Report"
+    centrifuge_taxonomic_classification = "Centrifuge Taxonomic Classification"
+    structural_annotation_gff = "Structural Annotation GFF"
+    functional_annotation_gff = "Functional Annotation GFF"
+    annotation_amino_acid_fasta = "Annotation Amino Acid FASTA"
+    annotation_enzyme_commission = "Annotation Enzyme Commission"
+    annotation_kegg_orthology = "Annotation KEGG Orthology"
+    assembly_coverage_bam = "Assembly Coverage BAM"
+    assembly_agp = "Assembly AGP"
+    assembly_scaffolds = "Assembly Scaffolds"
+    assembly_contigs = "Assembly Contigs"
+    assembly_coverage_stats = "Assembly Coverage Stats"
+    filtered_sequencing_reads = "Filtered Sequencing Reads"
+    qc_statistics = "QC Statistics"
+    tigrfam_annotation_gff = "TIGRFam Annotation GFF"
+    clusters_of_orthologous_groups__cog__annotation_gff = (
+        "Clusters of Orthologous Groups (COG) Annotation GFF"
+    )
+    cath_funfams__functional_families__annotation_gff = (
+        "CATH FunFams (Functional Families) Annotation GFF"
+    )
+    superfam_annotation_gff = "SUPERFam Annotation GFF"
+    smart_annotation_gff = "SMART Annotation GFF"
+    pfam_annotation_gff = "Pfam Annotation GFF"
+    direct_infusion_ft_icr_ms_raw_data = "Direct Infusion FT ICR-MS Raw Data"
+
+
+class DataObject(BaseModel):
+    id: str = Field(None)
+    name: str = Field(None, description="A human readable label for an entity")
+    description: str = Field(
+        None, description="a human-readable description of a thing"
+    )
+    alternative_identifiers: List[str] = Field(
+        None, description="A list of alternative identifiers for the entity."
+    )
+    compression_type: str = Field(
+        None, description="If provided, specifies the compression type"
+    )
+    data_object_type: FileTypeEnum = Field(None)
+    file_size_bytes: int = Field(None, description="Size of the file in bytes")
+    md5_checksum: str = Field(None, description="MD5 checksum of file (pre-compressed)")
+    type: str = Field(
+        "nmdc:DataObject",
+        description="An optional string that specifies the type object.  This is used to allow for searches for different kinds of objects.",
+    )
+    url: str = Field(None)
+    was_generated_by: str = Field(None)
+
+
+list_request_ops_per_field_type = {
+    (object,): ["$eq", "$neq", "$in", "$nin"],
+    (str,): ["$regex"],
+    (int, float): ["$gt", "$gte", "$lt", "$lte"],
+}
+
+list_request_ops_with_many_args = {"$in", "$nin"}
+
+
+def create_list_request_model_for(cls):
+    field_filters = []
+    sig = inspect.signature(cls)
+    for p in sig.parameters.values():
+        field_name, field_type = p.name, p.annotation
+        if hasattr(field_type, "__origin__"):  # a GenericAlias object, e.g. List[str].
+            field_type = field_type.__args__[0]
+        field_default = (
+            None if p.default in (inspect.Parameter.empty, []) else p.default
+        )
+        field_ops = []
+        for types_ok, type_ops in list_request_ops_per_field_type.items():
+            if field_type in types_ok or isinstance(field_type, types_ok):
+                field_ops.extend(type_ops)
+        for op in field_ops:
+            field_filters.append(
+                {
+                    "name": field_name,
+                    "arg_type": field_type,
+                    "default": field_default,
+                    "op": op,
+                }
+            )
+    create_model_kwargs = {"max_page_size": (int, 20), "page_token": (str, None)}
+    for ff in field_filters:
+        model_field_name = f'{ff["name"]}_{ff["op"][1:]}'
+        model_field_type = ff["arg_type"]
+        create_model_kwargs[model_field_name] = (model_field_type, ff["default"])
+    return create_model(f"{cls.__name__}ListRequest", **create_model_kwargs)
+
+
+def list_request_filter_to_mongo_filter(req: dict):
+    filter_ = {}
+    for k, v in req.items():
+        if not v:
+            continue
+        field, op = k.rsplit("_", maxsplit=1)
+        op = f"${op}"
+        if field not in filter_:
+            filter_[field] = {}
+        if op not in filter_[field]:
+            if op in list_request_ops_with_many_args:
+                filter_[field][op] = v.split(",")
+            else:
+                filter_[field][op] = v
+    return filter_
+
+
+DataObjectListRequest = create_list_request_model_for(DataObject)
+
+SimplifiedDocument = Dict[str, Any]
+
+schema_view = nmdc_schema_view()
+SimplifiedNMDCDatabase = create_model(
+    "NMDCDatabase",
+    **{
+        coll_name: Optional[list[SimplifiedDocument]]
+        for coll_name in get_collection_names_from_schema(schema_view)
+    },
+)

nmdc_runtime/api/models/object.py

@@ -0,0 +1,180 @@
+import datetime
+import hashlib
+import http
+from enum import Enum
+from typing import Optional, List, Dict
+
+from pydantic import (
+    field_validator,
+    model_validator,
+    Field,
+    StringConstraints,
+    BaseModel,
+    AnyUrl,
+    HttpUrl,
+    field_serializer,
+)
+from typing_extensions import Annotated
+
+
+class AccessMethodType(str, Enum):
+    s3 = "s3"
+    gs = "gs"
+    ftp = "ftp"
+    gsiftp = "gsiftp"
+    globus = "globus"
+    htsget = "htsget"
+    https = "https"
+    file = "file"
+
+
+class AccessURL(BaseModel):
+    headers: Optional[Dict[str, str]] = None
+    url: AnyUrl
+
+    @field_serializer("url")
+    def serialize_url(self, url: AnyUrl, _info):
+        return str(url)
+
+
+class AccessMethod(BaseModel):
+    access_id: Optional[Annotated[str, StringConstraints(min_length=1)]] = None
+    access_url: Optional[AccessURL] = None
+    region: Optional[str] = None
+    type: AccessMethodType = AccessMethodType.https
+
+    @model_validator(mode="before")
+    def at_least_one_of_access_id_and_url(cls, values):
+        access_id, access_url = values.get("access_id"), values.get("access_url")
+        if access_id is None and access_url is None:
+            raise ValueError(
+                "At least one of access_url and access_id must be provided."
+            )
+        return values
+
+
+ChecksumType = Annotated[
+    str,
+    StringConstraints(
+        pattern=rf"(?P<checksumtype>({'|'.join(sorted(hashlib.algorithms_guaranteed))}))"
+    ),
+]
+
+
+class Checksum(BaseModel):
+    checksum: Annotated[str, StringConstraints(min_length=1)]
+    type: ChecksumType
+
+
+DrsId = Annotated[str, StringConstraints(pattern=r"^[A-Za-z0-9._~\-]+$")]
+PortableFilename = Annotated[str, StringConstraints(pattern=r"^[A-Za-z0-9._\-]+$")]
+
+
+class ContentsObject(BaseModel):
+    contents: Optional[List["ContentsObject"]] = None
+    drs_uri: Optional[List[AnyUrl]] = None
+    id: Optional[DrsId] = None
+    name: PortableFilename
+
+    @model_validator(mode="before")
+    def no_contents_means_single_blob(cls, values):
+        contents, id_ = values.get("contents"), values.get("id")
+        if contents is None and id_ is None:
+            raise ValueError("no contents means no further nesting, so id required")
+        return values
+
+    @field_serializer("drs_uri")
+    def serialize_url(self, drs_uri: Optional[List[AnyUrl]], _info):
+        if drs_uri is not None and len(drs_uri) > 0:
+            return [str(u) for u in drs_uri]
+        return drs_uri
+
+
+# Note: Between Pydantic v1 and v2, the `update_forward_refs` method was renamed to `model_rebuild`.
+#       Reference: https://docs.pydantic.dev/2.11/migration/#changes-to-pydanticbasemodel
+ContentsObject.model_rebuild()
+
+Mimetype = Annotated[str, StringConstraints(pattern=r"^\w+/[-+.\w]+$")]
+SizeInBytes = Annotated[int, Field(strict=True, ge=0)]
+
+
+class Error(BaseModel):
+    msg: Optional[str] = None
+    status_code: http.HTTPStatus
+
+
+class DrsObjectBase(BaseModel):
+    aliases: Optional[List[str]] = None
+    description: Optional[str] = None
+    mime_type: Optional[Mimetype] = None
+    name: Optional[PortableFilename] = None
+
+
+class DrsObjectIn(DrsObjectBase):
+    access_methods: Optional[List[AccessMethod]] = None
+    checksums: List[Checksum]
+    contents: Optional[List[ContentsObject]] = None
+    created_time: datetime.datetime
+    size: SizeInBytes
+    updated_time: Optional[datetime.datetime] = None
+    version: Optional[str] = None
+
+    @model_validator(mode="before")
+    def no_contents_means_single_blob(cls, values):
+        contents, access_methods = values.get("contents"), values.get("access_methods")
+        if contents is None and access_methods is None:
+            raise ValueError(
+                "no contents means single blob, which requires access_methods"
+            )
+        return values
+
+    @field_validator("checksums")
+    @classmethod
+    def at_least_one_checksum(cls, v):
+        if not len(v) >= 1:
+            raise ValueError("At least one checksum requried")
+        return v
+
+
+class DrsObject(DrsObjectIn):
+    id: DrsId
+    self_uri: AnyUrl
+
+    @field_serializer("self_uri")
+    def serialize_url(self, self_uri: AnyUrl, _info):
+        return str(self_uri)
+
+
+Seconds = Annotated[int, Field(strict=True, gt=0)]
+
+
+class ObjectPresignedUrl(BaseModel):
+    url: HttpUrl
+    expires_in: Seconds = 300
+
+    @field_serializer("url")
+    def serialize_url(self, url: HttpUrl, _info):
+        return str(url)
+
+
+class DrsObjectOutBase(DrsObjectBase):
+    checksums: List[Checksum]
+    created_time: datetime.datetime
+    id: DrsId
+    self_uri: AnyUrl
+    size: SizeInBytes
+    updated_time: Optional[datetime.datetime] = None
+    version: Optional[str] = None
+
+    @field_serializer("self_uri")
+    def serialize_url(self, self_uri: AnyUrl, _info):
+        return str(self_uri)
+
+
+class DrsObjectBlobOut(DrsObjectOutBase):
+    access_methods: List[AccessMethod]
+
+
+class DrsObjectBundleOut(DrsObjectOutBase):
+    access_methods: Optional[List[AccessMethod]] = None
+    contents: List[ContentsObject]

nmdc_runtime/api/models/object_type.py

@@ -0,0 +1,20 @@
+import datetime
+from typing import Optional, List
+
+from pydantic import BaseModel
+
+from nmdc_runtime.api.models.object import DrsObject
+
+
+class ObjectTypeBase(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+
+class ObjectType(ObjectTypeBase):
+    id: str
+    created_at: datetime.datetime
+
+
+class DrsObjectWithTypes(DrsObject):
+    types: Optional[List[str]] = None

nmdc_runtime/api/models/operation.py

@@ -0,0 +1,66 @@
+import datetime
+from typing import Generic, TypeVar, Optional, List, Any, Union
+
+from pydantic import StringConstraints, BaseModel, HttpUrl, field_serializer
+
+from nmdc_runtime.api.models.util import ResultT
+from typing_extensions import Annotated
+
+MetadataT = TypeVar("MetadataT")
+
+
+PythonImportPath = Annotated[str, StringConstraints(pattern=r"^[A-Za-z0-9_.]+$")]
+
+
+class OperationError(BaseModel):
+    code: str
+    message: str
+    details: Any = None
+
+
+class Operation(BaseModel, Generic[ResultT, MetadataT]):
+    id: str
+    done: bool = False
+    expire_time: datetime.datetime
+    result: Optional[Union[ResultT, OperationError]] = None
+    metadata: Optional[MetadataT] = None
+
+
+class UpdateOperationRequest(BaseModel, Generic[ResultT, MetadataT]):
+    done: bool = False
+    result: Optional[Union[ResultT, OperationError]] = None
+    metadata: Optional[MetadataT] = {}
+
+
+class ListOperationsResponse(BaseModel, Generic[ResultT, MetadataT]):
+    resources: List[Operation[ResultT, MetadataT]]
+    next_page_token: Optional[str] = None
+
+
+class Result(BaseModel):
+    model: Optional[PythonImportPath] = None
+
+
+class EmptyResult(Result):
+    pass
+
+
+class Metadata(BaseModel):
+    # XXX alternative: set model field using __class__ on __init__()?
+    model: Optional[PythonImportPath] = None
+    cancelled: Optional[bool] = None
+
+
+class PausedOrNot(Metadata):
+    paused: bool
+
+
+class ObjectPutMetadata(Metadata):
+    object_id: str
+    site_id: str
+    url: HttpUrl
+    expires_in_seconds: int
+
+    @field_serializer("url")
+    def serialize_url(self, url: HttpUrl, _info):
+        return str(url)