### Wizard GUI Quickstart Started Metric

Source: https://github.com/treeverse/lakefs/blob/master/design/open/ttv-wizard-mvp.md

Indicates the start of the Quickstart process in the Wizard GUI.

```json
{
  "class": "spark_wizard",
  "name": "quickstart_start",
  "value": 1
}
```

--------------------------------

### Reset Branch Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/BranchesApi.md

Demonstrates how to reset a branch to a specific state. Includes setup for various authentication methods and error handling.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.BranchesApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    BranchesApi apiInstance = new BranchesApi(defaultClient);
    String repository = "repository_example"; // String | 
    String branch = "branch_example"; // String | 
    ResetCreation resetCreation = new ResetCreation(); // ResetCreation | 
    try {
      apiInstance.resetBranch(repository, branch, resetCreation)
            .execute();
    } catch (ApiException e) {
      System.err.println("Exception when calling BranchesApi#resetBranch");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Run a Single Test File

Source: https://github.com/treeverse/lakefs/blob/master/webui/test/README.md

Executes a specific test file, for example, 'quickstart.spec.ts', while skipping the setup phase.

```bash
SKIP_SETUP=true npx playwright test test/e2e/common/quickstart.spec.ts
```

--------------------------------

### Get Setup State

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/README.md

Checks if the LakeFS installation is already set up.

```APIDOC
## GET /setup_lakefs

### Description
Checks if the LakeFS installation is already set up.

### Method
GET

### Endpoint
/setup_lakefs
```

--------------------------------

### Setup Communication Preferences

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/InternalApi.md

Demonstrates how to set up communication preferences using the lakeFS SDK. Ensure the SDK is installed and configured with the correct host.

```python
import time
import os
import lakefs_sdk
from lakefs_sdk.models.comm_prefs_input import CommPrefsInput
from lakefs_sdk.rest import ApiException
from pprint import pprint

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


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

```

--------------------------------

### Create Tag Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/TagsApi.md

Demonstrates how to create a tag for a repository using the Java SDK. Includes setup for various authentication methods and error handling.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.TagsApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    TagsApi apiInstance = new TagsApi(defaultClient);
    String repository = "repository_example"; // String | 
    TagCreation tagCreation = new TagCreation(); // TagCreation | 
    try {
      Ref result = apiInstance.createTag(repository, tagCreation)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling TagsApi#createTag");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Install and Run lakeFS Sandbox

Source: https://github.com/treeverse/lakefs/blob/master/README.md

Installs lakeFS using pip and starts a standalone sandbox instance. Open the web browser to http://127.0.0.1:8000/ after execution.

```bash
pip install lakefs
python -m lakefs.quickstart
```

--------------------------------

### Create Repository Java Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/RepositoriesApi.md

Demonstrates how to create a new repository using the Repositories API. Includes setup for various authentication methods and error handling. Ensure all necessary imports are included.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.RepositoriesApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    RepositoriesApi apiInstance = new RepositoriesApi(defaultClient);
    RepositoryCreation repositoryCreation = new RepositoryCreation(); // RepositoryCreation | 
    Boolean bare = false; // Boolean | If true, create a bare repository with no initial commit and branch
    try {
      Repository result = apiInstance.createRepository(repositoryCreation)
            .bare(bare)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling RepositoriesApi#createRepository");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Java Example for uploadPart

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/ExperimentalApi.md

Demonstrates how to configure authentication and call the uploadPart method to get a presigned URL for uploading a file part. Ensure all necessary imports are included.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.ExperimentalApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    ExperimentalApi apiInstance = new ExperimentalApi(defaultClient);
    String repository = "repository_example"; // String | 
    String branch = "branch_example"; // String | 
    String uploadId = "uploadId_example"; // String | 
    String path = "path_example"; // String | 
    Integer partNumber = 56; // Integer | 
    UploadPartFrom uploadPartFrom = new UploadPartFrom(); // UploadPartFrom | 
    try {
      UploadTo result = apiInstance.uploadPart(repository, branch, uploadId, path, partNumber, uploadPartFrom)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling ExperimentalApi#uploadPart");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Generated README Content

Source: https://github.com/treeverse/lakefs/blob/master/design/open/ttv-wizard-mvp.md

Example content for a generated README.md file, summarizing setup steps and configurations without sensitive credentials.

```markdown
1. Created a repository "spark-repo" and branch "main".
2. Imported data from <S3 location>.
3. Generated the following configurations:
   <Spark configurations with hidden credentials>
   <Metastore configurations with hidden credentials>
4. Instructions to configure Hive Metastore with lakeFS.
5. Generated this README file and committed it.
```

--------------------------------

### Python Example for upload_object_preflight

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/InternalApi.md

Demonstrates how to use the upload_object_preflight method with different authentication configurations. Ensure you have the lakefs_sdk installed and environment variables for authentication are set.

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

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

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

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

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

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

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

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

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

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

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

```

--------------------------------

### Python AuthApi Create Group Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/AuthApi.md

This example demonstrates how to create a group using the AuthApi. It shows the setup for different authentication methods including basic, API key (cookie, OIDC, SAML), and JWT bearer tokens. Ensure environment variables for credentials are set.

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

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

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

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

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

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

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

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

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

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

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

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

```

--------------------------------

### SetupState Model Usage

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/SetupState.md

Demonstrates how to create a SetupState instance from a JSON string, convert it to a dictionary, and create a new instance from that dictionary. Requires the `lakefs_sdk` library.

```python
from lakefs_sdk.models.setup_state import SetupState

# TODO update the JSON string below
json = "{}"
# create an instance of SetupState from a JSON string
setup_state_instance = SetupState.from_json(json)
# print the JSON string representation of the object
print SetupState.to_json()

# convert the object into a dict
setup_state_dict = setup_state_instance.to_dict()
# create an instance of SetupState from a dict
setup_state_form_dict = setup_state.from_dict(setup_state_dict)
```

--------------------------------

### Get lakeFS Setup State

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/InternalApi.md

Retrieves the current setup state of the lakeFS installation. This is useful for checking if the initial configuration has been completed. Ensure the lakefs_sdk is installed and configured with the correct host.

```python
import time
import os
import lakefs_sdk
from lakefs_sdk.models.setup_state import SetupState
from lakefs_sdk.rest import ApiException
from pprint import pprint

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


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

--------------------------------

### Instantiate and Use Setup Model

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/Setup.md

Demonstrates how to create a Setup instance from a JSON string, convert it to a dictionary, and create a new instance from that dictionary. Requires the lakefs_sdk.models.setup module.

```python
from lakefs_sdk.models.setup import Setup

# TODO update the JSON string below
json = "{}"
# create an instance of Setup from a JSON string
setup_instance = Setup.from_json(json)
# print the JSON string representation of the object
print Setup.to_json()

# convert the object into a dict
setup_dict = setup_instance.to_dict()
# create an instance of Setup from a dict
setup_form_dict = setup.from_dict(setup_dict)
```

--------------------------------

### setup

Source: https://github.com/treeverse/lakefs/blob/master/clients/rust/docs/InternalApi.md

Sets up lakeFS and creates the first user. It takes a Setup object as input and returns CredentialsWithSecret.

```APIDOC
## setup

### Description
Sets up lakeFS and creates a first user.

### Method
POST

### Endpoint
/setup

### Parameters
#### Request Body
- **setup** (Setup) - Required - 

### Response
#### Success Response (200)
- **CredentialsWithSecret** (models::CredentialsWithSecret) - 

### Authorization
No authorization required

### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
```

--------------------------------

### Get lakeFS Setup State

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/InternalApi.md

Retrieves the current setup state of the lakeFS installation. Ensure the ApiClient is configured with the correct base path.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.InternalApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");

    InternalApi apiInstance = new InternalApi(defaultClient);
    try {
      SetupState result = apiInstance.getSetupState()
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling InternalApi#getSetupState");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Get Metadata Object Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/InternalApi.md

Demonstrates how to retrieve a lakeFS metadata object by its ID using the Internal API. Includes setup for various authentication methods.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.InternalApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    InternalApi apiInstance = new InternalApi(defaultClient);
    String repository = "repository_example"; // String | 
    String objectId = "objectId_example"; // String | 
    String type = "range"; // String | 
    Boolean presign = true; // Boolean | 
    try {
      File result = apiInstance.getMetadataObject(repository, objectId, type)
            .presign(presign)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling InternalApi#getMetadataObject");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### setup

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/README.md

Sets up lakeFS and creates the first user.

```APIDOC
## POST /setup_lakefs

### Description
Sets up lakeFS and creates the first user.

### Method
POST

### Endpoint
/setup_lakefs
```

--------------------------------

### Create Virtual Environment and Install Dependencies

Source: https://github.com/treeverse/lakefs/blob/master/clients/python-wrapper/tests/integration/README.md

Set up a Python virtual environment and install the necessary dependencies from requirements.txt.

```shell
python3 -m venv <your_venv_path>
source <your_venv_path>/bin/activate
pip install -r requirements
```

--------------------------------

### Run lakeFS Server with Docker

Source: https://github.com/treeverse/lakefs/blob/master/README.md

Starts a lakeFS server instance using Docker for a quickstart setup. This command maps port 8000 and runs the latest version of the lakeFS image.

```bash
docker run --pull always \
           --name lakefs \
           -p 8000:8000 \
           treeverse/lakefs:latest \
           run --quickstart
```

--------------------------------

### Perform STS Login

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/ExperimentalApi.md

Use this snippet to log in to lakeFS using STS. Ensure you have the lakefs_sdk installed and configured. This example shows the basic setup and API call for STS authentication.

```python
import time
import os
import lakefs_sdk
from lakefs_sdk.models.authentication_token import AuthenticationToken
from lakefs_sdk.models.sts_auth_request import StsAuthRequest
from lakefs_sdk.rest import ApiException
from pprint import pprint

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


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

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

```

--------------------------------

### Internal API: Setup

Source: https://github.com/treeverse/lakefs/blob/master/clients/rust/README.md

Sets up LakeFS and creates the first user.

```APIDOC
## POST /setup_lakefs

### Description
Sets up LakeFS and creates the first user.

### Method
POST

### Endpoint
/setup_lakefs
```

--------------------------------

### Get Tag Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/TagsApi.md

Demonstrates how to retrieve tag information using the get_tag method. It includes setup for different authentication methods (basic, cookie, OIDC, SAML, JWT) and error handling.

```python
import time
import os
import lakefs_sdk
from lakefs_sdk.models.ref import Ref
from lakefs_sdk.rest import ApiException
from pprint import pprint

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

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

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

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

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

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

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

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

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

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

    try:
        # get tag
        api_response = api_instance.get_tag(repository, tag)
        print("The response of TagsApi->get_tag:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling TagsApi->get_tag: %s\n" % e)

```

--------------------------------

### Create User with Java SDK

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/AuthApi.md

Demonstrates how to instantiate the Auth API client and create a user. Includes setup for various authentication methods like basic, cookie, OIDC, SAML, and JWT.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.AuthApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    AuthApi apiInstance = new AuthApi(defaultClient);
    UserCreation userCreation = new UserCreation(); // UserCreation | 
    try {
      User result = apiInstance.createUser()
            .userCreation(userCreation)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling AuthApi#createUser");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Python SDK Example for Get Garbage Collection Rules

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/InternalApi.md

This example demonstrates how to use the lakefs_sdk to fetch garbage collection rules for a specified repository. It includes setup for various authentication methods like basic auth, API keys, and JWT. Ensure environment variables for credentials are set.

```python
import time
import os
import lakefs_sdk
from lakefs_sdk.models.garbage_collection_rules import GarbageCollectionRules
from lakefs_sdk.rest import ApiException
from pprint import pprint

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

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

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

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

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

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

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

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

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

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

```

--------------------------------

### Python Upload Part Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/python/docs/ExperimentalApi.md

Demonstrates how to use the upload_part function from the Experimental API to get a presigned URL for uploading a file part. It includes setup for various authentication methods like basic, cookie, OIDC, SAML, and JWT.

```python
import time
import os
import lakefs_sdk
from lakefs_sdk.models.upload_part_from import UploadPartFrom
from lakefs_sdk.models.upload_to import UploadTo
from lakefs_sdk.rest import ApiException
from pprint import pprint

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

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure HTTP basic authorization: basic_auth
configuration = lakefs_sdk.Configuration(
    username = os.environ["USERNAME"],
    password = os.environ["PASSWORD"]
)

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

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

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

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

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

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

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

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

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

```

--------------------------------

### Get Credentials using Auth API

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/AuthApi.md

This Java example shows how to retrieve credentials for a user. It includes setup for multiple authentication types like basic, cookie, OIDC, SAML, and JWT. Ensure you replace placeholder values with your actual credentials.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.AuthApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    AuthApi apiInstance = new AuthApi(defaultClient);
    String userId = "userId_example"; // String | 
    String accessKeyId = "accessKeyId_example"; // String | 
    try {
      Credentials result = apiInstance.getCredentials(userId, accessKeyId)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling AuthApi#getCredentials");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Get Import Status Example

Source: https://github.com/treeverse/lakefs/blob/master/clients/java/docs/ImportApi.md

Use this Java code to retrieve the status of an import process. It includes setup for various authentication methods like basic, cookie, OIDC, SAML, and JWT. Ensure you replace placeholder credentials with your actual values.

```java
import io.lakefs.clients.sdk.ApiClient;
import io.lakefs.clients.sdk.ApiException;
import io.lakefs.clients.sdk.Configuration;
import io.lakefs.clients.sdk.auth.*;
import io.lakefs.clients.sdk.models.*;
import io.lakefs.clients.sdk.ImportApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("/api/v1");
    
    // Configure HTTP basic authorization: basic_auth
    HttpBasicAuth basic_auth = (HttpBasicAuth) defaultClient.getAuthentication("basic_auth");
    basic_auth.setUsername("YOUR USERNAME");
    basic_auth.setPassword("YOUR PASSWORD");

    // Configure API key authorization: cookie_auth
    ApiKeyAuth cookie_auth = (ApiKeyAuth) defaultClient.getAuthentication("cookie_auth");
    cookie_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //cookie_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: oidc_auth
    ApiKeyAuth oidc_auth = (ApiKeyAuth) defaultClient.getAuthentication("oidc_auth");
    oidc_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //oidc_auth.setApiKeyPrefix("Token");

    // Configure API key authorization: saml_auth
    ApiKeyAuth saml_auth = (ApiKeyAuth) defaultClient.getAuthentication("saml_auth");
    saml_auth.setApiKey("YOUR API KEY");
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //saml_auth.setApiKeyPrefix("Token");

    // Configure HTTP bearer authorization: jwt_token
    HttpBearerAuth jwt_token = (HttpBearerAuth) defaultClient.getAuthentication("jwt_token");
    jwt_token.setBearerToken("BEARER TOKEN");

    ImportApi apiInstance = new ImportApi(defaultClient);
    String repository = "repository_example"; // String | 
    String branch = "branch_example"; // String | 
    String id = "id_example"; // String | Unique identifier of the import process
    try {
      ImportStatus result = apiInstance.importStatus(repository, branch, id)
            .execute();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling ImportApi#importStatus");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```