ontology-loader 0.1.1__tar.gz

ontology_loader-0.1.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.3
+Name: ontology-loader
+Version: 0.1.1
+Summary: ontology_loader
+License: MIT
+Author: Sierra Moxon
+Author-email: smoxon@lbl.gov
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: chromadb (>=0.5.15,<0.6.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: curies (>=0.8.0,<0.9.0)
+Requires-Dist: linkml-store (>=0.2.6,<0.3.0)
+Requires-Dist: mongomock (>=4.3.0,<5.0.0)
+Requires-Dist: motor (>=3.6.0,<4.0.0)
+Requires-Dist: neo4j (>=5.25.0,<6.0.0)
+Requires-Dist: nmdc-schema
+Requires-Dist: oaklib (>=0.6.16,<0.7.0)
+Requires-Dist: pymongo (>=4.9.1,<5.0.0)
+Requires-Dist: pystow (>=0.5.6,<0.6.0)
+Requires-Dist: pytest (>=8.3.4,<9.0.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
+Requires-Dist: tox (>=4.24.1,<5.0.0)
+Description-Content-Type: text/markdown
+
+## ontology_loader
+
+Suite of tools to configure and load an ontology from the OboFoundary into the data object for OntologyClass as 
+specified by NMDC schema.
+
+## Development Environment
+
+#### Pre-requisites
+
+- >=Python 3.9
+- Poetry
+- Docker
+- MongoDB
+- NMDC materialized schema
+- ENV variable for MONGO_PASSWORD (or pass it in via the cli/runner itself directly)
+
+```bash
+
+% docker pull mongo
+% docker run -d --name mongodb-container -p 27017:27017 mongo
+```
+
+#### Basic mongosh commands
+```bash
+% docker ps
+% docker exec -it [mongodb-container-id] bash
+% mongosh
+% show dbs
+% use test
+% db.ontology_class_set.find().pretty()
+% db.ontology_relation_set.find().pretty()
+``` 
+
+#### Command line
+```bash
+% poetry install
+% poetry run ontology_loader --help
+% poetry run ontology_loader --source-ontology "envo"
+% poetry run ontology_loader --source-ontology "go"
+```
+
+#### Running the tests
+```bash
+% make test
+```
+
+#### Running the linter
+```bash
+% make lint
+```
+
+#### python example usage
+```bash
+pip install nmdc-ontology-loader
+```
+
+```python
+from  nmdc_ontology_loader.ontology_loader import OntologyLoader
+import tempfile
+
+def test_load_ontology():
+    """Test the load_ontology method."""
+    ontology_loader = OntologyLoader(
+        source_ontology="envo",
+        output_directory=tempfile.gettempdir(),
+        generate_reports=True,
+    )
+    ontology_loader.load_ontology()
+    assert ontology_loader.ontology_class_set
+    assert ontology_loader.ontology_relation_set
+    assert ontology_loader.ontology_class_set.count() > 0
+    assert ontology_loader.ontology_relation_set.count() > 0
+```

ontology_loader-0.1.1/README.md

@@ -0,0 +1,73 @@
+## ontology_loader
+
+Suite of tools to configure and load an ontology from the OboFoundary into the data object for OntologyClass as 
+specified by NMDC schema.
+
+## Development Environment
+
+#### Pre-requisites
+
+- >=Python 3.9
+- Poetry
+- Docker
+- MongoDB
+- NMDC materialized schema
+- ENV variable for MONGO_PASSWORD (or pass it in via the cli/runner itself directly)
+
+```bash
+
+% docker pull mongo
+% docker run -d --name mongodb-container -p 27017:27017 mongo
+```
+
+#### Basic mongosh commands
+```bash
+% docker ps
+% docker exec -it [mongodb-container-id] bash
+% mongosh
+% show dbs
+% use test
+% db.ontology_class_set.find().pretty()
+% db.ontology_relation_set.find().pretty()
+``` 
+
+#### Command line
+```bash
+% poetry install
+% poetry run ontology_loader --help
+% poetry run ontology_loader --source-ontology "envo"
+% poetry run ontology_loader --source-ontology "go"
+```
+
+#### Running the tests
+```bash
+% make test
+```
+
+#### Running the linter
+```bash
+% make lint
+```
+
+#### python example usage
+```bash
+pip install nmdc-ontology-loader
+```
+
+```python
+from  nmdc_ontology_loader.ontology_loader import OntologyLoader
+import tempfile
+
+def test_load_ontology():
+    """Test the load_ontology method."""
+    ontology_loader = OntologyLoader(
+        source_ontology="envo",
+        output_directory=tempfile.gettempdir(),
+        generate_reports=True,
+    )
+    ontology_loader.load_ontology()
+    assert ontology_loader.ontology_class_set
+    assert ontology_loader.ontology_relation_set
+    assert ontology_loader.ontology_class_set.count() > 0
+    assert ontology_loader.ontology_relation_set.count() > 0
+```

ontology_loader-0.1.1/pyproject.toml

@@ -0,0 +1,92 @@
+[tool.poetry]
+version = "0.1.1"
+description = "ontology_loader"
+authors = ["Sierra Moxon <smoxon@lbl.gov>"]
+license = "MIT"
+readme = "README.md"
+name = "ontology-loader"
+packages = [{ include = "ontology_loader", from = "src" }]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pymongo = "^4.9.1"
+nmdc-schema = "*"
+oaklib = "^0.6.16"
+click = "^8.1.7"
+curies = "^0.8.0"
+linkml-store = "^0.2.6"
+tiktoken = "^0.8.0"
+tabulate = "^0.9.0"
+chromadb = "^0.5.15"
+neo4j = "^5.25.0"
+motor = "^3.6.0"
+pystow = "^0.5.6"
+tox = "^4.24.1"
+pytest = "^8.3.4"
+mongomock = "^4.3.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = {version = ">=7.1.2"}
+tox = {version = ">=3.25.1"}
+pre-commit = {version = ">=3.3.3"}
+
+[tool.poetry.group.docs]
+optional = true
+
+[tool.poetry.group.docs.dependencies]
+sphinx = {version = ">=6.1.3"}
+sphinx-rtd-theme = {version = ">=1.0.0"}
+sphinx-autodoc-typehints = {version = ">=1.2.0"}
+sphinx-click = {version = ">=4.3.0"}
+myst-parser = {version = ">=0.18.1"}
+
+[tool.poetry.scripts]
+ontology_loader = "ontology_loader.cli:main"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+style = "pep440"
+
+
+[tool.black]
+line-length = 120
+target-version = ["py38", "py39", "py310"]
+
+[tool.ruff]
+extend-ignore = [
+    "D211",  # `no-blank-line-before-class`
+    "D212",  # `multi-line-summary-first-line`
+    ]
+line-length = 120
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+
+# Select or ignore from https://beta.ruff.rs/docs/rules/
+select = [
+    "B",  # bugbear
+    "D",  # pydocstyle
+    "E",  # pycodestyle errors
+    "F",  # Pyflakes
+    "I",  # isort 
+    "S",  # flake8-bandit
+    "W",  # Warning
+]
+
+unfixable = []
+target-version = "py311"
+
+[tool.ruff.mccabe]
+# Unlike Flake8, default to a complexity level of 10.
+max-complexity = 10
+
+[tool.codespell]
+skip = "*.po,*.ts,.git,pyproject.toml"
+count = ""
+quiet-level = 3
+# ignore-words-list = ""
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]
+build-backend = "poetry_dynamic_versioning.backend"

ontology_loader-0.1.1/src/ontology_loader/__init__.py

@@ -0,0 +1,8 @@
+"""Ontology Loader package."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("ontology-loader")
+except PackageNotFoundError:
+    __version__ = "unknown"

ontology_loader-0.1.1/src/ontology_loader/cli.py

@@ -0,0 +1,53 @@
+"""Cli methods for ontology loading from the command line."""
+
+import logging
+import os
+
+import click
+
+from src.ontology_loader.ontology_load_controller import OntologyLoaderController
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option("--db-host", default=os.getenv("MONGO_HOST", "localhost"), help="MongoDB connection URL")
+@click.option("--db-port", default=int(os.getenv("MONGO_PORT", 27018)), help="MongoDB connection port")
+@click.option("--db-name", default=os.getenv("MONGO_DB", "nmdc"), help="Database name")
+@click.option("--db-user", default=os.getenv("MONGO_USER", "admin"), help="Database user")
+@click.option("--db-password", default=os.getenv("MONGO_PASSWORD", ""), help="Database password")
+@click.option("--source-ontology", default="envo", help="Lowercase ontology prefix, e.g., envo, go, uberon, etc.")
+@click.option("--output-directory", default=None, help="Output directory for reporting, default is /tmp")
+@click.option("--generate-reports", default=True, help="Generate reports")
+def cli(db_host, db_port, db_name, db_user, db_password, source_ontology, output_directory, generate_reports):
+    """
+    CLI entry point for the ontology loader.
+
+    :param db_host: MongoDB connection URL, default is localhost
+    :param db_port: MongoDB connection port, default is 27018
+    :param db_name: Database name, default is nmdc
+    :param db_user: Database user, default is admin
+    :param db_password: Database password, default is blank
+    :param source_ontology: Lowercase ontology prefix, e.g., envo, go, uberon, etc.
+    :param output_directory: Output directory for reporting, default is /tmp
+    :param generate_reports: Generate reports or not, default is True
+    """
+    logger.info(f"Processing ontology: {source_ontology}")
+
+    # Initialize the MongoDB Loader
+    loader = OntologyLoaderController(
+        db_host=db_host,
+        db_port=db_port,
+        db_name=db_name,
+        db_user=db_user,
+        db_password=db_password,
+        source_ontology=source_ontology,
+        output_directory=output_directory,
+        generate_reports=generate_reports,
+    )
+    loader.run_ontology_loader()
+
+
+if __name__ == "__main__":
+    cli()

ontology_loader-0.1.1/src/ontology_loader/mongo_db_config.py

@@ -0,0 +1,21 @@
+"""Singleton class to store default parameters accessed from client environment or sensible defaults."""
+
+import os
+
+
+class MongoDBConfig:
+
+    """Singleton class to store default parameters accessed from client environment or sensible defaults."""
+
+    _instance = None
+
+    def __new__(cls):
+        """Create a new instance of MongoDBConfig if it does not exist."""
+        if cls._instance is None:
+            cls._instance = super(MongoDBConfig, cls).__new__(cls)
+            cls._instance.db_name = os.getenv("MONGO_DB", "nmdc")
+            cls._instance.db_user = os.getenv("MONGO_USER", "admin")
+            cls._instance.db_password = os.getenv("MONGO_PASSWORD", "")
+            cls._instance.db_host = os.getenv("MONGO_HOST", "localhost")
+            cls._instance.db_port = int(os.getenv("MONGO_PORT", 27018))
+        return cls._instance

ontology_loader-0.1.1/src/ontology_loader/mongodb_loader.py

@@ -0,0 +1,117 @@
+"""Load and process ontology terms and relations into MongoDB."""
+
+import logging
+from dataclasses import asdict, fields
+from typing import List, Optional
+
+from linkml_runtime import SchemaView
+from linkml_store import Client
+from nmdc_schema.nmdc import OntologyClass
+
+from src.ontology_loader.mongo_db_config import MongoDBConfig
+from src.ontology_loader.reporter import Report
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class MongoDBLoader:
+
+    """MongoDB Loader class to upsert OntologyClass objects and insert OntologyRelation objects into MongoDB."""
+
+    def __init__(self, schema_view: Optional[SchemaView] = None):
+        """
+        Initialize MongoDB using LinkML-store's client.
+
+        :param schema_view: LinkML SchemaView for ontology
+        :param db_config: Singleton configuration for MongoDB connection
+        """
+        db_config = MongoDBConfig()
+        self.schema_view = schema_view
+        self.db_host = db_config.db_host
+        self.db_port = db_config.db_port
+        self.db_name = db_config.db_name
+        self.db_user = db_config.db_user
+        self.db_password = db_config.db_password
+
+        # TODO: it might be that we are providing the connection string "incorrectly" (or differently) in linkml-store
+        # this exists so that the default env parameters in nmdc-runtime can be used as they are currently
+        # specified.
+        if self.db_host.startswith("mongodb://"):
+            # mongodb://mongo:27017
+            self.db_host = self.db_host.replace("mongodb://", "")
+            self.db_port = int(self.db_host.split(":")[1])
+            self.db_host = self.db_host.split(":")[0]
+
+        self.handle = (
+            f"mongodb://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}?authSource=admin"
+        )
+
+        logger.info(self.handle)
+        self.client = Client(handle=self.handle)
+
+        # Explicitly set the correct database
+        self.db = self.client.attach_database(
+            handle=self.handle,  # Ensure correct database is used
+        )
+        logger.info(f"Connected to MongoDB: {self.db}")
+
+    def upsert_ontology_classes(
+        self, ontology_classes: List[OntologyClass], collection_name: str = "ontology_class_set"
+    ):
+        """
+        Upsert each OntologyClass object into the 'ontology_class_set' collection and return reports.
+
+        :param ontology_classes: A list of OntologyClass objects to upsert
+        :param collection_name: The name of the MongoDB collection to upsert into.
+        :return: A tuple of two Report objects: one for updates and one for insertions.
+        """
+        collection = self.db.create_collection(collection_name, recreate_if_exists=False)
+        collection.index("id", unique=False)
+        logging.info(collection_name)
+
+        if not ontology_classes:
+            logging.info("No OntologyClass objects to upsert.")
+            return Report("update", [], []), Report("insert", [], [])
+
+        updates_report = []
+        insertions_report = []
+        ontology_fields = [field.name for field in fields(OntologyClass)]
+
+        for obj in ontology_classes:
+            filter_criteria = {"id": obj.id}
+            query_result = collection.find(filter_criteria)
+            existing_doc = query_result.rows[0] if query_result.num_rows > 0 else None
+
+            if existing_doc:
+                updated_fields = {
+                    key: getattr(obj, key) for key in ontology_fields if getattr(obj, key) != existing_doc.get(key)
+                }
+                if updated_fields:
+                    collection.upsert([asdict(obj)], filter_fields=["id"], update_fields=list(updated_fields.keys()))
+                    logging.debug(f"Updated existing OntologyClass (id={obj.id}): {updated_fields}")
+                    updates_report.append([obj.id] + [getattr(obj, field, "") for field in ontology_fields])
+                else:
+                    logging.debug(f"No changes detected for OntologyClass (id={obj.id}). Skipping update.")
+            else:
+                collection.upsert([asdict(obj)], filter_fields=["id"], update_fields=ontology_fields)
+                logging.debug(f"Inserted new OntologyClass (id={obj.id}).")
+                insertions_report.append([obj.id] + [getattr(obj, field, "") for field in ontology_fields])
+
+        logging.info(f"Finished upserting {len(ontology_classes)} OntologyClass objects into MongoDB.")
+        return Report("update", updates_report, ontology_fields), Report("insert", insertions_report, ontology_fields)
+
+    def insert_ontology_relations(self, ontology_relations, collection_name: str = "ontology_relation_set"):
+        """
+        Insert each OntologyClass object into the 'ontology_class_set' collection.
+
+        :param ontology_relations: A list of OntologyRelation objects to insert
+        :param collection_name: The name of the MongoDB collection to insert into.
+
+        """
+        collection = self.db.create_collection(collection_name, recreate_if_exists=False)
+        if ontology_relations:
+            for relation in ontology_relations:
+                collection.insert(relation)
+        else:
+            logger.info("No OntologyRelation objects to insert.")

ontology_loader-0.1.1/src/ontology_loader/ontology_load_controller.py

@@ -0,0 +1,72 @@
+"""Cli methods for ontology loading from the command line."""
+
+import logging
+import tempfile
+
+from src.ontology_loader.mongodb_loader import MongoDBLoader
+from src.ontology_loader.ontology_processor import OntologyProcessor
+from src.ontology_loader.reporter import ReportWriter
+from src.ontology_loader.utils import load_yaml_from_package
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class OntologyLoaderController:
+
+    """
+    OntologyLoader runner class for MongoDBLoader.
+
+    This class is responsible for running the MongoDBLoader with the given parameters from code other than
+    the command line support offered through the cli.py click interface.
+    """
+
+    def __init__(
+        self,
+        source_ontology: str = "envo",
+        output_directory: str = tempfile.gettempdir(),
+        generate_reports: bool = True,
+    ):
+        """Set the parameters for the OntologyLoader."""
+        self.source_ontology = source_ontology
+        self.output_directory = output_directory
+        self.generate_reports = generate_reports
+
+    def run_ontology_loader(self):
+        """Run the OntologyLoader and insert data into MongoDB."""
+        logging.info(f"Processing ontology: {self.source_ontology}")
+
+        # Load Schema View
+        nmdc_sv = load_yaml_from_package("nmdc_schema", "nmdc_materialized_patterns.yaml")
+        # Initialize the Ontology Processor
+        processor = OntologyProcessor(self.source_ontology)
+
+        # Process ontology terms and return a list of OntologyClass dicts produced by linkml json dumper as dict
+        ontology_classes = processor.get_terms_and_metadata()
+
+        logger.info(f"Extracted {len(ontology_classes)} ontology classes.")
+
+        # Process ontology relations and create OntologyRelation objects
+        ontology_relations = processor.get_relations_closure()
+
+        logger.info(f"Extracted {len(ontology_relations)} ontology relations.")
+
+        # Connect to MongoDB
+        db_manager = MongoDBLoader(schema_view=nmdc_sv)
+        # Insert data into MongoDB
+        updates_report, insertions_report = db_manager.upsert_ontology_classes(ontology_classes)
+        db_manager.insert_ontology_relations(ontology_relations)
+        db_manager.insert_ontology_relations(ontology_relations)
+
+        # Optionally write job reports
+        if self.generate_reports:
+            ReportWriter.write_reports(
+                reports=[updates_report, insertions_report], output_format="tsv", output_directory=self.output_directory
+            )
+
+        logger.info("Processing complete. Data inserted into MongoDB.")
+
+
+if __name__ == "__main__":
+    """Run the OntologyLoader."""
+    OntologyLoaderController().run_ontology_loader()

ontology_loader-0.1.1/src/ontology_loader/ontology_processor.py

@@ -0,0 +1,109 @@
+"""Ontology Processor class to process ontology terms and relations."""
+
+import gzip
+import logging
+import shutil
+
+import pystow
+from linkml_runtime.dumpers import json_dumper
+from nmdc_schema.nmdc import OntologyClass, OntologyRelation
+from oaklib import get_adapter
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class OntologyProcessor:
+
+    """Ontology Processor class to process ontology terms and relations."""
+
+    def __init__(self, ontology: str):
+        """
+        Initialize the OntologyProcessor with a given SQLite ontology.
+
+        :param ontology: The ontology prefix (e.g., "envo", "go", "uberon", etc.)
+
+        """
+        self.ontology = ontology
+        self.ontology_db_path = self.download_and_prepare_ontology()
+        self.adapter = get_adapter(f"sqlite:{self.ontology_db_path}")
+        self.adapter.precompute_lookups()  # Optimize lookups
+
+    def download_and_prepare_ontology(self):
+        """Download and prepare the ontology database for processing."""
+        logger.info(f"Preparing ontology: {self.ontology}")
+
+        # Get the ontology-specific pystow directory
+        source_ontology_module = pystow.module(self.ontology).base  # Example: ~/.pystow/envo
+
+        # If the directory exists, remove it and all its contents
+        if source_ontology_module.exists():
+            logger.info(f"Removing existing pystow directory for {self.ontology}: {source_ontology_module}")
+            shutil.rmtree(source_ontology_module)
+
+        # Define ontology URL
+        ontology_db_url_prefix = "https://s3.amazonaws.com/bbop-sqlite/"
+        ontology_db_url_suffix = ".db.gz"
+        ontology_url = ontology_db_url_prefix + self.ontology + ontology_db_url_suffix
+
+        # Define paths (download to the module-specific directory)
+        compressed_path = pystow.ensure(self.ontology, f"{self.ontology}.db.gz", url=ontology_url)
+        decompressed_path = compressed_path.with_suffix("")  # Remove .gz to get .db file
+
+        # Extract the file if not already extracted
+        if not decompressed_path.exists():
+            logger.info(f"Extracting {compressed_path} to {decompressed_path}...")
+            with gzip.open(compressed_path, "rb") as f_in:
+                with open(decompressed_path, "wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+
+        logger.info(f"Ontology database is ready at: {decompressed_path}")
+        return decompressed_path
+
+    def get_terms_and_metadata(self):
+        """Retrieve all terms that start with the ontology prefix and return a list of OntologyClass objects."""
+        ontology_classes = []
+
+        for entity in self.adapter.entities():
+            if entity.startswith(self.ontology.upper() + ":"):
+                ontology_class = OntologyClass(
+                    id=entity,
+                    type="nmdc:OntologyClass",
+                    alternative_names=self.adapter.entity_aliases(entity) or [],
+                    definition=self.adapter.definition(entity) or "",
+                )
+
+                ontology_classes.append(ontology_class)
+
+        return ontology_classes
+
+    def get_relations_closure(self, predicates=None):
+        """
+        Retrieve all ontology relations closure for terms.
+
+        :param predicates: List of predicates to consider (default: ["rdfs:subClassOf", "BFO:0000050"])
+
+        """
+        predicates = ["rdfs:subClassOf", "BFO:0000050"] if predicates is None else predicates
+        ontology_relations = []
+
+        for entity in self.adapter.entities():
+            if entity.startswith(self.ontology.upper() + ":"):
+                # Convert generator to list
+                ancestors_list = list(self.adapter.ancestors(entity, reflexive=True, predicates=predicates))
+
+                # Filter to keep only ENVO terms
+                filtered_ancestors = list(set(a for a in ancestors_list if a.startswith(self.ontology.upper() + ":")))
+
+                for ancestor in filtered_ancestors:
+                    ontology_relation = OntologyRelation(
+                        subject=entity,
+                        predicate="is_a",  # TODO: fix this to the real predicate that it came with
+                        object=ancestor,
+                        type="nmdc:OntologyRelation",
+                    )
+
+                    # Convert OntologyRelation instance to a dictionary
+                    ontology_relations.append(json_dumper.to_dict(ontology_relation))
+
+        return ontology_relations

ontology_loader-0.1.1/src/ontology_loader/reporter.py

@@ -0,0 +1,42 @@
+"""Reporting class to handle TSV dumping."""
+
+import csv
+import logging
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Report:
+
+    """Dataclass to hold report data."""
+
+    report_type: str  # "update" or "insert"
+    records: List[List[str]]
+    headers: List[str]
+
+
+class ReportWriter:
+
+    """ReportWriter class to write reports to TSV files."""
+
+    @staticmethod
+    def write_reports(reports: List[Report], output_format: str = "tsv", output_directory: Optional[str] = None):
+        """Write reports to TSV files."""
+        if output_directory is None:
+            output_directory = Path(tempfile.gettempdir())
+        else:
+            output_directory = Path(output_directory)
+
+        for report in reports:
+            file_path = output_directory / f"ontology_{report.report_type}s.{output_format}"
+            with file_path.open(mode="w", newline="", encoding="utf-8") as f:
+                writer = csv.writer(f, delimiter="\t") if output_format == "tsv" else csv.writer(f)
+                writer.writerow(["id"] + report.headers)
+                writer.writerows(report.records)
+            logging.info(f"Report generated: {file_path}")

ontology_loader-0.1.1/src/ontology_loader/utils.py

@@ -0,0 +1,17 @@
+"""Loads a YAML file from a given package."""
+
+import importlib.resources
+
+from linkml_runtime.utils.schemaview import SchemaView
+
+
+def load_yaml_from_package(package: str, filename: str) -> SchemaView:
+    """
+    Load a YAML file from a given package.
+
+    :param package: The package where the YAML file is located (e.g., "nmdc_schema").
+    :param filename: The YAML file to load (e.g., "nmdc_materialized_patterns.yaml").
+    :return: Parsed YAML data as a Python dictionary.
+    """
+    with importlib.resources.files(package).joinpath(filename).open("r") as f:
+        return SchemaView(f)