lakefs_sdk.AuthApi

All URIs are relative to /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_token_from_mailbox	GET /auth/get-token/mailboxes/{mailbox}	receive the token after user has authenticated on redirect URL.
get_token_redirect	GET /auth/get-token/start	start acquiring a token by logging in on a browser
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
oauth_callback	GET /oidc/callback
release_token_to_mailbox	GET /auth/get-token/release-token/{loginRequestToken}	release a token for the current (authenticated) user to the mailbox of this login request.
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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 
    user_id = 'user_id_example' # str | 

    try:
        # add group membership
        api_instance.add_group_membership(group_id, user_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	membership added successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 
    policy_id = 'policy_id_example' # str | 

    try:
        # attach policy to group
        api_instance.attach_policy_to_group(group_id, policy_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	policy attached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 
    policy_id = 'policy_id_example' # str | 

    try:
        # attach policy to user
        api_instance.attach_policy_to_user(user_id, policy_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	policy attached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.credentials_with_secret import CredentialsWithSecret
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 

    try:
        # create credentials
        api_response = api_instance.create_credentials(user_id)
        print("The response of AuthApi->create_credentials:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	credentials	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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(group_creation=group_creation)

create group

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.group import Group
from lakefs_sdk.models.group_creation import GroupCreation
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # create group
        api_response = api_instance.create_group(group_creation=group_creation)
        print("The response of AuthApi->create_group:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	group	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.policy import Policy
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # create policy
        api_response = api_instance.create_policy(policy)
        print("The response of AuthApi->create_policy:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

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	-
429	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(user_creation=user_creation)

create user

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.user import User
from lakefs_sdk.models.user_creation import UserCreation
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_creation = lakefs_sdk.UserCreation() # UserCreation |  (optional)

    try:
        # create user
        api_response = api_instance.create_user(user_creation=user_creation)
        print("The response of AuthApi->create_user:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

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	-
429	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, external_principal_creation=external_principal_creation)

attach external principal to user

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.external_principal_creation import ExternalPrincipalCreation
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 
    principal_id = 'principal_id_example' # str | 
    external_principal_creation = lakefs_sdk.ExternalPrincipalCreation() # ExternalPrincipalCreation |  (optional)

    try:
        # attach external principal to user
        api_instance.create_user_external_principal(user_id, principal_id, external_principal_creation=external_principal_creation)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	external principal attached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 
    access_key_id = 'access_key_id_example' # str | 

    try:
        # delete credentials
        api_instance.delete_credentials(user_id, access_key_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	credentials deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 

    try:
        # delete group
        api_instance.delete_group(group_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	group deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 
    user_id = 'user_id_example' # str | 

    try:
        # delete group membership
        api_instance.delete_group_membership(group_id, user_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	membership deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    policy_id = 'policy_id_example' # str | 

    try:
        # delete policy
        api_instance.delete_policy(policy_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	policy deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 

    try:
        # delete user
        api_instance.delete_user(user_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	user deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 
    principal_id = 'principal_id_example' # str | 

    try:
        # delete external principal from user
        api_instance.delete_user_external_principal(user_id, principal_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	external principal detached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 
    policy_id = 'policy_id_example' # str | 

    try:
        # detach policy from group
        api_instance.detach_policy_from_group(group_id, policy_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	policy detached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 
    policy_id = 'policy_id_example' # str | 

    try:
        # detach policy from user
        api_instance.detach_policy_from_user(user_id, policy_id)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	policy detached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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(external_login_information=external_login_information)

perform a login using an external authenticator

Example

import time
import os
import lakefs_sdk
from lakefs_sdk.models.authentication_token import AuthenticationToken
from lakefs_sdk.models.external_login_information import ExternalLoginInformation
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    external_login_information = lakefs_sdk.ExternalLoginInformation() # ExternalLoginInformation |  (optional)

    try:
        # perform a login using an external authenticator
        api_response = api_instance.external_principal_login(external_login_information=external_login_information)
        print("The response of AuthApi->external_principal_login:\n")
        pprint(api_response)
    except Exception 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	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.credentials import Credentials
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 
    access_key_id = 'access_key_id_example' # str | 

    try:
        # get credentials
        api_response = api_instance.get_credentials(user_id, access_key_id)
        print("The response of AuthApi->get_credentials:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	credentials	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.current_user import CurrentUser
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # get current user
        api_response = api_instance.get_current_user()
        print("The response of AuthApi->get_current_user:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.external_principal import ExternalPrincipal
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    principal_id = 'principal_id_example' # str | 

    try:
        # describe external principal by id
        api_response = api_instance.get_external_principal(principal_id)
        print("The response of AuthApi->get_external_principal:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	external principal	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.group import Group
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 

    try:
        # get group
        api_response = api_instance.get_group(group_id)
        print("The response of AuthApi->get_group:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	group	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.acl import ACL
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 

    try:
        # get ACL of group
        api_response = api_instance.get_group_acl(group_id)
        print("The response of AuthApi->get_group_acl:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	ACL of group	-
400	Bad Request	-
401	Unauthorized	-
404	Group not found, or group found but has no ACL	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.policy import Policy
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    policy_id = 'policy_id_example' # str | 

    try:
        # get policy
        api_response = api_instance.get_policy(policy_id)
        print("The response of AuthApi->get_policy:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

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

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

get_token_from_mailbox

AuthenticationToken get_token_from_mailbox(mailbox)

receive the token after user has authenticated on redirect URL.

Example

import time
import os
import lakefs_sdk
from lakefs_sdk.models.authentication_token import AuthenticationToken
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    mailbox = 'mailbox_example' # str | mailbox returned by getTokenRedirect

    try:
        # receive the token after user has authenticated on redirect URL.
        api_response = api_instance.get_token_from_mailbox(mailbox)
        print("The response of AuthApi->get_token_from_mailbox:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling AuthApi->get_token_from_mailbox: %s\n" % e)

Parameters

Name	Type	Description	Notes
mailbox	str	mailbox returned by getTokenRedirect

Return type

AuthenticationToken

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	user successfully logged in	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

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

get_token_redirect

Error get_token_redirect()

start acquiring a token by logging in on a browser

Example

import time
import os
import lakefs_sdk
from lakefs_sdk.models.error import Error
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/api/v1"
)


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

    try:
        # start acquiring a token by logging in on a browser
        api_response = api_instance.get_token_redirect()
        print("The response of AuthApi->get_token_redirect:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling AuthApi->get_token_redirect: %s\n" % e)

Parameters

This endpoint does not need any parameter.

Return type

Error

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
303	login on this page, await results on the mailbox URL	* Location - redirect to S3 * X-LakeFS-Mailbox - GET the token from this mailbox. Keep the mailbox SECRET!
401	Unauthorized	-
429	too many requests	-
501	Not Implemented	-
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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.user import User
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_example' # str | 

    try:
        # get user
        api_response = api_instance.get_user(user_id)
        print("The response of AuthApi->get_user:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	user	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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, prefix=prefix, after=after, amount=amount)

list group members

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.user_list import UserList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_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) (default to 100)

    try:
        # list group members
        api_response = api_instance.list_group_members(group_id, prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_group_members:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

UserList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	group member list	-
400	Bad Request	-
401	Unauthorized	-
429	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, prefix=prefix, after=after, amount=amount)

list group policies

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.policy_list import PolicyList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_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) (default to 100)

    try:
        # list group policies
        api_response = api_instance.list_group_policies(group_id, prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_group_policies:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

PolicyList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	policy list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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(prefix=prefix, after=after, amount=amount)

list groups

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.group_list import GroupList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.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) (default to 100)

    try:
        # list groups
        api_response = api_instance.list_groups(prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_groups:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

GroupList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	group list	-
400	Bad Request	-
401	Unauthorized	-
429	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(prefix=prefix, after=after, amount=amount)

list policies

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.policy_list import PolicyList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.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) (default to 100)

    try:
        # list policies
        api_response = api_instance.list_policies(prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_policies:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

PolicyList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	policy list	-
400	Bad Request	-
401	Unauthorized	-
429	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, prefix=prefix, after=after, amount=amount)

list user credentials

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.credentials_list import CredentialsList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_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) (default to 100)

    try:
        # list user credentials
        api_response = api_instance.list_user_credentials(user_id, prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_user_credentials:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

CredentialsList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	credential list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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, prefix=prefix, after=after, amount=amount)

list user external policies attached to a user

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.external_principal_list import ExternalPrincipalList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_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) (default to 100)

    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)
        print("The response of AuthApi->list_user_external_principals:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

ExternalPrincipalList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	external principals list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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, prefix=prefix, after=after, amount=amount)

list user groups

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.group_list import GroupList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_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) (default to 100)

    try:
        # list user groups
        api_response = api_instance.list_user_groups(user_id, prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_user_groups:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

GroupList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	group list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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, prefix=prefix, after=after, amount=amount, effective=effective)

list user policies

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.policy_list import PolicyList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    user_id = 'user_id_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) (default to 100)
    effective = False # bool | will return all distinct policies attached to the user or any of its groups (optional) (default to False)

    try:
        # list user policies
        api_response = api_instance.list_user_policies(user_id, prefix=prefix, after=after, amount=amount, effective=effective)
        print("The response of AuthApi->list_user_policies:\n")
        pprint(api_response)
    except Exception 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] [default to 100]
effective	bool	will return all distinct policies attached to the user or any of its groups	[optional] [default to False]

Return type

PolicyList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	policy list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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(prefix=prefix, after=after, amount=amount)

list users

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.models.user_list import UserList
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.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) (default to 100)

    try:
        # list users
        api_response = api_instance.list_users(prefix=prefix, after=after, amount=amount)
        print("The response of AuthApi->list_users:\n")
        pprint(api_response)
    except Exception 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] [default to 100]

Return type

UserList

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	user list	-
400	Bad Request	-
401	Unauthorized	-
429	too many requests	-
0	Internal Server Error	-

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

login

AuthenticationToken login(login_information=login_information)

perform a login

Example

import time
import os
import lakefs_sdk
from lakefs_sdk.models.authentication_token import AuthenticationToken
from lakefs_sdk.models.login_information import LoginInformation
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    login_information = lakefs_sdk.LoginInformation() # LoginInformation |  (optional)

    try:
        # perform a login
        api_response = api_instance.login(login_information=login_information)
        print("The response of AuthApi->login:\n")
        pprint(api_response)
    except Exception 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 -
400	Bad Request	-
401	Unauthorized	-
429	too many requests	-
0	Internal Server Error	-

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

oauth_callback

Error oauth_callback()

Example

import time
import os
import lakefs_sdk
from lakefs_sdk.models.error import Error
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/api/v1"
)


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

    try:
        api_response = api_instance.oauth_callback()
        print("The response of AuthApi->oauth_callback:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling AuthApi->oauth_callback: %s\n" % e)

Parameters

This endpoint does not need any parameter.

Return type

Error

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
302	successfully got token	-
401	failed to exchange authorization code for token	-
0	Internal Server Error	-

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

release_token_to_mailbox

release_token_to_mailbox(login_request_token)

release a token for the current (authenticated) user to the mailbox of this login request.

Example

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

import time
import os
import lakefs_sdk
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    login_request_token = 'login_request_token_example' # str | login request token returned by getTokenRedirect.

    try:
        # release a token for the current (authenticated) user to the mailbox of this login request.
        api_instance.release_token_to_mailbox(login_request_token)
    except Exception as e:
        print("Exception when calling AuthApi->release_token_to_mailbox: %s\n" % e)

Parameters

Name	Type	Description	Notes
login_request_token	str	login request token returned by getTokenRedirect.

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	token released	-
401	Unauthorized	-
429	too many requests	-
501	Not Implemented	-
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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.acl import ACL
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    group_id = 'group_id_example' # str | 
    acl = lakefs_sdk.ACL() # ACL | 

    try:
        # set ACL of group
        api_instance.set_group_acl(group_id, acl)
    except Exception 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, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	ACL successfully changed	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	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):
• Api Key Authentication (oidc_auth):
• Api Key Authentication (saml_auth):
• Bearer (JWT) Authentication (jwt_token):

import time
import os
import lakefs_sdk
from lakefs_sdk.models.policy import Policy
from lakefs_sdk.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to /api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = lakefs_sdk.Configuration(
    host = "/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_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

# Configure API key authorization: cookie_auth
configuration.api_key['cookie_auth'] = os.environ["API_KEY"]

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

# Configure API key authorization: oidc_auth
configuration.api_key['oidc_auth'] = os.environ["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'] = os.environ["API_KEY"]

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

# Configure Bearer authorization (JWT): jwt_token
configuration = lakefs_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_sdk.AuthApi(api_client)
    policy_id = 'policy_id_example' # str | 
    policy = lakefs_sdk.Policy() # Policy | 

    try:
        # update policy
        api_response = api_instance.update_policy(policy_id, policy)
        print("The response of AuthApi->update_policy:\n")
        pprint(api_response)
    except Exception 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, oidc_auth, saml_auth, jwt_token

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	-
429	too many requests	-
0	Internal Server Error	-

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