dhisana 0.0.1.dev208__tar.gz → 0.0.1.dev209__tar.gz

{dhisana-0.0.1.dev208 → dhisana-0.0.1.dev209}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev208
+Version: 0.0.1.dev209
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin

{dhisana-0.0.1.dev208 → dhisana-0.0.1.dev209}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='dhisana',  
-    version='0.0.1-dev208',
+    version='0.0.1-dev209',
     description='A Python SDK for Dhisana AI Platform',
     author='Admin',
     author_email='contact@dhisana.ai',

{dhisana-0.0.1.dev208 → dhisana-0.0.1.dev209}/src/dhisana/utils/google_oauth_tools.py

@@ -1,6 +1,7 @@
 import base64
 import json
 import logging
+import re
 from email.mime.text import MIMEText
 from typing import Any, Dict, List, Optional
 
@@ -19,6 +20,9 @@ from dhisana.utils.email_parse_helpers import (
     convert_date_to_iso,
     extract_email_body_in_plain_text,
 )
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from dhisana.utils.cache_output_tools import retrieve_output, cache_output
+from typing import Optional as _Optional  # avoid name clash in wrappers
 
 
 def get_google_access_token(tool_config: Optional[List[Dict]] = None) -> str:
@@ -253,3 +257,199 @@ async def reply_to_email_google_oauth_async(
         "email_labels": sent.get("labelIds", []),
     }
 
