biomapper 0.3.2__tar.gz → 0.4.0__tar.gz

{biomapper-0.3.2 → biomapper-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biomapper
-Version: 0.3.2
+Version: 0.4.0
 Summary: A unified Python toolkit for biological data harmonization and ontology mapping
 Home-page: https://github.com/arpanauts/biomapper
 License: MIT
@@ -20,19 +20,26 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Provides-Extra: api
 Provides-Extra: full
+Requires-Dist: chromadb (>=0.6.2,<0.7.0)
 Requires-Dist: cloudpickle (>=3.0.0,<4.0.0)
+Requires-Dist: cryptography (>=43.0.1)
 Requires-Dist: dspy-ai (>=2.1.8,<3.0.0)
 Requires-Dist: langfuse (>=2.57.1,<3.0.0)
 Requires-Dist: libChEBIpy (==1.0.10)
 Requires-Dist: matplotlib (>=3.8.0,<4.0.0)
+Requires-Dist: numpy (<2.0.0)
 Requires-Dist: openai (>=1.14.0,<2.0.0)
 Requires-Dist: pandas (>=2.0.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: python-multipart (==0.0.10)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: rdkit (>=2023.9.1,<2024.0.0)
 Requires-Dist: requests (>=2.25.1,<3.0.0)
 Requires-Dist: seaborn (>=0.13.0,<0.14.0)
 Requires-Dist: sqlalchemy (>=1.4.0,<2.0.0)
+Requires-Dist: torch (>=2.2.0,<3.0.0)
 Requires-Dist: tqdm (>=4.66.1,<5.0.0)
+Requires-Dist: transformers (>=4.38.2,<5.0.0)
 Requires-Dist: upsetplot (>=0.8.0,<0.9.0)
 Requires-Dist: venn (>=0.1.3,<0.2.0)
 Project-URL: Documentation, https://github.com/arpanauts/biomapper/blob/main/README.md

{biomapper-0.3.2 → biomapper-0.4.0}/biomapper/__init__.py

@@ -3,5 +3,5 @@
 from .standardization import RaMPClient
 from .core import SetAnalyzer
 
-__version__ = "0.3.2"
+__version__ = "0.4.0"
 __all__ = ["RaMPClient", "SetAnalyzer"]

{biomapper-0.3.2 → biomapper-0.4.0}/biomapper/core/protein_metadata_comparison.py

@@ -10,7 +10,7 @@ import pandas as pd
 from tqdm import tqdm
 import concurrent.futures
 
-from ..mapping.uniprot_focused_mapper import UniprotFocusedMapper
+from ..mapping.clients.uniprot_focused_mapper import UniprotFocusedMapper
 
 
 class ProteinMapping(TypedDict):

biomapper-0.4.0/biomapper/mapping/clients/__init__.py

@@ -0,0 +1 @@
+"""API clients for various compound and metabolite databases."""

{biomapper-0.3.2/biomapper/mapping → biomapper-0.4.0/biomapper/mapping/clients}/chebi_client.py

@@ -2,11 +2,23 @@
 
 import logging
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, Optional, TYPE_CHECKING
 import requests
 
-# Add type ignore comment since libchebipy doesn't have type stubs
-from libchebipy import ChebiEntity, search as chebi_search  # type: ignore[import-untyped, unused-ignore]
+if TYPE_CHECKING:
+    from libchebipy import ChebiEntity  # type: ignore
+
+    def chebi_search(query: str) -> list[Any]:
+        ...
+else:
+    try:
+        from libchebipy import ChebiEntity, search as chebi_search  # type: ignore
+    except ImportError:
+        ChebiEntity = Any
+
+        def chebi_search(query: str) -> list[Any]:
+            raise ImportError("libchebipy not installed")
+
 
 logger = logging.getLogger(__name__)
 
@@ -116,7 +128,7 @@ class ChEBIClient:
             logger.error("ChEBI entity processing failed: %s", str(e))
             raise ChEBIError(f"Entity processing failed: {str(e)}") from e
 
-    def get_entity_by_id(self, chebi_id: str) -> ChEBIResult:
+    def get_entity_by_id(self, chebi_id: str) -> Optional[ChEBIResult]:
         """Get ChEBI entity information by ID.
 
         Args:

{biomapper-0.3.2/biomapper/mapping → biomapper-0.4.0/biomapper/mapping/clients}/unichem_client.py

@@ -8,7 +8,7 @@ metabolite information across various chemical databases.
 
 import logging
 from dataclasses import dataclass
-from typing import Any, Optional, Set
+from typing import Dict, List, Optional, Set, Tuple, Any
 from pathlib import Path
 
 import pandas as pd
@@ -82,7 +82,7 @@ class UniChemClient:
             "inchikey": "inchikey",
         }
 
-    def _get_empty_result(self) -> dict[str, list[Any]]:
+    def _get_empty_result(self) -> Dict[str, List[Any]]:
         """Return an empty result dictionary with all source types."""
         return {
             "chembl_ids": [],
@@ -94,8 +94,8 @@ class UniChemClient:
         }
 
     def _process_compound_result(
-        self, data: list[dict[str, Any]]
-    ) -> dict[str, list[Any]]:
+        self, data: List[Dict[str, Any]]
+    ) -> Dict[str, List[Any]]:
         """Process compound results into categorized lists of IDs."""
         result = self._get_empty_result()
 
@@ -121,19 +121,19 @@ class UniChemClient:
 
         return result
 
-    def get_source_information(self) -> dict[str, Any]:
+    def get_source_information(self) -> Dict[str, Any]:
         """Retrieve information about available data sources."""
         try:
             response = self.session.get(
                 f"{self.config.base_url}/sources", timeout=self.config.timeout
             )
             response.raise_for_status()
-            json_response: dict[str, Any] = response.json()
+            json_response: Dict[str, Any] = response.json()
             return json_response
         except requests.RequestException as e:
             raise UniChemError(f"Failed to get source information: {e}") from e
 
-    def get_structure_search(self, structure: str, search_type: str) -> dict[str, Any]:
+    def get_structure_search(self, structure: str, search_type: str) -> Dict[str, Any]:
         """
         Search for compounds by structure.
 
@@ -146,7 +146,7 @@ class UniChemClient:
 
         Returns
         -------
-        dict[str, Any]
+        Dict[str, Any]
             Search results
         """
         valid_types = {"smiles", "inchi", "inchikey"}
@@ -159,7 +159,7 @@ class UniChemClient:
                 timeout=self.config.timeout,
             )
             response.raise_for_status()
-            json_response: dict[str, Any] = response.json()
+            json_response: Dict[str, Any] = response.json()
             return json_response
         except requests.RequestException as e:
             raise UniChemError(f"Structure search failed: {e}") from e
@@ -203,7 +203,7 @@ class UniChemClient:
 
     def get_compound_info_by_src_id(
         self, compound_id: str, src_db: str
-    ) -> dict[str, Any]:
+    ) -> Dict[str, Any]:
         """
         Retrieve compound cross-references from UniChem using the REST API.
         """
@@ -265,27 +265,27 @@ class UniChemClient:
     def map_dataframe(
         self,
         df: pd.DataFrame,
-        id_columns: dict[str, str],
-        target_sources: Optional[list[str]] = None,
+        id_columns: Dict[str, str],
+        target_sources: Optional[List[str]] = None,
         prefix_ids: bool = True,
-    ) -> tuple[pd.DataFrame, MappingResult]:
+    ) -> Tuple[pd.DataFrame, MappingResult]:
         """Map compound IDs in a DataFrame using UniChem.
 
         Parameters
         ----------
         df : pd.DataFrame
             Input DataFrame containing compound IDs
-        id_columns : dict[str, str]
+        id_columns : Dict[str, str]
             Mapping of source database names to column names
             Example: {'hmdb': 'HMDB_ID', 'pubchem': 'PUBCHEM_ID'}
-        target_sources : Optional[list[str]], default=None
+        target_sources : Optional[List[str]], default=None
             List of target databases to map to. If None, defaults to ['chembl', 'drugbank']
         prefix_ids : bool, default=True
             Whether to prefix mapped IDs with database name (e.g., CHEMBL_ID vs chembl)
 
         Returns
         -------
-        tuple[pd.DataFrame, MappingResult]
+        Tuple[pd.DataFrame, MappingResult]
             Tuple of (mapped DataFrame, mapping statistics)
         """
         # Validate inputs
@@ -306,7 +306,7 @@ class UniChemClient:
 
         mapped_count = 0
         total_count = 0
-        mapping_sources: set[str] = set()
+        mapping_sources: Set[str] = set()
 
         # Add INCHI column if not present
         inchi_col_name = "INCHI_ID" if prefix_ids else "inchi"
@@ -380,8 +380,8 @@ class UniChemClient:
     def map_csv(
         self,
         input_path: str | Path,
-        id_columns: dict[str, str],
-        target_sources: list[str] | None = None,
+        id_columns: Dict[str, str],
+        target_sources: List[str] | None = None,
         output_path: str | Path | None = None,
         prefix_ids: bool = True,
     ) -> MappingResult:

{biomapper-0.3.2/biomapper/mapping → biomapper-0.4.0/biomapper/mapping/clients}/uniprot_focused_mapper.py

@@ -1,6 +1,8 @@
+"""UniProt focused mapper for protein mapping."""
+
 import time
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Dict, List, Optional, Set, Any
 
 import requests
 
@@ -57,7 +59,7 @@ class UniprotFocusedMapper:
         session.mount("https://", adapter)
         return session
 
-    def get_available_mappings(self) -> dict[str, list[str]]:
+    def get_available_mappings(self) -> Dict[str, List[str]]:
         """Get available mapping categories and target databases.
 
         Returns:
@@ -68,7 +70,7 @@ class UniprotFocusedMapper:
             for category, dbs in self.CORE_MAPPINGS.items()
         }
 
-    def map_id(self, protein_id: str, target_db: str) -> dict[str, Any]:
+    def map_id(self, protein_id: str, target_db: str) -> Dict[str, Any]:
         """Map a UniProt ID to a target database ID.
 
         Args:
@@ -110,7 +112,7 @@ class UniprotFocusedMapper:
 
         return {}
 
-    def _submit_job(self, from_db: str, to_db: str, ids: list[str]) -> str | None:
+    def _submit_job(self, from_db: str, to_db: str, ids: List[str]) -> str | None:
         """Submit a mapping job to the UniProt API.
 
         Args:
@@ -138,7 +140,7 @@ class UniprotFocusedMapper:
         except (requests.exceptions.RequestException, ValueError):
             return None
 
-    def _get_job_results(self, url: str) -> dict[str, Any]:
+    def _get_job_results(self, url: str) -> Dict[str, Any]:
         """Get results from a completed mapping job.
 
         Args:
@@ -160,8 +162,8 @@ class UniprotFocusedMapper:
         return {}
 
     def _map_to_database(
-        self, from_db: str, to_db: str, ids: list[str]
-    ) -> dict[str, Any]:
+        self, from_db: str, to_db: str, ids: List[str]
+    ) -> Dict[str, Any]:
         """Map identifiers between databases."""
         max_attempts = 20  # Maximum number of polling attempts
         attempt = 0
@@ -223,7 +225,7 @@ class UniprotFocusedMapper:
             return error.response.status_code in {500, 502, 503, 504}
         return False
 
-    def _retry_request(self, url: str) -> dict[str, Any]:
+    def _retry_request(self, url: str) -> Dict[str, Any]:
         """Retry a failed request with exponential backoff."""
         for attempt in range(self.config.max_retries):
             try:
@@ -235,8 +237,8 @@ class UniprotFocusedMapper:
                 continue
         return {}  # Return empty dict if all retries fail
 
-    def _make_request(self, url: str) -> dict[str, Any]:
-        response: dict[str, Any] = {}
+    def _make_request(self, url: str) -> Dict[str, Any]:
+        response: Dict[str, Any] = {}
         try:
             results_req = requests.get(url, timeout=self.config.timeout)
             results_req.raise_for_status()
@@ -248,8 +250,8 @@ class UniprotFocusedMapper:
             return response
 
     def _generate_mappings(
-        self, proteins: set[str], categories: list[str] | None = None
-    ) -> dict[str, dict[str, list[str]]]:
+        self, proteins: Set[str], categories: Optional[List[str]] = None
+    ) -> Dict[str, Dict[str, List[str]]]:
         """Generate mappings for a set of proteins with progress tracking.
 
         Args:
@@ -259,7 +261,7 @@ class UniprotFocusedMapper:
         Returns:
             Dict mapping protein IDs to their database mappings.
         """
-        mappings: dict[str, dict[str, list[str]]] = {}
+        mappings: Dict[str, Dict[str, List[str]]] = {}
 
         # Process proteins in chunks
         for i in range(0, len(proteins), 100):  # Using chunk_size of 100
@@ -270,8 +272,8 @@ class UniprotFocusedMapper:
         return mappings
 
     def _process_chunk(
-        self, chunk: list[str], categories: list[str] | None = None
-    ) -> dict[str, dict[str, list[str]]]:
+        self, chunk: List[str], categories: Optional[List[str]] = None
+    ) -> Dict[str, Dict[str, List[str]]]:
         """Process a chunk of proteins for mapping.
 
         Args:
@@ -281,12 +283,12 @@ class UniprotFocusedMapper:
         Returns:
             Dictionary of mapping results for the chunk
         """
-        chunk_mappings: dict[str, dict[str, list[str]]] = {}
+        chunk_mappings: Dict[str, Dict[str, List[str]]] = {}
 
         for protein in chunk:
             try:
                 # Get valid target databases for each category
-                target_dbs: list[str] = []
+                target_dbs: List[str] = []
                 for category in categories or ["Protein/Gene"]:
                     if category in self.CORE_MAPPINGS:
                         target_dbs.extend(
@@ -298,11 +300,11 @@ class UniprotFocusedMapper:
                         )
 
                 # Map to each target database
-                protein_mappings: dict[str, list[str]] = {}
+                protein_mappings: Dict[str, List[str]] = {}
                 for target_db in target_dbs:
                     result = self.map_id(protein, target_db)
                     if result.get("results"):
-                        mapped_ids: list[str] = []
+                        mapped_ids: List[str] = []
                         for mapping in result["results"]:
                             to_id = mapping.get("to")
                             if isinstance(to_id, dict):

biomapper-0.4.0/biomapper/mapping/embeddings/__init__.py

@@ -0,0 +1 @@
+"""Embeddings package for managing different embedding models."""

biomapper-0.4.0/biomapper/mapping/embeddings/managers.py

@@ -0,0 +1,98 @@
+"""Embedding model management for compound mapping."""
+from abc import ABC, abstractmethod
+from typing import List, Optional, cast
+import torch
+from transformers import AutoModel, AutoTokenizer  # type: ignore
+
+
+class EmbeddingManager(ABC):
+    """Abstract base class for embedding managers."""
+
+    @abstractmethod
+    def embed_text(self, text: str) -> List[float]:
+        """Embed a single text string."""
+        pass
+
+    @abstractmethod
+    def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        """Embed a batch of text strings."""
+        pass
+
+
+class HuggingFaceEmbeddingManager(EmbeddingManager):
+    """Manages embeddings using HuggingFace models."""
+
+    def __init__(
+        self,
+        model_name: str = "sentence-transformers/all-mpnet-base-v2",
+        device: Optional[str] = None,
+    ):
+        self.model_name = model_name
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name).to(self.device)
+        self.model.eval()
+
+    def embed_text(self, text: str) -> List[float]:
+        """Embed a single text string."""
+        # Tokenize input
+        inputs = self.tokenizer(
+            text, return_tensors="pt", padding=True, truncation=True, max_length=512
+        )
+
+        # Move tensors to device
+        device_inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = self.model(**device_inputs)
+            # Use CLS token embedding
+            embedding = outputs.last_hidden_state[:, 0, :].cpu().numpy()
+
+        return cast(List[float], embedding[0].tolist())
+
+    def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        """Embed a batch of text strings."""
+        # Tokenize inputs and get dictionary of tensors
+        inputs = self.tokenizer(
+            texts, return_tensors="pt", padding=True, truncation=True, max_length=512
+        )
+
+        # Convert inputs to device if it's not already a dictionary
+        if not isinstance(inputs, dict):
+            inputs = dict(inputs)
+        device_inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = self.model(**device_inputs)
+            # Use CLS token embeddings for each text in batch
+            embeddings = outputs.last_hidden_state[:, 0, :].cpu().numpy()
+
+        return cast(List[List[float]], embeddings.tolist())
+
+
+class OpenAIEmbeddingManager(EmbeddingManager):
+    """Manages embeddings using OpenAI's API."""
+
+    def __init__(
+        self, api_key: Optional[str] = None, model: str = "text-embedding-ada-002"
+    ):
+        try:
+            import openai
+        except ImportError:
+            raise ImportError(
+                "OpenAI package not found. Install with 'pip install openai'"
+            )
+
+        self.client = openai.OpenAI(api_key=api_key)
+        self.model = model
+
+    def embed_text(self, text: str) -> List[float]:
+        """Embed a single text string."""
+        response = self.client.embeddings.create(model=self.model, input=text)
+        return response.data[0].embedding
+
+    def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        """Embed a batch of text strings."""
+        response = self.client.embeddings.create(model=self.model, input=texts)
+        return [data.embedding for data in response.data]

{biomapper-0.3.2 → biomapper-0.4.0}/biomapper/mapping/llm_mapper.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional, TYPE_CHECKING
 import time
 import os
 
-from langfuse import Langfuse  # type: ignore
+from langfuse import Langfuse
 from openai import OpenAI
 
 if TYPE_CHECKING:

{biomapper-0.3.2 → biomapper-0.4.0}/biomapper/mapping/metabolite_name_mapper.py

@@ -4,15 +4,15 @@ import logging
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Optional, List, Callable, Any
+from typing import List, Optional, Callable, Any
 import re
 from collections import defaultdict
 
 import pandas as pd
 
-from .chebi_client import ChEBIClient
-from .refmet_client import RefMetClient
-from .unichem_client import UniChemClient
+from .clients.chebi_client import ChEBIClient
+from .clients.refmet_client import RefMetClient
+from .clients.unichem_client import UniChemClient
 
 logger = logging.getLogger(__name__)