lakefs_enterprise_sdk.StagingApi

All URIs are relative to /api/v1

Method	HTTP request	Description
abort_presign_multipart_upload	DELETE /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}	Abort a presign multipart upload
complete_presign_multipart_upload	PUT /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}	Complete a presign multipart upload request
create_presign_multipart_upload	POST /repositories/{repository}/branches/{branch}/staging/pmpu	Initiate a multipart upload
get_physical_address	GET /repositories/{repository}/branches/{branch}/staging/backing	generate an address to which the client can upload an object
link_physical_address	PUT /repositories/{repository}/branches/{branch}/staging/backing	associate staging on this physical address with a path
presign_multipart_abort_request	POST /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/abort_request	Sign a multipart upload abort request
presign_multipart_complete_request	POST /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/complete_request	Sign a multipart upload completion request
presign_multipart_copy_part_request	POST /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/parts/{partNumber}/copy_request	Sign a multipart upload part copy request
presign_multipart_create_request	POST /repositories/{repository}/branches/{branch}/staging/pmpu/create_request	Sign a multipart upload create request
presign_multipart_prepare_request	POST /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/prepare_request	Sign the part, complete and abort requests of a multipart upload
upload_part	PUT /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/parts/{partNumber}
upload_part_copy	PUT /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId}/parts/{partNumber}/copy

abort_presign_multipart_upload

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

Abort a presign multipart upload

Aborts a presign multipart upload.

Example

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

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

Parameters

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str	relative to the branch
abort_presign_multipart_upload	AbortPresignMultipartUpload		[optional]

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	Presign multipart upload aborted	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

complete_presign_multipart_upload

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

Complete a presign multipart upload request

Completes a presign multipart upload by assembling the uploaded parts.

Example

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

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

Parameters

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

Return type

ObjectStats

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	Presign multipart upload completed	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
409	conflict with a commit, try here	-
429	too many requests	-
0	Internal Server Error	-

create_presign_multipart_upload

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

Initiate a multipart upload

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

Example

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

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

Parameters

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

Return type

PresignMultipartUpload

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
201	Presign multipart upload initiated	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

get_physical_address

StagingLocation get_physical_address(repository, branch, path, presign=presign)

