grepvine 0.1.0__py3-none-any.whl

grepvine/__init__.py

@@ -0,0 +1,65 @@
+"""Python SDK for the Grepvine search API."""
+
+from importlib.metadata import version
+
+from grepvine import models
+from grepvine._client import *
+from grepvine._generated.api.resources import (
+    Account,
+    APIKeys,
+    AsyncAccount,
+    AsyncAPIKeys,
+    AsyncMembers,
+    AsyncOrganizations,
+    AsyncSearch,
+    Members,
+    Organizations,
+    Search,
+)
+from grepvine._helpers import *
+from grepvine._retry import RetryPolicy
+from grepvine.errors import *
+
+__version__ = version("grepvine")
+__all__ = [
+    "__version__",
+    "models",
+    "paginate",
+    "Client",
+    "AsyncClient",
+    "RetryPolicy",
+    "Organizations",
+    "AsyncOrganizations",
+    "Members",
+    "AsyncMembers",
+    "Indexes",
+    "AsyncIndexes",
+    "Documents",
+    "AsyncDocuments",
+    "DocumentInput",
+    "MetadataValue",
+    "Search",
+    "AsyncSearch",
+    "APIKeys",
+    "AsyncAPIKeys",
+    "Account",
+    "AsyncAccount",
+    "DeviceLogin",
+    "AsyncDeviceLogin",
+    "GrepvineError",
+    "APIError",
+    "InvalidRequestError",
+    "InvalidPageError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "ConflictError",
+    "PreconditionFailedError",
+    "PayloadTooLargeError",
+    "RangeNotSatisfiableError",
+    "RateLimitedError",
+    "ServerError",
+    "ConfigurationError",
+    "TransportError",
+    "PartialBatchError",
+]

grepvine/_client.py

