lakefs_client.AuthApi

All URIs are relative to http://localhost/api/v1

Method	HTTP request	Description
add_group_membership	PUT /auth/groups/{groupId}/members/{userId}	add group membership
attach_policy_to_group	PUT /auth/groups/{groupId}/policies/{policyId}	attach policy to group
attach_policy_to_user	PUT /auth/users/{userId}/policies/{policyId}	attach policy to user
create_credentials	POST /auth/users/{userId}/credentials	create credentials
create_group	POST /auth/groups	create group
create_policy	POST /auth/policies	create policy
create_user	POST /auth/users	create user
create_user_external_principal	POST /auth/users/{userId}/external/principals	attach external principal to user
delete_credentials	DELETE /auth/users/{userId}/credentials/{accessKeyId}	delete credentials
delete_group	DELETE /auth/groups/{groupId}	delete group
delete_group_membership	DELETE /auth/groups/{groupId}/members/{userId}	delete group membership
delete_policy	DELETE /auth/policies/{policyId}	delete policy
delete_user	DELETE /auth/users/{userId}	delete user
delete_user_external_principal	DELETE /auth/users/{userId}/external/principals	delete external principal from user
detach_policy_from_group	DELETE /auth/groups/{groupId}/policies/{policyId}	detach policy from group
detach_policy_from_user	DELETE /auth/users/{userId}/policies/{policyId}	detach policy from user
external_principal_login	POST /auth/external/principal/login	perform a login using an external authenticator
get_credentials	GET /auth/users/{userId}/credentials/{accessKeyId}	get credentials
get_current_user	GET /user	get current user
get_external_principal	GET /auth/external/principals	describe external principal by id
get_group	GET /auth/groups/{groupId}	get group
get_group_acl	GET /auth/groups/{groupId}/acl	get ACL of group
get_policy	GET /auth/policies/{policyId}	get policy
get_user	GET /auth/users/{userId}	get user
list_group_members	GET /auth/groups/{groupId}/members	list group members
list_group_policies	GET /auth/groups/{groupId}/policies	list group policies
list_groups	GET /auth/groups	list groups
list_policies	GET /auth/policies	list policies
list_user_credentials	GET /auth/users/{userId}/credentials	list user credentials
list_user_external_principals	GET /auth/users/{userId}/external/principals/ls	list user external policies attached to a user
list_user_groups	GET /auth/users/{userId}/groups	list user groups
list_user_policies	GET /auth/users/{userId}/policies	list user policies
list_users	GET /auth/users	list users
login	POST /auth/login	perform a login
set_group_acl	POST /auth/groups/{groupId}/acl	set ACL of group
update_policy	PUT /auth/policies/{policyId}	update policy

add_group_membership

add_group_membership(group_id, user_id)

