aiagents4pharma 1.28.0__py3-none-any.whl → 1.30.0__py3-none-any.whl

aiagents4pharma/talk2scholars/tools/paper_download/arxiv_downloader.py

@@ -0,0 +1,108 @@
+"""
+Arxiv Paper Downloader
+
+This module provides an implementation of `AbstractPaperDownloader` for arXiv.
+It connects to the arXiv API, retrieves metadata for a research paper, and
+downloads the corresponding PDF.
+
+By using an abstract base class, this implementation is extendable to other
+APIs like PubMed, IEEE Xplore, etc.
+"""
+import xml.etree.ElementTree as ET
+from typing import Any, Dict
+import logging
+import hydra
+import requests
+from .abstract_downloader import AbstractPaperDownloader
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ArxivPaperDownloader(AbstractPaperDownloader):
+    """
+    Downloader class for arXiv.
+
+    This class interfaces with the arXiv API to fetch metadata
+    and retrieve PDFs of academic papers based on their arXiv IDs.
+    """
+
+    def __init__(self):
+        """
+        Initializes the arXiv paper downloader.
+
+        Uses Hydra for configuration management to retrieve API details.
+        """
+        with hydra.initialize(version_base=None, config_path="../../configs"):
+            cfg = hydra.compose(
+                config_name="config",
+                overrides=["tools/download_arxiv_paper=default"]
+            )
+            self.api_url = cfg.tools.download_arxiv_paper.api_url
+            self.request_timeout = cfg.tools.download_arxiv_paper.request_timeout
+            self.chunk_size = cfg.tools.download_arxiv_paper.chunk_size
+            self.pdf_base_url = cfg.tools.download_arxiv_paper.pdf_base_url
+    def fetch_metadata(self, paper_id: str) -> Dict[str, Any]:
+        """
+        Fetch metadata from arXiv for a given paper ID.
+
+        Args:
+            paper_id (str): The arXiv ID of the paper.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing metadata, including the XML response.
+        """
+        logger.info("Fetching metadata from arXiv for paper ID: %s", paper_id)
+        api_url = f"{self.api_url}?search_query=id:{paper_id}&start=0&max_results=1"
+        response = requests.get(api_url, timeout=self.request_timeout)
+        response.raise_for_status()
+        return {"xml": response.text}
+
+    def download_pdf(self, paper_id: str) -> Dict[str, Any]:
+        """
+        Download the PDF of a paper from arXiv.
+
+        This function first retrieves the paper's metadata to locate the PDF link
+        before downloading the file.
+
+        Args:
+            paper_id (str): The arXiv ID of the paper.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing:
+                - `pdf_object`: The binary content of the downloaded PDF.
+                - `pdf_url`: The URL from which the PDF was fetched.
+                - `arxiv_id`: The arXiv ID of the downloaded paper.
+        """
+        metadata = self.fetch_metadata(paper_id)
+
+        # Parse the XML response to locate the PDF link.
+        root = ET.fromstring(metadata["xml"])
+        ns = {"atom": "http://www.w3.org/2005/Atom"}
+        pdf_url = next(
+            (
+                link.attrib.get("href")
+                for entry in root.findall("atom:entry", ns)
+                for link in entry.findall("atom:link", ns)
+                if link.attrib.get("title") == "pdf"
+            ),
+            None,
+        )
+
+        if not pdf_url:
+            raise RuntimeError(f"Failed to download PDF for arXiv ID {paper_id}.")
+
+        logger.info("Downloading PDF from: %s", pdf_url)
+        pdf_response = requests.get(pdf_url, stream=True, timeout=self.request_timeout)
+        pdf_response.raise_for_status()
+
+        # Combine the PDF data from chunks.
+        pdf_object = b"".join(
+            chunk for chunk in pdf_response.iter_content(chunk_size=self.chunk_size) if chunk
+            )
+
+        return {
+            "pdf_object": pdf_object,
+            "pdf_url": pdf_url,
+            "arxiv_id": paper_id,
+        }

aiagents4pharma/talk2scholars/tools/paper_download/download_arxiv_input.py

