workweek 0.4.2__py3-none-any.whl

workweek/__init__.py

@@ -0,0 +1,6 @@
+"""WorkWeek Python SDK — thin HTTP wrapper for tenant app integration."""
+
+from workweek.client import WorkWeekClient, WorkWeekAPIError
+
+__all__ = ["WorkWeekClient", "WorkWeekAPIError"]
+__version__ = "0.4.2"

workweek/agents.py

@@ -0,0 +1,24 @@
+"""Agents module — manage saved agents."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class AgentsModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def list(self, limit: int = 50, offset: int = 0) -> dict:
+        """List saved agents."""
+        return self._client.get("/api/v1/agents", params={"limit": limit, "offset": offset})
+
+    def get(self, agent_id: str) -> dict:
+        """Get agent details."""
+        return self._client.get(f"/api/v1/agents/{agent_id}")
+
+    def create(self, data: dict) -> dict:
+        """Create a new agent."""
+        return self._client.post("/api/v1/agents", json=data)

workweek/analysis.py

@@ -0,0 +1,16 @@
+"""Analysis module — BACI and statistical analysis."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class AnalysisModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def run_baci(self, slug: str, params: dict) -> dict:
+        """Run BACI (Before-After-Control-Impact) analysis for an app."""
+        return self._client.post(f"/api/v1/app-api/{slug}/baci", json=params)

workweek/apps.py

