github.com/treeverse/lakefs@v1.24.1-0.20240520134607-95648127bfb0/clients/python/lakefs_sdk/client.py (about)

     1  import warnings
     2  
     3  from urllib3.util import parse_url, Url
     4  from lakefs_sdk import ApiClient
     5  from lakefs_sdk.api import actions_api
     6  from lakefs_sdk.api import auth_api
     7  from lakefs_sdk.api import branches_api
     8  from lakefs_sdk.api import commits_api
     9  from lakefs_sdk.api import config_api
    10  from lakefs_sdk.api import experimental_api
    11  from lakefs_sdk.api import external_api
    12  from lakefs_sdk.api import health_check_api
    13  from lakefs_sdk.api import import_api
    14  from lakefs_sdk.api import internal_api
    15  from lakefs_sdk.api import metadata_api
    16  from lakefs_sdk.api import objects_api
    17  from lakefs_sdk.api import refs_api
    18  from lakefs_sdk.api import repositories_api
    19  from lakefs_sdk.api import staging_api
    20  from lakefs_sdk.api import tags_api
    21  
    22  
    23  class _WrappedApiClient(ApiClient):
    24      """ApiClient that fixes some weirdness"""
    25  
    26      def files_parameters(self, files=None):
    27          """
    28          Transforms input file data into a formatted list to return file_parameters.
    29          Assume a string file_name is a path to the file to read.
    30          Assume a bytes file_name is a file-like object that we append the information.
    31          The parent class will handle the files to read.
    32          """
    33          if not files:
    34              return []
    35  
    36          params = []
    37          files_to_read = {}
    38  
    39          for idx, (key, value) in enumerate(files.items()):
    40              if not value:
    41                  continue
    42  
    43              # Ensure the value is always a list.
    44              file_names = value if isinstance(value, list) else [value]
    45  
    46              for file_name in file_names:
    47                  if type(file_name) is str:
    48                      files_to_read[key] = file_name
    49                  else:
    50                      name = f'{key}_{idx}'
    51                      mimetype = 'application/octet-stream'
    52                      params.append(tuple([key, tuple([name, value, mimetype])]))
    53  
    54          return super().files_parameters(files_to_read) + params
    55  
    56  class LakeFSClient:
    57      def __init__(self, configuration=None, header_name=None, header_value=None, cookie=None, pool_threads=1):
    58          configuration = LakeFSClient._ensure_endpoint(configuration)
    59          self._api = _WrappedApiClient(configuration=configuration, header_name=header_name,
    60                                            header_value=header_value, cookie=cookie, pool_threads=pool_threads)
    61          self.actions_api = actions_api.ActionsApi(self._api)
    62          self.auth_api = auth_api.AuthApi(self._api)
    63          self.branches_api = branches_api.BranchesApi(self._api)
    64          self.commits_api = commits_api.CommitsApi(self._api)
    65          self.config_api = config_api.ConfigApi(self._api)
    66          self.experimental_api = experimental_api.ExperimentalApi(self._api)
    67          self.external_api = external_api.ExternalApi(self._api)
    68          self.health_check_api = health_check_api.HealthCheckApi(self._api)
    69          self.import_api = import_api.ImportApi(self._api)
    70          self.internal_api = internal_api.InternalApi(self._api)
    71          self.metadata_api = metadata_api.MetadataApi(self._api)
    72          self.objects_api = objects_api.ObjectsApi(self._api)
    73          self.refs_api = refs_api.RefsApi(self._api)
    74          self.repositories_api = repositories_api.RepositoriesApi(self._api)
    75          self.staging_api = staging_api.StagingApi(self._api)
    76          self.tags_api = tags_api.TagsApi(self._api)
    77  
    78      @staticmethod
    79      def _ensure_endpoint(configuration):
    80          """Normalize lakefs connection endpoint found in configuration's host"""
    81          if not configuration or not configuration.host:
    82              return configuration
    83          try:
    84              # prefix http scheme if missing
    85              if not configuration.host.startswith('http://') and not configuration.host.startswith('https://'):
    86                  configuration.host = 'http://' + configuration.host
    87              # if 'host' not set any 'path', format the endpoint url with default 'path' based on the generated code
    88              o = parse_url(configuration.host)
    89              if not o.path or o.path == '/':
    90                  settings = configuration.get_host_settings()
    91                  if settings:
    92                      base_path = parse_url(settings[0].get('url')).path
    93                      configuration.host = Url(scheme=o.scheme, auth=o.auth, host=o.host, port=o.port,
    94                                               path=base_path, query=o.query, fragment=o.fragment).url
    95          except ValueError:
    96              pass
    97          return configuration