Prep for v1.0.5 (#460)

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ontogpt"
-version = "1.0.4"
+version = "1.0.5"
 description = "OntoGPT"
 authors = ["Chris Mungall <cjmungall@lbl.gov>", "J. Harry Caufield <jhc@lbl.gov>"]
 license = "BSD-3"
@@ -19,7 +19,7 @@ fastapi = {version = ">=0.88.0", optional = true}
 gilda = ">=1.0.0"
 inflect = ">=6.0.2"
 inflection = ">=0.5.1"
-linkml = "^1.8.0"
+linkml = "^1.8.3"
 linkml-owl = "^0.3.0"
 myst-parser = {version = ">=0.18.1", extras = ["docs"], optional = true}
 oaklib = ">=0.5.28"

src/ontogpt/clients/llm_client.py

@@ -20,6 +20,7 @@
 # Necessary to avoid repeated debug messages
 litellm.suppress_debug_info = True
 
+
 @dataclass
 class LLMClient:
 

src/ontogpt/engines/embedding_similarity_engine.py

@@ -1,4 +1,22 @@
-"""Similarity engine."""
+"""
+Embedding similarity engine.
+
+This module provides functionality for calculating the similarity between entities
+using embeddings and cosine similarity. It includes classes and methods for
+searching for similar entities and retrieving textual representations of entities.
+
+Classes:
+ EmbeddingSimilarity: A dataclass representing the similarity between two entities.
+ SimilarityEngine: A class for calculating similarity between entities.
+
+Methods:
+ SimilarityEngine.similarity(entity1: str, entity2: str) -> EmbeddingSimilarity:
+ Get similarity between two entities.
+ SimilarityEngine.search(entity1: str, entities: List[str]) -> Iterable[EmbeddingSimilarity]:
+ Search for similar entities.
+ SimilarityEngine.entity_text(entity: str) -> str:
+ Get text representation for an entity.
+"""
 
 import logging
 from dataclasses import dataclass
@@ -25,7 +43,7 @@ class EmbeddingSimilarity:
 
 @dataclass
 class SimilarityEngine(KnowledgeEngine):
- """Engine for generating synonyms."""
+ """Engine for finding embedding similarity."""
 
  adapter: BasicOntologyInterface = None
  autolabel: bool = True

src/ontogpt/engines/knowledge_engine.py

@@ -51,11 +51,13 @@ def chunk_text_by_sentence(text: str, window_size=3) -> Iterator[str]:
  left_index = max(0, right_index - window_size)
  yield ". ".join(sentences[left_index:right_index])
 
+
 def chunk_text_by_char(text: str, window_size=1000) -> Iterator[str]:
  """Chunk text into windows of characters."""
  for i in range(0, len(text), window_size):
  yield text[i : i + window_size]
 
+
 @dataclass
 class KnowledgeEngine(ABC):
  """

src/ontogpt/engines/mapping_engine.py

@@ -1,4 +1,34 @@
-"""Synonym engine."""
+"""
+Mapping engine.
+
+This module provides the `MappingEngine` class,
+which is responsible for generating and resolving
+mappings between concepts in different ontologies.
+It utilizes various classes and enums to represent
+mapping tasks, categorized mappings, and confidence levels.
+
+Classes:
+ MappingPredicate: Enum representing different types of mapping predicates.
+ Confidence: Enum representing different levels of confidence.
+ CategorizedMapping: Model representing a categorized mapping with various attributes.
+ MappingTask: Model representing a mapping task with various attributes.
+ MappingTaskCollection: Model representing a collection of mapping tasks.
+ Relationship: Model representing a relationship between concepts.
+ Concept: Model representing a concept with various attributes.
+ MappingEngine: Engine class for generating and resolving mappings.
+
+Functions:
+ categorize_mapping: Categorizes a mapping between a subject
+ and an object using a template.
+ _parse: Parses the payload from the categorization process into a `CategorizedMapping`.
+ categorize_mappings: Categorizes multiple mappings between subjects and object sources.
+ run_tasks: Runs a collection of mapping tasks and categorizes the results.
+ generate_tasks: Generates mapping tasks from a collection or
+ specified subjects and object sources.
+ from_sssom: Generates tasks from an SSSOM file.
+ categorize_sssom_mapping: Categorizes a single SSSOM mapping.
+ _concept: Retrieves a concept from an ontology adapter.
+"""
 
 import logging
 from copy import deepcopy

src/ontogpt/engines/reasoner_engine.py

@@ -1,4 +1,31 @@
-"""Reasoner engine."""
+"""
+Reasoner engine.
+
+This module provides the implementation of the
+ReasonerEngine class, which is used to perform
+reasoning tasks using a Language Model (LLM).
+The engine takes an ontology and a query task as input,
+translates it into an LLM prompt, and performs
+reasoning over the ontology.
+
+Classes:
+ ReasonerResult: Represents the result of a reason query.
+ ReasonerResultSet: Represents a set of reasoner results.
+ ReasonerEngine: Engine for performing reasoning using an LLM.
+
+Functions:
+ flatten_list(lst): Flattens a nested list into a single list.
+ reason(task, template_path=None, strict=False, evaluate=None): Performs
+ reasoning over axioms and query entailments.
+ reason_multiple(task_collection, **kwargs): Performs reasoning over multiple tasks.
+ _parse_single_answer(payload, task): Parses a single answer from the payload.
+ evaluate(result, task): Evaluates the result against the task.
+
+Usage:
+ The ReasonerEngine can be used to perform reasoning tasks
+ such as finding superclasses of a given class.
+ It can also provide explanations for the reasoning process.
+"""
 
 import logging
 import re

src/ontogpt/engines/spires_engine.py

@@ -504,19 +504,21 @@ def _parse_response_to_dict(
  # First split the text into sections, denoted by presence of multiple newlines
  # Each section may still have multiple fields, but we don't know how
  # they will be formatted
- sections = results.replace("*","").split("\n\n")
+ sections = results.replace("*", "").split("\n\n")
  ann = {}
  for section in sections:
  lines = section.splitlines()
  continued_line = ""
  for line in lines:
- line = line.replace("*","").strip()
+ line = line.replace("*", "").strip()
  # The line may be split into multiple lines,
  # and we can only tell if there's a delimiter at the end of this one
  # (though it may just be a misplaced delimiter)
  # TODO: this could be a different delimiter, globally defined
  if line.endswith(";"):
- logging.info(f"This line ends in a delimiter, assuming continuation: {line}")
+ logging.info(
+ f"This line ends in a delimiter, assuming continuation: {line}"
+ )
  continued_line = line
  continue
  # If there's nothing after the colon,

src/ontogpt/engines/synonym_engine.py

@@ -1,4 +1,20 @@
-"""Synonym engine."""
+"""
+Synonym engine.
+
+This module defines the SynonymEngine class,
+which is responsible for generating synonyms
+for given named entities within a specified domain.
+
+Classes:
+ SynonymEngine: Inherits from KnowledgeEngine and
+ provides a method to retrieve synonyms.
+
+Methods:
+ synonyms(named_entity: str, domain: str) -> List[str]:
+ Retrieves synonyms for the given named entity
+ within the specified domain.
+"""
+
 from dataclasses import dataclass
 from typing import List
 

src/ontogpt/engines/topic_classifier_engine.py

@@ -1,4 +1,17 @@
-"""Topic classifier engine."""
+"""
+Topic classifier engine.
+
+This module contains the `TopicClassifierEngine` class, which inherits from `KnowledgeEngine`.
+The engine is designed to classify input text based on a given topic.
+
+Classes:
+ TopicClassifierEngine: Engine for classifying input text based on its topic.
+
+Methods:
+ binary_classify(topic: str, text: str) -> bool:
+ Given a topic description, indicate whether it applies to the input text.
+ Returns True if the text matches the topic, otherwise returns False.
+"""
 
 import logging
 
@@ -8,6 +21,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 @dataclass
 class TopicClassifierEngine(KnowledgeEngine):
  """Engine for classifying input text based on its topic."""

src/ontogpt/evaluation/maxo/eval_maxo.py

@@ -244,7 +244,9 @@ def eval(self) -> EvaluationObjectSetRE:
  if extraction.extracted_object is not None:
  # Process all multi-object triples to 1 to 1 triples
  # so they may be more directly compared
- for extracted_triple in extraction.extracted_object.action_annotation_relationships:
+ for (
+ extracted_triple
+ ) in extraction.extracted_object.action_annotation_relationships:
  new_triple = extracted_triple
  for object in extracted_triple.object:
  new_triple.object = [object]

src/ontogpt/utils/clinical_cases.py

@@ -30,4 +30,4 @@ def get_kanjee_prompt() -> str:
  " the diagnoses. Again, the goal is to be as specific as possible with each of the "
  "diagnoses. Do you have any questions, Dr. GPT-4?\n\nHere is the case:"
  )
- return prompt
+ return prompt

src/ontogpt/webapp/main.py

@@ -55,9 +55,7 @@ class Query(BaseModel):
 def get_engine(datamodel: str, llm_model: str):
  if datamodel not in engines:
  template_details = get_template_details(template=datamodel)
- engines[datamodel] = SPIRESEngine(
- model=llm_model, template_details=template_details
- )
+ engines[datamodel] = SPIRESEngine(model=llm_model, template_details=template_details)
  return engines[datamodel]