redpine-sdk 0.1.5__py3-none-any.whl

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/_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/_generated/api/__init__.py

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

redpine/_generated/api/search/__init__.py

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

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/_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/_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