lakefs_enterprise_sdk.ExperimentalApi¶

All URIs are relative to /api/v1

Method	HTTP request	Description
abort_presign_multipart_upload	DELETE /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}	Abort a presign multipart upload
attach_tenant_group	PUT /auth/tenants/{tenantName}/groups/{groupId}	attach group to tenant
attach_tenant_user	PUT /auth/tenants/{tenantName}/users/{userId}	attach user to tenant
close_dataset_pull_request	DELETE /datasets/{dataset}/pulls/{pullRequest}	close a pull request
commit_async	POST /repositories/{repository}/branches/{branch}/commits/async	create commit asynchronously
commit_async_status	GET /repositories/{repository}/branches/{branch}/commits/async/{id}/status	get status of async commit operation
complete_presign_multipart_upload	PUT /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}	Complete a presign multipart upload request
create_dataset	POST /datasets	create dataset
create_dataset_metadata_key	POST /datasets/metadata	create a dataset metadata key
create_presign_multipart_upload	POST /repositories/{repository}/branches/{branch}/staging/pmpu	Initiate a multipart upload
create_pull_request	POST /repositories/{repository}/pulls	create pull request
create_pull_request_comment	POST /repositories/{repository}/pulls/{pull_request}/comments	create pull request comment
create_tenant	POST /auth/tenants	create tenant
create_user_external_principal	POST /auth/users/{userId}/external/principals	attach external principal to user
delete_dataset	DELETE /datasets/{dataset}	delete dataset
delete_dataset_metadata_key	DELETE /datasets/metadata/{key}	delete a dataset metadata key
delete_object_lifecycle_rules	DELETE /repositories/{repository}/settings/object_lifecycle	clear all object lifecycle rules for this repository
delete_pull_request_comment	DELETE /repositories/{repository}/pulls/{pull_request}/comments/{comment}	delete pull request comment
delete_tenant	DELETE /auth/tenants/{tenantName}	delete tenant
delete_user_external_principal	DELETE /auth/users/{userId}/external/principals	delete external principal from user
detach_tenant_group	DELETE /auth/tenants/{tenantName}/groups/{groupId}	detach group from tenant
detach_tenant_user	DELETE /auth/tenants/{tenantName}/users/{userId}	detach user from tenant
diff_dataset	GET /datasets/{dataset}/refs/{leftRef}/diff/{rightRef}	structured diff of a dataset definition between two refs
diff_dataset_pull_request	GET /datasets/{dataset}/pulls/{pullRequest}/diff	compiled JSON diff (base vs proposed) for a pull request
external_principal_login	POST /auth/external/principal/login	perform a login using an external authenticator
get_dataset	GET /datasets/{dataset}	get a dataset and its current definition
get_dataset_by_ref	GET /datasets/{dataset}/refs/{ref}	get a dataset definition at a ref (latest or v<N>)
get_dataset_metadata_key	GET /datasets/metadata/{key}	get a dataset metadata key
get_dataset_pull_request	GET /datasets/{dataset}/pulls/{pullRequest}	get a dataset pull request
get_dataset_version	GET /datasets/{dataset}/versions/{version}	get a single dataset version
get_external_principal	GET /auth/external/principals	describe external principal by id
get_license	GET /license
get_object_lifecycle_rules	GET /repositories/{repository}/settings/object_lifecycle	get object lifecycle rules
get_pull_request	GET /repositories/{repository}/pulls/{pull_request}	get pull request
get_pull_request_comment	GET /repositories/{repository}/pulls/{pull_request}/comments/{comment}	get pull request comment
get_tenant	GET /auth/tenants/{tenantName}	get tenant
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
hard_reset_branch	PUT /repositories/{repository}/branches/{branch}/hard_reset	hard reset branch
jwt_login	POST /auth/jwt/login	exchange an external IdP JWT for a lakeFS session token
list_all_dataset_pull_requests	GET /datasets/pulls	global list of pull requests across datasets
list_dataset_metadata_keys	GET /datasets/metadata	list dataset metadata keys
list_dataset_pull_requests	GET /datasets/{dataset}/pulls	list a dataset's pull requests
list_dataset_versions	GET /datasets/{dataset}/versions	list dataset versions, newest first
list_datasets	GET /datasets	list datasets
list_pull_request_comments	GET /repositories/{repository}/pulls/{pull_request}/comments	list pull request comments
list_pull_requests	GET /repositories/{repository}/pulls	list pull requests
list_tenant_groups	GET /auth/tenants/{tenantName}/groups	list groups attached to tenant
list_tenant_users	GET /auth/tenants/{tenantName}/users	list users attached to tenant
list_tenants	GET /auth/tenants	list tenants
list_user_external_principals	GET /auth/users/{userId}/external/principals/ls	list user external policies attached to a user
list_user_tenants	GET /user/tenants	list the tenants the current user is a member of
merge_dataset_pull_request	POST /datasets/{dataset}/pulls/{pullRequest}/merge	merge a pull request, publishing the next dataset version
merge_into_branch_async	POST /repositories/{repository}/refs/{sourceRef}/merge/{destinationBranch}/async	merge references asynchronously
merge_into_branch_async_status	GET /repositories/{repository}/refs/{sourceRef}/merge/{destinationBranch}/async/{id}/status	get status of async merge operation
merge_pull_request	PUT /repositories/{repository}/pulls/{pull_request}/merge	merge pull request
open_dataset_pull_request	POST /datasets/{dataset}/pulls	open a pull request proposing a dataset definition change
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.
run_mds_query	POST /mds/query	run a metadata search query
set_object_lifecycle_rules	PUT /repositories/{repository}/settings/object_lifecycle	replace all object lifecycle rules for this repository
sts_login	POST /sts/login	perform a login with STS
update_dataset	PUT /datasets/{dataset}	update a dataset, publishing a new version
update_dataset_metadata_key	PUT /datasets/metadata/{key}	update a dataset metadata key
update_dataset_pull_request	PATCH /datasets/{dataset}/pulls/{pullRequest}	re-author a pull request (title, description, and/or proposed definition)
update_object_user_metadata	PUT /repositories/{repository}/branches/{branch}/objects/stat/user_metadata	rewrite (all) object metadata
update_pull_request	PATCH /repositories/{repository}/pulls/{pull_request}	update pull request
update_pull_request_comment	PATCH /repositories/{repository}/pulls/{pull_request}/comments/{comment}	update pull request comment
update_tenant	PATCH /auth/tenants/{tenantName}	update tenant description
upload_part	PUT /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/parts/{partNumber}
upload_part_copy	PUT /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/parts/{partNumber}/copy

