gsuite-sdk 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

gsuite_api/__init__.py

@@ -0,0 +1,3 @@
+"""Google Suite Unified REST API Gateway."""
+
+__version__ = "0.1.0"

gsuite_api/dependencies.py

@@ -0,0 +1,99 @@
+"""FastAPI dependencies."""
+
+from functools import lru_cache
+from typing import Annotated
+
+from fastapi import Depends, HTTPException, Security, status
+from fastapi.security import APIKeyHeader
+
+from gsuite_calendar import Calendar
+from gsuite_core import GoogleAuth, Settings, SQLiteTokenStore, get_settings
+from gsuite_gmail import Gmail
+
+# API Key security
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+def get_api_key(
+    api_key: Annotated[str | None, Security(api_key_header)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> str | None:
+    """Validate API key if configured."""
+    if not settings.api_key:
+        return None
+
+    if not api_key or api_key != settings.api_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API key",
+        )
+
+    return api_key
+
+
+@lru_cache
+def get_auth() -> GoogleAuth:
+    """Get shared GoogleAuth instance."""
+    settings = get_settings()
+
+    if settings.token_storage == "secretmanager":
+        settings.validate_for_secretmanager()
+        from gsuite_core import SecretManagerTokenStore
+
+        token_store = SecretManagerTokenStore(
+            project_id=settings.gcp_project_id,
+            secret_name=settings.token_secret_name,
+        )
+    else:
+        token_store = SQLiteTokenStore(settings.token_db_path)
+
+    return GoogleAuth(token_store=token_store)
+
+
+def get_gmail(
+    auth: Annotated[GoogleAuth, Depends(get_auth)],
+    _api_key: Annotated[str | None, Depends(get_api_key)],
+) -> Gmail:
+    """Get authenticated Gmail client."""
+    if not auth.is_authenticated():
+        if auth.needs_refresh():
+            if not auth.refresh():
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Token expired. Re-authenticate required.",
+                )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Not authenticated. Run OAuth flow first.",
+            )
+
+    return Gmail(auth)
+
+
+def get_calendar(
+    auth: Annotated[GoogleAuth, Depends(get_auth)],
+    _api_key: Annotated[str | None, Depends(get_api_key)],
+) -> Calendar:
+    """Get authenticated Calendar client."""
+    if not auth.is_authenticated():
+        if auth.needs_refresh():
+            if not auth.refresh():
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Token expired. Re-authenticate required.",
+                )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Not authenticated. Run OAuth flow first.",
+            )
+
+    return Calendar(auth)
+
+
+# Type aliases
+GmailDep = Annotated[Gmail, Depends(get_gmail)]
+CalendarDep = Annotated[Calendar, Depends(get_calendar)]
+AuthDep = Annotated[GoogleAuth, Depends(get_auth)]
+ApiKeyDep = Annotated[str | None, Depends(get_api_key)]

gsuite_api/main.py