@@ -0,0 +1,60 @@
+# File: aiagents4pharma/talk2scholars/tools/paper_download/download_arxiv_input.py
+"""
+This module defines the `download_arxiv_paper` tool, which leverages the
+`ArxivPaperDownloader` class to fetch and download academic papers from arXiv
+based on their unique arXiv ID.
+"""
+from typing import Annotated, Any
+from pydantic import BaseModel, Field
+from langchain_core.tools import tool
+from langchain_core.messages import ToolMessage
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.types import Command
+
+# Local import from the same package:
+from .arxiv_downloader import ArxivPaperDownloader
+
+class DownloadArxivPaperInput(BaseModel):
+    """
+    Input schema for the arXiv paper download tool.
+    (Optional: if you decide to keep Pydantic validation in the future)
+    """
+    arxiv_id: str = Field(
+        description="The arXiv paper ID used to retrieve the paper details and PDF."
+        )
+    tool_call_id: Annotated[str, InjectedToolCallId]
+
+@tool(args_schema=DownloadArxivPaperInput, parse_docstring=True)
+def download_arxiv_paper(
+    arxiv_id: str,
+    tool_call_id: Annotated[str, InjectedToolCallId],
+) -> Command[Any]:
+    """
+    Download an arXiv paper's PDF using its unique arXiv ID.
+
+    This function:
+      1. Creates an `ArxivPaperDownloader` instance.
+      2. Fetches metadata from arXiv using the provided `arxiv_id`.
+      3. Downloads the PDF from the returned link.
+      4. Returns a `Command` object containing the PDF data and a success message.
+
+    Args:
+        arxiv_id (str): The unique arXiv paper ID.
+        tool_call_id (InjectedToolCallId): A unique identifier for tracking this tool call.
+
+    Returns:
+        Command[Any]: Contains metadata and messages about the success of the operation.
+    """
+    downloader = ArxivPaperDownloader()
+
+    # If the downloader fails or the arxiv_id is invalid, this might raise an error
+    pdf_data = downloader.download_pdf(arxiv_id)
+
+    content = f"Successfully downloaded PDF for arXiv ID {arxiv_id}"
+
+    return Command(
+        update={
+            "pdf_data": pdf_data,
+            "messages": [ToolMessage(content=content, tool_call_id=tool_call_id)],
+        }
+    )

aiagents4pharma/talk2scholars/tools/s2/multi_paper_rec.py

@@ -16,6 +16,7 @@ from langchain_core.tools.base import InjectedToolCallId
 from langgraph.types import Command
 from pydantic import BaseModel, Field
 
