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
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_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_pull_request_comment	DELETE /repositories/{repository}/pulls/{pull_request}/comments/{comment}	delete pull request comment
delete_user_external_principal	DELETE /auth/users/{userId}/external/principals	delete external principal from user
diff_dataset	GET /datasets/{dataset}/refs/{leftRef}/diff/{rightRef}	structured diff of a dataset definition between two refs
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_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_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_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_dataset_metadata_keys	GET /datasets/metadata	list dataset metadata keys
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_user_external_principals	GET /auth/users/{userId}/external/principals/ls	list user external policies attached to a user
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
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.
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_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
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	-

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_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_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_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	-

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	-

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_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_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_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_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_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_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	-

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 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.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

    try:
        # merge pull request
        api_response = api_instance.merge_pull_request(repository, pull_request)
        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

Return type¶

MergeResult

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

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	-

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_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	-

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	-