chores: port and adapter for downloader and loader of ontologies

Author: ecarrenolozano

example_usage.py

@@ -0,0 +1,18 @@
+# Example improved client usage
+from ontograph.api.client import OntologyClient
+
+# Initialize client
+client = OntologyClient()
+
+# List available ontologies
+ontologies = client.list_ontologies()
+
+# Download and load in one step
+go = client.load("go", format="obo")
+
+# Query operations
+parents = go.get_parents("GO:0008150")
+children = go.get_children("GO:0008150")
+
+# Advanced query
+results = go.query("ancestors:GO:0008150")

…tograph/adapters/obo_foundry_registry.py …tograph/adapters/obo_registry_adapter.pyontograph/adapters/obo_foundry_registry.py renamed to ontograph/adapters/obo_registry_adapter.py ontograph/adapters/obo_foundry_registry.py renamed to ontograph/adapters/obo_registry_adapter.py

@@ -1,13 +1,13 @@
 from pathlib import Path
-from types import NoneType
 from typing import Dict, List, Optional, Any
 import yaml
 from pooch import retrieve
 
 from ontograph.config.settings import OBO_FOUNDRY_REGISTRY_URL
+from ontograph.ports.ontology_registry_port import OntologyRegistryPort
 
 
-class OBOFoundryRegistry:
+class OBORegistryAdapter(OntologyRegistryPort):
     """Manages access to the OBO Foundry ontology registry."""
 
     def __init__(self, cache_dir: Path):
@@ -153,7 +153,6 @@ def get_download_url(self, ontology_id: str, format: str = "obo") -> Optional[st
         products = metadata.get("products", [])
         for product in products:
             if product.get("id", "").lower() == f"{ontology_id.lower()}.{format.lower()}":
-                print(f"ID: {product.get('id')}")
                 return product.get("ontology_purl")
 
         return None
@@ -189,8 +188,8 @@ def get_available_formats(self, ontology_id: str) -> List[str]:
     # Define the path to store the registry
     path = Path("./data/out")
 
-    # Create object registry
-    obo_reg = OBOFoundryRegistry(cache_dir=path)
+    # Create registry adapter object
+    obo_reg = OBORegistryAdapter(cache_dir=path)
 
     # Load the registry (in case of not having the registry it will be downloaded automatically)
     obo_reg.load_registry()
@@ -201,8 +200,10 @@ def get_available_formats(self, ontology_id: str) -> List[str]:
     # List of available ontologies
     print("Number of ontologies: {}".format(len(obo_reg.list_available_ontologies())))
 
-    # Print the link associated to that ontology
-    print(obo_reg.get_download_url("chebiche", "obo"))
+    # Print the link associated to a valid ontology (e.g., 'chebi')
+    print(obo_reg.get_download_url("chebi", "obo"))
 
-    # Print available formats
-    print(obo_reg.get_available_formats(ontology_id="chebicge"))
+    # Print available formats for a valid ontology
+    print(obo_reg.get_available_formats(ontology_id="chebi"))
+
+    # Tip: Use obo_reg.list_available_ontologies() to find valid ontology IDs.

ontograph/adapters/pooch_downloader.py …aph/adapters/pooch_downloader_adapter.pyontograph/adapters/pooch_downloader.py renamed to ontograph/adapters/pooch_downloader_adapter.py ontograph/adapters/pooch_downloader.py renamed to ontograph/adapters/pooch_downloader_adapter.py

@@ -3,19 +3,26 @@
 
 from pooch import retrieve
 
-from ontograph.adapters.obo_foundry_registry import OBOFoundryRegistry
-from ontograph.ports.downloader import AbstractDownloader
+from ontograph.ports.downloader_port import DownloaderPort
+from ontograph.ports.ontology_registry_port import OntologyRegistryPort
 
 
-class PoochDownloader(AbstractDownloader):
+class PoochDownloaderAdapter(DownloaderPort):
     """
     Concrete downloader using Pooch for caching ontology files.
     """
 
-    def __init__(self, cache_dir: Path = Path.home() / ".ontograph_cache"):
+    def __init__(self, cache_dir: Path, registry: OntologyRegistryPort):
+        """
+        Initialize the downloader adapter.
+
+        Args:
+            cache_dir (Path): Directory for caching downloaded files
+            registry (OntologyRegistryPort): Registry port for resolving download URLs
+        """
         self.cache_dir = cache_dir
         self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.registry = OBOFoundryRegistry(cache_dir)
+        self.registry = registry
 
     def _get_download_url(self, name_id: str, format: str) -> Optional[str]:
         """Get download URL from registry."""
@@ -37,6 +44,7 @@ def fetch(self, url: str, filename: str) -> Path:
             known_hash=None,  # Could later integrate SHA256 checksums
             fname=filename,
             path=self.cache_dir,
+            progressbar=True,
         )
         return Path(local_file)
 
@@ -47,15 +55,18 @@ def fetch_batch(self, resources: List[Dict[str, str]]) -> Dict[str, Path]:
         Args:
             resources (List[Dict[str, str]]): List of dictionaries containing:
                 - name_id: The ontology identifier
-                - format: The file format (e.g., 'obo', 'owl')
+                - format: The file format (e.g., 'obo', 'owl'). Defaults to 'obo' if not specified.
 
         Returns:
             Dict[str, Path]: Dictionary mapping ontology IDs to their cached paths
 
         Raises:
-            ValueError: If an ontology is not found or format is not supported
+            ValueError: If resources list is empty, an ontology is not found, or format is not supported
             KeyError: If required keys are missing in the resource dictionary
         """
+        if not resources:
+            raise ValueError("Resources list for batch download is empty.")
+
         results = {}
 
         for resource in resources:
@@ -79,35 +90,36 @@ def fetch_batch(self, resources: List[Dict[str, str]]) -> Dict[str, Path]:
 
         return results
 
-    def list_available_ontologies(self) -> List[Dict[str, str]]:
-        """
-        Get list of available ontologies from the registry.
 
-        Returns:
-            List[Dict[str, str]]: List of available ontologies with their metadata
-        """
-        return self.registry.list_available_ontologies()
+if __name__ == "__main__":
+    from ontograph.adapters.obo_registry_adapter import OBORegistryAdapter
 
-    def get_available_formats(self, ontology_id: str) -> List[str]:
-        """
-        Get available formats for an ontology.
+    # Defines the cache directory
+    cache_dir = Path("./data/out")
 
-        Args:
-            ontology_id: The ontology identifier
+    # Creates a registry object (real implementation OBORegistryAdapter)
+    registry = OBORegistryAdapter(cache_dir=cache_dir)
+    registry.load_registry()
 
-        Returns:
-            List[str]: List of available formats
-        """
-        return self.registry.get_available_formats(ontology_id)
+    # Creates a downloader object
+    downloader = PoochDownloaderAdapter(cache_dir=cache_dir, registry=registry)
 
-    def get_ontology_metadata(self, ontology_id: str) -> Optional[Dict]:
-        """
-        Get detailed metadata for an ontology.
+    ## Example 1. Download a single ontology file from the registry
+    ontology_id = "ado"
+    format = "owl"
 
-        Args:
-            ontology_id: The ontology identifier
+    # Extract the url from the registry
+    url = registry.get_download_url(ontology_id, format)
 
-        Returns:
-            Optional[Dict]: The ontology metadata or None if not found
-        """
-        return self.registry.get_ontology_metadata(ontology_id)
+    if url:
+        # Downloads the file
+        local_path = downloader.fetch(url=url, filename=f"{ontology_id}.{format}")
+        print(f"Downloaded {ontology_id}.{format} to: {local_path}")
+
+    ## Example 2. Batch download
+    resources = [
+        {"name_id": "chebi", "format": "owl"},
+        {"name_id": "go", "format": "obo"},
+    ]
+    batch_results = downloader.fetch_batch(resources)
+    print("Batch download results:", batch_results)

ontograph/adapters/pronto_graph.py …tograph/adapters/pronto_graph_adapter.pyontograph/adapters/pronto_graph.py renamed to ontograph/adapters/pronto_graph_adapter.py ontograph/adapters/pronto_graph.py renamed to ontograph/adapters/pronto_graph_adapter.py

@@ -1,9 +1,9 @@
 from typing import Any, List, Optional
 
-from ontograph.ports.graph_backend import GraphBackend
+from ontograph.ports.graph_backend_port import GraphBackendPort
 
 
-class ProntoGraph(GraphBackend):
+class ProntoGraphAdapter(GraphBackendPort):
     """Adapter implementing graph operations using Pronto."""
 
     def __init__(self, ontology):

ontograph/adapters/pronto_loader.py

@@ -3,10 +3,10 @@
 from typing import Union
 
 import pronto
-from ontograph.ports.ontology_loader import OntologyLoaderPort
+from ontograph.ports.ontology_loader_port import OntologyLoaderPort
 
 
-class ProntoOntologyLoader(OntologyLoaderPort):
+class ProntoLoaderAdapter(OntologyLoaderPort):
     """Adapter that loads ontologies using pronto."""
 
     def __init__(self, cache_dir: Union[str, Path] = None):
@@ -41,3 +41,21 @@ def load(self, name_id: str, format: str = "obo"):
             )
 
         return pronto.Ontology(str(file_path))
+
+
+if __name__ == "__main__":
+    # Example usage of ProntoLoaderAdapter
+    cache_dir = "data/out"  # or any directory where ontology files are cached
+    loader = ProntoLoaderAdapter(cache_dir=cache_dir)
+
+    # Example: Load a cached ontology file (must exist in cache_dir)
+    ontology_id = "go"  # Use a valid ontology ID
+    format = "obo"
+    try:
+        ontology = loader.load(ontology_id, format)
+        print(f"Loaded ontology: {ontology_id}.{format}")
+        print(f"Number of terms: {len(ontology.terms())}")
+    except FileNotFoundError as e:
+        print(e)
+    except ValueError as e:
+        print(e)

ontograph/api/client.py

@@ -1,131 +1,60 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from ontograph.config.container import OntographContainer
 from ontograph.core.ontology_graph import OntologyGraph
-from ontograph.ports.downloader import AbstractDownloader
-from ontograph.ports.ontology_loader import OntologyLoaderPort
+from ontograph.ports.downloader_port import DownloaderPort
+from ontograph.ports.ontology_loader_port import OntologyLoaderPort
 
 
 class OntologyClient:
     """Facade for interacting with ontologies."""
 
-    def __init__(self, cache_dir: Union[str, Path] = None):
+    def __init__(self, downloader: DownloaderPort, loader: OntologyLoaderPort):
         """
         Initialize the client.
 
         Args:
-            cache_dir: Optional directory for caching ontology files
+            downloader: The downloader port to use for fetching ontologies
+            loader: The loader port to use for loading ontologies
         """
-        cache_dir = Path(cache_dir) if cache_dir else None
-        self.loader: OntologyLoaderPort = OntographContainer.get_loader(cache_dir)
-        self.downloader: AbstractDownloader = OntographContainer.get_downloader(cache_dir)
+        self.downloader = downloader
+        self.loader = loader
         self.ontology_graph = None
 
     def list_ontologies(self) -> List[Dict[str, str]]:
-        """
-        Get a list of all available ontologies from OBO Foundry.
-
-        Returns:
-            List[Dict[str, str]]: List of ontologies with their metadata
-        """
+        """Get a list of all available ontologies from OBO Foundry."""
         return self.downloader.list_available_ontologies()
 
     def get_ontology_formats(self, ontology_id: str) -> List[str]:
-        """
-        Get available formats for an ontology.
-
-        Args:
-            ontology_id: The ontology identifier
-
-        Returns:
-            List[str]: Available formats
-        """
+        """Get available formats for an ontology."""
         return self.downloader.get_available_formats(ontology_id)
 
     def get_ontology_info(self, ontology_id: str) -> Optional[Dict]:
-        """
-        Get detailed metadata about an ontology.
-
-        Args:
-            ontology_id: The ontology identifier
-
-        Returns:
-            Optional[Dict]: Ontology metadata or None if not found
-        """
+        """Get detailed metadata about an ontology."""
         return self.downloader.get_ontology_metadata(ontology_id)
 
     def download(
         self, name_id: Union[str, List[Dict[str, str]]], format: str = "obo"
     ) -> Union[Path, Dict[str, Path]]:
-        """
-        Download ontology file(s).
-
-        Args:
-            name_id: Either a string identifier (e.g., 'go' for Gene Ontology)
-                    or a list of dictionaries with 'name_id' and 'format' keys
-            format: The file format ('obo' or 'owl'), used only when name_id is a string
-
-        Returns:
-            Union[Path, Dict[str, Path]]: Either a single path or a dictionary of paths
-                                        mapping ontology IDs to their cached locations
-
-        Examples:
-            # List available ontologies
-            client.list_ontologies()
-
-            # Check available formats
-            client.get_ontology_formats("go")
-
-            # Get ontology metadata
-            client.get_ontology_info("go")
-
-            # Single download
-            client.download("go", format="obo")
-
-            # Batch download
-            client.download([
-                {"name_id": "go", "format": "obo"},
-                {"name_id": "chebi", "format": "owl"}
-            ])
-        """
+        """Download ontology file(s)."""
         if isinstance(name_id, str):
-            # Single download
-            url = self.downloader._get_download_url(name_id, format)
+            url = self.downloader.get_download_url(name_id, format)
             if not url:
                 raise ValueError(
                     f"Cannot find download URL for ontology {name_id} in format {format}"
                 )
             return self.downloader.fetch(url, f"{name_id}.{format}")
         else:
-            # Batch download
             return self.downloader.fetch_batch(name_id)
 
     def load(self, name_id: str, format: str = "obo") -> OntologyGraph:
-        """
-        Load an ontology and return an OntologyGraph instance.
-
-        Args:
-            name_id: The ontology identifier
-            format: The file format
-
-        Returns:
-            OntologyGraph: The loaded ontology graph
-        """
+        """Load an ontology and return an OntologyGraph instance."""
         pronto_ontology = self.loader.load(name_id, format)
         self.ontology_graph = OntologyGraph(pronto_ontology)
         return self.ontology_graph
 
     def load_batch(self, resources: List[Dict[str, str]]) -> Dict[str, OntologyGraph]:
-        """
-        Load multiple ontologies and return their graph instances.
-
-        Args:
-            resources: List of dictionaries with 'name_id' and optional 'format' keys
-
-        Returns:
-            Dict[str, OntologyGraph]: Dictionary mapping ontology IDs to their graph instances
-        """
+        """Load multiple ontologies and return their graph instances."""
         graphs = {}
         for resource in resources:
             name_id = resource["name_id"]