add group membership

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    user_id = "userId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # add group membership
        api_instance.add_group_membership(group_id, user_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->add_group_membership: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
user_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	membership added successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

attach_policy_to_group

attach_policy_to_group(group_id, policy_id)

attach policy to group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    policy_id = "policyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # attach policy to group
        api_instance.attach_policy_to_group(group_id, policy_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->attach_policy_to_group: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
policy_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	policy attached successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

attach_policy_to_user

attach_policy_to_user(user_id, policy_id)

attach policy to user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    policy_id = "policyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # attach policy to user
        api_instance.attach_policy_to_user(user_id, policy_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->attach_policy_to_user: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
policy_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	policy attached successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

create_credentials

CredentialsWithSecret create_credentials(user_id)

create credentials

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.credentials_with_secret import CredentialsWithSecret
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # create credentials
        api_response = api_instance.create_credentials(user_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->create_credentials: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str

Return type

CredentialsWithSecret

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	credentials	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

create_group

Group create_group()

create group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.group_creation import GroupCreation
from lakefs_client.model.error import Error
from lakefs_client.model.group import Group
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_creation = GroupCreation(
        id="id_example",
    ) # GroupCreation |  (optional)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # create group
        api_response = api_instance.create_group(group_creation=group_creation)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->create_group: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_creation	GroupCreation		[optional]

Return type

Group

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	group	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

create_policy

Policy create_policy(policy)

create policy

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.policy import Policy
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    policy = Policy(
        id="id_example",
        creation_date=1,
        statement=[
            Statement(
                effect="allow",
                resource="resource_example",
                action=[
                    "action_example",
                ],
            ),
        ],
    ) # Policy | 

    # example passing only required values which don't have defaults set
    try:
        # create policy
        api_response = api_instance.create_policy(policy)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->create_policy: %s\n" % e)

Parameters

Name	Type	Description	Notes
policy	Policy

Return type

Policy

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	policy	-
400	Validation Error	-
401	Unauthorized	-
409	Resource Conflicts With Target	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

create_user

User create_user()

create user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from lakefs_client.model.user import User
from lakefs_client.model.user_creation import UserCreation
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_creation = UserCreation(
        id="id_example",
        invite_user=True,
    ) # UserCreation |  (optional)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # create user
        api_response = api_instance.create_user(user_creation=user_creation)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->create_user: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_creation	UserCreation		[optional]

Return type

User

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	user	-
400	validation error	-
401	Unauthorized	-
409	Resource Conflicts With Target	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

create_user_external_principal

create_user_external_principal(user_id, principal_id)

attach external principal to user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from lakefs_client.model.external_principal_creation import ExternalPrincipalCreation
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    principal_id = "principalId_example" # str | 
    external_principal_creation = ExternalPrincipalCreation(
        settings=[
            ExternalPrincipalSettings(
                key="key_example",
            ),
        ],
    ) # ExternalPrincipalCreation |  (optional)

    # example passing only required values which don't have defaults set
    try:
        # attach external principal to user
        api_instance.create_user_external_principal(user_id, principal_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->create_user_external_principal: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # attach external principal to user
        api_instance.create_user_external_principal(user_id, principal_id, external_principal_creation=external_principal_creation)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->create_user_external_principal: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
principal_id	str
external_principal_creation	ExternalPrincipalCreation		[optional]

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	external principal attached successfully	-
401	Unauthorized	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_credentials

delete_credentials(user_id, access_key_id)

delete credentials

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    access_key_id = "accessKeyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # delete credentials
        api_instance.delete_credentials(user_id, access_key_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->delete_credentials: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
access_key_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	credentials deleted successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_group

delete_group(group_id)

delete group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # delete group
        api_instance.delete_group(group_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->delete_group: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	group deleted successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_group_membership

delete_group_membership(group_id, user_id)

delete group membership

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    user_id = "userId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # delete group membership
        api_instance.delete_group_membership(group_id, user_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->delete_group_membership: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
user_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	membership deleted successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_policy

delete_policy(policy_id)

delete policy

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    policy_id = "policyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # delete policy
        api_instance.delete_policy(policy_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->delete_policy: %s\n" % e)

Parameters

Name	Type	Description	Notes
policy_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	policy deleted successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_user

delete_user(user_id)

delete user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # delete user
        api_instance.delete_user(user_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->delete_user: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	user deleted successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_user_external_principal

delete_user_external_principal(user_id, principal_id)

delete external principal from user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    principal_id = "principalId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # delete external principal from user
        api_instance.delete_user_external_principal(user_id, principal_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->delete_user_external_principal: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
principal_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	external principal detached successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

detach_policy_from_group

detach_policy_from_group(group_id, policy_id)

detach policy from group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    policy_id = "policyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # detach policy from group
        api_instance.detach_policy_from_group(group_id, policy_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->detach_policy_from_group: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
policy_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	policy detached successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

detach_policy_from_user

detach_policy_from_user(user_id, policy_id)

detach policy from user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    policy_id = "policyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # detach policy from user
        api_instance.detach_policy_from_user(user_id, policy_id)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->detach_policy_from_user: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
policy_id	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
204	policy detached successfully	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

external_principal_login

AuthenticationToken external_principal_login()

perform a login using an external authenticator

Example

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.authentication_token import AuthenticationToken
from lakefs_client.model.external_login_information import ExternalLoginInformation
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_client.ApiClient() as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    external_login_information = ExternalLoginInformation(
        token_expiration_duration=1,
        identity_request={},
    ) # ExternalLoginInformation |  (optional)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # perform a login using an external authenticator
        api_response = api_instance.external_principal_login(external_login_information=external_login_information)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->external_principal_login: %s\n" % e)

Parameters

Name	Type	Description	Notes
external_login_information	ExternalLoginInformation		[optional]

Return type

AuthenticationToken

Authorization

No authorization required

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	successful external login	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_credentials

Credentials get_credentials(user_id, access_key_id)

get credentials

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.credentials import Credentials
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    access_key_id = "accessKeyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # get credentials
        api_response = api_instance.get_credentials(user_id, access_key_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_credentials: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
access_key_id	str

Return type

Credentials

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	credentials	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_current_user

CurrentUser get_current_user()

get current user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.current_user import CurrentUser
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)

    # example, this endpoint has no required or optional parameters
    try:
        # get current user
        api_response = api_instance.get_current_user()
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_current_user: %s\n" % e)

Parameters

This endpoint does not need any parameter.

Return type

CurrentUser

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	user	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_external_principal

ExternalPrincipal get_external_principal(principal_id)

describe external principal by id

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.external_principal import ExternalPrincipal
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    principal_id = "principalId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # describe external principal by id
        api_response = api_instance.get_external_principal(principal_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_external_principal: %s\n" % e)

Parameters

Name	Type	Description	Notes
principal_id	str

Return type

ExternalPrincipal

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	external principal	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_group

Group get_group(group_id)

get group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from lakefs_client.model.group import Group
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # get group
        api_response = api_instance.get_group(group_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_group: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str

Return type

Group

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	group	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_group_acl

ACL get_group_acl(group_id)

get ACL of group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.acl import ACL
from lakefs_client.model.error_no_acl import ErrorNoACL
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # get ACL of group
        api_response = api_instance.get_group_acl(group_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_group_acl: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str

Return type

ACL

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	ACL of group	-
401	Unauthorized	-
404	Group not found, or group found but has no ACL	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_policy

Policy get_policy(policy_id)

get policy

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.policy import Policy
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    policy_id = "policyId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # get policy
        api_response = api_instance.get_policy(policy_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_policy: %s\n" % e)

Parameters

Name	Type	Description	Notes
policy_id	str

Return type

Policy

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	policy	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_user

User get_user(user_id)

get user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from lakefs_client.model.user import User
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 

    # example passing only required values which don't have defaults set
    try:
        # get user
        api_response = api_instance.get_user(user_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->get_user: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str

Return type

User

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	user	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_group_members

UserList list_group_members(group_id)

list group members

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.user_list import UserList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    try:
        # list group members
        api_response = api_instance.list_group_members(group_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_group_members: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list group members
        api_response = api_instance.list_group_members(group_id, prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_group_members: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

UserList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	group member list	-
401	Unauthorized	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_group_policies

PolicyList list_group_policies(group_id)

list group policies

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.policy_list import PolicyList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    try:
        # list group policies
        api_response = api_instance.list_group_policies(group_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_group_policies: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list group policies
        api_response = api_instance.list_group_policies(group_id, prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_group_policies: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

PolicyList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	policy list	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_groups

GroupList list_groups()

list groups

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.group_list import GroupList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list groups
        api_response = api_instance.list_groups(prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_groups: %s\n" % e)

Parameters

Name	Type	Description	Notes
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

GroupList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	group list	-
401	Unauthorized	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_policies

PolicyList list_policies()

list policies

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.policy_list import PolicyList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list policies
        api_response = api_instance.list_policies(prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_policies: %s\n" % e)

Parameters

Name	Type	Description	Notes
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

PolicyList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	policy list	-
401	Unauthorized	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_user_credentials

CredentialsList list_user_credentials(user_id)

list user credentials

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from lakefs_client.model.credentials_list import CredentialsList
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    try:
        # list user credentials
        api_response = api_instance.list_user_credentials(user_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_credentials: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list user credentials
        api_response = api_instance.list_user_credentials(user_id, prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_credentials: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

CredentialsList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	credential list	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_user_external_principals

ExternalPrincipalList list_user_external_principals(user_id)

list user external policies attached to a user

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.error import Error
from lakefs_client.model.external_principal_list import ExternalPrincipalList
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    try:
        # list user external policies attached to a user
        api_response = api_instance.list_user_external_principals(user_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_external_principals: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list user external policies attached to a user
        api_response = api_instance.list_user_external_principals(user_id, prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_external_principals: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

ExternalPrincipalList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	external principals list	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_user_groups

GroupList list_user_groups(user_id)

list user groups

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.group_list import GroupList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    try:
        # list user groups
        api_response = api_instance.list_user_groups(user_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_groups: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list user groups
        api_response = api_instance.list_user_groups(user_id, prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_groups: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

GroupList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	group list	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_user_policies

PolicyList list_user_policies(user_id)

list user policies

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.policy_list import PolicyList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    user_id = "userId_example" # str | 
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100
    effective = False # bool | will return all distinct policies attached to the user or any of its groups (optional) if omitted the server will use the default value of False

    # example passing only required values which don't have defaults set
    try:
        # list user policies
        api_response = api_instance.list_user_policies(user_id)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_policies: %s\n" % e)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list user policies
        api_response = api_instance.list_user_policies(user_id, prefix=prefix, after=after, amount=amount, effective=effective)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_user_policies: %s\n" % e)

Parameters

Name	Type	Description	Notes
user_id	str
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100
effective	bool	will return all distinct policies attached to the user or any of its groups	[optional] if omitted the server will use the default value of False

Return type

PolicyList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	policy list	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

list_users

UserList list_users()

list users

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.user_list import UserList
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    prefix = "prefix_example" # str | return items prefixed with this value (optional)
    after = "after_example" # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) if omitted the server will use the default value of 100

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # list users
        api_response = api_instance.list_users(prefix=prefix, after=after, amount=amount)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->list_users: %s\n" % e)

Parameters

Name	Type	Description	Notes
prefix	str	return items prefixed with this value	[optional]
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] if omitted the server will use the default value of 100

Return type

UserList

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	user list	-
401	Unauthorized	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

login

AuthenticationToken login()

perform a login

Example

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.authentication_token import AuthenticationToken
from lakefs_client.model.login_information import LoginInformation
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_client.ApiClient() as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    login_information = LoginInformation(
        access_key_id="access_key_id_example",
        secret_access_key="secret_access_key_example",
    ) # LoginInformation |  (optional)

    # example passing only required values which don't have defaults set
    # and optional values
    try:
        # perform a login
        api_response = api_instance.login(login_information=login_information)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->login: %s\n" % e)

Parameters

Name	Type	Description	Notes
login_information	LoginInformation		[optional]

Return type

AuthenticationToken

Authorization

No authorization required

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	successful login	* Set-Cookie -
401	Unauthorized	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

set_group_acl

set_group_acl(group_id, acl)

set ACL of group

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.acl import ACL
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    group_id = "groupId_example" # str | 
    acl = ACL(
        permission="permission_example",
    ) # ACL | 

    # example passing only required values which don't have defaults set
    try:
        # set ACL of group
        api_instance.set_group_acl(group_id, acl)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->set_group_acl: %s\n" % e)

Parameters

Name	Type	Description	Notes
group_id	str
acl	ACL

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
201	ACL successfully changed	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

update_policy

Policy update_policy(policy_id, policy)

update policy

Example

• Basic Authentication (basic_auth):
• Api Key Authentication (cookie_auth):
• Bearer (JWT) Authentication (jwt_token):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):

import time
import lakefs_client
from lakefs_client.api import auth_api
from lakefs_client.model.policy import Policy
from lakefs_client.model.error import Error
from pprint import pprint
# Defining the host is optional and defaults to http://localhost/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_client.Configuration(
    host = "http://localhost/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_client.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['cookie_auth'] = 'Bearer'

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_client.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['oidc_auth'] = 'Bearer'

# Configure API key authorization: saml_auth
configuration.api_key['saml_auth'] = 'YOUR_API_KEY'

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['saml_auth'] = 'Bearer'

# Enter a context with an instance of the API client
with lakefs_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = auth_api.AuthApi(api_client)
    policy_id = "policyId_example" # str | 
    policy = Policy(
        id="id_example",
        creation_date=1,
        statement=[
            Statement(
                effect="allow",
                resource="resource_example",
                action=[
                    "action_example",
                ],
            ),
        ],
    ) # Policy | 

    # example passing only required values which don't have defaults set
    try:
        # update policy
        api_response = api_instance.update_policy(policy_id, policy)
        pprint(api_response)
    except lakefs_client.ApiException as e:
        print("Exception when calling AuthApi->update_policy: %s\n" % e)

Parameters

Name	Type	Description	Notes
policy_id	str
policy	Policy

Return type

Policy

Authorization

basic_auth, cookie_auth, jwt_token, oidc_auth, saml_auth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

Status code	Description	Response headers
200	policy	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
420	too many requests	-
0	Internal Server Error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]