Postgres Gateway

Postgres Gateway Users API

Create Postgres Gateway Users

UsersAPI.create(user: UserWrite) → UserCreated

UsersAPI.create(user: Sequence[UserWrite]) → UserCreatedList

Create Users

Create postgres users.

Parameters: user (UserWrite | Sequence[UserWrite]) – The user(s) to create.
Returns: The created user(s)
Return type: UserCreated | UserCreatedList

Examples

Create user:

>>> import os
>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.postgres_gateway import UserWrite, SessionCredentials
>>> from cognite.client.data_classes import ClientCredentials
>>> client = CogniteClient()
>>> session = client.iam.sessions.create(
...     ClientCredentials(os.environ["IDP_CLIENT_ID"], os.environ["IDP_CLIENT_SECRET"]),
...     session_type="CLIENT_CREDENTIALS"
... )
>>> user = UserWrite(credentials=SessionCredentials(nonce=session.nonce))
>>> res = client.postgres_gateway.users.create(user)

Update Postgres Gateway Users

UsersAPI.update(items: cognite.client.data_classes.postgres_gateway.users.UserUpdate | cognite.client.data_classes.postgres_gateway.users.UserWrite) → User

UsersAPI.update(items: Sequence[cognite.client.data_classes.postgres_gateway.users.UserUpdate | cognite.client.data_classes.postgres_gateway.users.UserWrite]) → UserList

Update users

Update postgres users

Parameters: items (UserUpdate | UserWrite | Sequence[UserUpdate | UserWrite]) – The user(s) to update.
Returns: The updated user(s)
Return type: User | UserList

Examples

Update user:

>>> import os
>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.postgres_gateway import UserUpdate, SessionCredentials
>>> from cognite.client.data_classes import ClientCredentials
>>> client = CogniteClient()
>>> session = client.iam.sessions.create(
...     ClientCredentials(os.environ["IDP_CLIENT_ID"], os.environ["IDP_CLIENT_SECRET"]),
...     session_type="CLIENT_CREDENTIALS"
... )
>>> update = UserUpdate('myUser').credentials.set(SessionCredentials(nonce=session.nonce))
>>> res = client.postgres_gateway.users.update(update)

Delete Postgres Gateway Users

UsersAPI.delete(username: Union[str, SequenceNotStr[str]], ignore_unknown_ids: bool = False) → None

Delete postgres user(s)

Delete postgres users

Parameters

username (str | SequenceNotStr[str]) – Usernames of the users to delete.
ignore_unknown_ids (bool) – Ignore usernames that are not found

Examples

Delete users:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> client.postgres_gateway.users.delete(["myUser", "myUser2"])

Retrieve Postgres Gateway Users

UsersAPI.retrieve(username: str, ignore_unknown_ids: bool = False) → User

UsersAPI.retrieve(username: SequenceNotStr[str], ignore_unknown_ids: bool = False) → UserList

Retrieve a list of users by their usernames

Retrieve a list of postgres users by their usernames, optionally ignoring unknown usernames

Parameters

username (str | SequenceNotStr[str]) – Usernames of the users to retrieve.
ignore_unknown_ids (bool) – Ignore usernames that are not found

Returns

The retrieved user(s).

Return type

User | UserList

Examples

Retrieve user:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.postgres_gateway.users.retrieve("myUser", ignore_unknown_ids=True)

List Postgres Gateway Users

UsersAPI.list(limit: int = 25) → UserList

Fetch scoped users

List all users in a given project.

Parameters: limit (int) – Limits the number of results to be returned.
Returns: A list of users
Return type: UserList

Examples

List users:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> user_list = client.postgres_gateway.users.list(limit=5)

Iterate over users:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> for user in client.postgres_gateway.users:
...     user # do something with the user

Iterate over chunks of users to reduce memory load:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> for user_list in client.postgres_gateway.users(chunk_size=25):
...     user_list # do something with the users

Postgres Gateway Tables API

Create Postgres Gateway Tables

TablesAPI.create(username: str, items: TableWrite) → Table

TablesAPI.create(username: str, items: Sequence[TableWrite]) → TableList

Create tables

Parameters

username (str) – The name of the username (a.k.a. database) to be managed from the API
items (pg.TableWrite | Sequence[pg.TableWrite]) – The table(s) to create

