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

nmdc_runtime/site/translation/neon_benthic_translator.py

@@ -1,5 +1,6 @@
 import re
 import sqlite3
+from typing import Optional, Union
 
 import pandas as pd
 import requests_cache
@@ -10,7 +11,6 @@ from nmdc_runtime.site.util import get_basename
 from nmdc_runtime.site.translation.neon_utils import (
     _get_value_or_none,
     _create_controlled_identified_term_value,
-    _create_controlled_term_value,
     _create_geolocation_value,
     _create_quantity_value,
     _create_timestamp_value,
@@ -47,6 +47,7 @@ class NeonBenthicDataTranslator(Translator):
         site_code_mapping: dict,
         neon_envo_mappings_file: pd.DataFrame,
         neon_raw_data_file_mappings_file: pd.DataFrame,
+        neon_nmdc_instrument_map_df: pd.DataFrame = pd.DataFrame(),
         *args,
         **kwargs,
     ) -> None:
@@ -59,6 +60,7 @@ class NeonBenthicDataTranslator(Translator):
             "mms_benthicMetagenomeSequencing",
             "mms_benthicMetagenomeDnaExtraction",
             "amb_fieldParent",
+            "mms_benthicRawDataFiles",  # <--- ensure this is present
         )
 
         if all(k in benthic_data for k in neon_amb_data_tables):
@@ -77,6 +79,12 @@ class NeonBenthicDataTranslator(Translator):
             benthic_data["amb_fieldParent"].to_sql(
                 "amb_fieldParent", self.conn, if_exists="replace", index=False
             )
+            benthic_data["mms_benthicRawDataFiles"].to_sql(
+                "mms_benthicRawDataFiles",
+                self.conn,
+                if_exists="replace",
+                index=False,
+            )
         else:
             raise ValueError(
                 f"You are missing one of the aquatic benthic microbiome tables: {neon_amb_data_tables}"
@@ -86,19 +94,24 @@ class NeonBenthicDataTranslator(Translator):
             "neonEnvoTerms", self.conn, if_exists="replace", index=False
         )
 
-        self.neon_raw_data_file_mappings_df = neon_raw_data_file_mappings_file
-        self.neon_raw_data_file_mappings_df.to_sql(
-            "neonRawDataFile", self.conn, if_exists="replace", index=False
-        )
+        self.neon_raw_data_file_mappings_df = benthic_data["mms_benthicRawDataFiles"]
 
         self.site_code_mapping = site_code_mapping
 