@@ -0,0 +1,41 @@
+"""Apps module — tenant app config and page data."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class AppsModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def get_config(self, slug: str) -> dict:
+        """Get full app config (pages, charts, branding) for a tenant app."""
+        return self._client.get(f"/api/v1/app-api/{slug}/config")
+
+    def get_page_data(self, slug: str, page: str, filters: Optional[dict] = None) -> dict:
+        """Get chart data for a specific page, optionally with filters."""
+        params = {}
+        if filters:
+            params.update(filters)
+        return self._client.get(f"/api/v1/app-api/{slug}/page/{page}/data", params=params)
+
+    def get_filter_options(self, slug: str, page: str, filter_key: str) -> dict:
+        """Get available filter options for a page filter."""
+        return self._client.get(
+            f"/api/v1/app-api/{slug}/page/{page}/filter-options",
+            params={"filter_key": filter_key},
+        )
+
+    def update_frontend_config(self, slug: str, config: dict) -> dict:
+        """Update the frontend config for an app (pages, charts, branding)."""
+        return self._client.patch(
+            f"/api/v1/app-api/{slug}/frontend-config",
+            json=config,
+        )
+
+    def list_apps(self) -> dict:
+        """List all apps for the authenticated organization."""
+        return self._client.get("/api/v1/apps")

workweek/chat.py

@@ -0,0 +1,182 @@
+"""Chat module — conversational AI with SSE streaming.
+
+Wraps the chat-service /api/v1/chat/message Server-Sent Events stream into
+a Python iterator of typed events. Supports tool-calling progress
+(tool_start/tool_end) and incremental token output.
+"""
+
+from __future__ import annotations
+import json
+from typing import TYPE_CHECKING, Iterator, Optional
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class ChatEvent:
+    """A single SSE event from the chat-service /message stream.
+
+    Event types:
+        session     — initial session id confirmation
+        tool_start  — an MCP tool invocation began
+        tool_end    — an MCP tool invocation finished (with duration_ms)
+        token       — a partial assistant message token
+        done        — stream finished (final event)
+        error       — an error occurred mid-stream
+    """
+
+    def __init__(self, event_type: str, data: dict):
+        self.type = event_type
+        self.data = data
+
+    @property
+    def content(self) -> str:
+        """For 'token' events, the partial text. Empty string otherwise."""
+        return self.data.get("content", "") if self.type == "token" else ""
+
+    def __repr__(self) -> str:
+        return f"ChatEvent(type={self.type!r}, data={self.data!r})"
+
+
+class ChatModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def stream(
+        self,
+        message: str,
+        session_id: Optional[str] = None,
+    ) -> Iterator[ChatEvent]:
+        """Stream a chat message response from chat-service /message.
+
+        Yields ChatEvent objects until the 'done' event is received.
+
+        Usage::
+
+            for event in client.chat.stream("How many food trucks are active?"):
+                if event.type == "token":
+                    print(event.content, end="", flush=True)
+                elif event.type == "tool_start":
+                    print(f"\\n[tool: {event.data.get('tool_name')}]")
+
+        Args:
+            message: The user message to send.
+            session_id: Optional session id for conversation continuity. If
+                omitted, the server creates a new session and returns its id
+                in the first 'session' event.
+
+        Yields:
+            ChatEvent — one per SSE event from the upstream stream.
+        """
+        # Import lazily to avoid circular import on package init.
+        from workweek.client import WorkWeekAPIError
+
+        payload: dict = {"message": message}
+        if session_id:
+            payload["session_id"] = session_id
+
+        with self._client._http.stream(
+            "POST",
+            "/api/v1/chat/message",
+            json=payload,
+        ) as resp:
+            if resp.status_code >= 400:
+                body = resp.read().decode(errors="replace")
+                raise WorkWeekAPIError(resp.status_code, body)
+
+            for line in resp.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                try:
+                    data = json.loads(line[6:])
+                except json.JSONDecodeError:
+                    continue
+
+                event_type = data.get("type", "unknown")
+                yield ChatEvent(event_type, data)
+                if event_type == "done":
+                    return
+
+    def send(self, message: str, session_id: Optional[str] = None) -> str:
+        """Convenience: collect all tokens from stream() into a single string.
+
+        Returns the assembled assistant message text. Use stream() if you need
+        intermediate tool events or token-by-token rendering.
+        """
+        chunks: list[str] = []
+        for event in self.stream(message, session_id=session_id):
+            if event.type == "token":
+                chunks.append(event.content)
+        return "".join(chunks)
+
+    def with_team(
+        self,
+        team_id: str,
+        message: str,
+        session_id: Optional[str] = None,
+    ) -> Iterator[ChatEvent]:
+        """Stream a message through a declaratively-provisioned team (TD-102 Phase D).
+
+        Routes through chat-service `/api/v1/chat/message` with the optional
+        `team_id` parameter set. Chat-service loads the team, narrows the
+        LLM tool list to the team's allowed tools, and prepends the team's
+        specialty + backstory + TeamPromptContext additions to the system
+        prompt. The result: tool-calling actually works (vs the older
+        gateway team-chat path which was a bare LLM stream with no tools).
+
+        Yields the SAME ChatEvent shape as `client.chat.stream()` —
+        session/tool_start/tool_end/token/done. Use the existing chat
+        consumer code unchanged; the only difference is the request goes
+        through the team's specialty.
+
+        Usage::
+
+            session_id = None
+            for event in client.chat.with_team(team_id="<uuid>", message="..."):
+                if event.type == "session":
+                    session_id = event.data["session_id"]
+                elif event.type == "tool_start":
+                    print(f"\\n[tool: {event.data.get('tool_name')}]")
+                elif event.type == "token":
+                    print(event.content, end="", flush=True)
+
+        Args:
+            team_id: UUID of the team (from `POST /api/v1/teams/declare`).
+            message: The user message to send.
+            session_id: Optional session id for conversation continuity.
+                Server-side history is keyed on this id (Redis 7-day TTL).
+                If omitted, the server creates a new session and returns its
+                id in the first 'session' event.
+
+        Yields:
+            ChatEvent — same shape as `stream()`. Includes tool_start /
+            tool_end events when the team's agent uses tools (which it
+            should, for any data-shaped query).
+        """
+        from workweek.client import WorkWeekAPIError
+        import json
+
+        payload: dict = {"message": message, "team_id": team_id}
+        if session_id:
+            payload["session_id"] = session_id
+
+        with self._client._http.stream(
+            "POST",
+            "/api/v1/chat/message",
+            json=payload,
+        ) as resp:
+            if resp.status_code >= 400:
+                body = resp.read().decode(errors="replace")
+                raise WorkWeekAPIError(resp.status_code, body)
+
+            for line in resp.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                try:
+                    data = json.loads(line[6:])
+                except json.JSONDecodeError:
+                    continue
+                event_type = data.get("type", "unknown")
+                yield ChatEvent(event_type, data)
+                if event_type == "done":
+                    return

workweek/client.py

@@ -0,0 +1,108 @@
+"""Base HTTP client for WorkWeek API."""
+
+from __future__ import annotations
+
+import httpx
+
+from workweek.data import DataModule
+from workweek.apps import AppsModule
+from workweek.agents import AgentsModule
+from workweek.analysis import AnalysisModule
+from workweek.knowledge import KnowledgeModule
+from workweek.chat import ChatModule
+from workweek.teams import TeamsModule
+from workweek.execution import ExecutionModule
+from workweek.places import PlacesModule
+
+
+class WorkWeekAPIError(Exception):
+    """Raised when the WorkWeek API returns an error."""
+
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"HTTP {status_code}: {message}")
+
+
+class WorkWeekClient:
+    """WorkWeek Python SDK client.
+
+    Usage::
+
+        from workweek import WorkWeekClient
+
+        client = WorkWeekClient(
+            base_url="https://gw.askvai.com",
+            api_key="wk_rpt_...",
+        )
+        result = client.data.query(
+            dataset="sf_food_trucks_permits",
+            sql="SELECT COUNT(*) AS n FROM tbl WHERE status = 'APPROVED'",
+        )
+    """
+
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0):
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+        # TD-125: chat streams (chat.stream, chat.with_team) can run well
+        # past 30s for multi-tool turns. Give streaming endpoints a
+        # longer read timeout; short connect timeout keeps cold-start
+        # failure detection quick. Non-stream requests still use the
+        # caller's `timeout` value via per-request overrides in modules.
+        stream_timeout = httpx.Timeout(
+            connect=10.0,
+            read=120.0,
+            write=timeout,
+            pool=timeout,
+        )
+        self._http = httpx.Client(
+            base_url=self._base_url,
+            headers={"X-API-Key": api_key},
+            timeout=stream_timeout,
+        )
+
+        # Module accessors
+        self.data = DataModule(self)
+        self.apps = AppsModule(self)
+        self.agents = AgentsModule(self)
+        self.analysis = AnalysisModule(self)
+        self.knowledge = KnowledgeModule(self)
+        self.chat = ChatModule(self)
+        self.teams = TeamsModule(self)
+        self.execution = ExecutionModule(self)
+        self.places = PlacesModule(self)  # TD-107b — Google Places via Tier 3 BYOK
+
+    def _request(self, method: str, path: str, **kwargs) -> dict:
+        """Make an authenticated request and return JSON response."""
+        resp = self._http.request(method, path, **kwargs)
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise WorkWeekAPIError(resp.status_code, detail)
+        if resp.status_code == 204:
+            return {}
+        return resp.json()
+
+    def get(self, path: str, **kwargs) -> dict:
+        return self._request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs) -> dict:
+        return self._request("POST", path, **kwargs)
+
+    def patch(self, path: str, **kwargs) -> dict:
+        return self._request("PATCH", path, **kwargs)
+
+    def delete(self, path: str, **kwargs) -> dict:
+        return self._request("DELETE", path, **kwargs)
+
+    def close(self):
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()

workweek/data.py

@@ -0,0 +1,69 @@
+"""Data module — query Iceberg datasets via the WorkWeek SDK gateway.
+
+All methods hit /api/v1/sdk/* endpoints, which derive org_id from the API key
+and validate that SQL is SELECT-only. Use 'tbl' as the table reference in your
+SQL — every dataset is exposed under that name.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class DataModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def query(
+        self,
+        dataset: str,
+        sql: str,
+        limit: Optional[int] = None,
+    ) -> dict:
+        """Execute a SELECT query against an Iceberg dataset.
+
+        Args:
+            dataset: Dataset name (e.g. ``"sf_food_trucks_permits"``).
+            sql: DuckDB SELECT query. Use ``tbl`` as the table reference.
+                Only SELECT statements are permitted; INSERT/UPDATE/DELETE/
+                DROP/ALTER/etc. are rejected with HTTP 422.
+            limit: Optional row cap (1-500, defaults to 100 server-side).
+
+        Returns:
+            ``{"dataset": str, "row_count": int, "columns": [str], "rows": [dict]}``
+
+        Example::
+
+            result = client.data.query(
+                dataset="sf_food_trucks_permits",
+                sql="SELECT facilitytype, COUNT(*) AS n FROM tbl "
+                    "WHERE status = 'APPROVED' GROUP BY facilitytype",
+            )
+            for row in result["rows"]:
+                print(row)
+        """
+        payload: dict = {"dataset": dataset, "sql": sql}
+        if limit is not None:
+            payload["limit"] = limit
+        return self._client.post("/api/v1/sdk/query", json=payload)
+
+    def list_datasets(self) -> dict:
+        """List Iceberg datasets accessible to the API key's organization.
+
+        Returns:
+            ``{"count": int, "datasets": [{"name": str, "row_count": int}]}``
+        """
+        return self._client.get("/api/v1/sdk/datasets")
+
+    def get_schema(self, dataset: str) -> dict:
+        """Get the column schema for a dataset by sampling its first row.
+
+        Args:
+            dataset: Dataset name (e.g. ``"sf_food_trucks_permits"``).
+
+        Returns:
+            ``{"dataset": str, "columns": [str], "sample": dict | None}``
+        """
+        return self._client.get(f"/api/v1/sdk/datasets/{dataset}/schema")

workweek/execution.py

@@ -0,0 +1,129 @@
+"""Execution module — run queries and track executions."""
+
+from __future__ import annotations
+import time
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class ExecutionModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def run_query(
+        self,
+        query: str,
+        team_id: Optional[str] = None,
+        path_type: Optional[str] = None,
+        template_id: Optional[str] = None,
+        execution_metadata: Optional[dict] = None,
+        custom_instructions: Optional[str] = None,
+    ) -> dict:
+        """Submit a query for execution.
+
+        Args:
+            query: The research query or task description.
+            team_id: Team ID to scope the execution to.
+            path_type: Execution path — "crew", "single", "architect", "deep_research", "chat".
+            template_id: Research template ID (e.g. "candidate_dossier", "market_analysis").
+                Shorthand for execution_metadata={"template_id": ...}.
+            execution_metadata: Additional metadata passed to the execution engine.
+                For deep_research: template_id, max_steps, coaching_notes, etc.
+            custom_instructions: Free-form instructions injected into agent prompts.
+
+        Returns:
+            dict with execution_id, status, message.
+        """
+        payload: dict = {"query": query}
+        if team_id:
+            payload["team_id"] = team_id
+        if path_type:
+            payload["path_type"] = path_type
+        if custom_instructions:
+            payload["custom_instructions"] = custom_instructions
+
+        # Build execution_metadata — merge template_id shorthand with explicit metadata
+        meta = dict(execution_metadata or {})
+        if template_id:
+            meta["template_id"] = template_id
+        if meta:
+            payload["execution_metadata"] = meta
+
+        return self._client.post("/api/v1/query", json=payload)
+
+    def run_research(
+        self,
+        query: str,
+        template_id: Optional[str] = None,
+        team_id: Optional[str] = None,
+        max_steps: Optional[int] = None,
+        custom_instructions: Optional[str] = None,
+    ) -> dict:
+        """Submit a deep research query. Convenience wrapper around run_query().
+
+        Args:
+            query: The research question or candidate to investigate.
+            template_id: Research template — "candidate_dossier", "market_analysis",
+                "competitive_landscape", "technical_deep_dive", "financial_analysis",
+                "safety_report", "quick_lookup".
+            team_id: Team ID to scope the execution to.
+            max_steps: Override the template's default step budget (10-150).
+            custom_instructions: Additional guidance for the research engine.
+
+        Returns:
+            dict with execution_id, status, message.
+        """
+        meta: dict = {}
+        if template_id:
+            meta["template_id"] = template_id
+        if max_steps is not None:
+            meta["max_steps"] = max_steps
+
+        return self.run_query(
+            query=query,
+            team_id=team_id,
+            path_type="deep_research",
+            execution_metadata=meta or None,
+            custom_instructions=custom_instructions,
+        )
+
+    def wait_for_completion(
+        self,
+        execution_id: str,
+        poll_interval: float = 10.0,
+        timeout: float = 1800.0,
+    ) -> dict:
+        """Poll until execution completes or fails.
+
+        Args:
+            execution_id: The execution to wait for.
+            poll_interval: Seconds between status checks (default 10s).
+            timeout: Max seconds to wait (default 1800s / 30 min).
+
+        Returns:
+            Full execution dict with result.
+
+        Raises:
+            TimeoutError: If execution doesn't complete within timeout.
+        """
+        start = time.time()
+        while True:
+            data = self.get_status(execution_id)
+            status = data.get("status", "")
+            if status in ("completed", "failed"):
+                return data
+            if time.time() - start > timeout:
+                raise TimeoutError(
+                    f"Execution {execution_id} still '{status}' after {timeout}s"
+                )
+            time.sleep(poll_interval)
+
+    def get_status(self, execution_id: str) -> dict:
+        """Get execution status."""
+        return self._client.get(f"/api/v1/executions/{execution_id}")
+
+    def list_executions(self, limit: int = 20, offset: int = 0) -> dict:
+        """List recent executions."""
+        return self._client.get("/api/v1/executions", params={"limit": limit, "offset": offset})

workweek/knowledge.py

@@ -0,0 +1,23 @@
+"""Knowledge module — collections and document search."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class KnowledgeModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def list_collections(self) -> dict:
+        """List knowledge collections."""
+        return self._client.get("/api/v1/knowledge/collections")
+
+    def search(self, query: str, collection_id: str | None = None) -> dict:
+        """Search knowledge base."""
+        params = {"q": query}
+        if collection_id:
+            params["collection_id"] = collection_id
+        return self._client.get("/api/v1/knowledge/search", params=params)

workweek/places.py

@@ -0,0 +1,142 @@
+"""Places module — Google Places proxy via the WorkWeek SDK gateway.
+
+Routes through /api/v1/sdk/places/* which resolves the org's Google API key
+from the platform's per-org BYOK entitlements (see the WorkWeek Secrets &
+BYOK Architecture doc — Tier 3 pattern). The SDK caller never sees or
+manages the Google API key; the tenant's platform admin seeds the
+entitlement once per org via the Settings UI or the admin API.
+
+Zero-config for SDK callers: if you have a tenant API key and your org has
+a ``google_places`` entitlement, these methods just work. If the entitlement
+is missing, the methods return ``{"found": False, "reason": "not_configured"}``
+instead of raising — frontends can hide the UI section gracefully.
+
+Three methods:
+    client.places.search(name, lat, lon)      → top match by business name
+    client.places.details(place_id)           → reviews + website + hours
+    client.places.streetview(lat, lon)        → Google Maps pano deep-link URL
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class PlacesModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def search(self, name: str, lat: float, lon: float) -> dict:
+        """Search Google Places for a business by name, biased by lat/lon.
+
+        Args:
+            name: Business name to search for (e.g. ``"Corazon Mexicano"``).
+            lat: Latitude to bias search around.
+            lon: Longitude to bias search around.
+
+        Returns:
+            On match::
+
+                {
+                    "found": True,
+                    "google_name": str,
+                    "google_rating": float | None,
+                    "google_total_ratings": int,
+                    "google_price_level": str | None,
+                    "google_address": str,
+                    "place_id": str,
+                }
+
+            On no match / missing entitlement / upstream error::
+
+                {"found": False}                              # clean miss
+                {"found": False, "reason": "not_configured"}  # no entitlement
+                {"found": False, "error": "..."}              # upstream error
+
+        Example::
+
+            result = client.places.search(
+                name="Corazon Mexicano",
+                lat=37.7647,
+                lon=-122.4194,
+            )
+            if result["found"]:
+                print(f"{result['google_name']}: {result['google_rating']}★")
+        """
+        return self._client.get(
+            "/api/v1/sdk/places/search",
+            params={"name": name, "lat": lat, "lon": lon},
+        )
+
+    def details(self, place_id: str) -> dict:
+        """Fetch place details (reviews, website, opening hours) by place_id.
+
+        Args:
+            place_id: Google Places place_id (from a prior ``search()`` call).
+
+        Returns:
+            On success::
+
+                {
+                    "found": True,
+                    "reviews": [
+                        {
+                            "author_name": str,
+                            "rating": float | None,
+                            "text": str,
+                            "relative_time_description": str,
+                        },
+                        ...  # up to 5 reviews
+                    ],
+                    "website": str | None,
+                    "google_maps_url": str | None,
+                    "opening_hours": dict,
+                }
+
+            On missing entitlement or upstream error::
+
+                {"found": False, ...}
+
+        Reviews are capped at 5 per call; each review ``text`` is capped at
+        500 chars. If you need the full Google review text, call the Places
+        API directly (which you'd need if you're running your own backend
+        anyway — but the SDK keeps it simple for chat/display use cases).
+
+        Example::
+
+            details = client.places.details(result["place_id"])
+            for r in details.get("reviews", []):
+                print(f"{r['author_name']} ({r['rating']}★): {r['text'][:80]}")
+        """
+        return self._client.get(f"/api/v1/sdk/places/details/{place_id}")
+
+    def streetview(self, lat: float, lon: float) -> dict:
+        """Return a Google Maps Street View deep-link URL for the coordinates.
+
+        This endpoint does NOT call the Google Places API — the URL format is
+        a public Google Maps deep-link convention and requires no API key.
+        Google handles "no imagery at the exact location" by finding the
+        nearest available panorama automatically.
+
+        Args:
+            lat: Latitude.
+            lon: Longitude.
+
+        Returns::
+
+            {
+                "image_url": "",           # future: Street View Static image
+                "link_url": "https://www.google.com/maps/@?api=1&map_action=pano&viewpoint={lat},{lon}",
+            }
+
+        Example::
+
+            sv = client.places.streetview(37.7647, -122.4194)
+            # Open sv["link_url"] in a new tab to show Street View.
+        """
+        return self._client.get(
+            "/api/v1/sdk/places/streetview",
+            params={"lat": lat, "lon": lon},
+        )

workweek/teams.py

@@ -0,0 +1,20 @@
+"""Teams module — team management."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from workweek.client import WorkWeekClient
+
+
+class TeamsModule:
+    def __init__(self, client: WorkWeekClient):
+        self._client = client
+
+    def list(self) -> dict:
+        """List teams."""
+        return self._client.get("/api/v1/teams")
+
+    def get(self, team_id: int) -> dict:
+        """Get team details."""
+        return self._client.get(f"/api/v1/teams/{team_id}")

workweek-0.4.2.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: workweek
+Version: 0.4.2
+Summary: Official Python SDK for the WorkWeek platform — query datasets, run agents, chat, and embed WorkWeek capabilities into your apps.
+Author: WorkWeek
+License: Apache-2.0
+Project-URL: Homepage, https://workweek.io
+Project-URL: Documentation, https://docs.workweek.io
+Project-URL: Issues, https://github.com/rchow93/workweek-sdk-python/issues
+Keywords: workweek,sdk,ai,agents,iceberg,data
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Dynamic: license-file
+
+# WorkWeek Python SDK
+
+Official Python SDK for the [WorkWeek](https://workweek.io) platform.
+
+Embed WorkWeek's data, agents, and chat capabilities into your own Python apps with
+a thin, dependency-light HTTP client. Single runtime dependency: `httpx`.
+
+## Install
+
+From git (until published to PyPI):
+
+```bash
+pip install "workweek @ git+https://github.com/rchow93/workweek-sdk-python.git@v0.2.2"
+```
+
+For local development:
+
+```bash
+git clone https://github.com/rchow93/workweek-sdk-python.git
+cd workweek-sdk-python
+pip install -e .
+```
+
+## Quickstart
+
+```python
+from workweek import WorkWeekClient
+
+client = WorkWeekClient(
+    base_url="https://gw.askvai.com",
+    api_key="wk_rpt_...",  # Get from Settings → API Keys in the WorkWeek portal
+)
+
+# Query an Iceberg dataset
+result = client.data.query(
+    dataset="sf_food_trucks_permits",
+    sql="SELECT COUNT(*) AS n FROM tbl WHERE status = 'APPROVED'",
+)
+print(result["rows"])  # → [{"n": 163}]
+
+# Stream a chat message (v0.2.0+)
+for event in client.chat.stream("How many food trucks are active in SF?"):
+    if event.type == "token":
+        print(event.content, end="", flush=True)
+```
+
+## Authentication
+
+All requests use API key authentication via the `X-API-Key` header. Create a key
+in the WorkWeek portal under **Settings → API Keys**. Pass it to `WorkWeekClient`:
+
+```python
+client = WorkWeekClient(base_url="https://gw.askvai.com", api_key="wk_rpt_...")
+```
+
+The org and user context are derived from the API key — never pass `org_id` from
+the client.
+
+## Modules
+
+| Module | Purpose |
+|---|---|
+| `client.data` | Query Iceberg datasets via SQL, list available datasets, inspect schemas |
+| `client.chat` | Conversational AI with tool-calling and streaming responses |
+| `client.apps` | Tenant app config, page data, dashboard frontend management |
+| `client.agents` | Saved agent CRUD |
+| `client.teams` | Team listing |
+| `client.knowledge` | Knowledge collection search |
+| `client.analysis` | BACI and statistical analysis |
+| `client.execution` | Submit and track agent executions |
+
+## Error Handling
+
+```python
+from workweek import WorkWeekAPIError
+
+try:
+    result = client.data.query(dataset="missing", sql="SELECT 1")
+except WorkWeekAPIError as e:
+    print(f"HTTP {e.status_code}: {e.message}")
+```
+
+## Requirements
+
+- Python 3.10+
+- `httpx>=0.27.0`
+
+## License
+
+Apache License 2.0 — see [LICENSE](LICENSE).
+
+## Status
+
+Alpha. API may change before 1.0. Pin to a specific version in production:
+
+```bash
+pip install "workweek @ git+https://github.com/rchow93/workweek-sdk-python.git@v0.2.2"
+```

workweek-0.4.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+workweek/__init__.py,sha256=4lJG3URDpd-NlbdGB6d-uOOb7clhC8-GsmTwfd-4vX8,210
+workweek/agents.py,sha256=1h7fa37lcaSiYrfVUOALWbKKoMXdmeHCW-5gyB8SkzY,746
+workweek/analysis.py,sha256=4ME28X0wQvmUCYFCW6ctt1dgr7La-6xNIY-w57qztjg,504
+workweek/apps.py,sha256=Ik573pWvukCnOpSyff3RrVyBXlVFleWYEwPlQiqpFMA,1543
+workweek/chat.py,sha256=sZxV4MsXNgcEUqwLIXVcX1JxOdnRs4c_7fbDUAPorLk,6838
+workweek/client.py,sha256=iwMKD7s9y6mHwIGDQ0ZYh9BrZ7PIP_i2dNlvzJaUbBE,3544
+workweek/data.py,sha256=GGBVgIEUNq6fWq2TAWcM2R3IR0WL5cChVIigiXTKE2I,2380
+workweek/execution.py,sha256=yX2jDvnKilA4FH3uoG7m3Ks92jT404vbKQQxtkGNr74,4702
+workweek/knowledge.py,sha256=ba7wK5KclZrU9K5UsWPBqpwz0dwTUMVrJTZYQ0o-N_8,743
+workweek/places.py,sha256=RpM0xyyKJvrodHx3P2AMV7OfFtVguH4qPwT6DjY725o,5220
+workweek/teams.py,sha256=2NA-eNUANNAKeYf1tG4il3vjsW1w7MmrBxB6J4UMx9E,512
+workweek-0.4.2.dist-info/licenses/LICENSE,sha256=epJksMdTXjvUX6Vlijyb2wucKk6UDCqqu8b6KcS5QUc,10695
+workweek-0.4.2.dist-info/METADATA,sha256=X5mgqrPrsTJHEe13LJ0ah83nYRodO9OyM2xO5LnYATk,3794
+workweek-0.4.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+workweek-0.4.2.dist-info/top_level.txt,sha256=aarHybc0oh7oaoCQdB8gDlk58utqSIs88sEUKc923W8,9
+workweek-0.4.2.dist-info/RECORD,,

workweek-0.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

workweek-0.4.2.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend, and
+      hold each Contributor harmless for any liability incurred by, or
+      claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 WorkWeek
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

workweek-0.4.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+workweek