Returns

Created tables

Return type

pg.Table | pg.TableList

Examples

Create custom table:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.data_modeling import ViewId
>>> from cognite.client.data_classes.postgres_gateway import ViewTableWrite
>>> client = CogniteClient()
>>> table = ViewTableWrite(tablename="myCustom", options=ViewId(space="mySpace", external_id="myExternalId", version="v1"))
>>> res = client.postgres_gateway.tables.create("myUserName",table)

Delete Postgres Gateway Tables

TablesAPI.delete(username: str, tablename: Union[str, SequenceNotStr[str]], ignore_unknown_ids: bool = False) → None

Delete postgres table(s)

Parameters

username (str) – The name of the username (a.k.a. database) to be managed from the API
tablename (str | SequenceNotStr[str]) – The name of the table(s) to be deleted
ignore_unknown_ids (bool) – Ignore table names that are not found

Examples

Delete custom table:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> client.postgres_gateway.tables.delete("myUserName", ["myCustom", "myCustom2"])

Retrieve Postgres Gateway Tables

TablesAPI.retrieve(username: str, tablename: str, ignore_unknown_ids: Literal[False] = False) → Table

TablesAPI.retrieve(username: str, tablename: str, ignore_unknown_ids: Literal[True]) → cognite.client.data_classes.postgres_gateway.tables.Table | None

TablesAPI.retrieve(username: str, tablename: SequenceNotStr[str], ignore_unknown_ids: bool = False) → TableList

Retrieve a list of tables by their tables names

Retrieve a list of Postgres tables for a user by their table names, optionally ignoring unknown table names

Parameters

username (str) – The username (a.k.a. database) to be managed from the API
tablename (str | SequenceNotStr[str]) – The name of the table(s) to be retrieved
ignore_unknown_ids (bool) – Ignore table names not found

Returns

Foreign tables

Return type

pg.Table | pg.TableList | None

Examples

Retrieve custom table:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.postgres_gateway.tables.retrieve("myUserName", 'myCustom')

Get multiple custom tables by id:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.postgres_gateway.tables.retrieve("myUserName", ["myCustom", "myCustom2"])

List Postgres Gateway Tables

TablesAPI.list(username: str, include_built_ins: Optional[Literal['yes', 'no']] = 'no', limit: int | None = 25) → TableList

List postgres tables

List all tables in a given project.

Parameters

username (str) – The name of the username (a.k.a. database) to be managed from the API
include_built_ins (Literal['yes', 'no'] | None) – Determines if API should return built-in tables or not
limit (int | None) – Limits the number of results to be returned.

Returns

Foreign tables

Return type

pg.TableList

Examples

List tables:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> custom_table_list = client.postgres_gateway.tables.list("myUserName", limit=5)

Iterate over tables:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> for table in client.postgres_gateway.tables:
...     table # do something with the custom table

Iterate over chunks of tables to reduce memory load:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> for table_list in client.postgres_gateway.tables(chunk_size=25):
...     table_list # do something with the custom tables

Postgres Gateway classes

class cognite.client.data_classes.postgres_gateway.Column(name: 'str', type: 'ColumnType')

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns: A dictionary representation of the instance.
Return type: dict[str, Any]

class cognite.client.data_classes.postgres_gateway.ColumnList(resources: Iterable[Any], cognite_client: CogniteClient | None = None): Bases: CogniteResourceList[Column]

class cognite.client.data_classes.postgres_gateway.RawTable(tablename: str, options: RawTableOptions, columns: ColumnList, created_time: Optional[int] = None)

Bases: Table

Foreign tables.

This is the read/response format of the raw table.

Parameters

tablename (str) – Name of the foreign table.
options (RawTableOptions) – Table options
columns (ColumnList) – Foreign table columns.
created_time (int | None) – Time when the table was created.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns: A dictionary representation of the instance.
Return type: dict[str, Any]

class cognite.client.data_classes.postgres_gateway.RawTableOptions(database: 'str', table: 'str', primary_key: 'str | None' = None): Bases: CogniteObject