+# pylint: disable=R0914,R0912,R0915
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -26,7 +27,7 @@ class MultiPaperRecInput(BaseModel):
     """Input schema for multiple paper recommendations tool."""
 
     paper_ids: List[str] = Field(
-        description=("List of Semantic Scholar Paper IDs to get recommendations for")
+        description="List of Semantic Scholar Paper IDs to get recommendations for"
     )
     limit: int = Field(
         default=2,
@@ -44,14 +45,6 @@ class MultiPaperRecInput(BaseModel):
     model_config = {"arbitrary_types_allowed": True}
 
 
-# Load hydra configuration
-with hydra.initialize(version_base=None, config_path="../../configs"):
-    cfg = hydra.compose(
-        config_name="config", overrides=["tools/multi_paper_recommendation=default"]
-    )
-    cfg = cfg.tools.multi_paper_recommendation
-
-
 @tool(args_schema=MultiPaperRecInput, parse_docstring=True)
 def get_multi_paper_recommendations(
     paper_ids: List[str],
@@ -73,7 +66,14 @@ def get_multi_paper_recommendations(
     Returns:
         Dict[str, Any]: The recommendations and related information.
     """
-    logging.info(
+    # Load hydra configuration
+    with hydra.initialize(version_base=None, config_path="../../configs"):
+        cfg = hydra.compose(
+            config_name="config", overrides=["tools/multi_paper_recommendation=default"]
+        )
+        cfg = cfg.tools.multi_paper_recommendation
+        logger.info("Loaded configuration for multi-paper recommendation tool")
+    logger.info(
         "Starting multi-paper recommendations search with paper IDs: %s", paper_ids
     )
 
@@ -89,45 +89,61 @@ def get_multi_paper_recommendations(
     if year:
         params["year"] = year
 
-    # Getting recommendations
-    response = requests.post(
-        endpoint,
-        headers=headers,
-        params=params,
-        data=json.dumps(payload),
-        timeout=cfg.request_timeout,
-    )
-    logging.info(
+    # Wrap API call in try/except to catch connectivity issues and validate response format
+    try:
+        response = requests.post(
+            endpoint,
+            headers=headers,
+            params=params,
+            data=json.dumps(payload),
+            timeout=cfg.request_timeout,
+        )
+        response.raise_for_status()  # Raises HTTPError for bad responses
+    except requests.exceptions.RequestException as e:
+        logger.error(
+            "Failed to connect to Semantic Scholar API for multi-paper recommendations: %s",
+            e,
+        )
+        raise RuntimeError(
+            "Failed to connect to Semantic Scholar API. Please retry the same query."
+        ) from e
+
+    logger.info(
         "API Response Status for multi-paper recommendations: %s", response.status_code
     )
+    logger.info("Request params: %s", params)
 
     data = response.json()
-    recommendations = data.get("recommendedPapers", [])
 
+    # Check for expected data format
+    if "recommendedPapers" not in data:
+        logger.error("Unexpected API response format: %s", data)
+        raise RuntimeError(
+            "Unexpected response from Semantic Scholar API. The results could not be "
+            "retrieved due to an unexpected format. "
+            "Please modify your search query and try again."
+        )
+
+    recommendations = data.get("recommendedPapers", [])
     if not recommendations:
-        return Command(
-            update={  # Place 'messages' inside 'update'
-                "messages": [
-                    ToolMessage(
-                        content="No recommendations found based on multiple papers.",
-                        tool_call_id=tool_call_id,
-                    )
-                ]
-            }
+        logger.error(
+            "No recommendations returned from API for paper IDs: %s", paper_ids
+        )
+        raise RuntimeError(
+            "No recommendations were found for your query. Consider refining your search "
+            "by using more specific keywords or different terms."
         )
 
     # Create a dictionary to store the papers
     filtered_papers = {
         paper["paperId"]: {
-            # "semantic_scholar_id": paper["paperId"],  # Store Semantic Scholar ID
+            "paper_id": paper["paperId"],
             "Title": paper.get("title", "N/A"),
             "Abstract": paper.get("abstract", "N/A"),
             "Year": paper.get("year", "N/A"),
             "Citation Count": paper.get("citationCount", "N/A"),
             "URL": paper.get("url", "N/A"),
-            # "arXiv_ID": paper.get("externalIds", {}).get(
-            #     "ArXiv", "N/A"
-            # ),  # Extract arXiv ID
+            "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
         }
         for paper in recommendations
         if paper.get("title") and paper.get("authors")
@@ -156,7 +172,7 @@ def get_multi_paper_recommendations(
 
     return Command(
         update={
-            "multi_papers": filtered_papers,  # Now sending the dictionary directly
+            "multi_papers": filtered_papers,  # Sending the dictionary directly
             "last_displayed_papers": "multi_papers",
             "messages": [
                 ToolMessage(

aiagents4pharma/talk2scholars/tools/s2/retrieve_semantic_scholar_paper_id.py

@@ -19,14 +19,6 @@ from pydantic import Field
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Load hydra configuration
-with hydra.initialize(version_base=None, config_path="../../configs"):
-    cfg = hydra.compose(
-        config_name="config",
-        overrides=["tools/retrieve_semantic_scholar_paper_id=default"],
-    )
-    cfg = cfg.tools.retrieve_semantic_scholar_paper_id
-
 
 @tool("retrieve_semantic_scholar_paper_id", parse_docstring=True)
 def retrieve_semantic_scholar_paper_id(
@@ -49,6 +41,14 @@ def retrieve_semantic_scholar_paper_id(
     Returns:
         ToolMessage: A message containing the paper ID.
     """
+    # Load hydra configuration
+    with hydra.initialize(version_base=None, config_path="../../configs"):
+        cfg = hydra.compose(
+            config_name="config",
+            overrides=["tools/retrieve_semantic_scholar_paper_id=default"],
+        )
+        cfg = cfg.tools.retrieve_semantic_scholar_paper_id
+        logger.info("Loaded configuration for Semantic Scholar paper ID retrieval tool")
     logger.info("Retrieving ID of paper with title: %s", paper_title)
     endpoint = cfg.api_endpoint
     params = {

aiagents4pharma/talk2scholars/tools/s2/search.py

@@ -37,12 +37,6 @@ class SearchInput(BaseModel):
     tool_call_id: Annotated[str, InjectedToolCallId]
 
 
-# Load hydra configuration
-with hydra.initialize(version_base=None, config_path="../../configs"):
-    cfg = hydra.compose(config_name="config", overrides=["tools/search=default"])
-    cfg = cfg.tools.search
-
-
 @tool("search_tool", args_schema=SearchInput, parse_docstring=True)
 def search_tool(
     query: str,
@@ -56,13 +50,18 @@ def search_tool(
     Args:
         query (str): The search query string to find academic papers.
         tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
-        limit (int, optional): The maximum number of results to return. Defaults to 2.
+        limit (int, optional): The maximum number of results to return. Defaults to 5.
         year (str, optional): Year range for papers.
         Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
 
     Returns:
         The number of papers found on Semantic Scholar.
     """
+    # Load hydra configuration
+    with hydra.initialize(version_base=None, config_path="../../configs"):
+        cfg = hydra.compose(config_name="config", overrides=["tools/search=default"])
+        cfg = cfg.tools.search
+        logger.info("Loaded configuration for search tool")
     logger.info("Searching for papers on %s", query)
     endpoint = cfg.api_endpoint
     params = {
@@ -75,33 +74,47 @@ def search_tool(
     if year:
         params["year"] = year
 
-    response = requests.get(endpoint, params=params, timeout=10)
+    # Wrap API call in try/except to catch connectivity issues
+    try:
+        response = requests.get(endpoint, params=params, timeout=10)
+        response.raise_for_status()  # Raises HTTPError for bad responses
+    except requests.exceptions.RequestException as e:
+        logger.error("Failed to connect to Semantic Scholar API: %s", e)
+        raise RuntimeError(
+            "Failed to connect to Semantic Scholar API. Please retry the same query."
+        ) from e
+
     data = response.json()
+
+    # Check for expected data format
+    if "data" not in data:
+        logger.error("Unexpected API response format: %s", data)
+        raise RuntimeError(
+            "Unexpected response from Semantic Scholar API. The results could not be "
+            "retrieved due to an unexpected format. "
+            "Please modify your search query and try again."
+        )
+
     papers = data.get("data", [])
-    logger.info("Received %d papers", len(papers))
     if not papers:
-        return Command(
-            update={  # Place 'messages' inside 'update'
-                "messages": [
-                    ToolMessage(
-                        content="No papers found. Please try a different search query.",
-                        tool_call_id=tool_call_id,
-                    )
-                ]
-            }
+        logger.error(
+            "No papers returned from Semantic Scholar API for query: %s", query
         )
+        raise RuntimeError(
+            "No papers were found for your query. Consider refining your search "
+            "by using more specific keywords or different terms."
+        )
+
     # Create a dictionary to store the papers
     filtered_papers = {
         paper["paperId"]: {
-            # "semantic_scholar_id": paper["paperId"],  # Store Semantic Scholar ID
+            "paper_id": paper["paperId"],
             "Title": paper.get("title", "N/A"),
             "Abstract": paper.get("abstract", "N/A"),
             "Year": paper.get("year", "N/A"),
             "Citation Count": paper.get("citationCount", "N/A"),
             "URL": paper.get("url", "N/A"),
-            # "arXiv_ID": paper.get("externalIds", {}).get(
-            #     "ArXiv", "N/A"
-            # ),  # Extract arXiv ID
+            "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
         }
         for paper in papers
         if paper.get("title") and paper.get("authors")
@@ -129,7 +142,7 @@ def search_tool(
 
     return Command(
         update={
-            "papers": filtered_papers,  # Now sending the dictionary directly
+            "papers": filtered_papers,  # Sending the dictionary directly
             "last_displayed_papers": "papers",
             "messages": [
                 ToolMessage(

aiagents4pharma/talk2scholars/tools/s2/single_paper_rec.py

@@ -40,14 +40,6 @@ class SinglePaperRecInput(BaseModel):
     model_config = {"arbitrary_types_allowed": True}
 
 
-# Load hydra configuration
-with hydra.initialize(version_base=None, config_path="../../configs"):
-    cfg = hydra.compose(
-        config_name="config", overrides=["tools/single_paper_recommendation=default"]
-    )
-    cfg = cfg.tools.single_paper_recommendation
-
-
 @tool(args_schema=SinglePaperRecInput, parse_docstring=True)
 def get_single_paper_recommendations(
     paper_id: str,
@@ -56,19 +48,27 @@ def get_single_paper_recommendations(
     year: Optional[str] = None,
 ) -> Command[Any]:
     """
-    Get recommendations for on a single paper using its Semantic Scholar ID.
+    Get recommendations for a single paper using its Semantic Scholar ID.
     No other ID types are supported.
 
     Args:
         paper_id (str): The Semantic Scholar Paper ID to get recommendations for.
         tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
-        limit (int, optional): The maximum number of recommendations to return. Defaults to 2.
+        limit (int, optional): The maximum number of recommendations to return. Defaults to 5.
         year (str, optional): Year range for papers.
         Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
 
     Returns:
         Dict[str, Any]: The recommendations and related information.
     """
+    # Load hydra configuration
+    with hydra.initialize(version_base=None, config_path="../../configs"):
+        cfg = hydra.compose(
+            config_name="config",
+            overrides=["tools/single_paper_recommendation=default"],
+        )
+        cfg = cfg.tools.single_paper_recommendation
+        logger.info("Loaded configuration for single paper recommendation tool")
     logger.info(
         "Starting single paper recommendations search with paper ID: %s", paper_id
     )
@@ -84,48 +84,54 @@ def get_single_paper_recommendations(
     if year:
         params["year"] = year
 
-    response = requests.get(endpoint, params=params, timeout=cfg.request_timeout)
-    data = response.json()
-    response = requests.get(endpoint, params=params, timeout=10)
-    # print(f"API Response Status: {response.status_code}")
-    logging.info(
+    # Wrap API call in try/except to catch connectivity issues and check response format
+    try:
+        response = requests.get(endpoint, params=params, timeout=cfg.request_timeout)
+        response.raise_for_status()  # Raises HTTPError for bad responses
+    except requests.exceptions.RequestException as e:
+        logger.error(
+            "Failed to connect to Semantic Scholar API for recommendations: %s", e
+        )
+        raise RuntimeError(
+            "Failed to connect to Semantic Scholar API. Please retry the same query."
+        ) from e
+
+    logger.info(
         "API Response Status for recommendations of paper %s: %s",
         paper_id,
         response.status_code,
     )
-    if response.status_code != 200:
-        raise ValueError("Invalid paper ID or API error.")
-    # print(f"Request params: {params}")
-    logging.info("Request params: %s", params)
+    logger.info("Request params: %s", params)
 
     data = response.json()
-    recommendations = data.get("recommendedPapers", [])
 
+    # Check for expected data format
+    if "recommendedPapers" not in data:
+        logger.error("Unexpected API response format: %s", data)
+        raise RuntimeError(
+            "Unexpected response from Semantic Scholar API. The results could not be "
+            "retrieved due to an unexpected format. "
+            "Please modify your search query and try again."
+        )
+
+    recommendations = data.get("recommendedPapers", [])
     if not recommendations:
-        return Command(
-            update={
-                "papers": {},
-                "messages": [
-                    ToolMessage(
-                        content=f"No recommendations found for {paper_id}.",
-                        tool_call_id=tool_call_id,
-                    )
-                ],
-            }
+        logger.error("No recommendations returned from API for paper: %s", paper_id)
+        raise RuntimeError(
+            "No recommendations were found for your query. Consider refining your search "
+            "by using more specific keywords or different terms."
         )
 
     # Extract paper ID and title from recommendations
     filtered_papers = {
         paper["paperId"]: {
-            # "semantic_scholar_id": paper["paperId"],  # Store Semantic Scholar ID
+            "paper_id": paper["paperId"],
             "Title": paper.get("title", "N/A"),
             "Abstract": paper.get("abstract", "N/A"),
             "Year": paper.get("year", "N/A"),
             "Citation Count": paper.get("citationCount", "N/A"),
             "URL": paper.get("url", "N/A"),
-            # "arXiv_ID": paper.get("externalIds", {}).get(
-            #     "ArXiv", "N/A"
-            # ),  # Extract arXiv ID
+            "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
         }
         for paper in recommendations
         if paper.get("title") and paper.get("authors")
@@ -143,10 +149,10 @@ def get_single_paper_recommendations(
     logger.info("Filtered %d papers", len(filtered_papers))
 
     content = (
-        "Recommendations based on single paper were successful. "
-        "Papers are attached as an artifact."
+        "Recommendations based on the single paper were successful. "
+        "Papers are attached as an artifact. "
+        "Here is a summary of the recommendations:\n"
     )
-    content += " Here is a summary of the recommendations:\n"
     content += f"Number of papers found: {len(filtered_papers)}\n"
     content += f"Query Paper ID: {paper_id}\n"
     content += f"Year: {year}\n" if year else ""
@@ -154,7 +160,7 @@ def get_single_paper_recommendations(
 
     return Command(
         update={
-            "papers": filtered_papers,  # Now sending the dictionary directly
+            "papers": filtered_papers,  # Sending the dictionary directly
             "last_displayed_papers": "papers",
             "messages": [
                 ToolMessage(

aiagents4pharma/talk2scholars/tools/zotero/__init__.py

@@ -3,3 +3,5 @@ Import statements
 """
 
 from . import zotero_read
+from . import zotero_write
+from . import utils

aiagents4pharma/talk2scholars/tools/zotero/utils/__init__.py

@@ -0,0 +1,5 @@
+"""
+Import statements
+"""
+
+from . import zotero_path

aiagents4pharma/talk2scholars/tools/zotero/utils/zotero_path.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+
+"""
+Utility functions for Zotero tools.
+"""
+
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def get_item_collections(zot):
+    """
+    Fetch all Zotero collections and map item keys to their full collection paths.
+
+    Args:
+        zot (Zotero): An initialized Zotero client.
+
+    Returns:
+        dict: A dictionary mapping item keys to a list of full collection paths.
+    """
+    logger.info("Fetching Zotero collections...")
+
+    # Fetch all collections
+    collections = zot.collections()
+
+    # Create mappings: collection key → name and collection key → parent key
+    collection_map = {col["key"]: col["data"]["name"] for col in collections}
+    parent_map = {
+        col["key"]: col["data"].get("parentCollection") for col in collections
+    }
+
+    # Build full paths for collections
+    def build_collection_path(col_key):
+        path = []
+        while col_key:
+            path.insert(0, collection_map.get(col_key, "Unknown"))
+            col_key = parent_map.get(col_key)
+        return "/" + "/".join(path)  # Convert to "/path/to/collection"
+
+    collection_paths = {key: build_collection_path(key) for key in collection_map}
+
+    # Manually create an item-to-collection mapping with full paths
+    item_to_collections = {}
+
+    for collection in collections:
+        collection_key = collection["key"]
+        collection_items = zot.collection_items(
+            collection_key
+        )  # Fetch items in the collection
+
+        for item in collection_items:
+            item_key = item["data"]["key"]
+            if item_key in item_to_collections:
+                item_to_collections[item_key].append(collection_paths[collection_key])
+            else:
+                item_to_collections[item_key] = [collection_paths[collection_key]]
+
+    logger.info("Successfully mapped items to collection paths.")
+
+    return item_to_collections