@@ -0,0 +1,69 @@
+"""FastAPI application - Unified Google Suite API Gateway."""
+
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from gsuite_api.routes import calendar, drive, gmail, health, sheets
+from gsuite_core import get_settings
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler."""
+    print("🚀 Google Suite API starting up...")
+    yield
+    print("👋 Google Suite API shutting down...")
+
+
+def create_app() -> FastAPI:
+    """Create and configure FastAPI application."""
+    settings = get_settings()
+
+    app = FastAPI(
+        title="Google Suite API",
+        description="Unified REST API for Google Workspace - Gmail, Calendar, Drive, Sheets",
+        version="0.1.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+        lifespan=lifespan,
+    )
+
+    # CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Routes
+    app.include_router(health.router)
+    app.include_router(gmail.router, prefix="/gmail", tags=["Gmail"])
+    app.include_router(calendar.router, prefix="/calendar", tags=["Calendar"])
+    app.include_router(drive.router, prefix="/drive", tags=["Drive"])
+    app.include_router(sheets.router, prefix="/sheets", tags=["Sheets"])
+
+    return app
+
+
+app = create_app()
+
+
+def run():
+    """Run the API server."""
+    import uvicorn
+
+    settings = get_settings()
+    uvicorn.run(
+        "gsuite_api.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=True,
+    )
+
+
+if __name__ == "__main__":
+    run()

gsuite_api/routes/__init__.py

@@ -0,0 +1,5 @@
+"""API routes."""
+
+from gsuite_api.routes import calendar, drive, gmail, health, sheets
+
+__all__ = ["health", "gmail", "calendar", "drive", "sheets"]

gsuite_api/routes/calendar.py

@@ -0,0 +1,145 @@
+"""Calendar API routes."""
+
+from datetime import datetime
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from gsuite_api.dependencies import CalendarDep
+
+router = APIRouter()
+
+
+class EventResponse(BaseModel):
+    id: str
+    summary: str
+    description: str | None
+    location: str | None
+    start: str | None
+    end: str | None
+    all_day: bool
+    html_link: str | None
+
+
+class CreateEventRequest(BaseModel):
+    summary: str
+    start: str  # ISO format
+    end: str | None = None
+    description: str | None = None
+    location: str | None = None
+    all_day: bool = False
+
+
+@router.get("/events")
+async def list_events(
+    calendar: CalendarDep,
+    days: int = Query(7, le=365),
+    calendar_id: str | None = None,
+    limit: int = Query(100, le=500),
+):
+    """Get upcoming events."""
+    events = calendar.get_upcoming(days=days, calendar_id=calendar_id, max_results=limit)
+    return {
+        "events": [
+            EventResponse(
+                id=e.id,
+                summary=e.summary,
+                description=e.description,
+                location=e.location,
+                start=e.start.isoformat() if e.start else None,
+                end=e.end.isoformat() if e.end else None,
+                all_day=e.all_day,
+                html_link=e.html_link,
+            )
+            for e in events
+        ],
+        "count": len(events),
+    }
+
+
+@router.get("/events/today")
+async def list_today(calendar: CalendarDep, calendar_id: str | None = None):
+    """Get today's events."""
+    events = calendar.get_today(calendar_id=calendar_id)
+    return {
+        "events": [
+            EventResponse(
+                id=e.id,
+                summary=e.summary,
+                description=e.description,
+                location=e.location,
+                start=e.start.isoformat() if e.start else None,
+                end=e.end.isoformat() if e.end else None,
+                all_day=e.all_day,
+                html_link=e.html_link,
+            )
+            for e in events
+        ],
+        "count": len(events),
+    }
+
+
+@router.get("/events/{event_id}")
+async def get_event(event_id: str, calendar: CalendarDep, calendar_id: str | None = None):
+    """Get a specific event."""
+    event = calendar.get_event(event_id, calendar_id=calendar_id)
+    if not event:
+        raise HTTPException(status_code=404, detail="Event not found")
+
+    return EventResponse(
+        id=event.id,
+        summary=event.summary,
+        description=event.description,
+        location=event.location,
+        start=event.start.isoformat() if event.start else None,
+        end=event.end.isoformat() if event.end else None,
+        all_day=event.all_day,
+        html_link=event.html_link,
+    )
+
+
+@router.post("/events")
+async def create_event(request: CreateEventRequest, calendar: CalendarDep):
+    """Create a new event."""
+    start = datetime.fromisoformat(request.start)
+    end = datetime.fromisoformat(request.end) if request.end else None
+
+    event = calendar.create_event(
+        summary=request.summary,
+        start=start,
+        end=end,
+        description=request.description,
+        location=request.location,
+        all_day=request.all_day,
+    )
+
+    return {
+        "id": event.id,
+        "summary": event.summary,
+        "status": "created",
+    }
+
+
+@router.delete("/events/{event_id}")
+async def delete_event(event_id: str, calendar: CalendarDep, calendar_id: str | None = None):
+    """Delete an event."""
+    success = calendar.delete_event(event_id, calendar_id=calendar_id)
+    return {"status": "deleted" if success else "failed"}
+
+
+@router.get("/calendars")
+async def list_calendars(calendar: CalendarDep):
+    """List all accessible calendars."""
+    calendars = calendar.get_calendars()
+    return {
+        "calendars": [
+            {
+                "id": c.id,
+                "summary": c.summary,
+                "primary": c.primary,
+                "access_role": c.access_role,
+            }
+            for c in calendars
+        ],
+        "count": len(calendars),
+    }

gsuite_api/routes/drive.py

@@ -0,0 +1,91 @@
+"""Drive API routes."""
+
+from fastapi import APIRouter, File, Query, UploadFile
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class FileResponse(BaseModel):
+    id: str
+    name: str
+    mime_type: str
+    size: int
+    web_view_link: str | None
+
+
+class CreateFolderRequest(BaseModel):
+    name: str
+    parent_id: str | None = None
+
+
+@router.get("/files")
+async def list_files(
+    query: str | None = Query(None, description="Drive search query"),
+    parent_id: str | None = Query(None, description="Parent folder ID"),
+    limit: int = Query(100, le=1000),
+):
+    """
+    List Drive files.
+
+    Note: Drive routes are placeholders. Install gsuite-drive and configure auth.
+    """
+    return {
+        "status": "placeholder",
+        "message": "Drive API coming soon. Install gsuite-drive package.",
+        "files": [],
+    }
+
+
+@router.get("/files/{file_id}")
+async def get_file(file_id: str):
+    """Get a specific file."""
+    return {
+        "status": "placeholder",
+        "message": "Drive API coming soon",
+    }
+
+
+@router.post("/files/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    parent_id: str | None = None,
+):
+    """Upload a file."""
+    return {
+        "status": "placeholder",
+        "message": "Drive API coming soon",
+        "filename": file.filename,
+    }
+
+
+@router.post("/folders")
+async def create_folder(request: CreateFolderRequest):
+    """Create a folder."""
+    return {
+        "status": "placeholder",
+        "message": "Drive API coming soon",
+        "name": request.name,
+    }
+
+
+@router.delete("/files/{file_id}")
+async def delete_file(file_id: str):
+    """Delete a file."""
+    return {
+        "status": "placeholder",
+        "message": "Drive API coming soon",
+    }
+
+
+@router.post("/files/{file_id}/share")
+async def share_file(
+    file_id: str,
+    email: str = Query(...),
+    role: str = Query("reader"),
+):
+    """Share a file."""
+    return {
+        "status": "placeholder",
+        "message": "Drive API coming soon",
+    }

gsuite_api/routes/gmail.py

@@ -0,0 +1,148 @@
+"""Gmail API routes."""
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel, EmailStr
+
+from gsuite_api.dependencies import GmailDep
+
+router = APIRouter()
+
+
+class MessageResponse(BaseModel):
+    id: str
+    thread_id: str
+    subject: str
+    sender: str
+    recipient: str
+    date: str | None
+    snippet: str
+    is_unread: bool
+    is_starred: bool
+    labels: list[str]
+
+
+class SendRequest(BaseModel):
+    to: list[EmailStr]
+    subject: str
+    body: str
+    cc: list[EmailStr] | None = None
+    html: bool = False
+
+
+@router.get("/messages")
+async def list_messages(
+    gmail: GmailDep,
+    query: str | None = Query(None),
+    limit: int = Query(25, le=100),
+):
+    """List messages with optional search."""
+    messages = gmail.get_messages(query=query, max_results=limit)
+    return {
+        "messages": [
+            MessageResponse(
+                id=m.id,
+                thread_id=m.thread_id,
+                subject=m.subject,
+                sender=m.sender,
+                recipient=m.recipient,
+                date=m.date.isoformat() if m.date else None,
+                snippet=m.snippet,
+                is_unread=m.is_unread,
+                is_starred=m.is_starred,
+                labels=m.labels,
+            )
+            for m in messages
+        ],
+        "count": len(messages),
+    }
+
+
+@router.get("/messages/unread")
+async def list_unread(gmail: GmailDep, limit: int = Query(25, le=100)):
+    """Get unread messages."""
+    messages = gmail.get_unread(max_results=limit)
+    return {
+        "messages": [
+            MessageResponse(
+                id=m.id,
+                thread_id=m.thread_id,
+                subject=m.subject,
+                sender=m.sender,
+                recipient=m.recipient,
+                date=m.date.isoformat() if m.date else None,
+                snippet=m.snippet,
+                is_unread=m.is_unread,
+                is_starred=m.is_starred,
+                labels=m.labels,
+            )
+            for m in messages
+        ],
+        "count": len(messages),
+    }
+
+
+@router.get("/messages/{message_id}")
+async def get_message(message_id: str, gmail: GmailDep):
+    """Get a specific message."""
+    message = gmail.get_message(message_id)
+    if not message:
+        raise HTTPException(status_code=404, detail="Message not found")
+
+    return {
+        "id": message.id,
+        "thread_id": message.thread_id,
+        "subject": message.subject,
+        "sender": message.sender,
+        "recipient": message.recipient,
+        "date": message.date.isoformat() if message.date else None,
+        "snippet": message.snippet,
+        "body": message.body,
+        "labels": message.labels,
+    }
+
+
+@router.post("/messages/send")
+async def send_message(request: SendRequest, gmail: GmailDep):
+    """Send an email."""
+    message = gmail.send(
+        to=[str(e) for e in request.to],
+        subject=request.subject,
+        body=request.body,
+        cc=[str(e) for e in request.cc] if request.cc else None,
+        html=request.html,
+    )
+    return {"id": message.id, "status": "sent"}
+
+
+@router.post("/messages/{message_id}/read")
+async def mark_as_read(message_id: str, gmail: GmailDep):
+    """Mark message as read."""
+    message = gmail.get_message(message_id)
+    if not message:
+        raise HTTPException(status_code=404, detail="Message not found")
+    message.mark_as_read()
+    return {"status": "success"}
+
+
+@router.get("/labels")
+async def list_labels(gmail: GmailDep):
+    """List all labels."""
+    labels = gmail.get_labels()
+    return {
+        "labels": [
+            {
+                "id": l.id,
+                "name": l.name,
+                "type": l.type.value,
+                "messages_unread": l.messages_unread,
+            }
+            for l in labels
+        ],
+        "count": len(labels),
+    }
+
+
+@router.get("/profile")
+async def get_profile(gmail: GmailDep):
+    """Get user profile."""
+    return gmail.get_profile()

gsuite_api/routes/health.py

@@ -0,0 +1,134 @@
+"""Health check routes."""
+
+import os
+from datetime import UTC, datetime, timedelta
+
+from fastapi import APIRouter, HTTPException, Query, Security
+from fastapi.security import APIKeyHeader
+
+from gsuite_api.dependencies import AuthDep
+from gsuite_core import get_settings
+
+router = APIRouter(tags=["Health"])
+
+# Admin API key for logs endpoint
+admin_key_header = APIKeyHeader(name="X-Admin-Key", auto_error=False)
+
+
+def verify_admin_key(
+    admin_key: str | None = Security(admin_key_header),
+    api_key: str | None = Query(None, alias="api_key"),
+) -> str:
+    """Verify admin API key from header or query param."""
+    key = admin_key or api_key
+    expected = os.environ.get("ADMIN_API_KEY")
+
+    if not expected:
+        raise HTTPException(status_code=503, detail="Admin API key not configured")
+
+    if not key or key != expected:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    return key
+
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    settings = get_settings()
+    return {
+        "status": "healthy",
+        "service": "gsuite-api",
+        "version": settings.version,
+    }
+
+
+@router.get("/health/auth")
+async def auth_status(auth: AuthDep):
+    """Check authentication status."""
+    return {
+        "authenticated": auth.is_authenticated(),
+        "needs_refresh": auth.needs_refresh(),
+    }
+
+
+@router.get("/health/admin/logs")
+async def get_logs(
+    _admin: str = Security(verify_admin_key),
+    severity: str = Query("ERROR", description="Minimum severity: DEBUG, INFO, WARNING, ERROR"),
+    limit: int = Query(50, ge=1, le=500),
+    hours: int = Query(24, ge=1, le=168, description="Hours to look back"),
+):
+    """
+    Fetch recent logs from Cloud Logging.
+
+    Requires X-Admin-Key header or api_key query param.
+    """
+    try:
+        from google.cloud import logging as cloud_logging
+    except ImportError:
+        raise HTTPException(status_code=503, detail="google-cloud-logging not installed")
+
+    project_id = os.environ.get("GOOGLE_CLOUD_PROJECT") or os.environ.get("GCP_PROJECT")
+    service_name = os.environ.get("K_SERVICE", "google-suite")
+
+    if not project_id:
+        raise HTTPException(status_code=503, detail="GCP project not configured")
+
+    try:
+        client = cloud_logging.Client(project=project_id)
+
+        # Calculate time filter
+        now = datetime.now(UTC)
+        start_time = now - timedelta(hours=hours)
+
+        # Build filter - severity uses name not number
+        severity_upper = severity.upper()
+        if severity_upper not in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"):
+            severity_upper = "ERROR"
+
+        filter_str = f"""
+            resource.type="cloud_run_revision"
+            resource.labels.service_name="{service_name}"
+            timestamp>="{start_time.isoformat()}"
+            severity>={severity_upper}
+        """
+
+        entries = list(
+            client.list_entries(
+                filter_=filter_str,
+                order_by=cloud_logging.DESCENDING,
+                max_results=limit,
+            )
+        )
+
+        logs = []
+        for entry in entries:
+            payload = entry.payload
+            if isinstance(payload, dict):
+                message = payload.get("message", str(payload))
+            else:
+                message = str(payload) if payload else ""
+
+            logs.append(
+                {
+                    "timestamp": entry.timestamp.isoformat() if entry.timestamp else None,
+                    "severity": entry.severity or "DEFAULT",
+                    "message": message[:2000],  # Truncate long messages
+                }
+            )
+
+        return {
+            "service": service_name,
+            "project": project_id,
+            "filter": {
+                "severity": severity,
+                "hours": hours,
+                "limit": limit,
+            },
+            "count": len(logs),
+            "logs": logs,
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to fetch logs: {str(e)}")

gsuite_api/routes/sheets.py

@@ -0,0 +1,203 @@
+"""Sheets API routes."""
+
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from gsuite_api.dependencies import get_auth
+from gsuite_core import GoogleAuth
+from gsuite_sheets import Sheets
+
+router = APIRouter()
+
+
+def get_sheets(auth: Annotated[GoogleAuth, Depends(get_auth)]) -> Sheets:
+    """Get authenticated Sheets client."""
+    if not auth.is_authenticated():
+        if auth.needs_refresh():
+            if not auth.refresh():
+                raise HTTPException(
+                    status_code=401,
+                    detail="Token expired. Re-authenticate required.",
+                )
+        else:
+            raise HTTPException(
+                status_code=401,
+                detail="Not authenticated. Run OAuth flow first.",
+            )
+    return Sheets(auth)
+
+
+SheetsDep = Annotated[Sheets, Depends(get_sheets)]
+
+
+class UpdateRequest(BaseModel):
+    range: str
+    values: list[list[Any]]
+
+
+class AppendRequest(BaseModel):
+    values: list[list[Any]]
+
+
+class BatchUpdateRequest(BaseModel):
+    data: list[UpdateRequest]
+
+
+@router.get("/list")
+async def list_spreadsheets(
+    sheets: SheetsDep,
+    limit: int = Query(50, le=100),
+):
+    """List all spreadsheets accessible to the user."""
+    try:
+        spreadsheets = sheets.list_spreadsheets(max_results=limit)
+        return {
+            "count": len(spreadsheets),
+            "spreadsheets": spreadsheets,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{spreadsheet_id}")
+async def get_spreadsheet(
+    sheets: SheetsDep,
+    spreadsheet_id: str,
+):
+    """Get spreadsheet metadata and worksheets."""
+    try:
+        doc = sheets.open_by_key(spreadsheet_id)
+        return {
+            "id": doc.id,
+            "title": doc.title,
+            "url": doc.url,
+            "locale": doc.locale,
+            "time_zone": doc.time_zone,
+            "worksheets": [
+                {
+                    "id": ws.id,
+                    "title": ws.title,
+                    "index": ws.index,
+                    "row_count": ws.row_count,
+                    "column_count": ws.column_count,
+                }
+                for ws in doc.worksheets
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{spreadsheet_id}/values/{range:path}")
+async def get_values(
+    sheets: SheetsDep,
+    spreadsheet_id: str,
+    range: str,
+):
+    """Get values from a range (e.g., Sheet1!A1:D10)."""
+    try:
+        values = sheets.get_values(spreadsheet_id, range)
+        return {
+            "spreadsheet_id": spreadsheet_id,
+            "range": range,
+            "values": values,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/{spreadsheet_id}/values/{range:path}")
+async def update_values(
+    sheets: SheetsDep,
+    spreadsheet_id: str,
+    range: str,
+    request: UpdateRequest,
+):
+    """Update values in a range."""
+    try:
+        result = sheets.update_values(spreadsheet_id, range, request.values)
+        return {
+            "spreadsheet_id": spreadsheet_id,
+            "range": range,
+            "updated_cells": result.get("updatedCells", 0),
+            "updated_rows": result.get("updatedRows", 0),
+            "updated_columns": result.get("updatedColumns", 0),
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{spreadsheet_id}/values/{sheet_name}:append")
+async def append_values(
+    sheets: SheetsDep,
+    spreadsheet_id: str,
+    sheet_name: str,
+    request: AppendRequest,
+):
+    """Append values to a sheet."""
+    try:
+        result = sheets.append_values(spreadsheet_id, sheet_name, request.values)
+        return {
+            "spreadsheet_id": spreadsheet_id,
+            "sheet": sheet_name,
+            "appended_rows": len(request.values),
+            "updates": result.get("updates", {}),
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{spreadsheet_id}/values:batchUpdate")
+async def batch_update(
+    sheets: SheetsDep,
+    spreadsheet_id: str,
+    request: BatchUpdateRequest,
+):
+    """Batch update multiple ranges."""
+    try:
+        data = [{"range": d.range, "values": d.values} for d in request.data]
+        result = sheets.batch_update(spreadsheet_id, data)
+        return {
+            "spreadsheet_id": spreadsheet_id,
+            "updated_ranges": len(request.data),
+            "responses": result.get("responses", []),
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{spreadsheet_id}/values/{range:path}")
+async def clear_values(
+    sheets: SheetsDep,
+    spreadsheet_id: str,
+    range: str,
+):
+    """Clear values from a range."""
+    try:
+        sheets.clear_values(spreadsheet_id, range)
+        return {
+            "spreadsheet_id": spreadsheet_id,
+            "range": range,
+            "cleared": True,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/create")
+async def create_spreadsheet(
+    sheets: SheetsDep,
+    title: str = Query(...),
+):
+    """Create a new spreadsheet."""
+    try:
+        doc = sheets.create(title)
+        return {
+            "id": doc.id,
+            "title": doc.title,
+            "url": doc.url,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

{gsuite_sdk-0.1.0.dist-info → gsuite_sdk-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gsuite-sdk
-Version: 0.1.0
+Version: 0.1.2
 Summary: Unified Google Workspace SDK - Gmail, Calendar, Drive, Sheets
 Author-email: Pablo Alaniz <alanizpablo@gmail.com>
 License: MIT
@@ -30,11 +30,17 @@ Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.8.0; extra == "dev"
 Provides-Extra: cloudrun
 Requires-Dist: google-cloud-secret-manager>=2.18.0; extra == "cloudrun"
+Requires-Dist: google-cloud-logging>=3.9.0; extra == "cloudrun"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.109.0; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.27.0; extra == "api"
+Requires-Dist: python-multipart>=0.0.6; extra == "api"
+Requires-Dist: email-validator>=2.1.0; extra == "api"
+Provides-Extra: cli
+Requires-Dist: typer>=0.9.0; extra == "cli"
+Requires-Dist: rich>=13.7.0; extra == "cli"
 Provides-Extra: all
-Requires-Dist: fastapi>=0.109.0; extra == "all"
-Requires-Dist: uvicorn>=0.27.0; extra == "all"
-Requires-Dist: typer>=0.9.0; extra == "all"
-Requires-Dist: rich>=13.7.0; extra == "all"
+Requires-Dist: gsuite-sdk[api,cli,cloudrun]; extra == "all"
 Dynamic: license-file
 
 # Google Suite

{gsuite_sdk-0.1.0.dist-info → gsuite_sdk-0.1.2.dist-info}/RECORD

@@ -1,3 +1,12 @@
+gsuite_api/__init__.py,sha256=NteihQi3x0ke8bZuQJuyVWfVsWILNtO7-ul1KdzNPZQ,68
+gsuite_api/dependencies.py,sha256=UvGbHoAO7_VbTTlZOI_LtKA4FwvCZcML0zup_ne-woQ,3043
+gsuite_api/main.py,sha256=h86UuxgAyKQb2Vi8CA8CznpdDVL4qrqA30wrndEkc5I,1704
+gsuite_api/routes/__init__.py,sha256=OekJCAJzrjbfbOHT3OGnS4wRv13IPCNPGAF-g3UalfM,150
+gsuite_api/routes/calendar.py,sha256=siRzSIQb0wbQ7uK5OhLOteDo0WJnV4qB2PryOcWUYpo,4075
+gsuite_api/routes/drive.py,sha256=2tAcS0bdMrvQ36sfL9hg1Pu2xdBQAnY29Uta4nREDYA,2015
+gsuite_api/routes/gmail.py,sha256=lqHuaF3Q6fJvE-OC-Jwb9PGfq8BnoRnVz635qjf-4Zo,3971
+gsuite_api/routes/health.py,sha256=KiMD8OG4CYMAAfyOYC3OORsb7kPkvhS0TJYgMtTxS-Y,4077
+gsuite_api/routes/sheets.py,sha256=1SVe3amI1xXvGQpkgLAq-xcN-Vj2mM-jUoTm1TXxGnM,5617
 gsuite_calendar/__init__.py,sha256=bv5jfO0_cCq6Al7trpeE4qAlvghn9zweTYUEZN0g1TI,291
 gsuite_calendar/calendar_entity.py,sha256=banQQ4LpCgwnWmdBh_3cjduDTzp2fmBhsIqjZzU5ybw,755
 gsuite_calendar/client.py,sha256=fQQ6mxpjnIS2a6X6CO3Ff8wTcw8o-R4Ske--gVb-geI,8402
@@ -29,14 +38,14 @@ gsuite_gmail/parser.py,sha256=JeEfNkgpJdJFIQ2LXLrd7Wmr3xl2M7-uFM901o_84v8,4802
 gsuite_gmail/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gsuite_gmail/query.py,sha256=9UHSm6agDbQ-gAJcEd-CG7DucQ83eOMqr-xY2toCzf8,5812
 gsuite_gmail/thread.py,sha256=MiWsKgrtlvBIET3DEwZgEYVl_6L3qPRQfo3iRKYUyJw,1366
-gsuite_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=25xFe8kmZ3TZzs93SbzlDP_OHHkT5lsANRqQ_Ao2A0M,1069
+gsuite_sdk-0.1.2.dist-info/licenses/LICENSE,sha256=25xFe8kmZ3TZzs93SbzlDP_OHHkT5lsANRqQ_Ao2A0M,1069
 gsuite_sheets/__init__.py,sha256=llrLdudKQqoVQKhJE5GVMT_ibJr30vdjXZqrNjqQnXU,279
 gsuite_sheets/client.py,sha256=m1PLd0fgTHIJYWnmLldR4SCnAQtEAWs0XeqUu087mqk,10662
 gsuite_sheets/parser.py,sha256=jQcTcfwG6uYnlyXKOE5yv6Oc6nNVrgEs2nck1xLTxOQ,2267
 gsuite_sheets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gsuite_sheets/spreadsheet.py,sha256=3YFQHEVw2U9KaV-fsBzkXy-mTCygbJA1HZ2edgtxY-U,2674
 gsuite_sheets/worksheet.py,sha256=stD8ZUArs3-h4yYsS_XnjcKBvjUTikz3pLvxOHyET-c,5789
-gsuite_sdk-0.1.0.dist-info/METADATA,sha256=D5yY2KzdCM6tnixIzsV3hiZze5pw05cU70vfyurmMOk,10775
-gsuite_sdk-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-gsuite_sdk-0.1.0.dist-info/top_level.txt,sha256=owr7_TnX3SwC7hcmPZ0rmMqvKY16AiyfWf2HTJFf3Gs,68
-gsuite_sdk-0.1.0.dist-info/RECORD,,
+gsuite_sdk-0.1.2.dist-info/METADATA,sha256=NkmkE5uRtpZU5umvWuWmfrxw7qLSaMKvJ-59hhJN6_I,11058
+gsuite_sdk-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gsuite_sdk-0.1.2.dist-info/top_level.txt,sha256=LYM5pT8_lZMNAP--cPGd4Lb8pj_tgrFlFz8UYLVQSUs,79
+gsuite_sdk-0.1.2.dist-info/RECORD,,

{gsuite_sdk-0.1.0.dist-info → gsuite_sdk-0.1.2.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
+gsuite_api
 gsuite_calendar
 gsuite_core
 gsuite_drive