snowleopard 0.1.1__tar.gz → 0.3.0__tar.gz

{snowleopard-0.1.1 → snowleopard-0.3.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Snow Leopard AI
+Copyright (c) 2025 Snow Leopard, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{snowleopard-0.1.1 → snowleopard-0.3.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: snowleopard
-Version: 0.1.1
+Version: 0.3.0
 Summary: snowleopard.ai client library
 Author-email: Snowy <hello@snowleopard.ai>
 License: MIT License
         
-        Copyright (c) 2025 Snow Leopard AI
+        Copyright (c) 2025 Snow Leopard, Inc
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -34,7 +34,9 @@ Description-Content-Type: text/markdown
 
 # Snow Leopard SDK for Python
 
-Python client library for [Snow Leopard Playground](https://try.snowleopard.ai) APIs.
+This repo contains the Python client library for [Snow Leopard Playground](https://try.snowleopard.ai) APIs. 
+
+See our [API documentation](https://docs.snowleopard.ai/#api-documentation) for more details.
 
 ## Installation
 
@@ -45,16 +47,13 @@ pip install snowleopard
 ## Quick Start
 
 ```python
-from snowleopard import SnowLeopardPlaygroundClient
+from snowleopard import SnowLeopardClient
 
-# Initialize the client (or AsyncSnowLeopardPlaygroundClient)
-client = SnowLeopardPlaygroundClient(api_key="your-api-key")
+# Initialize the client (or AsyncSnowLeopardClient)
+client = SnowLeopardClient(api_key="your-api-key")
 
 # Query your data in natural language
-response = client.retrieve(
-    datafile_id="your-datafile-id",
-    user_query="How many users signed up last month?"
-)
+response = client.retrieve(user_query="How many users signed up last month?", datafile_id="your-datafile-id")
 ```
 
 ## Getting Started
@@ -69,7 +68,7 @@ response = client.retrieve(
     Or pass it directly to the client:
     
     ```python
-    SnowLeopardPlaygroundClient(api_key="your-api-key")
+    SnowLeopardClient(api_key="your-api-key")
     ```
 
 ## Usage
@@ -77,31 +76,31 @@ response = client.retrieve(
 ### Synchronous Client
 
 ```python
-from snowleopard import SnowLeopardPlaygroundClient
+from snowleopard import SnowLeopardClient
 
-with SnowLeopardPlaygroundClient() as client:
-    # Get data directly from a natural language query
-    response = client.retrieve("datafile-id", "What's the total revenue?")
-    print(response.data)
-    
-    # Stream natural language summary of live data
-    for chunk in client.response("datafile-id", "Show me top 10 customers"):
-        print(chunk)
+with SnowLeopardClient() as client:
+   # Get data directly from a natural language query
+   response = client.retrieve(user_query="How many superheroes are there?")
+   print(response.data)
+
+   # Stream natural language summary of live data
+   for chunk in client.response(user_query="How many superheroes are there?"):
+      print(chunk)
 ```
 
 ### Async Client
 
 ```python
-from snowleopard import AsyncSnowLeopardPlaygroundClient
+from snowleopard import AsyncSnowLeopardClient
 
-async with AsyncSnowLeopardPlaygroundClient() as client:
-    # Get complete results
-    response = await client.retrieve("datafile-id", "What's the total revenue?")
-    print(response.data)
+async with AsyncSnowLeopardClient() as client:
+   # Get complete results
+   response = await client.retrieve(user_query="How many superheroes are there?")
+   print(response.data)
 
-    # Get streaming results
-    async for chunk in client.response("datafile-id", "Show me top 10 customers"):
-        print(chunk)
+   # Get streaming results
+   async for chunk in client.response(user_query="How many superheroes are there?"):
+      print(chunk)
 ```
 
 ### CLI
@@ -110,10 +109,22 @@ The SDK includes a command-line interface:
 
 ```bash
 pip install snowleopard
-snowy retrieve <datafile-id> "How many records are there?"
-snowy response <datafile-id> "Summarize the data"
+snowy retrieve --datafile <datafile-id> "How many records are there?"
+snowy response --datafile <datafile-id> "Summarize the data"
 ```
 
+### On Premise Customers
+
+For our customers who have a separate deployment per dataset, you should declare <url> explicitly when creating a 
+client and omit <datafile id> when querying.
+
+Example:
+```python
+client = SnowLeopardClient(url="https://{your-vm-ip}:{port}", api_key="your-api-key")
+response = client.retrieve(user_query="How many users signed up last month?")
+```
+
+
 ## Contributing
 
 For SDK developer docs and how to contribute, see [CONTRIBUTING.md](CONTRIBUTING.md)

snowleopard-0.3.0/README.md

@@ -0,0 +1,96 @@
+# Snow Leopard SDK for Python
+
+This repo contains the Python client library for [Snow Leopard Playground](https://try.snowleopard.ai) APIs. 
+
+See our [API documentation](https://docs.snowleopard.ai/#api-documentation) for more details.
+
+## Installation
+
+```bash
+pip install snowleopard
+```
+
+## Quick Start
+
+```python
+from snowleopard import SnowLeopardClient
+
+# Initialize the client (or AsyncSnowLeopardClient)
+client = SnowLeopardClient(api_key="your-api-key")
+
+# Query your data in natural language
+response = client.retrieve(user_query="How many users signed up last month?", datafile_id="your-datafile-id")
+```
+
+## Getting Started
+
+1. **Get your API key** from [https://auth.snowleopard.ai/account/api_keys](https://auth.snowleopard.ai/account/api_keys)
+2. **Upload your datafiles** at [https://try.snowleopard.ai](https://try.snowleopard.ai)
+3. **Set your API key** via environment variable:
+    ```bash
+    export SNOWLEOPARD_API_KEY="your-api-key"
+    ```
+    
+    Or pass it directly to the client:
+    
+    ```python
+    SnowLeopardClient(api_key="your-api-key")
+    ```
+
+## Usage
+
+### Synchronous Client
+
+```python
+from snowleopard import SnowLeopardClient
+
+with SnowLeopardClient() as client:
+   # Get data directly from a natural language query
+   response = client.retrieve(user_query="How many superheroes are there?")
+   print(response.data)
+
+   # Stream natural language summary of live data
+   for chunk in client.response(user_query="How many superheroes are there?"):
+      print(chunk)
+```
+
+### Async Client
+
+```python
+from snowleopard import AsyncSnowLeopardClient
+
+async with AsyncSnowLeopardClient() as client:
+   # Get complete results
+   response = await client.retrieve(user_query="How many superheroes are there?")
+   print(response.data)
+
+   # Get streaming results
+   async for chunk in client.response(user_query="How many superheroes are there?"):
+      print(chunk)
+```
+
+### CLI
+
+The SDK includes a command-line interface:
+
+```bash
+pip install snowleopard
+snowy retrieve --datafile <datafile-id> "How many records are there?"
+snowy response --datafile <datafile-id> "Summarize the data"
+```
+
+### On Premise Customers
+
+For our customers who have a separate deployment per dataset, you should declare <url> explicitly when creating a 
+client and omit <datafile id> when querying.
+
+Example:
+```python
+client = SnowLeopardClient(url="https://{your-vm-ip}:{port}", api_key="your-api-key")
+response = client.retrieve(user_query="How many users signed up last month?")
+```
+
+
+## Contributing
+
+For SDK developer docs and how to contribute, see [CONTRIBUTING.md](CONTRIBUTING.md)

snowleopard-0.3.0/src/snowleopard/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# copyright 2025 Snow Leopard, Inc
+# released under the MIT license - see LICENSE file
+
+from snowleopard.async_client import AsyncSnowLeopardClient
+from snowleopard.client import SnowLeopardClient
+
+__version__ = "0.3.0"
+
+__all__ = [
+    "SnowLeopardClient",
+    "AsyncSnowLeopardClient",
+]

{snowleopard-0.1.1 → snowleopard-0.3.0}/src/snowleopard/async_client.py

@@ -7,10 +7,11 @@ from typing import AsyncGenerator, Optional, Dict, Any
 
 import httpx
 from snowleopard.client_base import SLClientBase
-from snowleopard.models import ResponseDataObjects, RetrieveResponseObjects, parse
+from snowleopard.error import APIBadRequest
+from snowleopard.models import APIError, parse, ResponseDataObjects, RetrieveResponseObjects
 
 
-class AsyncSnowLeopardPlaygroundClient(SLClientBase):
+class AsyncSnowLeopardClient(SLClientBase):
     client: httpx.AsyncClient
 
     def __init__(
@@ -26,9 +27,10 @@ class AsyncSnowLeopardPlaygroundClient(SLClientBase):
 
     async def retrieve(
         self,
-        datafile_id: str,
+        *,
         user_query: str,
         known_data: Optional[Dict[str, Any]] = None,
+        datafile_id: Optional[str] = None,
     ) -> RetrieveResponseObjects:
         resp = await self.client.post(
             url=self._build_path(datafile_id, "retrieve"),
@@ -38,18 +40,23 @@ class AsyncSnowLeopardPlaygroundClient(SLClientBase):
 
     async def response(
         self,
-        datafile_id: str,
-        user_query: str,
+        *,
         known_data: Optional[Dict[str, Any]] = None,
+        user_query: str,
+        datafile_id: Optional[str] = None,
     ) -> AsyncGenerator[ResponseDataObjects, None]:
         async with self.client.stream(
             "POST",
             self._build_path(datafile_id, "response"),
             json=self._build_request_body(user_query, known_data),
         ) as resp:
-            resp.raise_for_status()
+            if resp.status_code not in (400,):
+                resp.raise_for_status()
             async for line in resp.aiter_lines():
-                yield parse(json.loads(line))
+                resultObj = parse(json.loads(line))
+                if isinstance(resultObj, APIError) and resp.status_code == 400:
+                    raise APIBadRequest(resultObj.description)
+                yield resultObj
 
     async def __aenter__(self):
         await self.client.__aenter__()

{snowleopard-0.1.1 → snowleopard-0.3.0}/src/snowleopard/cli.py

@@ -9,8 +9,8 @@ import argparse
 from typing import List, Optional, Dict, Any
 
 from httpx import HTTPStatusError
-from snowleopard import __version__, SnowLeopardPlaygroundClient
-from snowleopard.models import RetrieveResponseError
+from snowleopard import __version__, SnowLeopardClient
+from snowleopard.error import APIBadRequest
 
 
 def _create_parser() -> argparse.ArgumentParser:
@@ -41,13 +41,15 @@ def _create_parser() -> argparse.ArgumentParser:
     response.set_defaults(command_func=_response)
 
     for subparser in (retrieve, response):
+        subparser.add_argument(
+            "--datafile", "-df", type=str, help="ID for playground datafile to query"
+        )
         subparser.add_argument(
             "--knownData",
             "-d",
             action="append",
             help="Known data in key=value format (can be specified multiple times)",
         )
-        subparser.add_argument("datafile", type=str, help="ID for Datafile to query")
         subparser.add_argument("question", type=str, help="Natural language query")
 
     return parser
@@ -60,7 +62,10 @@ def _parse_known_data(known_data_list: Optional[List[str]]) -> Optional[Dict[str
     result = {}
     for item in known_data_list:
         if "=" not in item:
-            print(f"Error: Invalid knownData format '{item}'. Expected key=value", file=sys.stderr)
+            print(
+                f"Error: Invalid knownData format '{item}'. Expected key=value",
+                file=sys.stderr,
+            )
             sys.exit(1)
         key, value = item.split("=", 1)
         result[key] = value
@@ -69,7 +74,7 @@ def _parse_known_data(known_data_list: Optional[List[str]]) -> Optional[Dict[str
 
 def _get_client(parsed_args):
     try:
-        client = SnowLeopardPlaygroundClient(api_key=parsed_args.apikey, loc=parsed_args.loc)
+        client = SnowLeopardClient(api_key=parsed_args.apikey, loc=parsed_args.loc)
     except Exception as e:
         print(str(e), file=sys.stderr)
         sys.exit(1)
@@ -77,26 +82,44 @@ def _get_client(parsed_args):
 
 
 def _retrieve(parsed_args):
+    hadErrors = False
     try:
         known_data = _parse_known_data(parsed_args.knownData)
         with _get_client(parsed_args) as client:
-            resp = client.retrieve(parsed_args.datafile, parsed_args.question, known_data)
+            resp = client.retrieve(
+                user_query=parsed_args.question,
+                known_data=known_data,
+                datafile_id=parsed_args.datafile,
+            )
             print(json.dumps(dataclasses.asdict(resp)))
-            if isinstance(resp, RetrieveResponseError):
-                sys.exit(1)
+    except APIBadRequest as e:
+        print(f"error: {str(e)}", file=sys.stderr)
+        hadErrors = True
     except HTTPStatusError as e:
         print(str(e), file=sys.stderr)
+        hadErrors = True
+    if hadErrors:
         sys.exit(1)
 
 
 def _response(parsed_args):
+    hadErrors = False
     try:
         known_data = _parse_known_data(parsed_args.knownData)
         with _get_client(parsed_args) as client:
-            for chunk in client.response(parsed_args.datafile, parsed_args.question, known_data):
+            for chunk in client.response(
+                known_data=known_data,
+                user_query=parsed_args.question,
+                datafile_id=parsed_args.datafile,
+            ):
                 print(json.dumps(dataclasses.asdict(chunk)))
+    except APIBadRequest as e:
+        print(f"error: {str(e)}", file=sys.stderr)
+        hadErrors = True
     except HTTPStatusError as e:
         print(str(e), file=sys.stderr)
+        hadErrors = True
+    if hadErrors:
         sys.exit(1)
 
 

{snowleopard-0.1.1 → snowleopard-0.3.0}/src/snowleopard/client.py

@@ -7,10 +7,11 @@ from typing import Optional, Generator, Dict, Any
 
 import httpx
 from snowleopard.client_base import SLClientBase
-from snowleopard.models import parse, RetrieveResponseObjects, ResponseDataObjects
+from snowleopard.error import APIBadRequest
+from snowleopard.models import APIError, parse, RetrieveResponseObjects, ResponseDataObjects
 
 
-class SnowLeopardPlaygroundClient(SLClientBase):
+class SnowLeopardClient(SLClientBase):
     client: httpx.Client
 
     def __init__(
@@ -26,32 +27,36 @@ class SnowLeopardPlaygroundClient(SLClientBase):
 
     def retrieve(
         self,
-        datafile_id: str,
+        *,
         user_query: str,
         known_data: Optional[Dict[str, Any]] = None,
+        datafile_id: Optional[str] = None,
     ) -> RetrieveResponseObjects:
         resp = self.client.post(
             url=self._build_path(datafile_id, "retrieve"),
             json=self._build_request_body(user_query, known_data),
         )
-        if resp.status_code not in (200, 409):
-            resp.raise_for_status()
         return self._parse_retrieve(resp)
 
     def response(
         self,
-        datafile_id: str,
-        user_query: str,
+        *,
         known_data: Optional[Dict[str, Any]] = None,
+        user_query: str,
+        datafile_id: Optional[str] = None,
     ) -> Generator[ResponseDataObjects, None, None]:
         with self.client.stream(
             "POST",
             url=self._build_path(datafile_id, "response"),
             json=self._build_request_body(user_query, known_data),
         ) as resp:
-            resp.raise_for_status()
+            if resp.status_code not in (400,):
+                resp.raise_for_status()
             for line in resp.iter_lines():
-                yield parse(json.loads(line))
+                resultObj = parse(json.loads(line))
+                if isinstance(resultObj, APIError) and resp.status_code == 400:
+                    raise APIBadRequest(resultObj.description)
+                yield resultObj
 
     def __enter__(self):
         self.client.__enter__()

snowleopard-0.3.0/src/snowleopard/client_base.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+# copyright 2025 Snow Leopard, Inc
+# released under the MIT license - see LICENSE file
+
+import os
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+
+import httpx
+
+from snowleopard.error import APIBadRequest
+from snowleopard.models import APIError, parse
+
+
+@dataclass
+class SLConfig:
+    api_key: str
+    timeout: httpx.Timeout
+    loc: str
+
+    def headers(self):
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+
+class SLClientBase:
+    @abstractmethod
+    def retrieve(
+        self,
+        *,
+        user_query: str,
+        known_data: Optional[Dict[str, Any]] = None,
+        datafile_id: Optional[str] = None,
+    ):
+        """
+        The primary for developers building AI agents that needs to retrieve data from a database directly.
+
+        Takes a natural language question (usually from the user or the agent) and returns the data required to answer
+        the query in an LLM-friendly object.
+
+        :param datafile_id: (optional) The playground datafile-id if hitting a Snow Leopard api directly
+        :param user_query: Natural language query to execute against the Playground datafile
+        :param known_data: Additional context about the user_query
+        """
+        ...
+
+    @abstractmethod
+    def response(
+        self,
+        *,
+        known_data: Optional[Dict[str, Any]] = None,
+        user_query: str,
+        datafile_id: Optional[str] = None,
+    ):
+        """
+        Takes a natural language question (usually from the user or the agent) and returns the data required to answer
+        the query as well as a LLM summary of the returned data.
+
+        :param datafile_id: (optional) The playground datafile-id if hitting a Snow Leopard api directly
+        :param user_query: Natural language query to execute against the Playground datafile
+        :param known_data: (optional) Additional context about the user_query
+        """
+        ...
+
+    @staticmethod
+    def _config(
+        api_key: Optional[str], timeout: Optional[httpx.Timeout], loc: Optional[str]
+    ) -> SLConfig:
+        api_key = api_key or os.environ.get("SNOWLEOPARD_API_KEY")
+        if api_key is None:
+            raise ValueError(
+                'Missing required argument "api_key" and environment variable "SNOWLEOPARD_API_KEY" not set'
+            )
+        timeout = timeout or httpx.Timeout(
+            connect=5.0, read=600.0, write=10.0, pool=5.0
+        )
+        loc = loc or os.environ.get("SNOWLEOPARD_LOC", "https://api.snowleopard.ai")
+        if not loc:
+            raise ValueError(
+                'Missing required argument "loc" and environment variable "SNOWLEOPARD_LOC" not set'
+            )
+        return SLConfig(api_key, timeout, loc)
+
+    @staticmethod
+    def _build_path(datafile_id: str, endpoint: str) -> str:
+        if datafile_id is None:
+            return endpoint
+        else:
+            return f"datafiles/{datafile_id}/{endpoint}"
+
+    @staticmethod
+    def _build_request_body(
+        user_query: str, known_data: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        if not isinstance(user_query, str) or not user_query.strip():
+            raise APIBadRequest('userQuery field must not be empty/whitespace')
+        body = {"userQuery": user_query}
+        if known_data is not None:
+            body["knownData"] = known_data
+        return body
+
+    @staticmethod
+    def _parse_retrieve(resp):
+        if resp.status_code not in (400, 409):
+            resp.raise_for_status()
+        try:
+            resultObj = parse(resp.json())
+        except Exception:
+            resp.raise_for_status()
+            raise
+        if isinstance(resultObj, APIError) and resp.status_code == 400:
+            raise APIBadRequest(resultObj.description)
+        return resultObj

snowleopard-0.3.0/src/snowleopard/error.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# copyright 2026 Snow Leopard, Inc
+# released under the MIT license - see LICENSE file
+
+class SLException(Exception):
+    pass
+
+
+class APIBadRequest(SLException):
+    pass

{snowleopard-0.1.1 → snowleopard-0.3.0}/src/snowleopard/models.py

@@ -11,25 +11,26 @@ from typing import Any, Dict, List, Optional, Union
 
 class StrEnum(str, Enum):
     """String enum compatible with Python 3.8"""
+
     pass
 
 
 @dataclass
-class RetrieveResponse:
-    objType = "retrieveResponse"
+class APIError:
+    objType = "apiError"
 
     callId: str
-    data: List[Union[SchemaData, ErrorSchemaData]]
-    responseStatus: ResponseStatus
+    responseStatus: str
+    description: str
 
 
 @dataclass
-class RetrieveResponseError:
-    objType = "apiError"
+class RetrieveResponse:
+    objType = "retrieveResponse"
 
     callId: str
-    responseStatus: str
-    description: str
+    data: List[Union[SchemaData, ErrorSchemaData]]
+    responseStatus: ResponseStatus
 
 
 @dataclass
@@ -96,19 +97,23 @@ class ResponseLLMResult:
 
 class ResponseStatus(StrEnum):
     SUCCESS = "SUCCESS"
+    BAD_REQUEST = "BAD_REQUEST"
     NOT_FOUND_IN_SCHEMA = "NOT_FOUND_IN_SCHEMA"
     UNKNOWN = "UNKNOWN"
     INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
     AUTHORIZATION_FAILED = "AUTHORIZATION_FAILED"
     LLM_ERROR = "LLM_ERROR"
     LLM_TOKEN_LIMIT_REACHED = "LLM_TOKEN_LIMIT_REACHED"
+    DB_ERROR = "DB_ERROR"
+    DB_CONNECTION_ERROR = "DB_CONNECTION_ERROR"
+    DB_SYNTAX_ERROR = "DB_SYNTAX_ERROR"
 
 
 _PARSE_OBJS = {
     o.objType: o
     for o in (
+        APIError,
         RetrieveResponse,
-        RetrieveResponseError,
         SchemaData,
         ErrorSchemaData,
         ResponseStart,
@@ -118,10 +123,12 @@ _PARSE_OBJS = {
     )
 }
 
-RetrieveResponseObjects = Union[RetrieveResponse, RetrieveResponseError]
+
+RetrieveResponseObjects = Union[APIError, RetrieveResponse]
+
 
 ResponseDataObjects = Union[
-    ErrorSchemaData,
+    APIError,
     ResponseStart,
     ResponseData,
     EarlyTermination,

snowleopard-0.1.1/README.md

@@ -1,85 +0,0 @@
-# Snow Leopard SDK for Python
-
-Python client library for [Snow Leopard Playground](https://try.snowleopard.ai) APIs.
-
-## Installation
-
-```bash
-pip install snowleopard
-```
-
-## Quick Start
-
-```python
-from snowleopard import SnowLeopardPlaygroundClient
-
-# Initialize the client (or AsyncSnowLeopardPlaygroundClient)
-client = SnowLeopardPlaygroundClient(api_key="your-api-key")
-
-# Query your data in natural language
-response = client.retrieve(
-    datafile_id="your-datafile-id",
-    user_query="How many users signed up last month?"
-)
-```
-
-## Getting Started
-
-1. **Get your API key** from [https://auth.snowleopard.ai/account/api_keys](https://auth.snowleopard.ai/account/api_keys)
-2. **Upload your datafiles** at [https://try.snowleopard.ai](https://try.snowleopard.ai)
-3. **Set your API key** via environment variable:
-    ```bash
-    export SNOWLEOPARD_API_KEY="your-api-key"
-    ```
-    
-    Or pass it directly to the client:
-    
-    ```python
-    SnowLeopardPlaygroundClient(api_key="your-api-key")
-    ```
-
-## Usage
-
-### Synchronous Client
-
-```python
-from snowleopard import SnowLeopardPlaygroundClient
-
-with SnowLeopardPlaygroundClient() as client:
-    # Get data directly from a natural language query
-    response = client.retrieve("datafile-id", "What's the total revenue?")
-    print(response.data)
-    
-    # Stream natural language summary of live data
-    for chunk in client.response("datafile-id", "Show me top 10 customers"):
-        print(chunk)
-```
-
-### Async Client
-
-```python
-from snowleopard import AsyncSnowLeopardPlaygroundClient
-
-async with AsyncSnowLeopardPlaygroundClient() as client:
-    # Get complete results
-    response = await client.retrieve("datafile-id", "What's the total revenue?")
-    print(response.data)
-
-    # Get streaming results
-    async for chunk in client.response("datafile-id", "Show me top 10 customers"):
-        print(chunk)
-```
-
-### CLI
-
-The SDK includes a command-line interface:
-
-```bash
-pip install snowleopard
-snowy retrieve <datafile-id> "How many records are there?"
-snowy response <datafile-id> "Summarize the data"
-```
-
-## Contributing
-
-For SDK developer docs and how to contribute, see [CONTRIBUTING.md](CONTRIBUTING.md)

snowleopard-0.1.1/src/snowleopard/__init__.py

@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-# copyright 2025 Snow Leopard, Inc
-# released under the MIT license - see LICENSE file
-
-from snowleopard.async_client import AsyncSnowLeopardPlaygroundClient
-from snowleopard.client import SnowLeopardPlaygroundClient
-
-__version__ = "0.1.1"
-
-__all__ = [
-    "SnowLeopardPlaygroundClient",
-    "AsyncSnowLeopardPlaygroundClient",
-]

snowleopard-0.1.1/src/snowleopard/client_base.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-# copyright 2025 Snow Leopard, Inc
-# released under the MIT license - see LICENSE file
-
-import os
-from dataclasses import dataclass
-from typing import Optional, Dict, Any
-
-import httpx
-
-from snowleopard.models import parse
-
-
-@dataclass
-class SLConfig:
-    api_key: str
-    timeout: httpx.Timeout
-    loc: str
-
-    def headers(self):
-        headers = {}
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-        return headers
-
-
-class SLClientBase:
-    @staticmethod
-    def _config(
-        api_key: Optional[str], timeout: Optional[httpx.Timeout], loc: Optional[str]
-    ) -> SLConfig:
-        api_key = api_key or os.environ.get("SNOWLEOPARD_API_KEY")
-        if api_key is None:
-            raise ValueError(
-                'Missing required argument "api_key" and environment variable "SNOWLEOPARD_API_KEY" not set'
-            )
-        timeout = timeout or httpx.Timeout(
-            connect=5.0, read=600.0, write=10.0, pool=5.0
-        )
-        loc = loc or os.environ.get("SNOWLEOPARD_LOC", "https://api.snowleopard.ai")
-        if not loc:
-            raise ValueError(
-                'Missing required argument "loc" and environment variable "SNOWLEOPARD_LOC" not set'
-            )
-        return SLConfig(api_key, timeout, loc)
-
-    @staticmethod
-    def _build_path(datafile_id: str, endpoint: str) -> str:
-        return f"datafiles/{datafile_id}/{endpoint}"
-
-    @staticmethod
-    def _build_request_body(
-        user_query: str, known_data: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        body = {"userQuery": user_query}
-        if known_data is not None:
-            body["knownData"] = known_data
-        return body
-
-    @staticmethod
-    def _parse_retrieve(resp):
-        try:
-            return parse(resp.json())
-        except Exception:
-            resp.raise_for_status()
-            raise