Source code for pinecone.admin.admin
from pinecone.config import OpenApiConfiguration, Config
from pinecone.openapi_support import ApiClient
from pinecone.core.openapi.oauth import API_VERSION
from pinecone.core.openapi.oauth.apis import OAuthApi
from pinecone.core.openapi.oauth.models import TokenRequest
from typing import Optional, Dict
from pinecone.utils import get_user_agent
import os
from copy import deepcopy
[docs]
class Admin:
"""
A class for accessing the Pinecone Admin API.
A prerequisite for using this class is to have a `service account <https://docs.pinecone.io/guides/organizations/manage-service-accounts>`_. To create a service
account, visit the `Pinecone web console <https://app.pinecone.io>`_ and navigate to
the ``Access > Service Accounts`` section.
After creating a service account, you will be provided with a client ID and secret.
These values can be passed to the Admin constructor or set the ``PINECONE_CLIENT_ID``
and ``PINECONE_CLIENT_SECRET`` environment variables.
:param client_id: The client ID for the Pinecone API. To obtain a client ID and secret,
you must create a service account via the Pinecone web console. This value can be
passed using keyword arguments or set the ``PINECONE_CLIENT_ID`` environment variable.
:type client_id: Optional[str]
:param client_secret: The client secret for the Pinecone API. To obtain a client ID
and secret, you must create a service account via the Pinecone web console. This value
can be passed using keyword arguments or set the ``PINECONE_CLIENT_SECRET`` environment
variable.
:type client_secret: Optional[str]
:param additional_headers: Additional headers to use for the Pinecone API. This is a
dictionary of key-value pairs. This is primarily used for internal testing
purposes.
:type additional_headers: Optional[Dict[str, str]]
"""
def __init__(
self,
client_id: Optional[str] = None,
client_secret: Optional[str] = None,
additional_headers: Optional[Dict[str, str]] = None,
):
"""
Initialize the ``Admin`` class.
:param client_id: The client ID for the Pinecone API. To obtain a client ID and secret,
you must create a service account via the Pinecone web console. This value can be
passed using keyword arguments or set the ``PINECONE_CLIENT_ID`` environment variable.
:type client_id: Optional[str]
:param client_secret: The client secret for the Pinecone API. To obtain a client ID
and secret, you must create a service account via the Pinecone web console. This value
can be passed using keyword arguments or set the ``PINECONE_CLIENT_SECRET`` environment
variable.
:type client_secret: Optional[str]
:param additional_headers: Additional headers to use for the Pinecone API. This is a
dictionary of key-value pairs. This is primarily used for internal testing
purposes.
:type additional_headers: Optional[Dict[str, str]]
"""
if client_id is not None:
self._client_id = client_id
else:
env_client_id = os.environ.get("PINECONE_CLIENT_ID", None)
if env_client_id is None:
raise ValueError(
"client_id is not set. Pass client_id to the Admin constructor or set the PINECONE_CLIENT_ID environment variable."
)
self._client_id = env_client_id
if client_secret is not None:
self._client_secret = client_secret
else:
env_client_secret = os.environ.get("PINECONE_CLIENT_SECRET", None)
if env_client_secret is None:
raise ValueError(
"client_secret is not set. Pass client_secret to the Admin constructor or set the PINECONE_CLIENT_SECRET environment variable."
)
self._client_secret = env_client_secret
if additional_headers is None:
additional_headers = {}
_oauth_api_config = OpenApiConfiguration(host="https://login.pinecone.io")
_oauth_api_client = ApiClient(configuration=_oauth_api_config)
_oauth_api_client.set_default_header("X-Pinecone-Api-Version", API_VERSION)
for key, value in additional_headers.items():
_oauth_api_client.set_default_header(key, value)
_oauth_api_client.user_agent = get_user_agent(Config())
_oauth_api = OAuthApi(_oauth_api_client)
token_request = TokenRequest(
client_id=self._client_id,
client_secret=self._client_secret,
grant_type="client_credentials",
audience="https://api.pinecone.io/",
)
token_response = _oauth_api.get_token(token_request)
self._token = token_response.access_token
_child_api_config = deepcopy(_oauth_api_config)
_child_api_config.host = "https://api.pinecone.io"
_child_api_config.api_key_prefix = {"BearerAuth": "Bearer"}
_child_api_config.api_key = {"BearerAuth": self._token}
self._child_api_client = ApiClient(configuration=_child_api_config)
self._child_api_client.set_default_header("X-Pinecone-Api-Version", API_VERSION)
for key, value in additional_headers.items():
self._child_api_client.set_default_header(key, value)
self._child_api_client.user_agent = get_user_agent(Config())
# Lazily initialize resources
self._project = None
self._api_key = None
@property
def project(self):
"""A namespace for project-related operations
Alias for :func:`projects`.
To learn about all project-related operations, see :func:`pinecone.admin.resources.ProjectResource`.
Examples
--------
.. code-block:: python
:caption: Creating a project
from pinecone import Admin
# Using environment variables to pass PINECONE_CLIENT_ID and PINECONE_CLIENT_SECRET
admin = Admin()
# Create a project with no quota for pod indexes
admin.project.create(
name="my-project"
max_pods=0
)
.. code-block:: python
:caption: Listing all projects
from pinecone import Admin
admin = Admin()
admin.projects.list()
.. code-block:: python
:caption: Deleting a project
from pinecone import Admin
admin = Admin()
project = admin.project.get(name="my-project")
admin.project.delete(project_id=project.id)
"""
if self._project is None:
from pinecone.admin.resources import ProjectResource
self._project = ProjectResource(self._child_api_client)
return self._project
@property
def projects(self):
"""Alias for :func:`project`"""
return self.project
@property
def api_key(self):
"""A namespace for api key-related operations
Alias for :func:`api_keys`.
To learn about all api key-related operations, see :func:`pinecone.admin.resources.ApiKeyResource`.
Examples
--------
.. code-block:: python
:caption: Creating an API key
from pinecone import Admin
admin = Admin()
project = admin.project.get(name="my-project")
admin.api_key.create(
name="my-api-key",
project_id=project.id,
description="my-api-key-description",
roles=["ProjectEditor"]
)
.. code-block:: python
:caption: Listing all API keys for a project
from pinecone import Admin
admin = Admin()
project = admin.project.get(name="my-project")
admin.api_key.list(project_id=project.id)
.. code-block:: python
:caption: Deleting an API key
from pinecone import Admin
admin = Admin()
project = admin.project.get(name="my-project")
# List api keys for the project
keys_list = admin.api_key.list(project_id=project.id)
# Delete the first api key in the list
admin.api_key.delete(api_key_id=keys_list[0].id)
"""
if self._api_key is None:
from pinecone.admin.resources import ApiKeyResource
self._api_key = ApiKeyResource(self._child_api_client)
return self._api_key
@property
def api_keys(self):
"""Alias for :func:`api_key`"""
return self.api_key