+        self.neon_nmdc_instrument_map_df = neon_nmdc_instrument_map_df
+
+    def _translate_manifest(self, manifest_id: str) -> nmdc.Manifest:
+        return nmdc.Manifest(
+            id=manifest_id,
+            manifest_category=nmdc.ManifestCategoryEnum.poolable_replicates,
+            type="nmdc:Manifest",
+        )
+
     def _translate_biosample(
         self, neon_id: str, nmdc_id: str, biosample_row: pd.DataFrame
     ) -> nmdc.Biosample:
         return nmdc.Biosample(
             id=nmdc_id,
-            part_of="nmdc:sty-11-pzmd0x14",
             env_broad_scale=_create_controlled_identified_term_value(
                 BENTHIC_BROAD_SCALE_MAPPINGS.get(
                     biosample_row["aquaticSiteType"].values[0]
@@ -146,8 +159,10 @@ class NeonBenthicDataTranslator(Translator):
             depth=nmdc.QuantityValue(
                 has_minimum_numeric_value=nmdc.Float("0"),
                 has_maximum_numeric_value=nmdc.Float("1"),
-                has_unit="meters",
+                has_unit="m",
+                type="nmdc:QuantityValue",
             ),
+            associated_studies=["nmdc:sty-11-pzmd0x14"],
         )
 
     def _translate_extraction_process(
@@ -185,10 +200,9 @@ class NeonBenthicDataTranslator(Translator):
             input_mass=_create_quantity_value(
                 _get_value_or_none(extraction_row, "sampleMass"), "g"
             ),
-            quality_control_report=nmdc.QualityControlReport(
-                status=_get_value_or_none(extraction_row, "qaqcStatus")
-            ),
+            qc_status=_get_value_or_none(extraction_row, "qaqcStatus"),
             processing_institution=processing_institution,
+            type="nmdc:Extraction",
         )
 
     def _translate_library_preparation(
@@ -201,13 +215,13 @@ class NeonBenthicDataTranslator(Translator):
         """
         Create LibraryPreparation process object. The input to LibraryPreparation process
         is the output ProcessedSample from an Extraction process. The output of LibraryPreparation
-        process is fed as input to an OmicsProcessing object.
+        process is fed as input to an NucleotideSequencing object.
 
         :param library_preparation_id: Minted id for LibraryPreparation process.
         :param library_preparation_input: Input to LibraryPreparation process is output from
         Extraction process.
         :param processed_sample_id: Minted ProcessedSample id which is output of LibraryPreparation
-        is also input to OmicsProcessing.
+        is also input to NucleotideSequencing.
         :param library_preparation_row: Metadata required to populate LibraryPreparation.
         :return: Object that using LibraryPreparation process model.
         """
@@ -226,31 +240,47 @@ class NeonBenthicDataTranslator(Translator):
             start_date=_get_value_or_none(library_preparation_row, "collectDate"),
             end_date=_get_value_or_none(library_preparation_row, "processedDate"),
             processing_institution=processing_institution,
+            type="nmdc:LibraryPreparation",
         )
 
-    def _translate_omics_processing(
+    def _get_instrument_id(self, instrument_model: Union[str | None]) -> str:
+        if not instrument_model:
+            raise ValueError(
+                f"instrument_model '{instrument_model}' could not be found in the NEON-NMDC instrument mapping TSV file."
+            )
+
+        df = self.neon_nmdc_instrument_map_df
+        matching_row = df[
+            df["NEON sequencingMethod"].str.contains(instrument_model, case=False)
+        ]
+
+        if not matching_row.empty:
+            nmdc_instrument_id = matching_row["NMDC instrument_set id"].values[0]
+            return nmdc_instrument_id
+
+    def _translate_nucleotide_sequencing(
         self,
-        omics_processing_id: str,
+        nucleotide_sequencing_id: str,
         processed_sample_id: str,
         raw_data_file_data: str,
-        omics_processing_row: pd.DataFrame,
-    ) -> nmdc.OmicsProcessing:
-        """Create nmdc OmicsProcessing object. This class typically models the run of a
-        Bioinformatics workflow on sequence data from a biosample. The input to an OmicsProcessing
-        process is the output from a LibraryPreparation process, and the output of OmicsProcessing
+        nucleotide_sequencing_row: pd.DataFrame,
+    ):
+        """Create nmdc NucleotideSequencing object. This class typically models the run of a
+        Bioinformatics workflow on sequence data from a biosample. The input to an NucleotideSequencing
+        process is the output from a LibraryPreparation process, and the output of NucleotideSequencing
         is a DataObject which has the FASTQ sequence file URLs embedded in them.
 
-        :param omics_processing_id: Minted id for an OmicsProcessing process.
+        :param nucleotide_sequencing_id: Minted id for an NucleotideSequencing process.
         :param processed_sample_id: ProcessedSample that is the output of LibraryPreparation.
         :param raw_data_file_data: R1/R2 DataObjects which have links to workflow processed output
         files embedded in them.
-        :param omics_processing_row: DataFrame with metadata for an OmicsProcessing workflow
+        :param nucleotide_sequencing_row: DataFrame with metadata for an NucleotideSequencing workflow
         process/run.
-        :return: OmicsProcessing object that models a Bioinformatics workflow process/run.
+        :return: NucleotideSequencing object that models a Bioinformatics workflow process/run.
         """
         processing_institution = None
         sequencing_facility = _get_value_or_none(
-            omics_processing_row, "sequencingFacilityID"
+            nucleotide_sequencing_row, "sequencingFacilityID"
         )
         if sequencing_facility is not None:
             if re.search("Battelle", sequencing_facility, re.IGNORECASE):
@@ -258,19 +288,21 @@ class NeonBenthicDataTranslator(Translator):
             elif re.search("Argonne", sequencing_facility, re.IGNORECASE):
                 processing_institution = "ANL"
 
-        return nmdc.OmicsProcessing(
-            id=omics_processing_id,
+        return nmdc.NucleotideSequencing(
+            id=nucleotide_sequencing_id,
             has_input=processed_sample_id,
             has_output=raw_data_file_data,
             processing_institution=processing_institution,
-            ncbi_project_name=_get_value_or_none(omics_processing_row, "ncbiProjectID"),
-            omics_type=_create_controlled_term_value(
-                omics_processing_row["investigation_type"].values[0]
+            ncbi_project_name=_get_value_or_none(
+                nucleotide_sequencing_row, "ncbiProjectID"
             ),
-            instrument_name=f"{_get_value_or_none(omics_processing_row, 'sequencingMethod')} {_get_value_or_none(omics_processing_row, 'instrument_model')}",
-            part_of="nmdc:sty-11-34xj1150",
-            name=f"Terrestrial soil microbial communities - {_get_value_or_none(omics_processing_row, 'dnaSampleID')}",
-            type="nmdc:OmicsProcessing",
+            instrument_used=self._get_instrument_id(
+                _get_value_or_none(nucleotide_sequencing_row, "instrument_model")
+            ),
+            name=f"Benthic microbial communities - {_get_value_or_none(nucleotide_sequencing_row, 'dnaSampleID')}",
+            type="nmdc:NucleotideSequencing",
+            associated_studies=["nmdc:sty-11-pzmd0x14"],
+            analyte_category="metagenome",
         )
 
     def _translate_processed_sample(
@@ -287,12 +319,14 @@ class NeonBenthicDataTranslator(Translator):
         :param sample_id: Value from `genomicsSampleID` or `dnaSampleID` column.
         :return: ProcessedSample objects to be stored in `processed_sample_set`.
         """
-        return nmdc.ProcessedSample(id=processed_sample_id, name=sample_id)
+        return nmdc.ProcessedSample(
+            id=processed_sample_id, name=sample_id, type="nmdc:ProcessedSample"
+        )
 
     def _translate_data_object(
-        self, do_id: str, url: str, do_type: str, checksum: str
+        self, do_id: str, url: str, do_type: str, manifest_id: str
     ) -> nmdc.DataObject:
-        """Create nmdc DataObject which is the output of an OmicsProcessing process. This
+        """Create nmdc DataObject which is the output of a NucleotideSequencing process. This
         object mainly contains information about the sequencing file that was generated as
         the result of running a Bioinformatics workflow on a certain ProcessedSample, which
         is the result of a LibraryPreparation process.
@@ -301,7 +335,6 @@ class NeonBenthicDataTranslator(Translator):
         :param url: URL of zipped FASTQ file on NEON file server. Retrieved from file provided
         by Hugh Cross at NEON.
         :param do_type: Indicate whether it is FASTQ for Read 1 or Read 2 (paired end sequencing).
-        :param checksum: Checksum value for FASTQ in zip file, once again provided by Hugh Cross
         at NEON.
         :return: DataObject with all the sequencing file metadata.
         """
@@ -314,14 +347,15 @@ class NeonBenthicDataTranslator(Translator):
             url=url,
             description=f"sequencing results for {basename}",
             type="nmdc:DataObject",
-            md5_checksum=checksum,
             data_object_type=do_type,
+            data_category=nmdc.DataCategoryEnum.instrument_data.text,
+            in_manifest=manifest_id,
         )
 
-    def get_database(self):
+    def get_database(self) -> nmdc.Database:
         database = nmdc.Database()
 
-        query = """
+        join_query = """
             SELECT
                 merged.laboratoryName,
                 merged.sequencingFacilityID,
@@ -349,200 +383,190 @@ class NeonBenthicDataTranslator(Translator):
                 afp.siteID,
                 afp.sampleID,
                 afp.collectDate
-            FROM 
-                (
-                    SELECT
-                        bs.collectDate,
-                        bs.laboratoryName,
-                        bs.sequencingFacilityID,
-                        bs.processedDate,
-                        bs.dnaSampleID,
-                        bs.dnaSampleCode,
-                        bs.internalLabID,
-                        bs.instrument_model,
-                        bs.sequencingMethod,
-                        bs.investigation_type,
-                        bs.qaqcStatus,
-                        bs.ncbiProjectID,
-                        bd.genomicsSampleID,
-                        bd.sequenceAnalysisType,
-                        bd.sampleMass,
-                        bd.nucleicAcidConcentration
-                    FROM 
-                        mms_benthicMetagenomeSequencing AS bs
-                    JOIN 
-                        mms_benthicMetagenomeDnaExtraction AS bd
-                    ON 
-                        bs.dnaSampleID = bd.dnaSampleID
-                ) AS merged
+            FROM (
+                SELECT
+                    bs.collectDate,
+                    bs.laboratoryName,
+                    bs.sequencingFacilityID,
+                    bs.processedDate,
+                    bs.dnaSampleID,
+                    bs.dnaSampleCode,
+                    bs.internalLabID,
+                    bs.instrument_model,
+                    bs.sequencingMethod,
+                    bs.investigation_type,
+                    bs.qaqcStatus,
+                    bs.ncbiProjectID,
+                    bd.genomicsSampleID,
+                    bd.sequenceAnalysisType,
+                    bd.sampleMass,
+                    bd.nucleicAcidConcentration
+                FROM mms_benthicMetagenomeSequencing AS bs
+                JOIN mms_benthicMetagenomeDnaExtraction AS bd
+                ON bs.dnaSampleID = bd.dnaSampleID
+            ) AS merged
             LEFT JOIN amb_fieldParent AS afp
-            ON
-                merged.genomicsSampleID = afp.geneticSampleID
+            ON merged.genomicsSampleID = afp.geneticSampleID
         """
-        benthic_samples = pd.read_sql_query(query, self.conn)
+        benthic_samples = pd.read_sql_query(join_query, self.conn)
         benthic_samples.to_sql(
             "benthicSamples", self.conn, if_exists="replace", index=False
         )
 
-        neon_biosample_ids = benthic_samples["sampleID"]
-        nmdc_biosample_ids = self._id_minter("nmdc:Biosample", len(neon_biosample_ids))
-        neon_to_nmdc_biosample_ids = dict(zip(neon_biosample_ids, nmdc_biosample_ids))
+        sample_ids = benthic_samples["sampleID"]
+        nmdc_biosample_ids = self._id_minter("nmdc:Biosample", len(sample_ids))
+        neon_to_nmdc_biosample_ids = dict(zip(sample_ids, nmdc_biosample_ids))
 
-        neon_extraction_ids = benthic_samples["sampleID"]
-        nmdc_extraction_ids = self._id_minter(
-            "nmdc:Extraction", len(neon_extraction_ids)
-        )
-        neon_to_nmdc_extraction_ids = dict(
-            zip(neon_extraction_ids, nmdc_extraction_ids)
-        )
+        nmdc_extraction_ids = self._id_minter("nmdc:Extraction", len(sample_ids))
+        neon_to_nmdc_extraction_ids = dict(zip(sample_ids, nmdc_extraction_ids))
 
-        neon_extraction_processed_ids = benthic_samples["sampleID"]
         nmdc_extraction_processed_ids = self._id_minter(
-            "nmdc:ProcessedSample", len(neon_extraction_processed_ids)
+            "nmdc:ProcessedSample", len(sample_ids)
         )
         neon_to_nmdc_extraction_processed_ids = dict(
-            zip(neon_extraction_processed_ids, nmdc_extraction_processed_ids)
+            zip(sample_ids, nmdc_extraction_processed_ids)
         )
 
-        neon_lib_prep_ids = benthic_samples["sampleID"]
-        nmdc_lib_prep_ids = self._id_minter(
-            "nmdc:LibraryPreparation", len(neon_lib_prep_ids)
-        )
-        neon_to_nmdc_lib_prep_ids = dict(zip(neon_lib_prep_ids, nmdc_lib_prep_ids))
+        nmdc_libprep_ids = self._id_minter("nmdc:LibraryPreparation", len(sample_ids))
+        neon_to_nmdc_libprep_ids = dict(zip(sample_ids, nmdc_libprep_ids))
 
-        neon_lib_prep_processed_ids = benthic_samples["sampleID"]
-        nmdc_lib_prep_processed_ids = self._id_minter(
-            "nmdc:ProcessedSample", len(neon_lib_prep_processed_ids)
+        nmdc_libprep_processed_ids = self._id_minter(
+            "nmdc:ProcessedSample", len(sample_ids)
         )
-        neon_to_nmdc_lib_prep_processed_ids = dict(
-            zip(neon_lib_prep_processed_ids, nmdc_lib_prep_processed_ids)
+        neon_to_nmdc_libprep_processed_ids = dict(
+            zip(sample_ids, nmdc_libprep_processed_ids)
         )
 
-        neon_omprc_ids = benthic_samples["sampleID"]
-        nmdc_omprc_ids = self._id_minter("nmdc:OmicsProcessing", len(neon_omprc_ids))
-        neon_to_nmdc_omprc_ids = dict(zip(neon_omprc_ids, nmdc_omprc_ids))
+        nmdc_ntseq_ids = self._id_minter("nmdc:NucleotideSequencing", len(sample_ids))
+        neon_to_nmdc_ntseq_ids = dict(zip(sample_ids, nmdc_ntseq_ids))
 
-        neon_raw_data_file_mappings_df = self.neon_raw_data_file_mappings_df
-        neon_raw_file_paths = neon_raw_data_file_mappings_df["rawDataFilePath"]
-        nmdc_data_object_ids = self._id_minter(
-            "nmdc:DataObject", len(neon_raw_file_paths)
-        )
-        neon_to_nmdc_data_object_ids = dict(
-            zip(neon_raw_file_paths, nmdc_data_object_ids)
-        )
+        raw_df = self.neon_raw_data_file_mappings_df
+        raw_file_paths = raw_df["rawDataFilePath"]
+        dataobject_ids = self._id_minter("nmdc:DataObject", len(raw_file_paths))
+        neon_to_nmdc_dataobject_ids = dict(zip(raw_file_paths, dataobject_ids))
 
-        for neon_id, nmdc_id in neon_to_nmdc_biosample_ids.items():
-            biosample_row = benthic_samples[benthic_samples["sampleID"] == neon_id]
+        for neon_id, biosample_id in neon_to_nmdc_biosample_ids.items():
+            row = benthic_samples[benthic_samples["sampleID"] == neon_id]
+            if row.empty:
+                continue
 
+            # Example of how you might call _translate_biosample:
             database.biosample_set.append(
-                self._translate_biosample(neon_id, nmdc_id, biosample_row)
+                self._translate_biosample(neon_id, biosample_id, row)
             )
 
-        for neon_id, nmdc_id in neon_to_nmdc_extraction_ids.items():
-            extraction_row = benthic_samples[benthic_samples["sampleID"] == neon_id]
+        for neon_id, extraction_id in neon_to_nmdc_extraction_ids.items():
+            row = benthic_samples[benthic_samples["sampleID"] == neon_id]
+            if row.empty:
+                continue
 
-            extraction_input = neon_to_nmdc_biosample_ids.get(neon_id)
-            processed_sample_id = neon_to_nmdc_extraction_processed_ids.get(neon_id)
+            biosample_id = neon_to_nmdc_biosample_ids.get(neon_id)
+            extraction_ps_id = neon_to_nmdc_extraction_processed_ids.get(neon_id)
 
-            if extraction_input is not None and processed_sample_id is not None:
-                database.extraction_set.append(
+            if biosample_id and extraction_ps_id:
+                database.material_processing_set.append(
                     self._translate_extraction_process(
-                        nmdc_id,
-                        extraction_input,
-                        processed_sample_id,
-                        extraction_row,
+                        extraction_id, biosample_id, extraction_ps_id, row
                     )
                 )
-
-                genomics_sample_id = _get_value_or_none(
-                    extraction_row, "genomicsSampleID"
-                )
-
+                genomics_sample_id = _get_value_or_none(row, "genomicsSampleID")
                 database.processed_sample_set.append(
                     self._translate_processed_sample(
-                        processed_sample_id,
+                        extraction_ps_id,
                         f"Extracted DNA from {genomics_sample_id}",
                     )
                 )
 
-        query = """
+        query2 = """
             SELECT dnaSampleID, GROUP_CONCAT(rawDataFilePath, '|') AS rawDataFilePaths
-            FROM neonRawDataFile
+            FROM mms_benthicRawDataFiles
             GROUP BY dnaSampleID
         """
-        neon_raw_data_files = pd.read_sql_query(query, self.conn)
-        neon_raw_data_files_dict = (
-            neon_raw_data_files.set_index("dnaSampleID")["rawDataFilePaths"]
+        raw_data_files_df = pd.read_sql_query(query2, self.conn)
+        dna_files_dict = (
+            raw_data_files_df.set_index("dnaSampleID")["rawDataFilePaths"]
             .str.split("|")
             .to_dict()
         )
-        filtered_neon_raw_data_files_dict = {
-            key: value
-            for key, value in neon_raw_data_files_dict.items()
-            if len(value) <= 2
-        }
-
-        for neon_id, nmdc_id in neon_to_nmdc_lib_prep_ids.items():
-            lib_prep_row = benthic_samples[benthic_samples["sampleID"] == neon_id]
-
-            lib_prep_input = neon_to_nmdc_extraction_processed_ids.get(neon_id)
-            processed_sample_id = neon_to_nmdc_lib_prep_processed_ids.get(neon_id)
-
-            if lib_prep_input is not None and processed_sample_id is not None:
-                database.library_preparation_set.append(
-                    self._translate_library_preparation(
-                        nmdc_id,
-                        lib_prep_input,
-                        processed_sample_id,
-                        lib_prep_row,
-                    )
+
+        dna_sample_to_manifest_id: dict[str, str] = {}
+
+        for neon_id, libprep_id in neon_to_nmdc_libprep_ids.items():
+            row = benthic_samples[benthic_samples["sampleID"] == neon_id]
+            if row.empty:
+                continue
+
+            extr_ps_id = neon_to_nmdc_extraction_processed_ids.get(neon_id)
+            libprep_ps_id = neon_to_nmdc_libprep_processed_ids.get(neon_id)
+            if not extr_ps_id or not libprep_ps_id:
+                continue
+
+            database.material_processing_set.append(
+                self._translate_library_preparation(
+                    libprep_id, extr_ps_id, libprep_ps_id, row
                 )
+            )
 
-                dna_sample_id = _get_value_or_none(lib_prep_row, "dnaSampleID")
+            dna_sample_id = _get_value_or_none(row, "dnaSampleID")
+            database.processed_sample_set.append(
+                self._translate_processed_sample(
+                    libprep_ps_id,
+                    f"Library preparation for {dna_sample_id}",
+                )
+            )
 
-                database.processed_sample_set.append(
-                    self._translate_processed_sample(
-                        processed_sample_id,
-                        f"Library preparation for {dna_sample_id}",
+            filepaths_for_dna: list[str] = dna_files_dict.get(dna_sample_id, [])
+            if not filepaths_for_dna:
+                # no raw files => skip
+                ntseq_id = neon_to_nmdc_ntseq_ids.get(neon_id)
+                if ntseq_id:
+                    continue
+                continue
+
+            # If multiple => we create a Manifest
+            manifest_id: Optional[str] = None
+            if len(filepaths_for_dna) > 2:
+                if dna_sample_id not in dna_sample_to_manifest_id:
+                    new_man_id = self._id_minter("nmdc:Manifest", 1)[0]
+                    dna_sample_to_manifest_id[dna_sample_id] = new_man_id
+                    database.manifest_set.append(self._translate_manifest(new_man_id))
+                manifest_id = dna_sample_to_manifest_id[dna_sample_id]
+
+            has_input_value = self.samp_procsm_dict.get(neon_id)
+            if not has_input_value:
+                continue
+
+            dataobject_ids_for_run: list[str] = []
+            for fp in filepaths_for_dna:
+                if fp not in neon_to_nmdc_dataobject_ids:
+                    continue
+                do_id = neon_to_nmdc_dataobject_ids[fp]
+
+                do_type = None
+                if "_R1.fastq.gz" in fp:
+                    do_type = "Metagenome Raw Read 1"
+                elif "_R2.fastq.gz" in fp:
+                    do_type = "Metagenome Raw Read 2"
+
+                database.data_object_set.append(
+                    self._translate_data_object(
+                        do_id=do_id,
+                        url=fp,
+                        do_type=do_type,
+                        manifest_id=manifest_id,
                     )
                 )
-
-                has_output = None
-                has_output_do_ids = []
-
-                if dna_sample_id in filtered_neon_raw_data_files_dict:
-                    has_output = filtered_neon_raw_data_files_dict[dna_sample_id]
-                    for item in has_output:
-                        if item in neon_to_nmdc_data_object_ids:
-                            has_output_do_ids.append(neon_to_nmdc_data_object_ids[item])
-
-                        checksum = None
-                        do_type = None
-
-                        checksum = neon_raw_data_file_mappings_df[
-                            neon_raw_data_file_mappings_df["rawDataFilePath"] == item
-                        ]["checkSum"].values[0]
-                        if "_R1.fastq.gz" in item:
-                            do_type = "Metagenome Raw Read 1"
-                        elif "_R2.fastq.gz" in item:
-                            do_type = "Metagenome Raw Read 2"
-
-                        database.data_object_set.append(
-                            self._translate_data_object(
-                                neon_to_nmdc_data_object_ids.get(item),
-                                item,
-                                do_type,
-                                checksum,
-                            )
-                        )
-
-                    database.omics_processing_set.append(
-                        self._translate_omics_processing(
-                            neon_to_nmdc_omprc_ids.get(neon_id),
-                            processed_sample_id,
-                            has_output_do_ids,
-                            lib_prep_row,
-                        )
+                dataobject_ids_for_run.append(do_id)
+
+            ntseq_id = neon_to_nmdc_ntseq_ids.get(neon_id)
+            if ntseq_id:
+                database.data_generation_set.append(
+                    self._translate_nucleotide_sequencing(
+                        ntseq_id,
+                        has_input_value,  # <--- from self.samp_procsm_dict
+                        dataobject_ids_for_run,
+                        row,
                     )
+                )
 
         return database