abort_presign_multipart_upload¶

abort_presign_multipart_upload(repository, branch, upload_id, path, abort_presign_multipart_upload=abort_presign_multipart_upload)

Abort a presign multipart upload

Aborts a presign multipart upload.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.abort_presign_multipart_upload import AbortPresignMultipartUpload
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    upload_id = 'upload_id_example' # str | 
    path = 'path_example' # str | relative to the branch
    abort_presign_multipart_upload = lakefs_enterprise_sdk.AbortPresignMultipartUpload() # AbortPresignMultipartUpload |  (optional)

    try:
        # Abort a presign multipart upload
        api_instance.abort_presign_multipart_upload(repository, branch, upload_id, path, abort_presign_multipart_upload=abort_presign_multipart_upload)
    except Exception as e:
        print("Exception when calling ExperimentalApi->abort_presign_multipart_upload: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str	relative to the branch
abort_presign_multipart_upload	AbortPresignMultipartUpload		[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
204	Presign multipart upload aborted	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

attach_tenant_group¶

attach_tenant_group(tenant_name, group_id)

attach group to tenant

Attach is idempotent: repeating an existing attachment succeeds as a no-op. The group must exist: a membership cannot be seeded for a group that has not been created.

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # attach group to tenant
        api_instance.attach_tenant_group(tenant_name, group_id)
    except Exception as e:
        print("Exception when calling ExperimentalApi->attach_tenant_group: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	str
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
201	group attached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

attach_tenant_user¶

attach_tenant_user(tenant_name, user_id)

attach user to tenant

Attach is idempotent: repeating an existing attachment succeeds as a no-op. The user must exist: a membership cannot be seeded for a user that has not been created.

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # attach user to tenant
        api_instance.attach_tenant_user(tenant_name, user_id)
    except Exception as e:
        print("Exception when calling ExperimentalApi->attach_tenant_user: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	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	user attached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

close_dataset_pull_request¶

close_dataset_pull_request(dataset, pull_request)

close a pull 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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    pull_request = 'pull_request_example' # str | 

    try:
        # close a pull request
        api_instance.close_dataset_pull_request(dataset, pull_request)
    except Exception as e:
        print("Exception when calling ExperimentalApi->close_dataset_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
pull_request	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	closed	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

commit_async¶

TaskCreation commit_async(repository, branch, commit_creation, source_metarange=source_metarange)

create commit asynchronously

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_enterprise_sdk
from lakefs_enterprise_sdk.models.commit_creation import CommitCreation
from lakefs_enterprise_sdk.models.task_creation import TaskCreation
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    commit_creation = lakefs_enterprise_sdk.CommitCreation() # CommitCreation | 
    source_metarange = 'source_metarange_example' # str | The source metarange to commit. Branch must not have uncommitted changes. (optional)

    try:
        # create commit asynchronously
        api_response = api_instance.commit_async(repository, branch, commit_creation, source_metarange=source_metarange)
        print("The response of ExperimentalApi->commit_async:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->commit_async: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
commit_creation	CommitCreation
source_metarange	str	The source metarange to commit. Branch must not have uncommitted changes.	[optional]

Return type¶

TaskCreation

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
202	commit task started	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

commit_async_status¶

CommitAsyncStatus commit_async_status(repository, branch, id)

get status of async commit operation

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_enterprise_sdk
from lakefs_enterprise_sdk.models.commit_async_status import CommitAsyncStatus
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    id = 'id_example' # str | Unique identifier of the commit async task

    try:
        # get status of async commit operation
        api_response = api_instance.commit_async_status(repository, branch, id)
        print("The response of ExperimentalApi->commit_async_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->commit_async_status: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
branch	str
id	str	Unique identifier of the commit async task

Return type¶

CommitAsyncStatus

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	commit task status	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
412	Precondition Failed	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

complete_presign_multipart_upload¶

ObjectStats complete_presign_multipart_upload(repository, branch, upload_id, path, complete_presign_multipart_upload=complete_presign_multipart_upload)

Complete a presign multipart upload request

Completes a presign multipart upload by assembling the uploaded parts.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.complete_presign_multipart_upload import CompletePresignMultipartUpload
from lakefs_enterprise_sdk.models.object_stats import ObjectStats
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    upload_id = 'upload_id_example' # str | 
    path = 'path_example' # str | relative to the branch
    complete_presign_multipart_upload = lakefs_enterprise_sdk.CompletePresignMultipartUpload() # CompletePresignMultipartUpload |  (optional)

    try:
        # Complete a presign multipart upload request
        api_response = api_instance.complete_presign_multipart_upload(repository, branch, upload_id, path, complete_presign_multipart_upload=complete_presign_multipart_upload)
        print("The response of ExperimentalApi->complete_presign_multipart_upload:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->complete_presign_multipart_upload: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str	relative to the branch
complete_presign_multipart_upload	CompletePresignMultipartUpload		[optional]

Return type¶

ObjectStats

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	Presign multipart upload completed	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
409	conflict with a commit, try here	-
429	too many requests	-
0	Internal Server Error	-

create_dataset¶

Dataset create_dataset(dataset_creation)

create dataset

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset import Dataset
from lakefs_enterprise_sdk.models.dataset_creation import DatasetCreation
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset_creation = lakefs_enterprise_sdk.DatasetCreation() # DatasetCreation | 

    try:
        # create dataset
        api_response = api_instance.create_dataset(dataset_creation)
        print("The response of ExperimentalApi->create_dataset:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->create_dataset: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset_creation	DatasetCreation

Return type¶

Dataset

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	dataset	-
400	Validation Error	-
401	Unauthorized	-
409	Resource Conflicts With Target	-
0	Internal Server Error	-

create_dataset_metadata_key¶

DatasetMetadataKey create_dataset_metadata_key(dataset_metadata_key)

create a dataset metadata key

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_metadata_key import DatasetMetadataKey
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset_metadata_key = lakefs_enterprise_sdk.DatasetMetadataKey() # DatasetMetadataKey | 

    try:
        # create a dataset metadata key
        api_response = api_instance.create_dataset_metadata_key(dataset_metadata_key)
        print("The response of ExperimentalApi->create_dataset_metadata_key:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->create_dataset_metadata_key: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset_metadata_key	DatasetMetadataKey

Return type¶

DatasetMetadataKey

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	dataset metadata key	-
400	Validation Error	-
401	Unauthorized	-
409	Resource Conflicts With Target	-
0	Internal Server Error	-

create_presign_multipart_upload¶

PresignMultipartUpload create_presign_multipart_upload(repository, branch, path, parts=parts)

Initiate a multipart upload

Initiates a multipart upload and returns an upload ID with presigned URLs for each part (optional). Part numbers starts with 1. Each part except the last one has minimum size depends on the underlying blockstore implementation. For example working with S3 blockstore, minimum size is 5MB (excluding the last part).

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_enterprise_sdk
from lakefs_enterprise_sdk.models.presign_multipart_upload import PresignMultipartUpload
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    path = 'path_example' # str | relative to the branch
    parts = 56 # int | number of presigned URL parts required to upload (optional)

    try:
        # Initiate a multipart upload
        api_response = api_instance.create_presign_multipart_upload(repository, branch, path, parts=parts)
        print("The response of ExperimentalApi->create_presign_multipart_upload:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->create_presign_multipart_upload: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
path	str	relative to the branch
parts	int	number of presigned URL parts required to upload	[optional]

Return type¶

PresignMultipartUpload

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	Presign multipart upload initiated	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

create_pull_request¶

PullRequestCreationResponse create_pull_request(repository, pull_request_creation)

create pull 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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request_creation import PullRequestCreation
from lakefs_enterprise_sdk.models.pull_request_creation_response import PullRequestCreationResponse
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request_creation = lakefs_enterprise_sdk.PullRequestCreation() # PullRequestCreation | 

    try:
        # create pull request
        api_response = api_instance.create_pull_request(repository, pull_request_creation)
        print("The response of ExperimentalApi->create_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->create_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
pull_request_creation	PullRequestCreation

Return type¶

PullRequestCreationResponse

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	pull request created	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
429	too many requests	-
0	Internal Server Error	-

create_pull_request_comment¶

PullRequestCommentCreationResponse create_pull_request_comment(repository, pull_request, pull_request_comment_creation)

create pull request comment

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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request_comment_creation import PullRequestCommentCreation
from lakefs_enterprise_sdk.models.pull_request_comment_creation_response import PullRequestCommentCreationResponse
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    pull_request_comment_creation = lakefs_enterprise_sdk.PullRequestCommentCreation() # PullRequestCommentCreation | 

    try:
        # create pull request comment
        api_response = api_instance.create_pull_request_comment(repository, pull_request, pull_request_comment_creation)
        print("The response of ExperimentalApi->create_pull_request_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->create_pull_request_comment: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
pull_request	str	pull request id
pull_request_comment_creation	PullRequestCommentCreation

Return type¶

PullRequestCommentCreationResponse

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	pull request comment created	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

create_tenant¶

Tenant create_tenant(tenant_creation)

create tenant

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_enterprise_sdk
from lakefs_enterprise_sdk.models.tenant import Tenant
from lakefs_enterprise_sdk.models.tenant_creation import TenantCreation
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    tenant_creation = lakefs_enterprise_sdk.TenantCreation() # TenantCreation | 

    try:
        # create tenant
        api_response = api_instance.create_tenant(tenant_creation)
        print("The response of ExperimentalApi->create_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->create_tenant: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_creation	TenantCreation

Return type¶

Tenant

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	tenant	-
400	Bad Request	-
401	Unauthorized	-
409	Resource Conflicts With Target	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_sdk.models.external_principal_creation import ExternalPrincipalCreation
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    user_id = 'user_id_example' # str | 
    principal_id = 'principal_id_example' # str | 
    external_principal_creation = lakefs_enterprise_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 ExperimentalApi->create_user_external_principal: %s\n" % e)

Parameters¶

Name	Type	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	-

delete_dataset¶

delete_dataset(dataset)

delete dataset

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 

    try:
        # delete dataset
        api_instance.delete_dataset(dataset)
    except Exception as e:
        print("Exception when calling ExperimentalApi->delete_dataset: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	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	dataset deleted successfully	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

delete_dataset_metadata_key¶

delete_dataset_metadata_key(key)

delete a dataset metadata key

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    key = 'key_example' # str | 

    try:
        # delete a dataset metadata key
        api_instance.delete_dataset_metadata_key(key)
    except Exception as e:
        print("Exception when calling ExperimentalApi->delete_dataset_metadata_key: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
key	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	dataset metadata key deleted successfully	-
401	Unauthorized	-
0	Internal Server Error	-

delete_object_lifecycle_rules¶

delete_object_lifecycle_rules(repository)

clear all object lifecycle rules for this repository

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 

    try:
        # clear all object lifecycle rules for this repository
        api_instance.delete_object_lifecycle_rules(repository)
    except Exception as e:
        print("Exception when calling ExperimentalApi->delete_object_lifecycle_rules: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	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	rules cleared	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

delete_pull_request_comment¶

delete_pull_request_comment(repository, pull_request, comment)

delete pull request comment

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    comment = 'comment_example' # str | pull request comment id

    try:
        # delete pull request comment
        api_instance.delete_pull_request_comment(repository, pull_request, comment)
    except Exception as e:
        print("Exception when calling ExperimentalApi->delete_pull_request_comment: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
pull_request	str	pull request id
comment	str	pull request comment id

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	pull request comment deleted successfully	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

delete_tenant¶

delete_tenant(tenant_name)

delete tenant

The tenant must hold no repositories; memberships are removed with it. The root tenant is reserved by the system and cannot be deleted.

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    tenant_name = 'tenant_name_example' # str | the tenant's unique name

    try:
        # delete tenant
        api_instance.delete_tenant(tenant_name)
    except Exception as e:
        print("Exception when calling ExperimentalApi->delete_tenant: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	str	the tenant's unique name

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	tenant deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
409	tenant not empty	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

detach_tenant_group¶

detach_tenant_group(tenant_name, group_id)

detach group from tenant

Detach is idempotent: removing a membership that is not present succeeds as a no-op, including for a group that does not exist. A 404 response refers to the tenant.

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # detach group from tenant
        api_instance.detach_tenant_group(tenant_name, group_id)
    except Exception as e:
        print("Exception when calling ExperimentalApi->detach_tenant_group: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	str
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 detached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

detach_tenant_user¶

detach_tenant_user(tenant_name, user_id)

detach user from tenant

Detach is idempotent: removing a membership that is not present succeeds as a no-op, including for a user that does not exist. A 404 response refers to the tenant.

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

    try:
        # detach user from tenant
        api_instance.detach_tenant_user(tenant_name, user_id)
    except Exception as e:
        print("Exception when calling ExperimentalApi->detach_tenant_user: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	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	user detached successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

diff_dataset¶

DatasetDiff diff_dataset(dataset, left_ref, right_ref)

structured diff of a dataset definition between two refs

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_diff import DatasetDiff
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    left_ref = 'left_ref_example' # str | 
    right_ref = 'right_ref_example' # str | 

    try:
        # structured diff of a dataset definition between two refs
        api_response = api_instance.diff_dataset(dataset, left_ref, right_ref)
        print("The response of ExperimentalApi->diff_dataset:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->diff_dataset: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
left_ref	str
right_ref	str

Return type¶

DatasetDiff

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	dataset diff	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

diff_dataset_pull_request¶

DatasetPullRequestDiff diff_dataset_pull_request(dataset, pull_request)

compiled JSON diff (base vs proposed) for a pull 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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request_diff import DatasetPullRequestDiff
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    pull_request = 'pull_request_example' # str | 

    try:
        # compiled JSON diff (base vs proposed) for a pull request
        api_response = api_instance.diff_dataset_pull_request(dataset, pull_request)
        print("The response of ExperimentalApi->diff_dataset_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->diff_dataset_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
pull_request	str

Return type¶

DatasetPullRequestDiff

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	diff	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_sdk.models.authentication_token import AuthenticationToken
from lakefs_enterprise_sdk.models.external_login_information import ExternalLoginInformation
from lakefs_enterprise_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_enterprise_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    external_login_information = lakefs_enterprise_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 ExperimentalApi->external_principal_login:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->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	-

get_dataset¶

Dataset get_dataset(dataset)

get a dataset and its current definition

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset import Dataset
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 

    try:
        # get a dataset and its current definition
        api_response = api_instance.get_dataset(dataset)
        print("The response of ExperimentalApi->get_dataset:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_dataset: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str

Return type¶

Dataset

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	dataset	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

get_dataset_by_ref¶

Dataset get_dataset_by_ref(dataset, ref)

get a dataset definition at a ref (latest or v)

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset import Dataset
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    ref = 'ref_example' # str | 

    try:
        # get a dataset definition at a ref (latest or v<N>)
        api_response = api_instance.get_dataset_by_ref(dataset, ref)
        print("The response of ExperimentalApi->get_dataset_by_ref:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_dataset_by_ref: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
ref	str

Return type¶

Dataset

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	dataset	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

get_dataset_metadata_key¶

DatasetMetadataKey get_dataset_metadata_key(key)

get a dataset metadata key

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_metadata_key import DatasetMetadataKey
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    key = 'key_example' # str | 

    try:
        # get a dataset metadata key
        api_response = api_instance.get_dataset_metadata_key(key)
        print("The response of ExperimentalApi->get_dataset_metadata_key:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_dataset_metadata_key: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
key	str

Return type¶

DatasetMetadataKey

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	dataset metadata key	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

get_dataset_pull_request¶

DatasetPullRequest get_dataset_pull_request(dataset, pull_request)

get a dataset pull 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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request import DatasetPullRequest
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    pull_request = 'pull_request_example' # str | 

    try:
        # get a dataset pull request
        api_response = api_instance.get_dataset_pull_request(dataset, pull_request)
        print("The response of ExperimentalApi->get_dataset_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_dataset_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
pull_request	str

Return type¶

DatasetPullRequest

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	pull request	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

get_dataset_version¶

DatasetVersion get_dataset_version(dataset, version)

get a single dataset version

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_version import DatasetVersion
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    version = 'version_example' # str | 

    try:
        # get a single dataset version
        api_response = api_instance.get_dataset_version(dataset, version)
        print("The response of ExperimentalApi->get_dataset_version:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_dataset_version: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
version	str

Return type¶

DatasetVersion

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	dataset version	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_sdk.models.external_principal import ExternalPrincipal
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 ExperimentalApi->get_external_principal:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->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	-

get_license¶

License get_license()

retrieve lakeFS license information

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_enterprise_sdk
from lakefs_enterprise_sdk.models.license import License
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

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

Parameters¶

This endpoint does not need any parameter.

Return type¶

License

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	lakeFS configuration	-
401	Unauthorized	-
501	Not Implemented	-
0	Internal Server Error	-

get_object_lifecycle_rules¶

ObjectLifecycleRules get_object_lifecycle_rules(repository)

get object lifecycle rules

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_enterprise_sdk
from lakefs_enterprise_sdk.models.object_lifecycle_rules import ObjectLifecycleRules
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 

    try:
        # get object lifecycle rules
        api_response = api_instance.get_object_lifecycle_rules(repository)
        print("The response of ExperimentalApi->get_object_lifecycle_rules:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_object_lifecycle_rules: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str

Return type¶

ObjectLifecycleRules

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	object lifecycle rules	* ETag -
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

get_pull_request¶

PullRequest get_pull_request(repository, pull_request)

get pull 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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request import PullRequest
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id

    try:
        # get pull request
        api_response = api_instance.get_pull_request(repository, pull_request)
        print("The response of ExperimentalApi->get_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
pull_request	str	pull request id

Return type¶

PullRequest

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	pull request	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

get_pull_request_comment¶

PullRequestComment get_pull_request_comment(repository, pull_request, comment)

get pull request comment

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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request_comment import PullRequestComment
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    comment = 'comment_example' # str | pull request comment id

    try:
        # get pull request comment
        api_response = api_instance.get_pull_request_comment(repository, pull_request, comment)
        print("The response of ExperimentalApi->get_pull_request_comment:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_pull_request_comment: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
pull_request	str	pull request id
comment	str	pull request comment id

Return type¶

PullRequestComment

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	pull request comment	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

get_tenant¶

Tenant get_tenant(tenant_name)

get tenant

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_enterprise_sdk
from lakefs_enterprise_sdk.models.tenant import Tenant
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    tenant_name = 'tenant_name_example' # str | the tenant's unique name

    try:
        # get tenant
        api_response = api_instance.get_tenant(tenant_name)
        print("The response of ExperimentalApi->get_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->get_tenant: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	str	the tenant's unique name

Return type¶

Tenant

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	tenant	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_sdk.models.authentication_token import AuthenticationToken
from lakefs_enterprise_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_enterprise_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 ExperimentalApi->get_token_from_mailbox:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->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	-

get_token_redirect¶

Error get_token_redirect()

start acquiring a token by logging in on a browser

Example¶

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.error import Error
from lakefs_enterprise_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_enterprise_sdk.Configuration(
    host = "/api/v1"
)


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

    try:
        # start acquiring a token by logging in on a browser
        api_response = api_instance.get_token_redirect()
        print("The response of ExperimentalApi->get_token_redirect:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->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	-

hard_reset_branch¶

hard_reset_branch(repository, branch, ref, force=force)

hard reset branch

Relocate branch to refer to ref. Branch must not contain uncommitted data.

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    ref = 'ref_example' # str | After reset, branch will point at this reference.
    force = False # bool |  (optional) (default to False)

    try:
        # hard reset branch
        api_instance.hard_reset_branch(repository, branch, ref, force=force)
    except Exception as e:
        print("Exception when calling ExperimentalApi->hard_reset_branch: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
ref	str	After reset, branch will point at this reference.
force	bool		[optional] [default to False]

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	reset successful	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

jwt_login¶

AuthenticationToken jwt_login(jwt_login_information)

exchange an external IdP JWT for a lakeFS session token

Example¶

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.authentication_token import AuthenticationToken
from lakefs_enterprise_sdk.models.jwt_login_information import JWTLoginInformation
from lakefs_enterprise_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_enterprise_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    jwt_login_information = lakefs_enterprise_sdk.JWTLoginInformation() # JWTLoginInformation | 

    try:
        # exchange an external IdP JWT for a lakeFS session token
        api_response = api_instance.jwt_login(jwt_login_information)
        print("The response of ExperimentalApi->jwt_login:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->jwt_login: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
jwt_login_information	JWTLoginInformation

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 JWT login	-
400	Bad Request	-
401	Unauthorized	-
501	JWT login is not configured on this lakeFS instance	-
0	Internal Server Error	-

list_all_dataset_pull_requests¶

DatasetPullRequestList list_all_dataset_pull_requests(prefix=prefix, after=after, amount=amount, status=status, dataset=dataset)

global list of pull requests across datasets

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request_list import DatasetPullRequestList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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)
    status = 'all' # str |  (optional) (default to 'all')
    dataset = 'dataset_example' # str | optional dataset-name filter (optional)

    try:
        # global list of pull requests across datasets
        api_response = api_instance.list_all_dataset_pull_requests(prefix=prefix, after=after, amount=amount, status=status, dataset=dataset)
        print("The response of ExperimentalApi->list_all_dataset_pull_requests:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_all_dataset_pull_requests: %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]
status	str		[optional] [default to 'all']
dataset	str	optional dataset-name filter	[optional]

Return type¶

DatasetPullRequestList

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	pull request list	-
401	Unauthorized	-
0	Internal Server Error	-

list_dataset_metadata_keys¶

DatasetMetadataKeyList list_dataset_metadata_keys(prefix=prefix, after=after, amount=amount)

list dataset metadata keys

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_metadata_key_list import DatasetMetadataKeyList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 dataset metadata keys
        api_response = api_instance.list_dataset_metadata_keys(prefix=prefix, after=after, amount=amount)
        print("The response of ExperimentalApi->list_dataset_metadata_keys:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_dataset_metadata_keys: %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¶

DatasetMetadataKeyList

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	dataset metadata key list	-
401	Unauthorized	-
0	Internal Server Error	-

list_dataset_pull_requests¶

DatasetPullRequestList list_dataset_pull_requests(dataset, prefix=prefix, after=after, amount=amount, status=status)

list a dataset's pull requests

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request_list import DatasetPullRequestList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_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)
    status = 'all' # str |  (optional) (default to 'all')

    try:
        # list a dataset's pull requests
        api_response = api_instance.list_dataset_pull_requests(dataset, prefix=prefix, after=after, amount=amount, status=status)
        print("The response of ExperimentalApi->list_dataset_pull_requests:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_dataset_pull_requests: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	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]
status	str		[optional] [default to 'all']

Return type¶

DatasetPullRequestList

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	pull request list	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

list_dataset_versions¶

DatasetVersionList list_dataset_versions(dataset, after=after, amount=amount)

list dataset versions, newest first

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_version_list import DatasetVersionList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    after = 'after_example' # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) (default to 100)

    try:
        # list dataset versions, newest first
        api_response = api_instance.list_dataset_versions(dataset, after=after, amount=amount)
        print("The response of ExperimentalApi->list_dataset_versions:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_dataset_versions: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] [default to 100]

Return type¶

DatasetVersionList

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	dataset version list	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

list_datasets¶

DatasetList list_datasets(prefix=prefix, after=after, amount=amount)

list datasets

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_list import DatasetList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 datasets
        api_response = api_instance.list_datasets(prefix=prefix, after=after, amount=amount)
        print("The response of ExperimentalApi->list_datasets:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_datasets: %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¶

DatasetList

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	dataset list	-
401	Unauthorized	-
0	Internal Server Error	-

list_pull_request_comments¶

PullRequestCommentList list_pull_request_comments(repository, pull_request, after=after, amount=amount)

list pull request comments

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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request_comment_list import PullRequestCommentList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    after = 'after_example' # str | return items after this value (optional)
    amount = 100 # int | how many items to return (optional) (default to 100)

    try:
        # list pull request comments
        api_response = api_instance.list_pull_request_comments(repository, pull_request, after=after, amount=amount)
        print("The response of ExperimentalApi->list_pull_request_comments:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_pull_request_comments: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
pull_request	str	pull request id
after	str	return items after this value	[optional]
amount	int	how many items to return	[optional] [default to 100]

Return type¶

PullRequestCommentList

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	list of pull request comments	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

list_pull_requests¶

PullRequestsList list_pull_requests(repository, prefix=prefix, after=after, amount=amount, status=status)

list pull requests

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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_requests_list import PullRequestsList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_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)
    status = 'all' # str |  (optional) (default to 'all')

    try:
        # list pull requests
        api_response = api_instance.list_pull_requests(repository, prefix=prefix, after=after, amount=amount, status=status)
        print("The response of ExperimentalApi->list_pull_requests:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_pull_requests: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	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]
status	str		[optional] [default to 'all']

Return type¶

PullRequestsList

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	list of pull requests	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

list_tenant_groups¶

GroupList list_tenant_groups(tenant_name, prefix=prefix, after=after, amount=amount)

list groups attached to tenant

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_enterprise_sdk
from lakefs_enterprise_sdk.models.group_list import GroupList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    tenant_name = 'tenant_name_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 groups attached to tenant
        api_response = api_instance.list_tenant_groups(tenant_name, prefix=prefix, after=after, amount=amount)
        print("The response of ExperimentalApi->list_tenant_groups:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_tenant_groups: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	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	tenant group list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

list_tenant_users¶

UserList list_tenant_users(tenant_name, prefix=prefix, after=after, amount=amount)

list users attached to tenant

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_enterprise_sdk
from lakefs_enterprise_sdk.models.user_list import UserList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    tenant_name = 'tenant_name_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 users attached to tenant
        api_response = api_instance.list_tenant_users(tenant_name, prefix=prefix, after=after, amount=amount)
        print("The response of ExperimentalApi->list_tenant_users:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_tenant_users: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	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	tenant user list	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

list_tenants¶

TenantList list_tenants(prefix=prefix, after=after, amount=amount)

list tenants

The reserved root tenant is implicit and never included in the listing.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.tenant_list import TenantList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 tenants
        api_response = api_instance.list_tenants(prefix=prefix, after=after, amount=amount)
        print("The response of ExperimentalApi->list_tenants:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_tenants: %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¶

TenantList

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	tenant list	-
400	Bad Request	-
401	Unauthorized	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_sdk.models.external_principal_list import ExternalPrincipalList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 ExperimentalApi->list_user_external_principals:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->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	-

list_user_tenants¶

TenantList list_user_tenants(prefix=prefix, after=after, amount=amount)

list the tenants the current user is a member of

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_enterprise_sdk
from lakefs_enterprise_sdk.models.tenant_list import TenantList
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(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 the tenants the current user is a member of
        api_response = api_instance.list_user_tenants(prefix=prefix, after=after, amount=amount)
        print("The response of ExperimentalApi->list_user_tenants:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->list_user_tenants: %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¶

TenantList

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	tenant list	-
400	Bad Request	-
401	Unauthorized	-
429	too many requests	-
0	Internal Server Error	-

merge_dataset_pull_request¶

DatasetPullRequestMergeResult merge_dataset_pull_request(dataset, pull_request)

merge a pull request, publishing the next dataset version

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request_merge_result import DatasetPullRequestMergeResult
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    pull_request = 'pull_request_example' # str | 

    try:
        # merge a pull request, publishing the next dataset version
        api_response = api_instance.merge_dataset_pull_request(dataset, pull_request)
        print("The response of ExperimentalApi->merge_dataset_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->merge_dataset_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
pull_request	str

Return type¶

DatasetPullRequestMergeResult

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	merged	-
401	Unauthorized	-
404	Resource Not Found	-
409	stale — latest advanced since the PR was opened	-
0	Internal Server Error	-

merge_into_branch_async¶

TaskCreation merge_into_branch_async(repository, source_ref, destination_branch, merge=merge)

merge references asynchronously

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_enterprise_sdk
from lakefs_enterprise_sdk.models.merge import Merge
from lakefs_enterprise_sdk.models.task_creation import TaskCreation
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    source_ref = 'source_ref_example' # str | source ref
    destination_branch = 'destination_branch_example' # str | destination branch name
    merge = lakefs_enterprise_sdk.Merge() # Merge |  (optional)

    try:
        # merge references asynchronously
        api_response = api_instance.merge_into_branch_async(repository, source_ref, destination_branch, merge=merge)
        print("The response of ExperimentalApi->merge_into_branch_async:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->merge_into_branch_async: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
source_ref	str	source ref
destination_branch	str	destination branch name
merge	Merge		[optional]

Return type¶

TaskCreation

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
202	merge task started	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

merge_into_branch_async_status¶

MergeAsyncStatus merge_into_branch_async_status(repository, source_ref, destination_branch, id)

get status of async merge operation

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_enterprise_sdk
from lakefs_enterprise_sdk.models.merge_async_status import MergeAsyncStatus
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    source_ref = 'source_ref_example' # str | source ref
    destination_branch = 'destination_branch_example' # str | destination branch name
    id = 'id_example' # str | Unique identifier of the merge async task

    try:
        # get status of async merge operation
        api_response = api_instance.merge_into_branch_async_status(repository, source_ref, destination_branch, id)
        print("The response of ExperimentalApi->merge_into_branch_async_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->merge_into_branch_async_status: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
source_ref	str	source ref
destination_branch	str	destination branch name
id	str	Unique identifier of the merge async task

Return type¶

MergeAsyncStatus

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	merge task status	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
412	Precondition Failed	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

merge_pull_request¶

MergeResult merge_pull_request(repository, pull_request, merge=merge)

merge pull request

Merge the pull request's source branch into its destination branch. When the repository's pull request settings enable delete_source_branch_on_merge, a successful merge also deletes the source branch unless it is the default branch, has uncommitted changes, or has moved since the merge.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.merge import Merge
from lakefs_enterprise_sdk.models.merge_result import MergeResult
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    merge = lakefs_enterprise_sdk.Merge() # Merge |  (optional)

    try:
        # merge pull request
        api_response = api_instance.merge_pull_request(repository, pull_request, merge=merge)
        print("The response of ExperimentalApi->merge_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->merge_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
pull_request	str	pull request id
merge	Merge		[optional]

Return type¶

MergeResult

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	merge completed	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
409	Conflict Deprecated: content schema will return Error format and not an empty MergeResult	-
412	precondition failed	-
429	too many requests	-
0	Internal Server Error	-

open_dataset_pull_request¶

DatasetPullRequest open_dataset_pull_request(dataset, dataset_pull_request_creation)

open a pull request proposing a dataset definition change

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request import DatasetPullRequest
from lakefs_enterprise_sdk.models.dataset_pull_request_creation import DatasetPullRequestCreation
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    dataset_pull_request_creation = lakefs_enterprise_sdk.DatasetPullRequestCreation() # DatasetPullRequestCreation | 

    try:
        # open a pull request proposing a dataset definition change
        api_response = api_instance.open_dataset_pull_request(dataset, dataset_pull_request_creation)
        print("The response of ExperimentalApi->open_dataset_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->open_dataset_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
dataset_pull_request_creation	DatasetPullRequestCreation

Return type¶

DatasetPullRequest

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	pull request	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

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_enterprise_sdk
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

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

run_mds_query¶

MDSQueryResponse run_mds_query(mds_query_request)

run a metadata search query

Runs a read-only SQL query over object_metadata tables, each belonging to one repository and ref. Requires fs:QueryMetadata on every repository referenced; the result is read from result_url rather than returned inline.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.mds_query_request import MDSQueryRequest
from lakefs_enterprise_sdk.models.mds_query_response import MDSQueryResponse
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    mds_query_request = lakefs_enterprise_sdk.MDSQueryRequest() # MDSQueryRequest | 

    try:
        # run a metadata search query
        api_response = api_instance.run_mds_query(mds_query_request)
        print("The response of ExperimentalApi->run_mds_query:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->run_mds_query: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
mds_query_request	MDSQueryRequest

Return type¶

MDSQueryResponse

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	Object store location for metadata search query results	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

set_object_lifecycle_rules¶

set_object_lifecycle_rules(repository, object_lifecycle_rules, if_match=if_match)

replace all object lifecycle rules for this repository

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_enterprise_sdk
from lakefs_enterprise_sdk.models.object_lifecycle_rules import ObjectLifecycleRules
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    object_lifecycle_rules = lakefs_enterprise_sdk.ObjectLifecycleRules() # ObjectLifecycleRules | 
    if_match = 'if_match_example' # str | if provided, the rules will be updated only if the current ETag matches the provided value (optional)

    try:
        # replace all object lifecycle rules for this repository
        api_instance.set_object_lifecycle_rules(repository, object_lifecycle_rules, if_match=if_match)
    except Exception as e:
        print("Exception when calling ExperimentalApi->set_object_lifecycle_rules: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
object_lifecycle_rules	ObjectLifecycleRules
if_match	str	if provided, the rules will be updated only if the current ETag matches the provided value	[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
204	rules updated	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
412	Precondition Failed	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

sts_login¶

AuthenticationToken sts_login(sts_auth_request)

perform a login with STS

Example¶

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.authentication_token import AuthenticationToken
from lakefs_enterprise_sdk.models.sts_auth_request import StsAuthRequest
from lakefs_enterprise_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_enterprise_sdk.Configuration(
    host = "/api/v1"
)


# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    sts_auth_request = lakefs_enterprise_sdk.StsAuthRequest() # StsAuthRequest | 

    try:
        # perform a login with STS
        api_response = api_instance.sts_login(sts_auth_request)
        print("The response of ExperimentalApi->sts_login:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->sts_login: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
sts_auth_request	StsAuthRequest

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 STS login	-
400	Bad Request	-
401	Unauthorized	-
429	too many requests	-
0	Internal Server Error	-

update_dataset¶

Dataset update_dataset(dataset, dataset_update)

update a dataset, publishing a new version

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset import Dataset
from lakefs_enterprise_sdk.models.dataset_update import DatasetUpdate
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    dataset_update = lakefs_enterprise_sdk.DatasetUpdate() # DatasetUpdate | 

    try:
        # update a dataset, publishing a new version
        api_response = api_instance.update_dataset(dataset, dataset_update)
        print("The response of ExperimentalApi->update_dataset:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_dataset: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
dataset_update	DatasetUpdate

Return type¶

Dataset

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	dataset	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
0	Internal Server Error	-

update_dataset_metadata_key¶

DatasetMetadataKey update_dataset_metadata_key(key, dataset_metadata_key_update)

update a dataset metadata key

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_metadata_key import DatasetMetadataKey
from lakefs_enterprise_sdk.models.dataset_metadata_key_update import DatasetMetadataKeyUpdate
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    key = 'key_example' # str | 
    dataset_metadata_key_update = lakefs_enterprise_sdk.DatasetMetadataKeyUpdate() # DatasetMetadataKeyUpdate | 

    try:
        # update a dataset metadata key
        api_response = api_instance.update_dataset_metadata_key(key, dataset_metadata_key_update)
        print("The response of ExperimentalApi->update_dataset_metadata_key:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_dataset_metadata_key: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
key	str
dataset_metadata_key_update	DatasetMetadataKeyUpdate

Return type¶

DatasetMetadataKey

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	dataset metadata key	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

update_dataset_pull_request¶

DatasetPullRequest update_dataset_pull_request(dataset, pull_request, dataset_pull_request_update)

re-author a pull request (title, description, and/or proposed definition)

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_enterprise_sdk
from lakefs_enterprise_sdk.models.dataset_pull_request import DatasetPullRequest
from lakefs_enterprise_sdk.models.dataset_pull_request_update import DatasetPullRequestUpdate
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    dataset = 'dataset_example' # str | 
    pull_request = 'pull_request_example' # str | 
    dataset_pull_request_update = lakefs_enterprise_sdk.DatasetPullRequestUpdate() # DatasetPullRequestUpdate | 

    try:
        # re-author a pull request (title, description, and/or proposed definition)
        api_response = api_instance.update_dataset_pull_request(dataset, pull_request, dataset_pull_request_update)
        print("The response of ExperimentalApi->update_dataset_pull_request:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_dataset_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
dataset	str
pull_request	str
dataset_pull_request_update	DatasetPullRequestUpdate

Return type¶

DatasetPullRequest

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	pull request	-
400	Validation Error	-
401	Unauthorized	-
404	Resource Not Found	-
0	Internal Server Error	-

update_object_user_metadata¶

update_object_user_metadata(repository, branch, path, update_object_user_metadata)

rewrite (all) object metadata

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_enterprise_sdk
from lakefs_enterprise_sdk.models.update_object_user_metadata import UpdateObjectUserMetadata
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | branch to update
    path = 'path_example' # str | path to object relative to the branch
    update_object_user_metadata = lakefs_enterprise_sdk.UpdateObjectUserMetadata() # UpdateObjectUserMetadata | 

    try:
        # rewrite (all) object metadata
        api_instance.update_object_user_metadata(repository, branch, path, update_object_user_metadata)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_object_user_metadata: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
branch	str	branch to update
path	str	path to object relative to the branch
update_object_user_metadata	UpdateObjectUserMetadata

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	User metadata updated	-
401	Unauthorized	-
404	Resource Not Found	-
400	Bad Request	-
429	too many requests	-
0	Internal Server Error	-

update_pull_request¶

update_pull_request(repository, pull_request, pull_request_basic)

update pull 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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request_basic import PullRequestBasic
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    pull_request_basic = lakefs_enterprise_sdk.PullRequestBasic() # PullRequestBasic | 

    try:
        # update pull request
        api_instance.update_pull_request(repository, pull_request, pull_request_basic)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_pull_request: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
pull_request	str	pull request id
pull_request_basic	PullRequestBasic

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
200	pull request updated successfully	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

update_pull_request_comment¶

update_pull_request_comment(repository, pull_request, comment, pull_request_comment_update)

update pull request comment

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_enterprise_sdk
from lakefs_enterprise_sdk.models.pull_request_comment_update import PullRequestCommentUpdate
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    pull_request = 'pull_request_example' # str | pull request id
    comment = 'comment_example' # str | pull request comment id
    pull_request_comment_update = lakefs_enterprise_sdk.PullRequestCommentUpdate() # PullRequestCommentUpdate | 

    try:
        # update pull request comment
        api_instance.update_pull_request_comment(repository, pull_request, comment, pull_request_comment_update)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_pull_request_comment: %s\n" % e)

Parameters¶

Name	Type	Description
repository	str
pull_request	str	pull request id
comment	str	pull request comment id
pull_request_comment_update	PullRequestCommentUpdate

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
204	pull request comment updated successfully	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

update_tenant¶

Tenant update_tenant(tenant_name, tenant_update)

update tenant description

The root tenant is reserved by the system and cannot be updated.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.tenant import Tenant
from lakefs_enterprise_sdk.models.tenant_update import TenantUpdate
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    tenant_name = 'tenant_name_example' # str | the tenant's unique name
    tenant_update = lakefs_enterprise_sdk.TenantUpdate() # TenantUpdate | 

    try:
        # update tenant description
        api_response = api_instance.update_tenant(tenant_name, tenant_update)
        print("The response of ExperimentalApi->update_tenant:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->update_tenant: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
tenant_name	str	the tenant's unique name
tenant_update	TenantUpdate

Return type¶

Tenant

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	tenant	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

upload_part¶

UploadTo upload_part(repository, branch, upload_id, path, part_number, upload_part_from)

Return a presigned URL to upload into a presigned multipart upload.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.upload_part_from import UploadPartFrom
from lakefs_enterprise_sdk.models.upload_to import UploadTo
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    upload_id = 'upload_id_example' # str | 
    path = 'path_example' # str | 
    part_number = 56 # int | 
    upload_part_from = lakefs_enterprise_sdk.UploadPartFrom() # UploadPartFrom | 

    try:
        api_response = api_instance.upload_part(repository, branch, upload_id, path, part_number, upload_part_from)
        print("The response of ExperimentalApi->upload_part:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ExperimentalApi->upload_part: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str
part_number	int
upload_part_from	UploadPartFrom

Return type¶

UploadTo

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	presigned URL to use for upload	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

upload_part_copy¶

upload_part_copy(repository, branch, upload_id, path, part_number, upload_part_copy_from)

Upload a part by copying part of another object.

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_enterprise_sdk
from lakefs_enterprise_sdk.models.upload_part_copy_from import UploadPartCopyFrom
from lakefs_enterprise_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_enterprise_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_enterprise_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_enterprise_sdk.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lakefs_enterprise_sdk.ExperimentalApi(api_client)
    repository = 'repository_example' # str | 
    branch = 'branch_example' # str | 
    upload_id = 'upload_id_example' # str | 
    path = 'path_example' # str | 
    part_number = 56 # int | 
    upload_part_copy_from = lakefs_enterprise_sdk.UploadPartCopyFrom() # UploadPartCopyFrom | 

    try:
        api_instance.upload_part_copy(repository, branch, upload_id, path, part_number, upload_part_copy_from)
    except Exception as e:
        print("Exception when calling ExperimentalApi->upload_part_copy: %s\n" % e)

Parameters¶

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str
part_number	int
upload_part_copy_from	UploadPartCopyFrom

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
204	part copied	* ETag -
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-