@@ -0,0 +1,159 @@
+"""The synchronous and asynchronous clients."""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+from typing import Any, Final, Self
+
+import httpx
+
+from grepvine._generated.api.resources import _GeneratedAsyncClient, _GeneratedClient
+from grepvine._generated.client import Client as _Connection
+from grepvine._helpers import (
+    AsyncDeviceLogin,
+    AsyncDocuments,
+    AsyncIndexes,
+    DeviceLogin,
+    Documents,
+    Indexes,
+)
+from grepvine._retry import AsyncRetryTransport, RetryPolicy, RetryTransport
+from grepvine.errors import ConfigurationError, map_error
+
+DEFAULT_ENDPOINT: Final = "https://api.grepvine.ai"
+DEFAULT_TIMEOUT: Final = 60.0
+__all__ = ["AsyncClient", "Client"]
+
+
+def _options(
+    api_key: str | None, endpoint: str, timeout: float | httpx.Timeout | None
+) -> dict[str, Any]:
+    url = endpoint.rstrip("/")
+    if not url.startswith(("https://", "http://")):
+        raise ConfigurationError(f"the endpoint must be an http or https URL, not {endpoint!r}")
+    headers = {"User-Agent": f"grepvine-python/{version('grepvine')} httpx/{httpx.__version__}"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    return {
+        "base_url": url if url.endswith("/v1") else f"{url}/v1",
+        "headers": headers,
+        "timeout": timeout,
+    }
+
+
+def _session(http: httpx.Client | httpx.AsyncClient, response: httpx.Response) -> None:
+    """Send the CSRF token a sign-in issued with every later request; httpx keeps the cookie."""
+    if token := response.headers.get("x-csrf-token"):
+        http.headers["X-Csrf-Token"] = token
+
+
+class Client(_GeneratedClient):
+    """A client of the Grepvine API.
+
+    Args:
+        api_key: The API key sent as a bearer token. Without one, only the
+            methods that need no credentials work, such as ``account.login``
+            and ``device_login.authorize``; after ``account.login`` the
+            client uses the signed-in session.
+        endpoint: The service URL, with or without ``/v1``.
+        timeout: Seconds, or an ``httpx.Timeout``, for each request.
+        retry: How requests are retried; see `RetryPolicy`.
+        transport: The ``httpx`` transport requests go through, for example
+            an ``httpx.MockTransport`` in tests.
+
+    Use it as a context manager, or call `close`, to release its connections.
+    `http` is the ``httpx.Client`` it sends requests with.
+    """
+
+    indexes: Indexes
+    documents: Documents
+    device_login: DeviceLogin
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        endpoint: str = DEFAULT_ENDPOINT,
+        timeout: float | httpx.Timeout | None = DEFAULT_TIMEOUT,
+        retry: RetryPolicy | None = None,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        options = _options(api_key, endpoint, timeout)
+        inner = transport or httpx.HTTPTransport()
+        self.http = httpx.Client(
+            **options,
+            transport=RetryTransport(inner, retry or RetryPolicy()),
+            event_hooks={"response": [self._on_response]},
+        )
+        connection = _Connection(base_url=options["base_url"]).set_httpx_client(self.http)
+        super().__init__(connection)
+        self.indexes = Indexes(connection)
+        self.documents = Documents(connection)
+        self.device_login = DeviceLogin(connection)
+
+    def _on_response(self, response: httpx.Response) -> None:
+        _session(self.http, response)
+        if response.status_code >= 400:
+            response.read()
+            raise map_error(response)
+
+    def close(self) -> None:
+        """Close the client's connections."""
+        self.http.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+
+class AsyncClient(_GeneratedAsyncClient):
+    """An asynchronous client of the Grepvine API.
+
+    It takes the same arguments as `Client`, with an
+    ``httpx.AsyncBaseTransport`` as ``transport``, and its methods are
+    coroutines. Use it with ``async with``, or call `aclose`.
+    """
+
+    indexes: AsyncIndexes
+    documents: AsyncDocuments
+    device_login: AsyncDeviceLogin
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        endpoint: str = DEFAULT_ENDPOINT,
+        timeout: float | httpx.Timeout | None = DEFAULT_TIMEOUT,
+        retry: RetryPolicy | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        options = _options(api_key, endpoint, timeout)
+        inner = transport or httpx.AsyncHTTPTransport()
+        self.http = httpx.AsyncClient(
+            **options,
+            transport=AsyncRetryTransport(inner, retry or RetryPolicy()),
+            event_hooks={"response": [self._on_response]},
+        )
+        connection = _Connection(base_url=options["base_url"]).set_async_httpx_client(self.http)
+        super().__init__(connection)
+        self.indexes = AsyncIndexes(connection)
+        self.documents = AsyncDocuments(connection)
+        self.device_login = AsyncDeviceLogin(connection)
+
+    async def _on_response(self, response: httpx.Response) -> None:
+        _session(self.http, response)
+        if response.status_code >= 400:
+            await response.aread()
+            raise map_error(response)
+
+    async def aclose(self) -> None:
+        """Close the client's connections."""
+        await self.http.aclose()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.aclose()

grepvine/_generated/__init__.py

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

grepvine/_generated/api/__init__.py

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

grepvine/_generated/api/api_keys/__init__.py

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

grepvine/_generated/api/api_keys/create_api_key.py

@@ -0,0 +1,160 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response
+
+from ...models.api_key_created import APIKeyCreated
+from ...models.create_api_key_request import CreateAPIKeyRequest
+from ...models.error import Error
+
+
+def _get_kwargs(
+    *,
+    body: CreateAPIKeyRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api-keys",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> APIKeyCreated | Error:
+    if response.status_code == 201:
+        response_201 = APIKeyCreated.from_dict(response.json())
+
+        return response_201
+
+    response_default = Error.from_dict(response.json())
+
+    return response_default
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[APIKeyCreated | 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,
+    body: CreateAPIKeyRequest,
+) -> Response[APIKeyCreated | Error]:
+    """Create an API key
+
+    Args:
+        body (CreateAPIKeyRequest):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        Response[APIKeyCreated | Error]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateAPIKeyRequest,
+) -> APIKeyCreated | Error | None:
+    """Create an API key
+
+    Args:
+        body (CreateAPIKeyRequest):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        APIKeyCreated | Error
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateAPIKeyRequest,
+) -> Response[APIKeyCreated | Error]:
+    """Create an API key
+
+    Args:
+        body (CreateAPIKeyRequest):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        Response[APIKeyCreated | Error]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateAPIKeyRequest,
+) -> APIKeyCreated | Error | None:
+    """Create an API key
+
+    Args:
+        body (CreateAPIKeyRequest):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        APIKeyCreated | Error
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

grepvine/_generated/api/api_keys/list_api_keys.py

@@ -0,0 +1,176 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+
+from ...models.api_key_page import APIKeyPage
+from ...models.error import Error
+from ...types import Unset
+
+
+def _get_kwargs(
+    *,
+    amount: int | Unset = 50,
+    page: str | Unset = UNSET,
+) -> dict[str, Any]:
+
+    params: dict[str, Any] = {}
+
+    params["amount"] = amount
+
+    params["page"] = page
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api-keys",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> APIKeyPage | Error:
+    if response.status_code == 200:
+        response_200 = APIKeyPage.from_dict(response.json())
+
+        return response_200
+
+    response_default = Error.from_dict(response.json())
+
+    return response_default
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[APIKeyPage | 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,
+    amount: int | Unset = 50,
+    page: str | Unset = UNSET,
+) -> Response[APIKeyPage | Error]:
+    """List API keys
+
+    Args:
+        amount (int | Unset):  Default: 50.
+        page (str | Unset):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        Response[APIKeyPage | Error]
+    """
+
+    kwargs = _get_kwargs(
+        amount=amount,
+        page=page,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    amount: int | Unset = 50,
+    page: str | Unset = UNSET,
+) -> APIKeyPage | Error | None:
+    """List API keys
+
+    Args:
+        amount (int | Unset):  Default: 50.
+        page (str | Unset):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        APIKeyPage | Error
+    """
+
+    return sync_detailed(
+        client=client,
+        amount=amount,
+        page=page,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    amount: int | Unset = 50,
+    page: str | Unset = UNSET,
+) -> Response[APIKeyPage | Error]:
+    """List API keys
+
+    Args:
+        amount (int | Unset):  Default: 50.
+        page (str | Unset):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        Response[APIKeyPage | Error]
+    """
+
+    kwargs = _get_kwargs(
+        amount=amount,
+        page=page,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    amount: int | Unset = 50,
+    page: str | Unset = UNSET,
+) -> APIKeyPage | Error | None:
+    """List API keys
+
+    Args:
+        amount (int | Unset):  Default: 50.
+        page (str | Unset):
+
+    Raises:
+        grepvine.APIError: The service answered with an error.
+        grepvine.TransportError: The request could not be delivered.
+
+    Returns:
+        APIKeyPage | Error
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            amount=amount,
+            page=page,
+        )
+    ).parsed