+
+# ---------------------------------------------------------------------------
+# Google Calendar (OAuth per-user)
+# ---------------------------------------------------------------------------
+
+@assistant_tool
+async def get_calendar_events_using_google_oauth_async(
+    start_date: str,
+    end_date: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Retrieve events from the user's primary Google Calendar using a per-user OAuth token.
+
+    start_date, end_date: 'YYYY-MM-DD' strings (inclusive start, inclusive end day as 23:59:59Z).
+    Returns a list of event dicts from the Calendar API.
+    """
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}"}
+    url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
+
+    time_min = f"{start_date}T00:00:00Z"
+    time_max = f"{end_date}T23:59:59Z"
+    params = {
+        "timeMin": time_min,
+        "timeMax": time_max,
+        "maxResults": 10,
+        "singleEvents": True,
+        "orderBy": "startTime",
+    }
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=headers, params=params)
+        resp.raise_for_status()
+        data = resp.json() or {}
+        events = data.get("items", [])
+        if not events:
+            logging.info("No upcoming events found within the specified range (OAuth).")
+        return events
+
+
+# ---------------------------------------------------------------------------
+# Google Sheets and Docs (OAuth per-user)
+# ---------------------------------------------------------------------------
+
+def _get_sheet_id_from_url(sheet_url: str) -> str:
+    match = re.search(r"/d/([a-zA-Z0-9-_]+)/", sheet_url)
+    if not match:
+        raise ValueError("Could not extract spreadsheet ID from the provided URL.")
+    return match.group(1)
+
+
+def _get_document_id_from_url(doc_url: str) -> str:
+    match = re.search(r"/d/([a-zA-Z0-9-_]+)/", doc_url)
+    if not match:
+        raise ValueError("Could not extract document ID from the provided URL.")
+    return match.group(1)
+
+
+@assistant_tool
+async def read_google_sheet_using_google_oauth(
+    sheet_url: str,
+    range_name: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> List[List[str]]:
+    """
+    Read data from a Google Sheet using the connected user's OAuth token.
+
+    If range_name is empty, reads the first sheet tab by fetching spreadsheet metadata.
+    """
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    spreadsheet_id = _get_sheet_id_from_url(sheet_url)
+
+    # Default range to first sheet title if not supplied
+    if not range_name:
+        meta_url = f"https://sheets.googleapis.com/v4/spreadsheets/{spreadsheet_id}"
+        async with httpx.AsyncClient(timeout=30) as client:
+            meta_resp = await client.get(meta_url, headers=headers)
+            meta_resp.raise_for_status()
+            meta = meta_resp.json() or {}
+            sheets = meta.get("sheets", [])
+            if not sheets:
+                return []
+            range_name = (sheets[0].get("properties") or {}).get("title") or "Sheet1"
+
+    values_url = f"https://sheets.googleapis.com/v4/spreadsheets/{spreadsheet_id}/values/{range_name}"
+    async with httpx.AsyncClient(timeout=30) as client:
+        val_resp = await client.get(values_url, headers=headers)
+        val_resp.raise_for_status()
+        data = val_resp.json() or {}
+        return data.get("values", [])
+
+
+@assistant_tool
+async def read_google_document_using_google_oauth(
+    doc_url: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    """
+    Read text content from a Google Doc using the connected user's OAuth token.
+    Concatenates all text runs in the document body.
+    """
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    document_id = _get_document_id_from_url(doc_url)
+    url = f"https://docs.googleapis.com/v1/documents/{document_id}"
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=headers)
+        resp.raise_for_status()
+        doc = resp.json() or {}
+
+    content = (doc.get("body") or {}).get("content", [])
+    parts: List[str] = []
+    for element in content:
+        paragraph = element.get("paragraph")
+        if not paragraph:
+            continue
+        for elem in paragraph.get("elements", []) or []:
+            text_run = elem.get("textRun")
+            if text_run:
+                parts.append(text_run.get("content", ""))
+
+    return "".join(parts)
+
+
+@assistant_tool
+async def search_google_places_using_google_oauth(
+    query: str,
+    location_bias: dict = None,
+    number_of_results: int = 3,
+    tool_config: _Optional[List[Dict]] = None,
+) -> List[str]:
+    """
+    Search Google Places (New) with a per-user OAuth token.
+
+    - Requires that the OAuth token has Maps/Places access enabled for the project.
+    - Returns a list of JSON strings, each being a place object.
+    """
+    
+
+    token = get_google_access_token(tool_config)
+    url = "https://places.googleapis.com/v1/places:searchText"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {token}",
+        # Field mask is required to limit returned fields
+        "X-Goog-FieldMask": (
+            "places.displayName,places.formattedAddress,places.location,"
+            "places.websiteUri,places.rating,places.reviews"
+        ),
+    }
+
+    body: Dict[str, Any] = {"textQuery": query}
+    if location_bias:
+        body["locationBias"] = {
+            "circle": {
+                "center": {
+                    "latitude": location_bias.get("latitude"),
+                    "longitude": location_bias.get("longitude"),
+                },
+                "radius": location_bias.get("radius", 5000),
+            }
+        }
+
+    # Cache key based on query, count and bias
+    bias_str = json.dumps(location_bias, sort_keys=True) if location_bias else "None"
+    cache_key = f"oauth_places:{query}:{number_of_results}:{bias_str}"
+    cached = retrieve_output("search_google_places_oauth", cache_key)
+    if cached is not None:
+        return cached
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        try:
+            resp = await client.post(url, headers=headers, json=body)
+            if resp.status_code == 429:
+                return [json.dumps({"error": "Rate limit exceeded (429)"})]
+            resp.raise_for_status()
+            data = resp.json() or {}
+            places = (data.get("places") or [])[: max(0, int(number_of_results))]
+            out = [json.dumps(p) for p in places]
+            cache_output("search_google_places_oauth", cache_key, out)
+            return out
+        except httpx.HTTPStatusError as exc:
+            try:
+                err_json = exc.response.json()
+            except Exception:
+                err_json = {"status": exc.response.status_code, "text": exc.response.text}
+            logging.warning(f"Places OAuth request failed: {err_json}")
+            return [json.dumps({"error": err_json})]
+        except Exception as e:
+            logging.exception("Places OAuth request failed")
+            return [json.dumps({"error": str(e)})]

{dhisana-0.0.1.dev208 → dhisana-0.0.1.dev209}/src/dhisana.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev208
+Version: 0.0.1.dev209
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin