github.com/treeverse/lakefs@v1.24.1-0.20240520134607-95648127bfb0/clients/python-legacy/docs/InternalApi.md (about) 1 # lakefs_client.InternalApi 2 3 All URIs are relative to *http://localhost/api/v1* 4 5 Method | HTTP request | Description 6 ------------- | ------------- | ------------- 7 [**create_branch_protection_rule_preflight**](InternalApi.md#create_branch_protection_rule_preflight) | **GET** /repositories/{repository}/branch_protection/set_allowed | 8 [**create_commit_record**](InternalApi.md#create_commit_record) | **POST** /repositories/{repository}/commits | create commit record 9 [**create_symlink_file**](InternalApi.md#create_symlink_file) | **POST** /repositories/{repository}/refs/{branch}/symlink | creates symlink files corresponding to the given directory 10 [**delete_repository_metadata**](InternalApi.md#delete_repository_metadata) | **DELETE** /repositories/{repository}/metadata | delete repository metadata 11 [**dump_refs**](InternalApi.md#dump_refs) | **PUT** /repositories/{repository}/refs/dump | Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations 12 [**get_auth_capabilities**](InternalApi.md#get_auth_capabilities) | **GET** /auth/capabilities | list authentication capabilities supported 13 [**get_garbage_collection_config**](InternalApi.md#get_garbage_collection_config) | **GET** /config/garbage-collection | 14 [**get_lake_fs_version**](InternalApi.md#get_lake_fs_version) | **GET** /config/version | 15 [**get_setup_state**](InternalApi.md#get_setup_state) | **GET** /setup_lakefs | check if the lakeFS installation is already set up 16 [**get_storage_config**](InternalApi.md#get_storage_config) | **GET** /config/storage | 17 [**get_usage_report_summary**](InternalApi.md#get_usage_report_summary) | **GET** /usage-report/summary | get usage report summary 18 [**internal_create_branch_protection_rule**](InternalApi.md#internal_create_branch_protection_rule) | **POST** /repositories/{repository}/branch_protection | 19 [**internal_delete_branch_protection_rule**](InternalApi.md#internal_delete_branch_protection_rule) | **DELETE** /repositories/{repository}/branch_protection | 20 [**internal_delete_garbage_collection_rules**](InternalApi.md#internal_delete_garbage_collection_rules) | **DELETE** /repositories/{repository}/gc/rules | 21 [**internal_get_branch_protection_rules**](InternalApi.md#internal_get_branch_protection_rules) | **GET** /repositories/{repository}/branch_protection | get branch protection rules 22 [**internal_get_garbage_collection_rules**](InternalApi.md#internal_get_garbage_collection_rules) | **GET** /repositories/{repository}/gc/rules | 23 [**internal_set_garbage_collection_rules**](InternalApi.md#internal_set_garbage_collection_rules) | **POST** /repositories/{repository}/gc/rules | 24 [**post_stats_events**](InternalApi.md#post_stats_events) | **POST** /statistics | post stats events, this endpoint is meant for internal use only 25 [**prepare_garbage_collection_commits**](InternalApi.md#prepare_garbage_collection_commits) | **POST** /repositories/{repository}/gc/prepare_commits | save lists of active commits for garbage collection 26 [**prepare_garbage_collection_uncommitted**](InternalApi.md#prepare_garbage_collection_uncommitted) | **POST** /repositories/{repository}/gc/prepare_uncommited | save repository uncommitted metadata for garbage collection 27 [**restore_refs**](InternalApi.md#restore_refs) | **PUT** /repositories/{repository}/refs/restore | Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations 28 [**set_garbage_collection_rules_preflight**](InternalApi.md#set_garbage_collection_rules_preflight) | **GET** /repositories/{repository}/gc/rules/set_allowed | 29 [**set_repository_metadata**](InternalApi.md#set_repository_metadata) | **POST** /repositories/{repository}/metadata | set repository metadata 30 [**setup**](InternalApi.md#setup) | **POST** /setup_lakefs | setup lakeFS and create a first user 31 [**setup_comm_prefs**](InternalApi.md#setup_comm_prefs) | **POST** /setup_comm_prefs | setup communications preferences 32 [**stage_object**](InternalApi.md#stage_object) | **PUT** /repositories/{repository}/branches/{branch}/objects | stage an object's metadata for the given branch 33 [**upload_object_preflight**](InternalApi.md#upload_object_preflight) | **GET** /repositories/{repository}/branches/{branch}/objects/stage_allowed | 34 35 36 # **create_branch_protection_rule_preflight** 37 > create_branch_protection_rule_preflight(repository) 38 39 40 41 ### Example 42 43 * Basic Authentication (basic_auth): 44 * Api Key Authentication (cookie_auth): 45 * Bearer (JWT) Authentication (jwt_token): 46 * Api Key Authentication (oidc_auth): 47 * Api Key Authentication (saml_auth): 48 49 ```python 50 import time 51 import lakefs_client 52 from lakefs_client.api import internal_api 53 from lakefs_client.model.error import Error 54 from pprint import pprint 55 # Defining the host is optional and defaults to http://localhost/api/v1 56 # See configuration.py for a list of all supported configuration parameters. 57 configuration = lakefs_client.Configuration( 58 host = "http://localhost/api/v1" 59 ) 60 61 # The client must configure the authentication and authorization parameters 62 # in accordance with the API server security policy. 63 # Examples for each auth method are provided below, use the example that 64 # satisfies your auth use case. 65 66 # Configure HTTP basic authorization: basic_auth 67 configuration = lakefs_client.Configuration( 68 username = 'YOUR_USERNAME', 69 password = 'YOUR_PASSWORD' 70 ) 71 72 # Configure API key authorization: cookie_auth 73 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 74 75 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 76 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 77 78 # Configure Bearer authorization (JWT): jwt_token 79 configuration = lakefs_client.Configuration( 80 access_token = 'YOUR_BEARER_TOKEN' 81 ) 82 83 # Configure API key authorization: oidc_auth 84 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 85 86 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 87 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 88 89 # Configure API key authorization: saml_auth 90 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 91 92 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 93 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 94 95 # Enter a context with an instance of the API client 96 with lakefs_client.ApiClient(configuration) as api_client: 97 # Create an instance of the API class 98 api_instance = internal_api.InternalApi(api_client) 99 repository = "repository_example" # str | 100 101 # example passing only required values which don't have defaults set 102 try: 103 api_instance.create_branch_protection_rule_preflight(repository) 104 except lakefs_client.ApiException as e: 105 print("Exception when calling InternalApi->create_branch_protection_rule_preflight: %s\n" % e) 106 ``` 107 108 109 ### Parameters 110 111 Name | Type | Description | Notes 112 ------------- | ------------- | ------------- | ------------- 113 **repository** | **str**| | 114 115 ### Return type 116 117 void (empty response body) 118 119 ### Authorization 120 121 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 122 123 ### HTTP request headers 124 125 - **Content-Type**: Not defined 126 - **Accept**: application/json 127 128 129 ### HTTP response details 130 131 | Status code | Description | Response headers | 132 |-------------|-------------|------------------| 133 **204** | User has permissions to create a branch protection rule in this repository | - | 134 **401** | Unauthorized | - | 135 **404** | Resource Not Found | - | 136 **409** | Resource Conflicts With Target | - | 137 **420** | too many requests | - | 138 **0** | Internal Server Error | - | 139 140 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 141 142 # **create_commit_record** 143 > create_commit_record(repository, commit_record_creation) 144 145 create commit record 146 147 ### Example 148 149 * Basic Authentication (basic_auth): 150 * Api Key Authentication (cookie_auth): 151 * Bearer (JWT) Authentication (jwt_token): 152 * Api Key Authentication (oidc_auth): 153 * Api Key Authentication (saml_auth): 154 155 ```python 156 import time 157 import lakefs_client 158 from lakefs_client.api import internal_api 159 from lakefs_client.model.commit_record_creation import CommitRecordCreation 160 from lakefs_client.model.error import Error 161 from pprint import pprint 162 # Defining the host is optional and defaults to http://localhost/api/v1 163 # See configuration.py for a list of all supported configuration parameters. 164 configuration = lakefs_client.Configuration( 165 host = "http://localhost/api/v1" 166 ) 167 168 # The client must configure the authentication and authorization parameters 169 # in accordance with the API server security policy. 170 # Examples for each auth method are provided below, use the example that 171 # satisfies your auth use case. 172 173 # Configure HTTP basic authorization: basic_auth 174 configuration = lakefs_client.Configuration( 175 username = 'YOUR_USERNAME', 176 password = 'YOUR_PASSWORD' 177 ) 178 179 # Configure API key authorization: cookie_auth 180 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 181 182 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 183 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 184 185 # Configure Bearer authorization (JWT): jwt_token 186 configuration = lakefs_client.Configuration( 187 access_token = 'YOUR_BEARER_TOKEN' 188 ) 189 190 # Configure API key authorization: oidc_auth 191 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 192 193 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 194 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 195 196 # Configure API key authorization: saml_auth 197 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 198 199 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 200 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 201 202 # Enter a context with an instance of the API client 203 with lakefs_client.ApiClient(configuration) as api_client: 204 # Create an instance of the API class 205 api_instance = internal_api.InternalApi(api_client) 206 repository = "repository_example" # str | 207 commit_record_creation = CommitRecordCreation( 208 commit_id="commit_id_example", 209 version=0, 210 committer="committer_example", 211 message="message_example", 212 metarange_id="metarange_id_example", 213 creation_date=1, 214 parents=[ 215 "parents_example", 216 ], 217 metadata={ 218 "key": "key_example", 219 }, 220 generation=1, 221 force=False, 222 ) # CommitRecordCreation | 223 224 # example passing only required values which don't have defaults set 225 try: 226 # create commit record 227 api_instance.create_commit_record(repository, commit_record_creation) 228 except lakefs_client.ApiException as e: 229 print("Exception when calling InternalApi->create_commit_record: %s\n" % e) 230 ``` 231 232 233 ### Parameters 234 235 Name | Type | Description | Notes 236 ------------- | ------------- | ------------- | ------------- 237 **repository** | **str**| | 238 **commit_record_creation** | [**CommitRecordCreation**](CommitRecordCreation.md)| | 239 240 ### Return type 241 242 void (empty response body) 243 244 ### Authorization 245 246 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 247 248 ### HTTP request headers 249 250 - **Content-Type**: application/json 251 - **Accept**: application/json 252 253 254 ### HTTP response details 255 256 | Status code | Description | Response headers | 257 |-------------|-------------|------------------| 258 **204** | commit record created | - | 259 **400** | Validation Error | - | 260 **401** | Unauthorized | - | 261 **403** | Forbidden | - | 262 **404** | Resource Not Found | - | 263 **420** | too many requests | - | 264 **0** | Internal Server Error | - | 265 266 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 267 268 # **create_symlink_file** 269 > StorageURI create_symlink_file(repository, branch) 270 271 creates symlink files corresponding to the given directory 272 273 ### Example 274 275 * Basic Authentication (basic_auth): 276 * Api Key Authentication (cookie_auth): 277 * Bearer (JWT) Authentication (jwt_token): 278 * Api Key Authentication (oidc_auth): 279 * Api Key Authentication (saml_auth): 280 281 ```python 282 import time 283 import lakefs_client 284 from lakefs_client.api import internal_api 285 from lakefs_client.model.error import Error 286 from lakefs_client.model.storage_uri import StorageURI 287 from pprint import pprint 288 # Defining the host is optional and defaults to http://localhost/api/v1 289 # See configuration.py for a list of all supported configuration parameters. 290 configuration = lakefs_client.Configuration( 291 host = "http://localhost/api/v1" 292 ) 293 294 # The client must configure the authentication and authorization parameters 295 # in accordance with the API server security policy. 296 # Examples for each auth method are provided below, use the example that 297 # satisfies your auth use case. 298 299 # Configure HTTP basic authorization: basic_auth 300 configuration = lakefs_client.Configuration( 301 username = 'YOUR_USERNAME', 302 password = 'YOUR_PASSWORD' 303 ) 304 305 # Configure API key authorization: cookie_auth 306 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 307 308 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 309 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 310 311 # Configure Bearer authorization (JWT): jwt_token 312 configuration = lakefs_client.Configuration( 313 access_token = 'YOUR_BEARER_TOKEN' 314 ) 315 316 # Configure API key authorization: oidc_auth 317 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 318 319 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 320 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 321 322 # Configure API key authorization: saml_auth 323 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 324 325 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 326 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 327 328 # Enter a context with an instance of the API client 329 with lakefs_client.ApiClient(configuration) as api_client: 330 # Create an instance of the API class 331 api_instance = internal_api.InternalApi(api_client) 332 repository = "repository_example" # str | 333 branch = "branch_example" # str | 334 location = "location_example" # str | path to the table data (optional) 335 336 # example passing only required values which don't have defaults set 337 try: 338 # creates symlink files corresponding to the given directory 339 api_response = api_instance.create_symlink_file(repository, branch) 340 pprint(api_response) 341 except lakefs_client.ApiException as e: 342 print("Exception when calling InternalApi->create_symlink_file: %s\n" % e) 343 344 # example passing only required values which don't have defaults set 345 # and optional values 346 try: 347 # creates symlink files corresponding to the given directory 348 api_response = api_instance.create_symlink_file(repository, branch, location=location) 349 pprint(api_response) 350 except lakefs_client.ApiException as e: 351 print("Exception when calling InternalApi->create_symlink_file: %s\n" % e) 352 ``` 353 354 355 ### Parameters 356 357 Name | Type | Description | Notes 358 ------------- | ------------- | ------------- | ------------- 359 **repository** | **str**| | 360 **branch** | **str**| | 361 **location** | **str**| path to the table data | [optional] 362 363 ### Return type 364 365 [**StorageURI**](StorageURI.md) 366 367 ### Authorization 368 369 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 370 371 ### HTTP request headers 372 373 - **Content-Type**: Not defined 374 - **Accept**: application/json 375 376 377 ### HTTP response details 378 379 | Status code | Description | Response headers | 380 |-------------|-------------|------------------| 381 **201** | location created | - | 382 **401** | Unauthorized | - | 383 **404** | Resource Not Found | - | 384 **420** | too many requests | - | 385 **0** | Internal Server Error | - | 386 387 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 388 389 # **delete_repository_metadata** 390 > delete_repository_metadata(repository, repository_metadata_keys) 391 392 delete repository metadata 393 394 Delete specified keys from the repository's metadata. 395 396 ### Example 397 398 * Basic Authentication (basic_auth): 399 * Api Key Authentication (cookie_auth): 400 * Bearer (JWT) Authentication (jwt_token): 401 * Api Key Authentication (oidc_auth): 402 * Api Key Authentication (saml_auth): 403 404 ```python 405 import time 406 import lakefs_client 407 from lakefs_client.api import internal_api 408 from lakefs_client.model.repository_metadata_keys import RepositoryMetadataKeys 409 from lakefs_client.model.error import Error 410 from pprint import pprint 411 # Defining the host is optional and defaults to http://localhost/api/v1 412 # See configuration.py for a list of all supported configuration parameters. 413 configuration = lakefs_client.Configuration( 414 host = "http://localhost/api/v1" 415 ) 416 417 # The client must configure the authentication and authorization parameters 418 # in accordance with the API server security policy. 419 # Examples for each auth method are provided below, use the example that 420 # satisfies your auth use case. 421 422 # Configure HTTP basic authorization: basic_auth 423 configuration = lakefs_client.Configuration( 424 username = 'YOUR_USERNAME', 425 password = 'YOUR_PASSWORD' 426 ) 427 428 # Configure API key authorization: cookie_auth 429 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 430 431 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 432 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 433 434 # Configure Bearer authorization (JWT): jwt_token 435 configuration = lakefs_client.Configuration( 436 access_token = 'YOUR_BEARER_TOKEN' 437 ) 438 439 # Configure API key authorization: oidc_auth 440 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 441 442 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 443 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 444 445 # Configure API key authorization: saml_auth 446 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 447 448 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 449 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 450 451 # Enter a context with an instance of the API client 452 with lakefs_client.ApiClient(configuration) as api_client: 453 # Create an instance of the API class 454 api_instance = internal_api.InternalApi(api_client) 455 repository = "repository_example" # str | 456 repository_metadata_keys = RepositoryMetadataKeys( 457 keys=[ 458 "keys_example", 459 ], 460 ) # RepositoryMetadataKeys | 461 462 # example passing only required values which don't have defaults set 463 try: 464 # delete repository metadata 465 api_instance.delete_repository_metadata(repository, repository_metadata_keys) 466 except lakefs_client.ApiException as e: 467 print("Exception when calling InternalApi->delete_repository_metadata: %s\n" % e) 468 ``` 469 470 471 ### Parameters 472 473 Name | Type | Description | Notes 474 ------------- | ------------- | ------------- | ------------- 475 **repository** | **str**| | 476 **repository_metadata_keys** | [**RepositoryMetadataKeys**](RepositoryMetadataKeys.md)| | 477 478 ### Return type 479 480 void (empty response body) 481 482 ### Authorization 483 484 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 485 486 ### HTTP request headers 487 488 - **Content-Type**: application/json 489 - **Accept**: application/json 490 491 492 ### HTTP response details 493 494 | Status code | Description | Response headers | 495 |-------------|-------------|------------------| 496 **204** | repository metadata keys deleted successfully | - | 497 **401** | Unauthorized | - | 498 **420** | too many requests | - | 499 **0** | Internal Server Error | - | 500 501 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 502 503 # **dump_refs** 504 > RefsDump dump_refs(repository) 505 506 Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations 507 508 ### Example 509 510 * Basic Authentication (basic_auth): 511 * Api Key Authentication (cookie_auth): 512 * Bearer (JWT) Authentication (jwt_token): 513 * Api Key Authentication (oidc_auth): 514 * Api Key Authentication (saml_auth): 515 516 ```python 517 import time 518 import lakefs_client 519 from lakefs_client.api import internal_api 520 from lakefs_client.model.refs_dump import RefsDump 521 from lakefs_client.model.error import Error 522 from pprint import pprint 523 # Defining the host is optional and defaults to http://localhost/api/v1 524 # See configuration.py for a list of all supported configuration parameters. 525 configuration = lakefs_client.Configuration( 526 host = "http://localhost/api/v1" 527 ) 528 529 # The client must configure the authentication and authorization parameters 530 # in accordance with the API server security policy. 531 # Examples for each auth method are provided below, use the example that 532 # satisfies your auth use case. 533 534 # Configure HTTP basic authorization: basic_auth 535 configuration = lakefs_client.Configuration( 536 username = 'YOUR_USERNAME', 537 password = 'YOUR_PASSWORD' 538 ) 539 540 # Configure API key authorization: cookie_auth 541 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 542 543 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 544 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 545 546 # Configure Bearer authorization (JWT): jwt_token 547 configuration = lakefs_client.Configuration( 548 access_token = 'YOUR_BEARER_TOKEN' 549 ) 550 551 # Configure API key authorization: oidc_auth 552 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 553 554 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 555 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 556 557 # Configure API key authorization: saml_auth 558 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 559 560 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 561 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 562 563 # Enter a context with an instance of the API client 564 with lakefs_client.ApiClient(configuration) as api_client: 565 # Create an instance of the API class 566 api_instance = internal_api.InternalApi(api_client) 567 repository = "repository_example" # str | 568 569 # example passing only required values which don't have defaults set 570 try: 571 # Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations 572 api_response = api_instance.dump_refs(repository) 573 pprint(api_response) 574 except lakefs_client.ApiException as e: 575 print("Exception when calling InternalApi->dump_refs: %s\n" % e) 576 ``` 577 578 579 ### Parameters 580 581 Name | Type | Description | Notes 582 ------------- | ------------- | ------------- | ------------- 583 **repository** | **str**| | 584 585 ### Return type 586 587 [**RefsDump**](RefsDump.md) 588 589 ### Authorization 590 591 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 592 593 ### HTTP request headers 594 595 - **Content-Type**: Not defined 596 - **Accept**: application/json 597 598 599 ### HTTP response details 600 601 | Status code | Description | Response headers | 602 |-------------|-------------|------------------| 603 **201** | refs dump | - | 604 **400** | Validation Error | - | 605 **401** | Unauthorized | - | 606 **404** | Resource Not Found | - | 607 **420** | too many requests | - | 608 **0** | Internal Server Error | - | 609 610 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 611 612 # **get_auth_capabilities** 613 > AuthCapabilities get_auth_capabilities() 614 615 list authentication capabilities supported 616 617 ### Example 618 619 620 ```python 621 import time 622 import lakefs_client 623 from lakefs_client.api import internal_api 624 from lakefs_client.model.error import Error 625 from lakefs_client.model.auth_capabilities import AuthCapabilities 626 from pprint import pprint 627 # Defining the host is optional and defaults to http://localhost/api/v1 628 # See configuration.py for a list of all supported configuration parameters. 629 configuration = lakefs_client.Configuration( 630 host = "http://localhost/api/v1" 631 ) 632 633 634 # Enter a context with an instance of the API client 635 with lakefs_client.ApiClient() as api_client: 636 # Create an instance of the API class 637 api_instance = internal_api.InternalApi(api_client) 638 639 # example, this endpoint has no required or optional parameters 640 try: 641 # list authentication capabilities supported 642 api_response = api_instance.get_auth_capabilities() 643 pprint(api_response) 644 except lakefs_client.ApiException as e: 645 print("Exception when calling InternalApi->get_auth_capabilities: %s\n" % e) 646 ``` 647 648 649 ### Parameters 650 This endpoint does not need any parameter. 651 652 ### Return type 653 654 [**AuthCapabilities**](AuthCapabilities.md) 655 656 ### Authorization 657 658 No authorization required 659 660 ### HTTP request headers 661 662 - **Content-Type**: Not defined 663 - **Accept**: application/json 664 665 666 ### HTTP response details 667 668 | Status code | Description | Response headers | 669 |-------------|-------------|------------------| 670 **200** | auth capabilities | - | 671 **420** | too many requests | - | 672 **0** | Internal Server Error | - | 673 674 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 675 676 # **get_garbage_collection_config** 677 > GarbageCollectionConfig get_garbage_collection_config() 678 679 680 681 get information of gc settings 682 683 ### Example 684 685 * Basic Authentication (basic_auth): 686 * Api Key Authentication (cookie_auth): 687 * Bearer (JWT) Authentication (jwt_token): 688 * Api Key Authentication (oidc_auth): 689 * Api Key Authentication (saml_auth): 690 691 ```python 692 import time 693 import lakefs_client 694 from lakefs_client.api import internal_api 695 from lakefs_client.model.garbage_collection_config import GarbageCollectionConfig 696 from lakefs_client.model.error import Error 697 from pprint import pprint 698 # Defining the host is optional and defaults to http://localhost/api/v1 699 # See configuration.py for a list of all supported configuration parameters. 700 configuration = lakefs_client.Configuration( 701 host = "http://localhost/api/v1" 702 ) 703 704 # The client must configure the authentication and authorization parameters 705 # in accordance with the API server security policy. 706 # Examples for each auth method are provided below, use the example that 707 # satisfies your auth use case. 708 709 # Configure HTTP basic authorization: basic_auth 710 configuration = lakefs_client.Configuration( 711 username = 'YOUR_USERNAME', 712 password = 'YOUR_PASSWORD' 713 ) 714 715 # Configure API key authorization: cookie_auth 716 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 717 718 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 719 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 720 721 # Configure Bearer authorization (JWT): jwt_token 722 configuration = lakefs_client.Configuration( 723 access_token = 'YOUR_BEARER_TOKEN' 724 ) 725 726 # Configure API key authorization: oidc_auth 727 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 728 729 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 730 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 731 732 # Configure API key authorization: saml_auth 733 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 734 735 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 736 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 737 738 # Enter a context with an instance of the API client 739 with lakefs_client.ApiClient(configuration) as api_client: 740 # Create an instance of the API class 741 api_instance = internal_api.InternalApi(api_client) 742 743 # example, this endpoint has no required or optional parameters 744 try: 745 api_response = api_instance.get_garbage_collection_config() 746 pprint(api_response) 747 except lakefs_client.ApiException as e: 748 print("Exception when calling InternalApi->get_garbage_collection_config: %s\n" % e) 749 ``` 750 751 752 ### Parameters 753 This endpoint does not need any parameter. 754 755 ### Return type 756 757 [**GarbageCollectionConfig**](GarbageCollectionConfig.md) 758 759 ### Authorization 760 761 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 762 763 ### HTTP request headers 764 765 - **Content-Type**: Not defined 766 - **Accept**: application/json 767 768 769 ### HTTP response details 770 771 | Status code | Description | Response headers | 772 |-------------|-------------|------------------| 773 **200** | lakeFS garbage collection config | - | 774 **401** | Unauthorized | - | 775 776 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 777 778 # **get_lake_fs_version** 779 > VersionConfig get_lake_fs_version() 780 781 782 783 get version of lakeFS server 784 785 ### Example 786 787 * Basic Authentication (basic_auth): 788 * Api Key Authentication (cookie_auth): 789 * Bearer (JWT) Authentication (jwt_token): 790 * Api Key Authentication (oidc_auth): 791 * Api Key Authentication (saml_auth): 792 793 ```python 794 import time 795 import lakefs_client 796 from lakefs_client.api import internal_api 797 from lakefs_client.model.version_config import VersionConfig 798 from lakefs_client.model.error import Error 799 from pprint import pprint 800 # Defining the host is optional and defaults to http://localhost/api/v1 801 # See configuration.py for a list of all supported configuration parameters. 802 configuration = lakefs_client.Configuration( 803 host = "http://localhost/api/v1" 804 ) 805 806 # The client must configure the authentication and authorization parameters 807 # in accordance with the API server security policy. 808 # Examples for each auth method are provided below, use the example that 809 # satisfies your auth use case. 810 811 # Configure HTTP basic authorization: basic_auth 812 configuration = lakefs_client.Configuration( 813 username = 'YOUR_USERNAME', 814 password = 'YOUR_PASSWORD' 815 ) 816 817 # Configure API key authorization: cookie_auth 818 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 819 820 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 821 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 822 823 # Configure Bearer authorization (JWT): jwt_token 824 configuration = lakefs_client.Configuration( 825 access_token = 'YOUR_BEARER_TOKEN' 826 ) 827 828 # Configure API key authorization: oidc_auth 829 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 830 831 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 832 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 833 834 # Configure API key authorization: saml_auth 835 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 836 837 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 838 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 839 840 # Enter a context with an instance of the API client 841 with lakefs_client.ApiClient(configuration) as api_client: 842 # Create an instance of the API class 843 api_instance = internal_api.InternalApi(api_client) 844 845 # example, this endpoint has no required or optional parameters 846 try: 847 api_response = api_instance.get_lake_fs_version() 848 pprint(api_response) 849 except lakefs_client.ApiException as e: 850 print("Exception when calling InternalApi->get_lake_fs_version: %s\n" % e) 851 ``` 852 853 854 ### Parameters 855 This endpoint does not need any parameter. 856 857 ### Return type 858 859 [**VersionConfig**](VersionConfig.md) 860 861 ### Authorization 862 863 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 864 865 ### HTTP request headers 866 867 - **Content-Type**: Not defined 868 - **Accept**: application/json 869 870 871 ### HTTP response details 872 873 | Status code | Description | Response headers | 874 |-------------|-------------|------------------| 875 **200** | lakeFS version | - | 876 **401** | Unauthorized | - | 877 878 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 879 880 # **get_setup_state** 881 > SetupState get_setup_state() 882 883 check if the lakeFS installation is already set up 884 885 ### Example 886 887 888 ```python 889 import time 890 import lakefs_client 891 from lakefs_client.api import internal_api 892 from lakefs_client.model.error import Error 893 from lakefs_client.model.setup_state import SetupState 894 from pprint import pprint 895 # Defining the host is optional and defaults to http://localhost/api/v1 896 # See configuration.py for a list of all supported configuration parameters. 897 configuration = lakefs_client.Configuration( 898 host = "http://localhost/api/v1" 899 ) 900 901 902 # Enter a context with an instance of the API client 903 with lakefs_client.ApiClient() as api_client: 904 # Create an instance of the API class 905 api_instance = internal_api.InternalApi(api_client) 906 907 # example, this endpoint has no required or optional parameters 908 try: 909 # check if the lakeFS installation is already set up 910 api_response = api_instance.get_setup_state() 911 pprint(api_response) 912 except lakefs_client.ApiException as e: 913 print("Exception when calling InternalApi->get_setup_state: %s\n" % e) 914 ``` 915 916 917 ### Parameters 918 This endpoint does not need any parameter. 919 920 ### Return type 921 922 [**SetupState**](SetupState.md) 923 924 ### Authorization 925 926 No authorization required 927 928 ### HTTP request headers 929 930 - **Content-Type**: Not defined 931 - **Accept**: application/json 932 933 934 ### HTTP response details 935 936 | Status code | Description | Response headers | 937 |-------------|-------------|------------------| 938 **200** | lakeFS setup state | - | 939 **420** | too many requests | - | 940 **0** | Internal Server Error | - | 941 942 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 943 944 # **get_storage_config** 945 > StorageConfig get_storage_config() 946 947 948 949 retrieve lakeFS storage configuration 950 951 ### Example 952 953 * Basic Authentication (basic_auth): 954 * Api Key Authentication (cookie_auth): 955 * Bearer (JWT) Authentication (jwt_token): 956 * Api Key Authentication (oidc_auth): 957 * Api Key Authentication (saml_auth): 958 959 ```python 960 import time 961 import lakefs_client 962 from lakefs_client.api import internal_api 963 from lakefs_client.model.error import Error 964 from lakefs_client.model.storage_config import StorageConfig 965 from pprint import pprint 966 # Defining the host is optional and defaults to http://localhost/api/v1 967 # See configuration.py for a list of all supported configuration parameters. 968 configuration = lakefs_client.Configuration( 969 host = "http://localhost/api/v1" 970 ) 971 972 # The client must configure the authentication and authorization parameters 973 # in accordance with the API server security policy. 974 # Examples for each auth method are provided below, use the example that 975 # satisfies your auth use case. 976 977 # Configure HTTP basic authorization: basic_auth 978 configuration = lakefs_client.Configuration( 979 username = 'YOUR_USERNAME', 980 password = 'YOUR_PASSWORD' 981 ) 982 983 # Configure API key authorization: cookie_auth 984 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 985 986 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 987 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 988 989 # Configure Bearer authorization (JWT): jwt_token 990 configuration = lakefs_client.Configuration( 991 access_token = 'YOUR_BEARER_TOKEN' 992 ) 993 994 # Configure API key authorization: oidc_auth 995 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 996 997 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 998 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 999 1000 # Configure API key authorization: saml_auth 1001 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1002 1003 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1004 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1005 1006 # Enter a context with an instance of the API client 1007 with lakefs_client.ApiClient(configuration) as api_client: 1008 # Create an instance of the API class 1009 api_instance = internal_api.InternalApi(api_client) 1010 1011 # example, this endpoint has no required or optional parameters 1012 try: 1013 api_response = api_instance.get_storage_config() 1014 pprint(api_response) 1015 except lakefs_client.ApiException as e: 1016 print("Exception when calling InternalApi->get_storage_config: %s\n" % e) 1017 ``` 1018 1019 1020 ### Parameters 1021 This endpoint does not need any parameter. 1022 1023 ### Return type 1024 1025 [**StorageConfig**](StorageConfig.md) 1026 1027 ### Authorization 1028 1029 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1030 1031 ### HTTP request headers 1032 1033 - **Content-Type**: Not defined 1034 - **Accept**: application/json 1035 1036 1037 ### HTTP response details 1038 1039 | Status code | Description | Response headers | 1040 |-------------|-------------|------------------| 1041 **200** | lakeFS storage configuration | - | 1042 **401** | Unauthorized | - | 1043 1044 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1045 1046 # **get_usage_report_summary** 1047 > InstallationUsageReport get_usage_report_summary() 1048 1049 get usage report summary 1050 1051 ### Example 1052 1053 * Basic Authentication (basic_auth): 1054 * Api Key Authentication (cookie_auth): 1055 * Bearer (JWT) Authentication (jwt_token): 1056 * Api Key Authentication (oidc_auth): 1057 * Api Key Authentication (saml_auth): 1058 1059 ```python 1060 import time 1061 import lakefs_client 1062 from lakefs_client.api import internal_api 1063 from lakefs_client.model.installation_usage_report import InstallationUsageReport 1064 from lakefs_client.model.error import Error 1065 from pprint import pprint 1066 # Defining the host is optional and defaults to http://localhost/api/v1 1067 # See configuration.py for a list of all supported configuration parameters. 1068 configuration = lakefs_client.Configuration( 1069 host = "http://localhost/api/v1" 1070 ) 1071 1072 # The client must configure the authentication and authorization parameters 1073 # in accordance with the API server security policy. 1074 # Examples for each auth method are provided below, use the example that 1075 # satisfies your auth use case. 1076 1077 # Configure HTTP basic authorization: basic_auth 1078 configuration = lakefs_client.Configuration( 1079 username = 'YOUR_USERNAME', 1080 password = 'YOUR_PASSWORD' 1081 ) 1082 1083 # Configure API key authorization: cookie_auth 1084 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1085 1086 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1087 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1088 1089 # Configure Bearer authorization (JWT): jwt_token 1090 configuration = lakefs_client.Configuration( 1091 access_token = 'YOUR_BEARER_TOKEN' 1092 ) 1093 1094 # Configure API key authorization: oidc_auth 1095 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1096 1097 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1098 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1099 1100 # Configure API key authorization: saml_auth 1101 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1102 1103 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1104 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1105 1106 # Enter a context with an instance of the API client 1107 with lakefs_client.ApiClient(configuration) as api_client: 1108 # Create an instance of the API class 1109 api_instance = internal_api.InternalApi(api_client) 1110 1111 # example, this endpoint has no required or optional parameters 1112 try: 1113 # get usage report summary 1114 api_response = api_instance.get_usage_report_summary() 1115 pprint(api_response) 1116 except lakefs_client.ApiException as e: 1117 print("Exception when calling InternalApi->get_usage_report_summary: %s\n" % e) 1118 ``` 1119 1120 1121 ### Parameters 1122 This endpoint does not need any parameter. 1123 1124 ### Return type 1125 1126 [**InstallationUsageReport**](InstallationUsageReport.md) 1127 1128 ### Authorization 1129 1130 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1131 1132 ### HTTP request headers 1133 1134 - **Content-Type**: Not defined 1135 - **Accept**: application/json, application/text 1136 1137 1138 ### HTTP response details 1139 1140 | Status code | Description | Response headers | 1141 |-------------|-------------|------------------| 1142 **200** | Usage report | - | 1143 **400** | Bad Request | - | 1144 **401** | Unauthorized | - | 1145 **404** | Resource Not Found | - | 1146 **420** | too many requests | - | 1147 **0** | Internal Server Error | - | 1148 1149 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1150 1151 # **internal_create_branch_protection_rule** 1152 > internal_create_branch_protection_rule(repository, branch_protection_rule) 1153 1154 1155 1156 ### Example 1157 1158 * Basic Authentication (basic_auth): 1159 * Api Key Authentication (cookie_auth): 1160 * Bearer (JWT) Authentication (jwt_token): 1161 * Api Key Authentication (oidc_auth): 1162 * Api Key Authentication (saml_auth): 1163 1164 ```python 1165 import time 1166 import lakefs_client 1167 from lakefs_client.api import internal_api 1168 from lakefs_client.model.error import Error 1169 from lakefs_client.model.branch_protection_rule import BranchProtectionRule 1170 from pprint import pprint 1171 # Defining the host is optional and defaults to http://localhost/api/v1 1172 # See configuration.py for a list of all supported configuration parameters. 1173 configuration = lakefs_client.Configuration( 1174 host = "http://localhost/api/v1" 1175 ) 1176 1177 # The client must configure the authentication and authorization parameters 1178 # in accordance with the API server security policy. 1179 # Examples for each auth method are provided below, use the example that 1180 # satisfies your auth use case. 1181 1182 # Configure HTTP basic authorization: basic_auth 1183 configuration = lakefs_client.Configuration( 1184 username = 'YOUR_USERNAME', 1185 password = 'YOUR_PASSWORD' 1186 ) 1187 1188 # Configure API key authorization: cookie_auth 1189 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1190 1191 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1192 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1193 1194 # Configure Bearer authorization (JWT): jwt_token 1195 configuration = lakefs_client.Configuration( 1196 access_token = 'YOUR_BEARER_TOKEN' 1197 ) 1198 1199 # Configure API key authorization: oidc_auth 1200 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1201 1202 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1203 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1204 1205 # Configure API key authorization: saml_auth 1206 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1207 1208 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1209 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1210 1211 # Enter a context with an instance of the API client 1212 with lakefs_client.ApiClient(configuration) as api_client: 1213 # Create an instance of the API class 1214 api_instance = internal_api.InternalApi(api_client) 1215 repository = "repository_example" # str | 1216 branch_protection_rule = BranchProtectionRule( 1217 pattern="stable_*", 1218 ) # BranchProtectionRule | 1219 1220 # example passing only required values which don't have defaults set 1221 try: 1222 api_instance.internal_create_branch_protection_rule(repository, branch_protection_rule) 1223 except lakefs_client.ApiException as e: 1224 print("Exception when calling InternalApi->internal_create_branch_protection_rule: %s\n" % e) 1225 ``` 1226 1227 1228 ### Parameters 1229 1230 Name | Type | Description | Notes 1231 ------------- | ------------- | ------------- | ------------- 1232 **repository** | **str**| | 1233 **branch_protection_rule** | [**BranchProtectionRule**](BranchProtectionRule.md)| | 1234 1235 ### Return type 1236 1237 void (empty response body) 1238 1239 ### Authorization 1240 1241 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1242 1243 ### HTTP request headers 1244 1245 - **Content-Type**: application/json 1246 - **Accept**: application/json 1247 1248 1249 ### HTTP response details 1250 1251 | Status code | Description | Response headers | 1252 |-------------|-------------|------------------| 1253 **204** | branch protection rule created successfully | - | 1254 **401** | Unauthorized | - | 1255 **404** | Resource Not Found | - | 1256 **420** | too many requests | - | 1257 **0** | Internal Server Error | - | 1258 1259 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1260 1261 # **internal_delete_branch_protection_rule** 1262 > internal_delete_branch_protection_rule(repository, inline_object1) 1263 1264 1265 1266 ### Example 1267 1268 * Basic Authentication (basic_auth): 1269 * Api Key Authentication (cookie_auth): 1270 * Bearer (JWT) Authentication (jwt_token): 1271 * Api Key Authentication (oidc_auth): 1272 * Api Key Authentication (saml_auth): 1273 1274 ```python 1275 import time 1276 import lakefs_client 1277 from lakefs_client.api import internal_api 1278 from lakefs_client.model.error import Error 1279 from lakefs_client.model.inline_object1 import InlineObject1 1280 from pprint import pprint 1281 # Defining the host is optional and defaults to http://localhost/api/v1 1282 # See configuration.py for a list of all supported configuration parameters. 1283 configuration = lakefs_client.Configuration( 1284 host = "http://localhost/api/v1" 1285 ) 1286 1287 # The client must configure the authentication and authorization parameters 1288 # in accordance with the API server security policy. 1289 # Examples for each auth method are provided below, use the example that 1290 # satisfies your auth use case. 1291 1292 # Configure HTTP basic authorization: basic_auth 1293 configuration = lakefs_client.Configuration( 1294 username = 'YOUR_USERNAME', 1295 password = 'YOUR_PASSWORD' 1296 ) 1297 1298 # Configure API key authorization: cookie_auth 1299 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1300 1301 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1302 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1303 1304 # Configure Bearer authorization (JWT): jwt_token 1305 configuration = lakefs_client.Configuration( 1306 access_token = 'YOUR_BEARER_TOKEN' 1307 ) 1308 1309 # Configure API key authorization: oidc_auth 1310 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1311 1312 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1313 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1314 1315 # Configure API key authorization: saml_auth 1316 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1317 1318 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1319 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1320 1321 # Enter a context with an instance of the API client 1322 with lakefs_client.ApiClient(configuration) as api_client: 1323 # Create an instance of the API class 1324 api_instance = internal_api.InternalApi(api_client) 1325 repository = "repository_example" # str | 1326 inline_object1 = InlineObject1( 1327 pattern="pattern_example", 1328 ) # InlineObject1 | 1329 1330 # example passing only required values which don't have defaults set 1331 try: 1332 api_instance.internal_delete_branch_protection_rule(repository, inline_object1) 1333 except lakefs_client.ApiException as e: 1334 print("Exception when calling InternalApi->internal_delete_branch_protection_rule: %s\n" % e) 1335 ``` 1336 1337 1338 ### Parameters 1339 1340 Name | Type | Description | Notes 1341 ------------- | ------------- | ------------- | ------------- 1342 **repository** | **str**| | 1343 **inline_object1** | [**InlineObject1**](InlineObject1.md)| | 1344 1345 ### Return type 1346 1347 void (empty response body) 1348 1349 ### Authorization 1350 1351 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1352 1353 ### HTTP request headers 1354 1355 - **Content-Type**: application/json 1356 - **Accept**: application/json 1357 1358 1359 ### HTTP response details 1360 1361 | Status code | Description | Response headers | 1362 |-------------|-------------|------------------| 1363 **204** | branch protection rule deleted successfully | - | 1364 **401** | Unauthorized | - | 1365 **404** | Resource Not Found | - | 1366 **420** | too many requests | - | 1367 **0** | Internal Server Error | - | 1368 1369 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1370 1371 # **internal_delete_garbage_collection_rules** 1372 > internal_delete_garbage_collection_rules(repository) 1373 1374 1375 1376 ### Example 1377 1378 * Basic Authentication (basic_auth): 1379 * Api Key Authentication (cookie_auth): 1380 * Bearer (JWT) Authentication (jwt_token): 1381 * Api Key Authentication (oidc_auth): 1382 * Api Key Authentication (saml_auth): 1383 1384 ```python 1385 import time 1386 import lakefs_client 1387 from lakefs_client.api import internal_api 1388 from lakefs_client.model.error import Error 1389 from pprint import pprint 1390 # Defining the host is optional and defaults to http://localhost/api/v1 1391 # See configuration.py for a list of all supported configuration parameters. 1392 configuration = lakefs_client.Configuration( 1393 host = "http://localhost/api/v1" 1394 ) 1395 1396 # The client must configure the authentication and authorization parameters 1397 # in accordance with the API server security policy. 1398 # Examples for each auth method are provided below, use the example that 1399 # satisfies your auth use case. 1400 1401 # Configure HTTP basic authorization: basic_auth 1402 configuration = lakefs_client.Configuration( 1403 username = 'YOUR_USERNAME', 1404 password = 'YOUR_PASSWORD' 1405 ) 1406 1407 # Configure API key authorization: cookie_auth 1408 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1409 1410 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1411 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1412 1413 # Configure Bearer authorization (JWT): jwt_token 1414 configuration = lakefs_client.Configuration( 1415 access_token = 'YOUR_BEARER_TOKEN' 1416 ) 1417 1418 # Configure API key authorization: oidc_auth 1419 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1420 1421 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1422 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1423 1424 # Configure API key authorization: saml_auth 1425 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1426 1427 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1428 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1429 1430 # Enter a context with an instance of the API client 1431 with lakefs_client.ApiClient(configuration) as api_client: 1432 # Create an instance of the API class 1433 api_instance = internal_api.InternalApi(api_client) 1434 repository = "repository_example" # str | 1435 1436 # example passing only required values which don't have defaults set 1437 try: 1438 api_instance.internal_delete_garbage_collection_rules(repository) 1439 except lakefs_client.ApiException as e: 1440 print("Exception when calling InternalApi->internal_delete_garbage_collection_rules: %s\n" % e) 1441 ``` 1442 1443 1444 ### Parameters 1445 1446 Name | Type | Description | Notes 1447 ------------- | ------------- | ------------- | ------------- 1448 **repository** | **str**| | 1449 1450 ### Return type 1451 1452 void (empty response body) 1453 1454 ### Authorization 1455 1456 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1457 1458 ### HTTP request headers 1459 1460 - **Content-Type**: Not defined 1461 - **Accept**: application/json 1462 1463 1464 ### HTTP response details 1465 1466 | Status code | Description | Response headers | 1467 |-------------|-------------|------------------| 1468 **204** | deleted garbage collection rules successfully | - | 1469 **401** | Unauthorized | - | 1470 **404** | Resource Not Found | - | 1471 **420** | too many requests | - | 1472 **0** | Internal Server Error | - | 1473 1474 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1475 1476 # **internal_get_branch_protection_rules** 1477 > [BranchProtectionRule] internal_get_branch_protection_rules(repository) 1478 1479 get branch protection rules 1480 1481 ### Example 1482 1483 * Basic Authentication (basic_auth): 1484 * Api Key Authentication (cookie_auth): 1485 * Bearer (JWT) Authentication (jwt_token): 1486 * Api Key Authentication (oidc_auth): 1487 * Api Key Authentication (saml_auth): 1488 1489 ```python 1490 import time 1491 import lakefs_client 1492 from lakefs_client.api import internal_api 1493 from lakefs_client.model.error import Error 1494 from lakefs_client.model.branch_protection_rule import BranchProtectionRule 1495 from pprint import pprint 1496 # Defining the host is optional and defaults to http://localhost/api/v1 1497 # See configuration.py for a list of all supported configuration parameters. 1498 configuration = lakefs_client.Configuration( 1499 host = "http://localhost/api/v1" 1500 ) 1501 1502 # The client must configure the authentication and authorization parameters 1503 # in accordance with the API server security policy. 1504 # Examples for each auth method are provided below, use the example that 1505 # satisfies your auth use case. 1506 1507 # Configure HTTP basic authorization: basic_auth 1508 configuration = lakefs_client.Configuration( 1509 username = 'YOUR_USERNAME', 1510 password = 'YOUR_PASSWORD' 1511 ) 1512 1513 # Configure API key authorization: cookie_auth 1514 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1515 1516 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1517 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1518 1519 # Configure Bearer authorization (JWT): jwt_token 1520 configuration = lakefs_client.Configuration( 1521 access_token = 'YOUR_BEARER_TOKEN' 1522 ) 1523 1524 # Configure API key authorization: oidc_auth 1525 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1526 1527 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1528 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1529 1530 # Configure API key authorization: saml_auth 1531 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1532 1533 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1534 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1535 1536 # Enter a context with an instance of the API client 1537 with lakefs_client.ApiClient(configuration) as api_client: 1538 # Create an instance of the API class 1539 api_instance = internal_api.InternalApi(api_client) 1540 repository = "repository_example" # str | 1541 1542 # example passing only required values which don't have defaults set 1543 try: 1544 # get branch protection rules 1545 api_response = api_instance.internal_get_branch_protection_rules(repository) 1546 pprint(api_response) 1547 except lakefs_client.ApiException as e: 1548 print("Exception when calling InternalApi->internal_get_branch_protection_rules: %s\n" % e) 1549 ``` 1550 1551 1552 ### Parameters 1553 1554 Name | Type | Description | Notes 1555 ------------- | ------------- | ------------- | ------------- 1556 **repository** | **str**| | 1557 1558 ### Return type 1559 1560 [**[BranchProtectionRule]**](BranchProtectionRule.md) 1561 1562 ### Authorization 1563 1564 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1565 1566 ### HTTP request headers 1567 1568 - **Content-Type**: Not defined 1569 - **Accept**: application/json 1570 1571 1572 ### HTTP response details 1573 1574 | Status code | Description | Response headers | 1575 |-------------|-------------|------------------| 1576 **200** | branch protection rules | - | 1577 **401** | Unauthorized | - | 1578 **404** | Resource Not Found | - | 1579 **420** | too many requests | - | 1580 **0** | Internal Server Error | - | 1581 1582 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1583 1584 # **internal_get_garbage_collection_rules** 1585 > GarbageCollectionRules internal_get_garbage_collection_rules(repository) 1586 1587 1588 1589 ### Example 1590 1591 * Basic Authentication (basic_auth): 1592 * Api Key Authentication (cookie_auth): 1593 * Bearer (JWT) Authentication (jwt_token): 1594 * Api Key Authentication (oidc_auth): 1595 * Api Key Authentication (saml_auth): 1596 1597 ```python 1598 import time 1599 import lakefs_client 1600 from lakefs_client.api import internal_api 1601 from lakefs_client.model.garbage_collection_rules import GarbageCollectionRules 1602 from lakefs_client.model.error import Error 1603 from pprint import pprint 1604 # Defining the host is optional and defaults to http://localhost/api/v1 1605 # See configuration.py for a list of all supported configuration parameters. 1606 configuration = lakefs_client.Configuration( 1607 host = "http://localhost/api/v1" 1608 ) 1609 1610 # The client must configure the authentication and authorization parameters 1611 # in accordance with the API server security policy. 1612 # Examples for each auth method are provided below, use the example that 1613 # satisfies your auth use case. 1614 1615 # Configure HTTP basic authorization: basic_auth 1616 configuration = lakefs_client.Configuration( 1617 username = 'YOUR_USERNAME', 1618 password = 'YOUR_PASSWORD' 1619 ) 1620 1621 # Configure API key authorization: cookie_auth 1622 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1623 1624 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1625 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1626 1627 # Configure Bearer authorization (JWT): jwt_token 1628 configuration = lakefs_client.Configuration( 1629 access_token = 'YOUR_BEARER_TOKEN' 1630 ) 1631 1632 # Configure API key authorization: oidc_auth 1633 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1634 1635 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1636 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1637 1638 # Configure API key authorization: saml_auth 1639 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1640 1641 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1642 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1643 1644 # Enter a context with an instance of the API client 1645 with lakefs_client.ApiClient(configuration) as api_client: 1646 # Create an instance of the API class 1647 api_instance = internal_api.InternalApi(api_client) 1648 repository = "repository_example" # str | 1649 1650 # example passing only required values which don't have defaults set 1651 try: 1652 api_response = api_instance.internal_get_garbage_collection_rules(repository) 1653 pprint(api_response) 1654 except lakefs_client.ApiException as e: 1655 print("Exception when calling InternalApi->internal_get_garbage_collection_rules: %s\n" % e) 1656 ``` 1657 1658 1659 ### Parameters 1660 1661 Name | Type | Description | Notes 1662 ------------- | ------------- | ------------- | ------------- 1663 **repository** | **str**| | 1664 1665 ### Return type 1666 1667 [**GarbageCollectionRules**](GarbageCollectionRules.md) 1668 1669 ### Authorization 1670 1671 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1672 1673 ### HTTP request headers 1674 1675 - **Content-Type**: Not defined 1676 - **Accept**: application/json 1677 1678 1679 ### HTTP response details 1680 1681 | Status code | Description | Response headers | 1682 |-------------|-------------|------------------| 1683 **200** | gc rule list | - | 1684 **401** | Unauthorized | - | 1685 **404** | Resource Not Found | - | 1686 **420** | too many requests | - | 1687 **0** | Internal Server Error | - | 1688 1689 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1690 1691 # **internal_set_garbage_collection_rules** 1692 > internal_set_garbage_collection_rules(repository, garbage_collection_rules) 1693 1694 1695 1696 ### Example 1697 1698 * Basic Authentication (basic_auth): 1699 * Api Key Authentication (cookie_auth): 1700 * Bearer (JWT) Authentication (jwt_token): 1701 * Api Key Authentication (oidc_auth): 1702 * Api Key Authentication (saml_auth): 1703 1704 ```python 1705 import time 1706 import lakefs_client 1707 from lakefs_client.api import internal_api 1708 from lakefs_client.model.garbage_collection_rules import GarbageCollectionRules 1709 from lakefs_client.model.error import Error 1710 from pprint import pprint 1711 # Defining the host is optional and defaults to http://localhost/api/v1 1712 # See configuration.py for a list of all supported configuration parameters. 1713 configuration = lakefs_client.Configuration( 1714 host = "http://localhost/api/v1" 1715 ) 1716 1717 # The client must configure the authentication and authorization parameters 1718 # in accordance with the API server security policy. 1719 # Examples for each auth method are provided below, use the example that 1720 # satisfies your auth use case. 1721 1722 # Configure HTTP basic authorization: basic_auth 1723 configuration = lakefs_client.Configuration( 1724 username = 'YOUR_USERNAME', 1725 password = 'YOUR_PASSWORD' 1726 ) 1727 1728 # Configure API key authorization: cookie_auth 1729 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1730 1731 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1732 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1733 1734 # Configure Bearer authorization (JWT): jwt_token 1735 configuration = lakefs_client.Configuration( 1736 access_token = 'YOUR_BEARER_TOKEN' 1737 ) 1738 1739 # Configure API key authorization: oidc_auth 1740 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1741 1742 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1743 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1744 1745 # Configure API key authorization: saml_auth 1746 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1747 1748 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1749 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1750 1751 # Enter a context with an instance of the API client 1752 with lakefs_client.ApiClient(configuration) as api_client: 1753 # Create an instance of the API class 1754 api_instance = internal_api.InternalApi(api_client) 1755 repository = "repository_example" # str | 1756 garbage_collection_rules = GarbageCollectionRules( 1757 default_retention_days=1, 1758 branches=[ 1759 GarbageCollectionRule( 1760 branch_id="branch_id_example", 1761 retention_days=1, 1762 ), 1763 ], 1764 ) # GarbageCollectionRules | 1765 1766 # example passing only required values which don't have defaults set 1767 try: 1768 api_instance.internal_set_garbage_collection_rules(repository, garbage_collection_rules) 1769 except lakefs_client.ApiException as e: 1770 print("Exception when calling InternalApi->internal_set_garbage_collection_rules: %s\n" % e) 1771 ``` 1772 1773 1774 ### Parameters 1775 1776 Name | Type | Description | Notes 1777 ------------- | ------------- | ------------- | ------------- 1778 **repository** | **str**| | 1779 **garbage_collection_rules** | [**GarbageCollectionRules**](GarbageCollectionRules.md)| | 1780 1781 ### Return type 1782 1783 void (empty response body) 1784 1785 ### Authorization 1786 1787 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1788 1789 ### HTTP request headers 1790 1791 - **Content-Type**: application/json 1792 - **Accept**: application/json 1793 1794 1795 ### HTTP response details 1796 1797 | Status code | Description | Response headers | 1798 |-------------|-------------|------------------| 1799 **204** | set garbage collection rules successfully | - | 1800 **401** | Unauthorized | - | 1801 **404** | Resource Not Found | - | 1802 **420** | too many requests | - | 1803 **0** | Internal Server Error | - | 1804 1805 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1806 1807 # **post_stats_events** 1808 > post_stats_events(stats_events_list) 1809 1810 post stats events, this endpoint is meant for internal use only 1811 1812 ### Example 1813 1814 * Basic Authentication (basic_auth): 1815 * Api Key Authentication (cookie_auth): 1816 * Bearer (JWT) Authentication (jwt_token): 1817 * Api Key Authentication (oidc_auth): 1818 * Api Key Authentication (saml_auth): 1819 1820 ```python 1821 import time 1822 import lakefs_client 1823 from lakefs_client.api import internal_api 1824 from lakefs_client.model.error import Error 1825 from lakefs_client.model.stats_events_list import StatsEventsList 1826 from pprint import pprint 1827 # Defining the host is optional and defaults to http://localhost/api/v1 1828 # See configuration.py for a list of all supported configuration parameters. 1829 configuration = lakefs_client.Configuration( 1830 host = "http://localhost/api/v1" 1831 ) 1832 1833 # The client must configure the authentication and authorization parameters 1834 # in accordance with the API server security policy. 1835 # Examples for each auth method are provided below, use the example that 1836 # satisfies your auth use case. 1837 1838 # Configure HTTP basic authorization: basic_auth 1839 configuration = lakefs_client.Configuration( 1840 username = 'YOUR_USERNAME', 1841 password = 'YOUR_PASSWORD' 1842 ) 1843 1844 # Configure API key authorization: cookie_auth 1845 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1846 1847 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1848 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1849 1850 # Configure Bearer authorization (JWT): jwt_token 1851 configuration = lakefs_client.Configuration( 1852 access_token = 'YOUR_BEARER_TOKEN' 1853 ) 1854 1855 # Configure API key authorization: oidc_auth 1856 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1857 1858 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1859 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1860 1861 # Configure API key authorization: saml_auth 1862 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1863 1864 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1865 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1866 1867 # Enter a context with an instance of the API client 1868 with lakefs_client.ApiClient(configuration) as api_client: 1869 # Create an instance of the API class 1870 api_instance = internal_api.InternalApi(api_client) 1871 stats_events_list = StatsEventsList( 1872 events=[ 1873 StatsEvent( 1874 _class="_class_example", 1875 name="name_example", 1876 count=1, 1877 ), 1878 ], 1879 ) # StatsEventsList | 1880 1881 # example passing only required values which don't have defaults set 1882 try: 1883 # post stats events, this endpoint is meant for internal use only 1884 api_instance.post_stats_events(stats_events_list) 1885 except lakefs_client.ApiException as e: 1886 print("Exception when calling InternalApi->post_stats_events: %s\n" % e) 1887 ``` 1888 1889 1890 ### Parameters 1891 1892 Name | Type | Description | Notes 1893 ------------- | ------------- | ------------- | ------------- 1894 **stats_events_list** | [**StatsEventsList**](StatsEventsList.md)| | 1895 1896 ### Return type 1897 1898 void (empty response body) 1899 1900 ### Authorization 1901 1902 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 1903 1904 ### HTTP request headers 1905 1906 - **Content-Type**: application/json 1907 - **Accept**: application/json 1908 1909 1910 ### HTTP response details 1911 1912 | Status code | Description | Response headers | 1913 |-------------|-------------|------------------| 1914 **204** | reported successfully | - | 1915 **400** | Bad Request | - | 1916 **401** | Unauthorized | - | 1917 **420** | too many requests | - | 1918 **0** | Internal Server Error | - | 1919 1920 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 1921 1922 # **prepare_garbage_collection_commits** 1923 > GarbageCollectionPrepareResponse prepare_garbage_collection_commits(repository) 1924 1925 save lists of active commits for garbage collection 1926 1927 ### Example 1928 1929 * Basic Authentication (basic_auth): 1930 * Api Key Authentication (cookie_auth): 1931 * Bearer (JWT) Authentication (jwt_token): 1932 * Api Key Authentication (oidc_auth): 1933 * Api Key Authentication (saml_auth): 1934 1935 ```python 1936 import time 1937 import lakefs_client 1938 from lakefs_client.api import internal_api 1939 from lakefs_client.model.error import Error 1940 from lakefs_client.model.garbage_collection_prepare_response import GarbageCollectionPrepareResponse 1941 from pprint import pprint 1942 # Defining the host is optional and defaults to http://localhost/api/v1 1943 # See configuration.py for a list of all supported configuration parameters. 1944 configuration = lakefs_client.Configuration( 1945 host = "http://localhost/api/v1" 1946 ) 1947 1948 # The client must configure the authentication and authorization parameters 1949 # in accordance with the API server security policy. 1950 # Examples for each auth method are provided below, use the example that 1951 # satisfies your auth use case. 1952 1953 # Configure HTTP basic authorization: basic_auth 1954 configuration = lakefs_client.Configuration( 1955 username = 'YOUR_USERNAME', 1956 password = 'YOUR_PASSWORD' 1957 ) 1958 1959 # Configure API key authorization: cookie_auth 1960 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 1961 1962 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1963 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 1964 1965 # Configure Bearer authorization (JWT): jwt_token 1966 configuration = lakefs_client.Configuration( 1967 access_token = 'YOUR_BEARER_TOKEN' 1968 ) 1969 1970 # Configure API key authorization: oidc_auth 1971 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 1972 1973 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1974 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 1975 1976 # Configure API key authorization: saml_auth 1977 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 1978 1979 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 1980 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 1981 1982 # Enter a context with an instance of the API client 1983 with lakefs_client.ApiClient(configuration) as api_client: 1984 # Create an instance of the API class 1985 api_instance = internal_api.InternalApi(api_client) 1986 repository = "repository_example" # str | 1987 1988 # example passing only required values which don't have defaults set 1989 try: 1990 # save lists of active commits for garbage collection 1991 api_response = api_instance.prepare_garbage_collection_commits(repository) 1992 pprint(api_response) 1993 except lakefs_client.ApiException as e: 1994 print("Exception when calling InternalApi->prepare_garbage_collection_commits: %s\n" % e) 1995 ``` 1996 1997 1998 ### Parameters 1999 2000 Name | Type | Description | Notes 2001 ------------- | ------------- | ------------- | ------------- 2002 **repository** | **str**| | 2003 2004 ### Return type 2005 2006 [**GarbageCollectionPrepareResponse**](GarbageCollectionPrepareResponse.md) 2007 2008 ### Authorization 2009 2010 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2011 2012 ### HTTP request headers 2013 2014 - **Content-Type**: Not defined 2015 - **Accept**: application/json 2016 2017 2018 ### HTTP response details 2019 2020 | Status code | Description | Response headers | 2021 |-------------|-------------|------------------| 2022 **201** | paths to commit dataset | - | 2023 **401** | Unauthorized | - | 2024 **403** | Forbidden | - | 2025 **404** | Resource Not Found | - | 2026 **420** | too many requests | - | 2027 **0** | Internal Server Error | - | 2028 2029 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2030 2031 # **prepare_garbage_collection_uncommitted** 2032 > PrepareGCUncommittedResponse prepare_garbage_collection_uncommitted(repository) 2033 2034 save repository uncommitted metadata for garbage collection 2035 2036 ### Example 2037 2038 * Basic Authentication (basic_auth): 2039 * Api Key Authentication (cookie_auth): 2040 * Bearer (JWT) Authentication (jwt_token): 2041 * Api Key Authentication (oidc_auth): 2042 * Api Key Authentication (saml_auth): 2043 2044 ```python 2045 import time 2046 import lakefs_client 2047 from lakefs_client.api import internal_api 2048 from lakefs_client.model.prepare_gc_uncommitted_response import PrepareGCUncommittedResponse 2049 from lakefs_client.model.prepare_gc_uncommitted_request import PrepareGCUncommittedRequest 2050 from lakefs_client.model.error import Error 2051 from pprint import pprint 2052 # Defining the host is optional and defaults to http://localhost/api/v1 2053 # See configuration.py for a list of all supported configuration parameters. 2054 configuration = lakefs_client.Configuration( 2055 host = "http://localhost/api/v1" 2056 ) 2057 2058 # The client must configure the authentication and authorization parameters 2059 # in accordance with the API server security policy. 2060 # Examples for each auth method are provided below, use the example that 2061 # satisfies your auth use case. 2062 2063 # Configure HTTP basic authorization: basic_auth 2064 configuration = lakefs_client.Configuration( 2065 username = 'YOUR_USERNAME', 2066 password = 'YOUR_PASSWORD' 2067 ) 2068 2069 # Configure API key authorization: cookie_auth 2070 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 2071 2072 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2073 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 2074 2075 # Configure Bearer authorization (JWT): jwt_token 2076 configuration = lakefs_client.Configuration( 2077 access_token = 'YOUR_BEARER_TOKEN' 2078 ) 2079 2080 # Configure API key authorization: oidc_auth 2081 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 2082 2083 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2084 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 2085 2086 # Configure API key authorization: saml_auth 2087 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 2088 2089 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2090 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 2091 2092 # Enter a context with an instance of the API client 2093 with lakefs_client.ApiClient(configuration) as api_client: 2094 # Create an instance of the API class 2095 api_instance = internal_api.InternalApi(api_client) 2096 repository = "repository_example" # str | 2097 prepare_gc_uncommitted_request = PrepareGCUncommittedRequest( 2098 continuation_token="continuation_token_example", 2099 ) # PrepareGCUncommittedRequest | (optional) 2100 2101 # example passing only required values which don't have defaults set 2102 try: 2103 # save repository uncommitted metadata for garbage collection 2104 api_response = api_instance.prepare_garbage_collection_uncommitted(repository) 2105 pprint(api_response) 2106 except lakefs_client.ApiException as e: 2107 print("Exception when calling InternalApi->prepare_garbage_collection_uncommitted: %s\n" % e) 2108 2109 # example passing only required values which don't have defaults set 2110 # and optional values 2111 try: 2112 # save repository uncommitted metadata for garbage collection 2113 api_response = api_instance.prepare_garbage_collection_uncommitted(repository, prepare_gc_uncommitted_request=prepare_gc_uncommitted_request) 2114 pprint(api_response) 2115 except lakefs_client.ApiException as e: 2116 print("Exception when calling InternalApi->prepare_garbage_collection_uncommitted: %s\n" % e) 2117 ``` 2118 2119 2120 ### Parameters 2121 2122 Name | Type | Description | Notes 2123 ------------- | ------------- | ------------- | ------------- 2124 **repository** | **str**| | 2125 **prepare_gc_uncommitted_request** | [**PrepareGCUncommittedRequest**](PrepareGCUncommittedRequest.md)| | [optional] 2126 2127 ### Return type 2128 2129 [**PrepareGCUncommittedResponse**](PrepareGCUncommittedResponse.md) 2130 2131 ### Authorization 2132 2133 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2134 2135 ### HTTP request headers 2136 2137 - **Content-Type**: application/json 2138 - **Accept**: application/json 2139 2140 2141 ### HTTP response details 2142 2143 | Status code | Description | Response headers | 2144 |-------------|-------------|------------------| 2145 **201** | paths to commit dataset | - | 2146 **400** | Validation Error | - | 2147 **401** | Unauthorized | - | 2148 **403** | Forbidden | - | 2149 **404** | Resource Not Found | - | 2150 **420** | too many requests | - | 2151 **0** | Internal Server Error | - | 2152 2153 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2154 2155 # **restore_refs** 2156 > restore_refs(repository, refs_restore) 2157 2158 Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations 2159 2160 ### Example 2161 2162 * Basic Authentication (basic_auth): 2163 * Api Key Authentication (cookie_auth): 2164 * Bearer (JWT) Authentication (jwt_token): 2165 * Api Key Authentication (oidc_auth): 2166 * Api Key Authentication (saml_auth): 2167 2168 ```python 2169 import time 2170 import lakefs_client 2171 from lakefs_client.api import internal_api 2172 from lakefs_client.model.refs_restore import RefsRestore 2173 from lakefs_client.model.error import Error 2174 from pprint import pprint 2175 # Defining the host is optional and defaults to http://localhost/api/v1 2176 # See configuration.py for a list of all supported configuration parameters. 2177 configuration = lakefs_client.Configuration( 2178 host = "http://localhost/api/v1" 2179 ) 2180 2181 # The client must configure the authentication and authorization parameters 2182 # in accordance with the API server security policy. 2183 # Examples for each auth method are provided below, use the example that 2184 # satisfies your auth use case. 2185 2186 # Configure HTTP basic authorization: basic_auth 2187 configuration = lakefs_client.Configuration( 2188 username = 'YOUR_USERNAME', 2189 password = 'YOUR_PASSWORD' 2190 ) 2191 2192 # Configure API key authorization: cookie_auth 2193 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 2194 2195 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2196 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 2197 2198 # Configure Bearer authorization (JWT): jwt_token 2199 configuration = lakefs_client.Configuration( 2200 access_token = 'YOUR_BEARER_TOKEN' 2201 ) 2202 2203 # Configure API key authorization: oidc_auth 2204 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 2205 2206 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2207 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 2208 2209 # Configure API key authorization: saml_auth 2210 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 2211 2212 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2213 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 2214 2215 # Enter a context with an instance of the API client 2216 with lakefs_client.ApiClient(configuration) as api_client: 2217 # Create an instance of the API class 2218 api_instance = internal_api.InternalApi(api_client) 2219 repository = "repository_example" # str | 2220 refs_restore = RefsRestore( 2221 commits_meta_range_id="commits_meta_range_id_example", 2222 tags_meta_range_id="tags_meta_range_id_example", 2223 branches_meta_range_id="branches_meta_range_id_example", 2224 force=False, 2225 ) # RefsRestore | 2226 2227 # example passing only required values which don't have defaults set 2228 try: 2229 # Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations 2230 api_instance.restore_refs(repository, refs_restore) 2231 except lakefs_client.ApiException as e: 2232 print("Exception when calling InternalApi->restore_refs: %s\n" % e) 2233 ``` 2234 2235 2236 ### Parameters 2237 2238 Name | Type | Description | Notes 2239 ------------- | ------------- | ------------- | ------------- 2240 **repository** | **str**| | 2241 **refs_restore** | [**RefsRestore**](RefsRestore.md)| | 2242 2243 ### Return type 2244 2245 void (empty response body) 2246 2247 ### Authorization 2248 2249 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2250 2251 ### HTTP request headers 2252 2253 - **Content-Type**: application/json 2254 - **Accept**: application/json 2255 2256 2257 ### HTTP response details 2258 2259 | Status code | Description | Response headers | 2260 |-------------|-------------|------------------| 2261 **200** | refs successfully loaded | - | 2262 **400** | Validation Error | - | 2263 **401** | Unauthorized | - | 2264 **404** | Resource Not Found | - | 2265 **420** | too many requests | - | 2266 **0** | Internal Server Error | - | 2267 2268 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2269 2270 # **set_garbage_collection_rules_preflight** 2271 > set_garbage_collection_rules_preflight(repository) 2272 2273 2274 2275 ### Example 2276 2277 * Basic Authentication (basic_auth): 2278 * Api Key Authentication (cookie_auth): 2279 * Bearer (JWT) Authentication (jwt_token): 2280 * Api Key Authentication (oidc_auth): 2281 * Api Key Authentication (saml_auth): 2282 2283 ```python 2284 import time 2285 import lakefs_client 2286 from lakefs_client.api import internal_api 2287 from lakefs_client.model.error import Error 2288 from pprint import pprint 2289 # Defining the host is optional and defaults to http://localhost/api/v1 2290 # See configuration.py for a list of all supported configuration parameters. 2291 configuration = lakefs_client.Configuration( 2292 host = "http://localhost/api/v1" 2293 ) 2294 2295 # The client must configure the authentication and authorization parameters 2296 # in accordance with the API server security policy. 2297 # Examples for each auth method are provided below, use the example that 2298 # satisfies your auth use case. 2299 2300 # Configure HTTP basic authorization: basic_auth 2301 configuration = lakefs_client.Configuration( 2302 username = 'YOUR_USERNAME', 2303 password = 'YOUR_PASSWORD' 2304 ) 2305 2306 # Configure API key authorization: cookie_auth 2307 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 2308 2309 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2310 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 2311 2312 # Configure Bearer authorization (JWT): jwt_token 2313 configuration = lakefs_client.Configuration( 2314 access_token = 'YOUR_BEARER_TOKEN' 2315 ) 2316 2317 # Configure API key authorization: oidc_auth 2318 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 2319 2320 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2321 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 2322 2323 # Configure API key authorization: saml_auth 2324 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 2325 2326 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2327 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 2328 2329 # Enter a context with an instance of the API client 2330 with lakefs_client.ApiClient(configuration) as api_client: 2331 # Create an instance of the API class 2332 api_instance = internal_api.InternalApi(api_client) 2333 repository = "repository_example" # str | 2334 2335 # example passing only required values which don't have defaults set 2336 try: 2337 api_instance.set_garbage_collection_rules_preflight(repository) 2338 except lakefs_client.ApiException as e: 2339 print("Exception when calling InternalApi->set_garbage_collection_rules_preflight: %s\n" % e) 2340 ``` 2341 2342 2343 ### Parameters 2344 2345 Name | Type | Description | Notes 2346 ------------- | ------------- | ------------- | ------------- 2347 **repository** | **str**| | 2348 2349 ### Return type 2350 2351 void (empty response body) 2352 2353 ### Authorization 2354 2355 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2356 2357 ### HTTP request headers 2358 2359 - **Content-Type**: Not defined 2360 - **Accept**: application/json 2361 2362 2363 ### HTTP response details 2364 2365 | Status code | Description | Response headers | 2366 |-------------|-------------|------------------| 2367 **204** | User has permissions to set garbage collection rules on this repository | - | 2368 **401** | Unauthorized | - | 2369 **404** | Resource Not Found | - | 2370 **420** | too many requests | - | 2371 **0** | Internal Server Error | - | 2372 2373 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2374 2375 # **set_repository_metadata** 2376 > set_repository_metadata(repository, repository_metadata_set) 2377 2378 set repository metadata 2379 2380 Set repository metadata. This will only add or update the provided keys, and will not remove any existing keys. 2381 2382 ### Example 2383 2384 * Basic Authentication (basic_auth): 2385 * Api Key Authentication (cookie_auth): 2386 * Bearer (JWT) Authentication (jwt_token): 2387 * Api Key Authentication (oidc_auth): 2388 * Api Key Authentication (saml_auth): 2389 2390 ```python 2391 import time 2392 import lakefs_client 2393 from lakefs_client.api import internal_api 2394 from lakefs_client.model.repository_metadata_set import RepositoryMetadataSet 2395 from lakefs_client.model.error import Error 2396 from pprint import pprint 2397 # Defining the host is optional and defaults to http://localhost/api/v1 2398 # See configuration.py for a list of all supported configuration parameters. 2399 configuration = lakefs_client.Configuration( 2400 host = "http://localhost/api/v1" 2401 ) 2402 2403 # The client must configure the authentication and authorization parameters 2404 # in accordance with the API server security policy. 2405 # Examples for each auth method are provided below, use the example that 2406 # satisfies your auth use case. 2407 2408 # Configure HTTP basic authorization: basic_auth 2409 configuration = lakefs_client.Configuration( 2410 username = 'YOUR_USERNAME', 2411 password = 'YOUR_PASSWORD' 2412 ) 2413 2414 # Configure API key authorization: cookie_auth 2415 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 2416 2417 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2418 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 2419 2420 # Configure Bearer authorization (JWT): jwt_token 2421 configuration = lakefs_client.Configuration( 2422 access_token = 'YOUR_BEARER_TOKEN' 2423 ) 2424 2425 # Configure API key authorization: oidc_auth 2426 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 2427 2428 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2429 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 2430 2431 # Configure API key authorization: saml_auth 2432 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 2433 2434 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2435 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 2436 2437 # Enter a context with an instance of the API client 2438 with lakefs_client.ApiClient(configuration) as api_client: 2439 # Create an instance of the API class 2440 api_instance = internal_api.InternalApi(api_client) 2441 repository = "repository_example" # str | 2442 repository_metadata_set = RepositoryMetadataSet( 2443 metadata={ 2444 "key": "key_example", 2445 }, 2446 ) # RepositoryMetadataSet | 2447 2448 # example passing only required values which don't have defaults set 2449 try: 2450 # set repository metadata 2451 api_instance.set_repository_metadata(repository, repository_metadata_set) 2452 except lakefs_client.ApiException as e: 2453 print("Exception when calling InternalApi->set_repository_metadata: %s\n" % e) 2454 ``` 2455 2456 2457 ### Parameters 2458 2459 Name | Type | Description | Notes 2460 ------------- | ------------- | ------------- | ------------- 2461 **repository** | **str**| | 2462 **repository_metadata_set** | [**RepositoryMetadataSet**](RepositoryMetadataSet.md)| | 2463 2464 ### Return type 2465 2466 void (empty response body) 2467 2468 ### Authorization 2469 2470 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2471 2472 ### HTTP request headers 2473 2474 - **Content-Type**: application/json 2475 - **Accept**: application/json 2476 2477 2478 ### HTTP response details 2479 2480 | Status code | Description | Response headers | 2481 |-------------|-------------|------------------| 2482 **204** | repository metadata set successfully | - | 2483 **401** | Unauthorized | - | 2484 **404** | Resource Not Found | - | 2485 **420** | too many requests | - | 2486 **0** | Internal Server Error | - | 2487 2488 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2489 2490 # **setup** 2491 > CredentialsWithSecret setup(setup) 2492 2493 setup lakeFS and create a first user 2494 2495 ### Example 2496 2497 2498 ```python 2499 import time 2500 import lakefs_client 2501 from lakefs_client.api import internal_api 2502 from lakefs_client.model.credentials_with_secret import CredentialsWithSecret 2503 from lakefs_client.model.setup import Setup 2504 from lakefs_client.model.error import Error 2505 from pprint import pprint 2506 # Defining the host is optional and defaults to http://localhost/api/v1 2507 # See configuration.py for a list of all supported configuration parameters. 2508 configuration = lakefs_client.Configuration( 2509 host = "http://localhost/api/v1" 2510 ) 2511 2512 2513 # Enter a context with an instance of the API client 2514 with lakefs_client.ApiClient() as api_client: 2515 # Create an instance of the API class 2516 api_instance = internal_api.InternalApi(api_client) 2517 setup = Setup( 2518 username="username_example", 2519 key=AccessKeyCredentials( 2520 access_key_id="AKIAIOSFODNN7EXAMPLE", 2521 secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", 2522 ), 2523 ) # Setup | 2524 2525 # example passing only required values which don't have defaults set 2526 try: 2527 # setup lakeFS and create a first user 2528 api_response = api_instance.setup(setup) 2529 pprint(api_response) 2530 except lakefs_client.ApiException as e: 2531 print("Exception when calling InternalApi->setup: %s\n" % e) 2532 ``` 2533 2534 2535 ### Parameters 2536 2537 Name | Type | Description | Notes 2538 ------------- | ------------- | ------------- | ------------- 2539 **setup** | [**Setup**](Setup.md)| | 2540 2541 ### Return type 2542 2543 [**CredentialsWithSecret**](CredentialsWithSecret.md) 2544 2545 ### Authorization 2546 2547 No authorization required 2548 2549 ### HTTP request headers 2550 2551 - **Content-Type**: application/json 2552 - **Accept**: application/json 2553 2554 2555 ### HTTP response details 2556 2557 | Status code | Description | Response headers | 2558 |-------------|-------------|------------------| 2559 **200** | user created successfully | - | 2560 **400** | Bad Request | - | 2561 **409** | setup was already called | - | 2562 **420** | too many requests | - | 2563 **0** | Internal Server Error | - | 2564 2565 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2566 2567 # **setup_comm_prefs** 2568 > setup_comm_prefs(comm_prefs_input) 2569 2570 setup communications preferences 2571 2572 ### Example 2573 2574 2575 ```python 2576 import time 2577 import lakefs_client 2578 from lakefs_client.api import internal_api 2579 from lakefs_client.model.comm_prefs_input import CommPrefsInput 2580 from lakefs_client.model.error import Error 2581 from pprint import pprint 2582 # Defining the host is optional and defaults to http://localhost/api/v1 2583 # See configuration.py for a list of all supported configuration parameters. 2584 configuration = lakefs_client.Configuration( 2585 host = "http://localhost/api/v1" 2586 ) 2587 2588 2589 # Enter a context with an instance of the API client 2590 with lakefs_client.ApiClient() as api_client: 2591 # Create an instance of the API class 2592 api_instance = internal_api.InternalApi(api_client) 2593 comm_prefs_input = CommPrefsInput( 2594 email="email_example", 2595 feature_updates=True, 2596 security_updates=True, 2597 ) # CommPrefsInput | 2598 2599 # example passing only required values which don't have defaults set 2600 try: 2601 # setup communications preferences 2602 api_instance.setup_comm_prefs(comm_prefs_input) 2603 except lakefs_client.ApiException as e: 2604 print("Exception when calling InternalApi->setup_comm_prefs: %s\n" % e) 2605 ``` 2606 2607 2608 ### Parameters 2609 2610 Name | Type | Description | Notes 2611 ------------- | ------------- | ------------- | ------------- 2612 **comm_prefs_input** | [**CommPrefsInput**](CommPrefsInput.md)| | 2613 2614 ### Return type 2615 2616 void (empty response body) 2617 2618 ### Authorization 2619 2620 No authorization required 2621 2622 ### HTTP request headers 2623 2624 - **Content-Type**: application/json 2625 - **Accept**: application/json 2626 2627 2628 ### HTTP response details 2629 2630 | Status code | Description | Response headers | 2631 |-------------|-------------|------------------| 2632 **200** | communication preferences saved successfully | - | 2633 **409** | setup was already completed | - | 2634 **412** | wrong setup state for this operation | - | 2635 **420** | too many requests | - | 2636 **0** | Internal Server Error | - | 2637 2638 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2639 2640 # **stage_object** 2641 > ObjectStats stage_object(repository, branch, path, object_stage_creation) 2642 2643 stage an object's metadata for the given branch 2644 2645 ### Example 2646 2647 * Basic Authentication (basic_auth): 2648 * Api Key Authentication (cookie_auth): 2649 * Bearer (JWT) Authentication (jwt_token): 2650 * Api Key Authentication (oidc_auth): 2651 * Api Key Authentication (saml_auth): 2652 2653 ```python 2654 import time 2655 import lakefs_client 2656 from lakefs_client.api import internal_api 2657 from lakefs_client.model.object_stage_creation import ObjectStageCreation 2658 from lakefs_client.model.error import Error 2659 from lakefs_client.model.object_stats import ObjectStats 2660 from pprint import pprint 2661 # Defining the host is optional and defaults to http://localhost/api/v1 2662 # See configuration.py for a list of all supported configuration parameters. 2663 configuration = lakefs_client.Configuration( 2664 host = "http://localhost/api/v1" 2665 ) 2666 2667 # The client must configure the authentication and authorization parameters 2668 # in accordance with the API server security policy. 2669 # Examples for each auth method are provided below, use the example that 2670 # satisfies your auth use case. 2671 2672 # Configure HTTP basic authorization: basic_auth 2673 configuration = lakefs_client.Configuration( 2674 username = 'YOUR_USERNAME', 2675 password = 'YOUR_PASSWORD' 2676 ) 2677 2678 # Configure API key authorization: cookie_auth 2679 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 2680 2681 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2682 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 2683 2684 # Configure Bearer authorization (JWT): jwt_token 2685 configuration = lakefs_client.Configuration( 2686 access_token = 'YOUR_BEARER_TOKEN' 2687 ) 2688 2689 # Configure API key authorization: oidc_auth 2690 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 2691 2692 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2693 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 2694 2695 # Configure API key authorization: saml_auth 2696 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 2697 2698 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2699 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 2700 2701 # Enter a context with an instance of the API client 2702 with lakefs_client.ApiClient(configuration) as api_client: 2703 # Create an instance of the API class 2704 api_instance = internal_api.InternalApi(api_client) 2705 repository = "repository_example" # str | 2706 branch = "branch_example" # str | 2707 path = "path_example" # str | relative to the branch 2708 object_stage_creation = ObjectStageCreation( 2709 physical_address="physical_address_example", 2710 checksum="checksum_example", 2711 size_bytes=1, 2712 mtime=1, 2713 metadata=ObjectUserMetadata( 2714 key="key_example", 2715 ), 2716 content_type="content_type_example", 2717 force=False, 2718 ) # ObjectStageCreation | 2719 2720 # example passing only required values which don't have defaults set 2721 try: 2722 # stage an object's metadata for the given branch 2723 api_response = api_instance.stage_object(repository, branch, path, object_stage_creation) 2724 pprint(api_response) 2725 except lakefs_client.ApiException as e: 2726 print("Exception when calling InternalApi->stage_object: %s\n" % e) 2727 ``` 2728 2729 2730 ### Parameters 2731 2732 Name | Type | Description | Notes 2733 ------------- | ------------- | ------------- | ------------- 2734 **repository** | **str**| | 2735 **branch** | **str**| | 2736 **path** | **str**| relative to the branch | 2737 **object_stage_creation** | [**ObjectStageCreation**](ObjectStageCreation.md)| | 2738 2739 ### Return type 2740 2741 [**ObjectStats**](ObjectStats.md) 2742 2743 ### Authorization 2744 2745 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2746 2747 ### HTTP request headers 2748 2749 - **Content-Type**: application/json 2750 - **Accept**: application/json 2751 2752 2753 ### HTTP response details 2754 2755 | Status code | Description | Response headers | 2756 |-------------|-------------|------------------| 2757 **201** | object metadata | - | 2758 **400** | Validation Error | - | 2759 **401** | Unauthorized | - | 2760 **403** | Forbidden | - | 2761 **404** | Resource Not Found | - | 2762 **420** | too many requests | - | 2763 **0** | Internal Server Error | - | 2764 2765 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2766 2767 # **upload_object_preflight** 2768 > upload_object_preflight(repository, branch, path) 2769 2770 2771 2772 ### Example 2773 2774 * Basic Authentication (basic_auth): 2775 * Api Key Authentication (cookie_auth): 2776 * Bearer (JWT) Authentication (jwt_token): 2777 * Api Key Authentication (oidc_auth): 2778 * Api Key Authentication (saml_auth): 2779 2780 ```python 2781 import time 2782 import lakefs_client 2783 from lakefs_client.api import internal_api 2784 from lakefs_client.model.error import Error 2785 from pprint import pprint 2786 # Defining the host is optional and defaults to http://localhost/api/v1 2787 # See configuration.py for a list of all supported configuration parameters. 2788 configuration = lakefs_client.Configuration( 2789 host = "http://localhost/api/v1" 2790 ) 2791 2792 # The client must configure the authentication and authorization parameters 2793 # in accordance with the API server security policy. 2794 # Examples for each auth method are provided below, use the example that 2795 # satisfies your auth use case. 2796 2797 # Configure HTTP basic authorization: basic_auth 2798 configuration = lakefs_client.Configuration( 2799 username = 'YOUR_USERNAME', 2800 password = 'YOUR_PASSWORD' 2801 ) 2802 2803 # Configure API key authorization: cookie_auth 2804 configuration.api_key['cookie_auth'] = 'YOUR_API_KEY' 2805 2806 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2807 # configuration.api_key_prefix['cookie_auth'] = 'Bearer' 2808 2809 # Configure Bearer authorization (JWT): jwt_token 2810 configuration = lakefs_client.Configuration( 2811 access_token = 'YOUR_BEARER_TOKEN' 2812 ) 2813 2814 # Configure API key authorization: oidc_auth 2815 configuration.api_key['oidc_auth'] = 'YOUR_API_KEY' 2816 2817 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2818 # configuration.api_key_prefix['oidc_auth'] = 'Bearer' 2819 2820 # Configure API key authorization: saml_auth 2821 configuration.api_key['saml_auth'] = 'YOUR_API_KEY' 2822 2823 # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed 2824 # configuration.api_key_prefix['saml_auth'] = 'Bearer' 2825 2826 # Enter a context with an instance of the API client 2827 with lakefs_client.ApiClient(configuration) as api_client: 2828 # Create an instance of the API class 2829 api_instance = internal_api.InternalApi(api_client) 2830 repository = "repository_example" # str | 2831 branch = "branch_example" # str | 2832 path = "path_example" # str | relative to the branch 2833 2834 # example passing only required values which don't have defaults set 2835 try: 2836 api_instance.upload_object_preflight(repository, branch, path) 2837 except lakefs_client.ApiException as e: 2838 print("Exception when calling InternalApi->upload_object_preflight: %s\n" % e) 2839 ``` 2840 2841 2842 ### Parameters 2843 2844 Name | Type | Description | Notes 2845 ------------- | ------------- | ------------- | ------------- 2846 **repository** | **str**| | 2847 **branch** | **str**| | 2848 **path** | **str**| relative to the branch | 2849 2850 ### Return type 2851 2852 void (empty response body) 2853 2854 ### Authorization 2855 2856 [basic_auth](../README.md#basic_auth), [cookie_auth](../README.md#cookie_auth), [jwt_token](../README.md#jwt_token), [oidc_auth](../README.md#oidc_auth), [saml_auth](../README.md#saml_auth) 2857 2858 ### HTTP request headers 2859 2860 - **Content-Type**: Not defined 2861 - **Accept**: application/json 2862 2863 2864 ### HTTP response details 2865 2866 | Status code | Description | Response headers | 2867 |-------------|-------------|------------------| 2868 **204** | User has permissions to upload this object. This does not guarantee that the upload will be successful or even possible. It indicates only the permission at the time of calling this endpoint | - | 2869 **401** | Unauthorized | - | 2870 **403** | Forbidden | - | 2871 **404** | Resource Not Found | - | 2872 **420** | too many requests | - | 2873 **0** | Internal Server Error | - | 2874 2875 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) 2876