class cognite.client.data_classes.postgres_gateway.RawTableWrite(tablename: str, options: RawTableOptions, columns: collections.abc.Sequence[cognite.client.data_classes.postgres_gateway.tables.Column] | cognite.client.data_classes.postgres_gateway.tables.ColumnList)

Bases: TableWrite

Foreign tables.

This is the read/response format of the raw table.

Parameters

tablename (str) – Name of the foreign table.
options (RawTableOptions) – Table options
columns (Sequence[Column] | ColumnList) – Foreign table columns.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns: A dictionary representation of the instance.
Return type: dict[str, Any]

class cognite.client.data_classes.postgres_gateway.SessionCredentials(nonce: 'str'): Bases: CogniteObject

class cognite.client.data_classes.postgres_gateway.Table(tablename: str, created_time: Optional[int] = None)

Bases: _TableCore, ABC

Foreign tables.

This is the read/response format of the custom table.

Parameters

tablename (str) – Name of the foreign table.
created_time (int | None) – Time when the table was created

class cognite.client.data_classes.postgres_gateway.TableList(resources: Iterable[Any], cognite_client: CogniteClient | None = None): Bases: WriteableCogniteResourceList[TableWrite, Table]

class cognite.client.data_classes.postgres_gateway.TableWrite(tablename: str)

Bases: _TableCore, ABC

View and create foreign tables for a given user.

This is the write/request format of the table.

class cognite.client.data_classes.postgres_gateway.TableWriteList(resources: Iterable[Any], cognite_client: CogniteClient | None = None): Bases: CogniteResourceList[TableWrite]

class cognite.client.data_classes.postgres_gateway.User(username: str, created_time: int, last_updated_time: int, session_id: Optional[int] = None)

Bases: _UserCore

A user.

This is the read/response format of the user for list and retrieve endpoints.

Parameters

username (str) – Username to authenticate the user on the DB.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
session_id (int | None) – ID of the session tied to this user.

class cognite.client.data_classes.postgres_gateway.UserCreated(host: str, username: str, password: str, created_time: int, last_updated_time: int, session_id: Optional[int] = None)

Bases: User

A user.

This is the read/response format of the user for the create endpoint

Parameters

host (str) – Host of the DB.
username (str) – Username to authenticate the user on the DB.
password (str) – Password to authenticate the user on the DB.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
session_id (int | None) – ID of the session tied to this user.

class cognite.client.data_classes.postgres_gateway.UserCreatedList(resources: Iterable[Any], cognite_client: CogniteClient | None = None): Bases: WriteableCogniteResourceList[UserWrite, UserCreated]

class cognite.client.data_classes.postgres_gateway.UserList(resources: Iterable[Any], cognite_client: CogniteClient | None = None): Bases: WriteableCogniteResourceList[UserWrite, User]

class cognite.client.data_classes.postgres_gateway.UserWrite(credentials: Optional[SessionCredentials] = None)

Bases: _UserCore

A postgres gateway user (also a typical postgres user) owns the foreign tables (built in or custom).

The created postgres user only has access to use foreign tables and cannot directly create tables users. To create foreign tables use the Postgres Gateway Tables APIs

This is the write/request format of the user.

Parameters: credentials (SessionCredentials | None) – Credentials for authenticating towards CDF using a CDF session.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns: A dictionary representation of the instance.
Return type: dict[str, Any]

class cognite.client.data_classes.postgres_gateway.UserWriteList(resources: Iterable[Any], cognite_client: CogniteClient | None = None): Bases: CogniteResourceList[UserWrite]

class cognite.client.data_classes.postgres_gateway.ViewTable(tablename: str, options: ViewId, created_time: Optional[int] = None)

Bases: Table

Foreign tables.

This is the read/response format of the custom table.

Parameters

tablename (str) – Name of the foreign table.
options (ViewId) – Table options
created_time (int | None) – Time when the table was created.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns: A dictionary representation of the instance.
Return type: dict[str, Any]

class cognite.client.data_classes.postgres_gateway.ViewTableWrite(tablename: str, options: ViewId)

Bases: TableWrite

Foreign tables.

This is the read/response format of the custom table.

Parameters

tablename (str) – Name of the foreign table.
options (ViewId) – Table options

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns: A dictionary representation of the instance.
Return type: dict[str, Any]