redpine-sdk 0.1.5__tar.gz

redpine_sdk-0.1.5/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.5
+Name: redpine-sdk
+Version: 0.1.5
+Summary: Python client for the Redpine search API
+Project-URL: Homepage, https://redpine.ai
+Project-URL: Documentation, https://docs.redpine.ai/docs/sdks
+Project-URL: Repository, https://github.com/redpine-ai/redpine-sdk-python
+License: MIT
+Keywords: rag,redpine,retrieval,scientific-literature,search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT 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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: attrs>=23.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dateutil>=2.8
+Requires-Dist: typing-extensions>=4.12
+Description-Content-Type: text/markdown
+
+# redpine-sdk
+
+Python client for the Redpine search API. Python 3.10+, sync and async.
+
+```bash
+pip install redpine-sdk
+```
+
+```python
+from redpine import Redpine, F
+
+client = Redpine()  # reads REDPINE_API_KEY
+r = client.search("crispr delivery", collections=["corpus"], filters=F("issn").eq("1664-302X"))
+for hit in r.results:
+    print(hit.id, hit.text[:80])
+```
+
+Docs: https://docs.redpine.ai/docs/sdks

redpine_sdk-0.1.5/README.md

@@ -0,0 +1,18 @@
+# redpine-sdk
+
+Python client for the Redpine search API. Python 3.10+, sync and async.
+
+```bash
+pip install redpine-sdk
+```
+
+```python
+from redpine import Redpine, F
+
+client = Redpine()  # reads REDPINE_API_KEY
+r = client.search("crispr delivery", collections=["corpus"], filters=F("issn").eq("1664-302X"))
+for hit in r.results:
+    print(hit.id, hit.text[:80])
+```
+
+Docs: https://docs.redpine.ai/docs/sdks

redpine_sdk-0.1.5/openapi-python-client.yaml

@@ -0,0 +1,2 @@
+package_name_override: _generated
+project_name_override: redpine-generated

redpine_sdk-0.1.5/pyproject.toml