generate an address to which the client can upload an object

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.staging_location import StagingLocation
  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.StagingApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      path = 'path_example' # str | relative to the branch
      presign = True # bool |  (optional)
  
      try:
          # generate an address to which the client can upload an object
          api_response = api_instance.get_physical_address(repository, branch, path, presign=presign)
          print("The response of StagingApi->get_physical_address:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling StagingApi->get_physical_address: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
path	str	relative to the branch
presign	bool		[optional]

Return type

StagingLocation

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	physical address for staging area	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

link_physical_address

ObjectStats link_physical_address(repository, branch, path, staging_metadata, if_none_match=if_none_match, if_match=if_match)

associate staging on this physical address with a path

Link the physical address with the path in lakeFS, creating an uncommitted change. An address under the repository's data prefix must be one getPhysicalAddress issued for this path, and is accepted with fs:WriteObject on the path. Any other address refers to data lakeFS did not write and is treated as an import: it additionally requires fs:ImportFromStorage on that address.

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_stats import ObjectStats
  from lakefs_enterprise_sdk.models.staging_metadata import StagingMetadata
  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.StagingApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      path = 'path_example' # str | relative to the branch
      staging_metadata = lakefs_enterprise_sdk.StagingMetadata() # StagingMetadata | 
      if_none_match = '*' # str | Set to \"*\" to atomically allow the upload only if the key has no object yet. Other values are not supported. (optional)
      if_match = '2e9ec317e197e02e4264d128c2e7e681' # str | Set to the object's ETag to atomically allow operations only if the object's current ETag matches the provided value. (optional)
  
      try:
          # associate staging on this physical address with a path
          api_response = api_instance.link_physical_address(repository, branch, path, staging_metadata, if_none_match=if_none_match, if_match=if_match)
          print("The response of StagingApi->link_physical_address:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling StagingApi->link_physical_address: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
path	str	relative to the branch
staging_metadata	StagingMetadata
if_none_match	str	Set to \"*\" to atomically allow the upload only if the key has no object yet. Other values are not supported.	[optional]
if_match	str	Set to the object's ETag to atomically allow operations only if the object's current ETag matches the provided value.	[optional]

Return type

ObjectStats

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	object metadata	-
400	Validation Error	-
401	Unauthorized	-
403	Forbidden	-
404	Internal Server Error	-
409	conflict with a commit, try here	-
412	Precondition Failed	-
429	too many requests	-
501	Not Implemented	-
0	Internal Server Error	-

presign_multipart_abort_request

PresignedURL presign_multipart_abort_request(repository, branch, upload_id, path, presign_multipart_input)

Sign a multipart upload abort request

Returns a presigned URL that aborts a multipart upload. The client DELETEs it; lakeFS does not.

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.presign_multipart_input import PresignMultipartInput
  from lakefs_enterprise_sdk.models.presigned_url import PresignedURL
  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.StagingApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      upload_id = 'upload_id_example' # str | 
      path = 'path_example' # str | relative to the branch
      presign_multipart_input = lakefs_enterprise_sdk.PresignMultipartInput() # PresignMultipartInput | 
  
      try:
          # Sign a multipart upload abort request
          api_response = api_instance.presign_multipart_abort_request(repository, branch, upload_id, path, presign_multipart_input)
          print("The response of StagingApi->presign_multipart_abort_request:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling StagingApi->presign_multipart_abort_request: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str	relative to the branch
presign_multipart_input	PresignMultipartInput

Return type

PresignedURL

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

presign_multipart_complete_request

PresignedURL presign_multipart_complete_request(repository, branch, upload_id, path, presign_multipart_input)

Sign a multipart upload completion request

Returns a presigned URL that completes a multipart upload. The client POSTs its own CompleteMultipartUpload body listing the parts and their ETags, then links the object using linkPhysicalAddress. The client sends the request; lakeFS does not.

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.presign_multipart_input import PresignMultipartInput
  from lakefs_enterprise_sdk.models.presigned_url import PresignedURL
  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.StagingApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      upload_id = 'upload_id_example' # str | 
      path = 'path_example' # str | relative to the branch
      presign_multipart_input = lakefs_enterprise_sdk.PresignMultipartInput() # PresignMultipartInput | 
  
      try:
          # Sign a multipart upload completion request
          api_response = api_instance.presign_multipart_complete_request(repository, branch, upload_id, path, presign_multipart_input)
          print("The response of StagingApi->presign_multipart_complete_request:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling StagingApi->presign_multipart_complete_request: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str	relative to the branch
presign_multipart_input	PresignMultipartInput

Return type

PresignedURL

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

presign_multipart_copy_part_request

PresignMultipartCopyPartResult presign_multipart_copy_part_request(repository, branch, upload_id, part_number, path, upload_part_copy_from)

Sign a multipart upload part copy request

Returns a presigned URL and the headers that copy a part of a multipart upload from an existing object on the object store. The client sends the request; lakeFS does not.

Example

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

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

Parameters

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

Return type

PresignMultipartCopyPartResult

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

presign_multipart_create_request

PresignMultipartCreateResult presign_multipart_create_request(repository, branch, path)

Sign a multipart upload create request

Returns a physical address and a presigned URL that creates a multipart upload on the object store. The client sends the request; lakeFS does not.

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.presign_multipart_create_result import PresignMultipartCreateResult
  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.StagingApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      path = 'path_example' # str | relative to the branch
  
      try:
          # Sign a multipart upload create request
          api_response = api_instance.presign_multipart_create_request(repository, branch, path)
          print("The response of StagingApi->presign_multipart_create_request:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling StagingApi->presign_multipart_create_request: %s\n" % e)
  

Parameters

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

Return type

PresignMultipartCreateResult

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

presign_multipart_prepare_request

PresignMultipartPrepareResult presign_multipart_prepare_request(repository, branch, upload_id, path, presign_multipart_prepare_input)

Sign the part, complete and abort requests of a multipart upload

Returns presigned URLs that upload parts 1 to part_count, one that completes the upload and one that aborts it. The client PUTs each part, then POSTs its own CompleteMultipartUpload body to the complete URL, or DELETEs the abort URL. The client sends the requests; lakeFS does not.

Example

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

  import time
  import os
  import lakefs_enterprise_sdk
  from lakefs_enterprise_sdk.models.presign_multipart_prepare_input import PresignMultipartPrepareInput
  from lakefs_enterprise_sdk.models.presign_multipart_prepare_result import PresignMultipartPrepareResult
  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.StagingApi(api_client)
      repository = 'repository_example' # str | 
      branch = 'branch_example' # str | 
      upload_id = 'upload_id_example' # str | 
      path = 'path_example' # str | relative to the branch
      presign_multipart_prepare_input = lakefs_enterprise_sdk.PresignMultipartPrepareInput() # PresignMultipartPrepareInput | 
  
      try:
          # Sign the part, complete and abort requests of a multipart upload
          api_response = api_instance.presign_multipart_prepare_request(repository, branch, upload_id, path, presign_multipart_prepare_input)
          print("The response of StagingApi->presign_multipart_prepare_request:\n")
          pprint(api_response)
      except Exception as e:
          print("Exception when calling StagingApi->presign_multipart_prepare_request: %s\n" % e)
  

Parameters

Name	Type	Description	Notes
repository	str
branch	str
upload_id	str
path	str	relative to the branch
presign_multipart_prepare_input	PresignMultipartPrepareInput

Return type

PresignMultipartPrepareResult

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

upload_part

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

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

Example

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

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

Parameters

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

Return type

UploadTo

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
200	presigned URL to use for upload	-
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-

upload_part_copy

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

Upload a part by copying part of another object.

Example

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

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

Parameters

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

Return type

void (empty response body)

Authorization

basic_auth, cookie_auth, oidc_auth, saml_auth, jwt_token

HTTP request headers

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

HTTP response details

Status code	Description	Response headers
204	part copied	* ETag -
400	Bad Request	-
401	Unauthorized	-
404	Resource Not Found	-
429	too many requests	-
0	Internal Server Error	-