lakefs_enterprise_sdk.InternalApi

All URIs are relative to /api/v1

Method	HTTP request	Description
create_branch_protection_rule_preflight	GET /repositories/{repository}/branch_protection/set_allowed
create_commit_record	POST /repositories/{repository}/commits	create commit record
create_symlink_file	POST /repositories/{repository}/refs/{branch}/symlink	creates symlink files corresponding to the given directory
delete_repository_metadata	DELETE /repositories/{repository}/metadata	delete repository metadata
dump_refs	PUT /repositories/{repository}/refs/dump	Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations
get_auth_capabilities	GET /auth/capabilities	list authentication capabilities supported
get_garbage_collection_config	GET /config/garbage-collection
get_lake_fs_version	GET /config/version
get_metadata_object	GET /repositories/{repository}/metadata/object/{type}/{object_id}	return a lakeFS metadata object by ID
get_setup_state	GET /setup_lakefs	check if the lakeFS installation is already set up
get_storage_config	GET /config/storage
get_usage_report_summary	GET /usage-report/summary	get usage report summary
internal_create_branch_protection_rule	POST /repositories/{repository}/branch_protection
internal_delete_branch_protection_rule	DELETE /repositories/{repository}/branch_protection
internal_delete_garbage_collection_rules	DELETE /repositories/{repository}/gc/rules
internal_get_branch_protection_rules	GET /repositories/{repository}/branch_protection	get branch protection rules
internal_get_garbage_collection_rules	GET /repositories/{repository}/gc/rules
internal_set_garbage_collection_rules	POST /repositories/{repository}/gc/rules
post_stats_events	POST /statistics	post stats events, this endpoint is meant for internal use only
prepare_garbage_collection_commits	POST /repositories/{repository}/gc/prepare_commits	save lists of active commits for garbage collection
prepare_garbage_collection_commits_async	POST /repositories/{repository}/gc/prepare_commits/async	prepare gc commits
prepare_garbage_collection_commits_status	GET /repositories/{repository}/gc/prepare_commits/status	get status of prepare gc commits operation
prepare_garbage_collection_uncommitted	POST /repositories/{repository}/gc/prepare_uncommited	save repository uncommitted metadata for garbage collection
restore_refs	PUT /repositories/{repository}/refs/restore	Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations
set_branch_lifecycle_policies_preflight	GET /repositories/{repository}/settings/branch_lifecycle/set_allowed
set_garbage_collection_rules_preflight	GET /repositories/{repository}/gc/rules/set_allowed
set_repository_metadata	POST /repositories/{repository}/metadata	set repository metadata
setup	POST /setup_lakefs	setup lakeFS and create a first user
setup_comm_prefs	POST /setup_comm_prefs	setup communications preferences
stage_object	PUT /repositories/{repository}/branches/{branch}/objects	stage an object's metadata for the given branch
upload_object_preflight	GET /repositories/{repository}/branches/{branch}/objects/stage_allowed

create_branch_protection_rule_preflight

create_branch_protection_rule_preflight(repository)

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.rest import ApiException
  from pprint import pprint
  
  # Defining the host is optional and defaults to /api/v1
  # See configuration.py for a list of all supported configuration parameters.
  configuration = lakefs_enterprise_sdk.Configuration(
      host = "/api/v1"
  )
  
  # The client must configure the authentication and authorization parameters
  # in accordance with the API server security policy.
  # Examples for each auth method are provided below, use the example that
  # satisfies your auth use case.
  
  # Configure HTTP basic authorization: basic_auth
  configuration = lakefs_enterprise_sdk.Configuration(
      username = os.environ["USERNAME"],
      password = os.environ["PASSWORD"]
  )
  
  # Configure API key authorization: cookie_auth
  configuration.api_key['cookie_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['cookie_auth'] = 'Bearer'
  
  # Configure API key authorization: oidc_auth
  configuration.api_key['oidc_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['oidc_auth'] = 'Bearer'
  
  # Configure API key authorization: saml_auth
  configuration.api_key['saml_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['saml_auth'] = 'Bearer'
  
  # Configure Bearer authorization (JWT): jwt_token
  configuration = lakefs_enterprise_sdk.Configuration(
      access_token = os.environ["BEARER_TOKEN"]
  )
  
  # Enter a context with an instance of the API client
  with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
      # Create an instance of the API class
      api_instance = lakefs_enterprise_sdk.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          api_instance.create_branch_protection_rule_preflight(repository)
      except Exception as e:
          print("Exception when calling InternalApi->create_branch_protection_rule_preflight: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	User has permissions to create a branch protection rule in this repository	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
409	Resource Conflicts With Target	-
429	too many requests	-
0	Internal Server Error	-

create_commit_record

create_commit_record(repository, commit_record_creation)

create commit record

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_record_creation import CommitRecordCreation
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      commit_record_creation = lakefs_enterprise_sdk.CommitRecordCreation() # CommitRecordCreation | 
  
      try:
          # create commit record
          api_instance.create_commit_record(repository, commit_record_creation)
      except Exception as e:
          print("Exception when calling InternalApi->create_commit_record: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
commit_record_creation	CommitRecordCreation

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

create_symlink_file

StorageURI create_symlink_file(repository, branch, location=location)

creates symlink files corresponding to the given directory

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.storage_uri import StorageURI
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      location = 'location_example' # str | path to the table data (optional)
  
      try:
          # creates symlink files corresponding to the given directory
          api_response = api_instance.create_symlink_file(repository, branch, location=location)
          print("The response of InternalApi->create_symlink_file:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->create_symlink_file: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
location	str	path to the table data	[optional]

Return type

StorageURI

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

delete_repository_metadata

delete_repository_metadata(repository, repository_metadata_keys)

delete repository metadata

Delete specified keys from the repository's 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.repository_metadata_keys import RepositoryMetadataKeys
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      repository_metadata_keys = lakefs_enterprise_sdk.RepositoryMetadataKeys() # RepositoryMetadataKeys | 
  
      try:
          # delete repository metadata
          api_instance.delete_repository_metadata(repository, repository_metadata_keys)
      except Exception as e:
          print("Exception when calling InternalApi->delete_repository_metadata: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
repository_metadata_keys	RepositoryMetadataKeys

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	repository metadata keys deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
429	too many requests	-
0	Internal Server Error	-

dump_refs

RefsDump dump_refs(repository)

Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations

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.refs_dump import RefsDump
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          # Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations 
          api_response = api_instance.dump_refs(repository)
          print("The response of InternalApi->dump_refs:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->dump_refs: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

RefsDump

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

get_auth_capabilities

AuthCapabilities get_auth_capabilities()

list authentication capabilities supported

Example

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.auth_capabilities import AuthCapabilities
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.InternalApi(api_client)

    try:
        # list authentication capabilities supported
        api_response = api_instance.get_auth_capabilities()
        print("The response of InternalApi->get_auth_capabilities:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling InternalApi->get_auth_capabilities: %s\n" % e)

Parameters

This endpoint does not need any parameter.

Return type

AuthCapabilities

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	auth capabilities	-
429	too many requests	-
0	Internal Server Error	-

get_garbage_collection_config

GarbageCollectionConfig get_garbage_collection_config()

get information of gc settings

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.garbage_collection_config import GarbageCollectionConfig
  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.InternalApi(api_client)
  
      try:
          api_response = api_instance.get_garbage_collection_config()
          print("The response of InternalApi->get_garbage_collection_config:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->get_garbage_collection_config: %s\n" % e)
  

Parameters

This endpoint does not need any parameter.

Return type

GarbageCollectionConfig

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 garbage collection config	-
401	Unauthorized	-

get_lake_fs_version

VersionConfig get_lake_fs_version()

get version of lakeFS server

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.version_config import VersionConfig
  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.InternalApi(api_client)
  
      try:
          api_response = api_instance.get_lake_fs_version()
          print("The response of InternalApi->get_lake_fs_version:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->get_lake_fs_version: %s\n" % e)
  

Parameters

This endpoint does not need any parameter.

Return type

VersionConfig

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 version	-
401	Unauthorized	-

get_metadata_object

bytearray get_metadata_object(repository, object_id, type, presign=presign)

return a lakeFS metadata object 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.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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      object_id = 'object_id_example' # str | 
      type = 'type_example' # str | 
      presign = True # bool |  (optional)
  
      try:
          # return a lakeFS metadata object by ID
          api_response = api_instance.get_metadata_object(repository, object_id, type, presign=presign)
          print("The response of InternalApi->get_metadata_object:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->get_metadata_object: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
object_id	str
type	str
presign	bool		[optional]

Return type

bytearray

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

• Content-Type: Not defined
• Accept: application/octet-stream, application/json

HTTP response details

Status code	Description	Response headers
200	object content	* Content-Length -
302	Redirect to a pre-signed URL for the object	* Location - redirect to S3
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

get_setup_state

SetupState get_setup_state()

check if the lakeFS installation is already set up

Example

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.setup_state import SetupState
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.InternalApi(api_client)

    try:
        # check if the lakeFS installation is already set up
        api_response = api_instance.get_setup_state()
        print("The response of InternalApi->get_setup_state:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling InternalApi->get_setup_state: %s\n" % e)

Parameters

This endpoint does not need any parameter.

Return type

SetupState

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	lakeFS setup state	-
429	too many requests	-
0	Internal Server Error	-

get_storage_config

StorageConfig get_storage_config()

retrieve lakeFS storage configuration

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.storage_config import StorageConfig
  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.InternalApi(api_client)
  
      try:
          api_response = api_instance.get_storage_config()
          print("The response of InternalApi->get_storage_config:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->get_storage_config: %s\n" % e)
  

Parameters

This endpoint does not need any parameter.

Return type

StorageConfig

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 storage configuration	-
401	Unauthorized	-

get_usage_report_summary

InstallationUsageReport get_usage_report_summary()

get usage report summary

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.installation_usage_report import InstallationUsageReport
  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.InternalApi(api_client)
  
      try:
          # get usage report summary
          api_response = api_instance.get_usage_report_summary()
          print("The response of InternalApi->get_usage_report_summary:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->get_usage_report_summary: %s\n" % e)
  

Parameters

This endpoint does not need any parameter.

Return type

InstallationUsageReport

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

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

internal_create_branch_protection_rule

internal_create_branch_protection_rule(repository, branch_protection_rule)

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.branch_protection_rule import BranchProtectionRule
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      branch_protection_rule = lakefs_enterprise_sdk.BranchProtectionRule() # BranchProtectionRule | 
  
      try:
          api_instance.internal_create_branch_protection_rule(repository, branch_protection_rule)
      except Exception as e:
          print("Exception when calling InternalApi->internal_create_branch_protection_rule: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch_protection_rule	BranchProtectionRule

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	branch protection rule created successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

internal_delete_branch_protection_rule

internal_delete_branch_protection_rule(repository, internal_delete_branch_protection_rule_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.internal_delete_branch_protection_rule_request import InternalDeleteBranchProtectionRuleRequest
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      internal_delete_branch_protection_rule_request = lakefs_enterprise_sdk.InternalDeleteBranchProtectionRuleRequest() # InternalDeleteBranchProtectionRuleRequest | 
  
      try:
          api_instance.internal_delete_branch_protection_rule(repository, internal_delete_branch_protection_rule_request)
      except Exception as e:
          print("Exception when calling InternalApi->internal_delete_branch_protection_rule: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
internal_delete_branch_protection_rule_request	InternalDeleteBranchProtectionRuleRequest

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	branch protection rule deleted successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

internal_delete_garbage_collection_rules

internal_delete_garbage_collection_rules(repository)

Deprecated; use deleteGCRules.

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.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          api_instance.internal_delete_garbage_collection_rules(repository)
      except Exception as e:
          print("Exception when calling InternalApi->internal_delete_garbage_collection_rules: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	deleted garbage collection rules successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

internal_get_branch_protection_rules

List[BranchProtectionRule] internal_get_branch_protection_rules(repository)

get branch protection rules

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.branch_protection_rule import BranchProtectionRule
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          # get branch protection rules
          api_response = api_instance.internal_get_branch_protection_rules(repository)
          print("The response of InternalApi->internal_get_branch_protection_rules:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->internal_get_branch_protection_rules: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

List[BranchProtectionRule]

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

internal_get_garbage_collection_rules

GarbageCollectionRules internal_get_garbage_collection_rules(repository)

Deprecated; use getGCRules.

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.garbage_collection_rules import GarbageCollectionRules
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          api_response = api_instance.internal_get_garbage_collection_rules(repository)
          print("The response of InternalApi->internal_get_garbage_collection_rules:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->internal_get_garbage_collection_rules: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

GarbageCollectionRules

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

internal_set_garbage_collection_rules

internal_set_garbage_collection_rules(repository, garbage_collection_rules)

Deprecated; use setGCRules.

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.garbage_collection_rules import GarbageCollectionRules
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      garbage_collection_rules = lakefs_enterprise_sdk.GarbageCollectionRules() # GarbageCollectionRules | 
  
      try:
          api_instance.internal_set_garbage_collection_rules(repository, garbage_collection_rules)
      except Exception as e:
          print("Exception when calling InternalApi->internal_set_garbage_collection_rules: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
garbage_collection_rules	GarbageCollectionRules

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	set garbage collection rules successfully	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

post_stats_events

post_stats_events(stats_events_list)

post stats events, this endpoint is meant for internal use only

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.stats_events_list import StatsEventsList
  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.InternalApi(api_client)
      stats_events_list = lakefs_enterprise_sdk.StatsEventsList() # StatsEventsList | 
  
      try:
          # post stats events, this endpoint is meant for internal use only
          api_instance.post_stats_events(stats_events_list)
      except Exception as e:
          print("Exception when calling InternalApi->post_stats_events: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
stats_events_list	StatsEventsList

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

prepare_garbage_collection_commits

GarbageCollectionPrepareResponse prepare_garbage_collection_commits(repository)

save lists of active commits for garbage collection

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.garbage_collection_prepare_response import GarbageCollectionPrepareResponse
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          # save lists of active commits for garbage collection
          api_response = api_instance.prepare_garbage_collection_commits(repository)
          print("The response of InternalApi->prepare_garbage_collection_commits:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->prepare_garbage_collection_commits: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

GarbageCollectionPrepareResponse

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

prepare_garbage_collection_commits_async

TaskCreation prepare_garbage_collection_commits_async(repository)

prepare gc commits

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.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.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          # prepare gc commits
          api_response = api_instance.prepare_garbage_collection_commits_async(repository)
          print("The response of InternalApi->prepare_garbage_collection_commits_async:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->prepare_garbage_collection_commits_async: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

TaskCreation

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

prepare_garbage_collection_commits_status

PrepareGarbageCollectionCommitsStatus prepare_garbage_collection_commits_status(repository, id)

get status of prepare gc commits 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.prepare_garbage_collection_commits_status import PrepareGarbageCollectionCommitsStatus
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      id = 'id_example' # str | Unique identifier of the prepare GC commits task
  
      try:
          # get status of prepare gc commits operation
          api_response = api_instance.prepare_garbage_collection_commits_status(repository, id)
          print("The response of InternalApi->prepare_garbage_collection_commits_status:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->prepare_garbage_collection_commits_status: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
id	str	Unique identifier of the prepare GC commits task

Return type

PrepareGarbageCollectionCommitsStatus

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	prepare GC commits task status	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

prepare_garbage_collection_uncommitted

PrepareGCUncommittedResponse prepare_garbage_collection_uncommitted(repository, prepare_gc_uncommitted_request=prepare_gc_uncommitted_request)

save repository uncommitted metadata for garbage collection

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.prepare_gc_uncommitted_request import PrepareGCUncommittedRequest
  from lakefs_enterprise_sdk.models.prepare_gc_uncommitted_response import PrepareGCUncommittedResponse
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      prepare_gc_uncommitted_request = lakefs_enterprise_sdk.PrepareGCUncommittedRequest() # PrepareGCUncommittedRequest |  (optional)
  
      try:
          # save repository uncommitted metadata for garbage collection
          api_response = api_instance.prepare_garbage_collection_uncommitted(repository, prepare_gc_uncommitted_request=prepare_gc_uncommitted_request)
          print("The response of InternalApi->prepare_garbage_collection_uncommitted:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->prepare_garbage_collection_uncommitted: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
prepare_gc_uncommitted_request	PrepareGCUncommittedRequest		[optional]

Return type

PrepareGCUncommittedResponse

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	paths to commit dataset	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

restore_refs

restore_refs(repository, refs_restore)

Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations

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.refs_restore import RefsRestore
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      refs_restore = lakefs_enterprise_sdk.RefsRestore() # RefsRestore | 
  
      try:
          # Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations 
          api_instance.restore_refs(repository, refs_restore)
      except Exception as e:
          print("Exception when calling InternalApi->restore_refs: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
refs_restore	RefsRestore

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

set_branch_lifecycle_policies_preflight

set_branch_lifecycle_policies_preflight(repository)

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.rest import ApiException
  from pprint import pprint
  
  # Defining the host is optional and defaults to /api/v1
  # See configuration.py for a list of all supported configuration parameters.
  configuration = lakefs_enterprise_sdk.Configuration(
      host = "/api/v1"
  )
  
  # The client must configure the authentication and authorization parameters
  # in accordance with the API server security policy.
  # Examples for each auth method are provided below, use the example that
  # satisfies your auth use case.
  
  # Configure HTTP basic authorization: basic_auth
  configuration = lakefs_enterprise_sdk.Configuration(
      username = os.environ["USERNAME"],
      password = os.environ["PASSWORD"]
  )
  
  # Configure API key authorization: cookie_auth
  configuration.api_key['cookie_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['cookie_auth'] = 'Bearer'
  
  # Configure API key authorization: oidc_auth
  configuration.api_key['oidc_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['oidc_auth'] = 'Bearer'
  
  # Configure API key authorization: saml_auth
  configuration.api_key['saml_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['saml_auth'] = 'Bearer'
  
  # Configure Bearer authorization (JWT): jwt_token
  configuration = lakefs_enterprise_sdk.Configuration(
      access_token = os.environ["BEARER_TOKEN"]
  )
  
  # Enter a context with an instance of the API client
  with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
      # Create an instance of the API class
      api_instance = lakefs_enterprise_sdk.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          api_instance.set_branch_lifecycle_policies_preflight(repository)
      except Exception as e:
          print("Exception when calling InternalApi->set_branch_lifecycle_policies_preflight: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	User has permissions to set branch lifecycle policies in this repository	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

set_garbage_collection_rules_preflight

set_garbage_collection_rules_preflight(repository)

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.rest import ApiException
  from pprint import pprint
  
  # Defining the host is optional and defaults to /api/v1
  # See configuration.py for a list of all supported configuration parameters.
  configuration = lakefs_enterprise_sdk.Configuration(
      host = "/api/v1"
  )
  
  # The client must configure the authentication and authorization parameters
  # in accordance with the API server security policy.
  # Examples for each auth method are provided below, use the example that
  # satisfies your auth use case.
  
  # Configure HTTP basic authorization: basic_auth
  configuration = lakefs_enterprise_sdk.Configuration(
      username = os.environ["USERNAME"],
      password = os.environ["PASSWORD"]
  )
  
  # Configure API key authorization: cookie_auth
  configuration.api_key['cookie_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['cookie_auth'] = 'Bearer'
  
  # Configure API key authorization: oidc_auth
  configuration.api_key['oidc_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['oidc_auth'] = 'Bearer'
  
  # Configure API key authorization: saml_auth
  configuration.api_key['saml_auth'] = os.environ["API_KEY"]
  
  # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
  # configuration.api_key_prefix['saml_auth'] = 'Bearer'
  
  # Configure Bearer authorization (JWT): jwt_token
  configuration = lakefs_enterprise_sdk.Configuration(
      access_token = os.environ["BEARER_TOKEN"]
  )
  
  # Enter a context with an instance of the API client
  with lakefs_enterprise_sdk.ApiClient(configuration) as api_client:
      # Create an instance of the API class
      api_instance = lakefs_enterprise_sdk.InternalApi(api_client)
      repository = 'repository_example' # str | 
  
      try:
          api_instance.set_garbage_collection_rules_preflight(repository)
      except Exception as e:
          print("Exception when calling InternalApi->set_garbage_collection_rules_preflight: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	User has permissions to set garbage collection rules on this repository	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

set_repository_metadata

set_repository_metadata(repository, repository_metadata_set)

set repository metadata

Set repository metadata. This will only add or update the provided keys, and will not remove any existing 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.repository_metadata_set import RepositoryMetadataSet
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      repository_metadata_set = lakefs_enterprise_sdk.RepositoryMetadataSet() # RepositoryMetadataSet | 
  
      try:
          # set repository metadata
          api_instance.set_repository_metadata(repository, repository_metadata_set)
      except Exception as e:
          print("Exception when calling InternalApi->set_repository_metadata: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
repository_metadata_set	RepositoryMetadataSet

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

setup

CredentialsWithSecret setup(setup)

setup lakeFS and create a first user

Example

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.credentials_with_secret import CredentialsWithSecret
from lakefs_enterprise_sdk.models.setup import Setup
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.InternalApi(api_client)
    setup = lakefs_enterprise_sdk.Setup() # Setup | 

    try:
        # setup lakeFS and create a first user
        api_response = api_instance.setup(setup)
        print("The response of InternalApi->setup:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling InternalApi->setup: %s\n" % e)

Parameters

Name	Type	Description	Notes
setup	Setup

Return type

CredentialsWithSecret

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	user created successfully	-
400	Bad Request	-
409	setup was already called	-
429	too many requests	-
0	Internal Server Error	-

setup_comm_prefs

setup_comm_prefs(comm_prefs_input)

setup communications preferences

Example

import time
import os
import lakefs_enterprise_sdk
from lakefs_enterprise_sdk.models.comm_prefs_input import CommPrefsInput
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.InternalApi(api_client)
    comm_prefs_input = lakefs_enterprise_sdk.CommPrefsInput() # CommPrefsInput | 

    try:
        # setup communications preferences
        api_instance.setup_comm_prefs(comm_prefs_input)
    except Exception as e:
        print("Exception when calling InternalApi->setup_comm_prefs: %s\n" % e)

Parameters

Name	Type	Description	Notes
comm_prefs_input	CommPrefsInput

Return type

void (empty response body)

Authorization

No authorization required

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	communication preferences saved successfully	-
400	Bad Request	-
409	setup was already completed	-
412	wrong setup state for this operation	-
429	too many requests	-
0	Internal Server Error	-

stage_object

ObjectStats stage_object(repository, branch, path, object_stage_creation)

stage an object's metadata for the given branch

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.object_stage_creation import ObjectStageCreation
  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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      path = 'path_example' # str | relative to the branch
      object_stage_creation = lakefs_enterprise_sdk.ObjectStageCreation() # ObjectStageCreation | 
  
      try:
          # stage an object's metadata for the given branch
          api_response = api_instance.stage_object(repository, branch, path, object_stage_creation)
          print("The response of InternalApi->stage_object:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling InternalApi->stage_object: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
path	str	relative to the branch
object_stage_creation	ObjectStageCreation

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
201	object metadata	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

upload_object_preflight

upload_object_preflight(repository, branch, path)

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.InternalApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      path = 'path_example' # str | relative to the branch
  
      try:
          api_instance.upload_object_preflight(repository, branch, path)
      except Exception as e:
          print("Exception when calling InternalApi->upload_object_preflight: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
path	str	relative to the branch

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	User has permissions to upload this object. This does not guarantee that the upload will be successful or even possible. It indicates only the permission at the time of calling this endpoint	-
400	Bad Request	-
401	Unauthorized	-
403	Forbidden	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-