@@ -0,0 +1,58 @@
+[project]
+name = "redpine-sdk"
+version = "0.1.5"
+description = "Python client for the Redpine search API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+keywords = ["redpine", "search", "retrieval", "scientific-literature", "rag"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+dependencies = [
+  "httpx>=0.27",
+  "attrs>=23.1",
+  "python-dateutil>=2.8",
+  "typing-extensions>=4.12",
+]
+
+[project.urls]
+Homepage = "https://redpine.ai"
+Documentation = "https://docs.redpine.ai/docs/sdks"
+Repository = "https://github.com/redpine-ai/redpine-sdk-python"
+
+[dependency-groups]
+dev = [
+  "pytest>=8",
+  "pytest-asyncio>=0.23",
+  "respx>=0.21",
+  "openapi-python-client>=0.21",
+  "ruff>=0.5",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/redpine"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+extend-exclude = ["src/redpine/_generated"]

redpine_sdk-0.1.5/src/redpine/__init__.py

@@ -0,0 +1,33 @@
+"""Redpine SDK — Python client for the Redpine search API."""
+
+from .client import AsyncRedpine, Redpine
+from .errors import (
+    AccessDenied,
+    AssistedUnavailable,
+    AuthError,
+    Expired,
+    InsufficientCredits,
+    NotFound,
+    QuotaExceeded,
+    RedpineError,
+    ValidationError,
+)
+from .filters import F, Field, Filter
+
+__version__ = "0.1.5"
+__all__ = [
+    "AccessDenied",
+    "AssistedUnavailable",
+    "AsyncRedpine",
+    "AuthError",
+    "Expired",
+    "F",
+    "Field",
+    "Filter",
+    "InsufficientCredits",
+    "NotFound",
+    "QuotaExceeded",
+    "Redpine",
+    "RedpineError",
+    "ValidationError",
+]

redpine_sdk-0.1.5/src/redpine/_generated/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Redpine Connect Search API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

redpine_sdk-0.1.5/src/redpine/_generated/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

redpine_sdk-0.1.5/src/redpine/_generated/api/search/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

redpine_sdk-0.1.5/src/redpine/_generated/api/search/get_cached_result.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.search_results_preview_response import SearchResultsPreviewResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    query_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/search/results/{query_id}".format(
+            query_id=quote(str(query_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Error | SearchResultsPreviewResponse | None:
+    if response.status_code == 200:
+        response_200 = SearchResultsPreviewResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+
+    if response.status_code == 410:
+        response_410 = Error.from_dict(response.json())
+
+        return response_410
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Error | SearchResultsPreviewResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    query_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[Error | SearchResultsPreviewResponse]:
+    """Re-fetch cached results
+
+     Retrieve previously returned search results using the queryId from a prior search response. Returns
+    the same results without billing. The request must use the same API key that performed the original
+    search. Results are available for 7 days.
+
+    Each result carries `locked`/`tokens`/`cost`: a result not yet paid for through POST
+    /api/v1/search/unlock comes back as a teaser (`locked: true`), never the full text.
+
+    Args:
+        query_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Error | SearchResultsPreviewResponse]
+    """
+
+    kwargs = _get_kwargs(
+        query_id=query_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    query_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> Error | SearchResultsPreviewResponse | None:
+    """Re-fetch cached results
+
+     Retrieve previously returned search results using the queryId from a prior search response. Returns
+    the same results without billing. The request must use the same API key that performed the original
+    search. Results are available for 7 days.
+
+    Each result carries `locked`/`tokens`/`cost`: a result not yet paid for through POST
+    /api/v1/search/unlock comes back as a teaser (`locked: true`), never the full text.
+
+    Args:
+        query_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Error | SearchResultsPreviewResponse
+    """
+
+    return sync_detailed(
+        query_id=query_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    query_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[Error | SearchResultsPreviewResponse]:
+    """Re-fetch cached results
+
+     Retrieve previously returned search results using the queryId from a prior search response. Returns
+    the same results without billing. The request must use the same API key that performed the original
+    search. Results are available for 7 days.
+
+    Each result carries `locked`/`tokens`/`cost`: a result not yet paid for through POST
+    /api/v1/search/unlock comes back as a teaser (`locked: true`), never the full text.
+
+    Args:
+        query_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Error | SearchResultsPreviewResponse]
+    """
+
+    kwargs = _get_kwargs(
+        query_id=query_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    query_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> Error | SearchResultsPreviewResponse | None:
+    """Re-fetch cached results
+
+     Retrieve previously returned search results using the queryId from a prior search response. Returns
+    the same results without billing. The request must use the same API key that performed the original
+    search. Results are available for 7 days.
+
+    Each result carries `locked`/`tokens`/`cost`: a result not yet paid for through POST
+    /api/v1/search/unlock comes back as a teaser (`locked: true`), never the full text.
+
+    Args:
+        query_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Error | SearchResultsPreviewResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            query_id=query_id,
+            client=client,
+        )
+    ).parsed

redpine_sdk-0.1.5/src/redpine/_generated/api/search/get_quota.py

@@ -0,0 +1,142 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.quota_info import QuotaInfo
+from ...types import Response
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/search/quota",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Error | QuotaInfo | None:
+    if response.status_code == 200:
+        response_200 = QuotaInfo.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Error | QuotaInfo]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[Error | QuotaInfo]:
+    """Current quota usage and limits
+
+     Daily and monthly query usage and limits for the authenticated organization.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Error | QuotaInfo]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Error | QuotaInfo | None:
+    """Current quota usage and limits
+
+     Daily and monthly query usage and limits for the authenticated organization.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Error | QuotaInfo
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[Error | QuotaInfo]:
+    """Current quota usage and limits
+
+     Daily and monthly query usage and limits for the authenticated organization.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Error | QuotaInfo]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Error | QuotaInfo | None:
+    """Current quota usage and limits
+
+     Daily and monthly query usage and limits for the authenticated organization.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Error | QuotaInfo
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

redpine_sdk-0.1.5/src/redpine/_generated/api/search/list_collections.py

@@ -0,0 +1,152 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.collections_response import CollectionsResponse
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/search/collections",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> CollectionsResponse | Error | None:
+    if response.status_code == 200:
+        response_200 = CollectionsResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 403:
+        response_403 = Error.from_dict(response.json())
+
+        return response_403
+
+    if response.status_code == 429:
+        response_429 = Error.from_dict(response.json())
+
+        return response_429
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[CollectionsResponse | Error]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[CollectionsResponse | Error]:
+    """List collections
+
+     List all document collections accessible to the authenticated API key.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[CollectionsResponse | Error]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+) -> CollectionsResponse | Error | None:
+    """List collections
+
+     List all document collections accessible to the authenticated API key.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        CollectionsResponse | Error
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[CollectionsResponse | Error]:
+    """List collections
+
+     List all document collections accessible to the authenticated API key.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[CollectionsResponse | Error]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+) -> CollectionsResponse | Error | None:
+    """List collections
+
+     List all document collections accessible to the authenticated API key.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        CollectionsResponse | Error
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed