text: # coding: utf-8
  
  """
      Pure Storage FlashBlade REST 1.7 Python SDK
  
      Pure Storage FlashBlade REST 1.7 Python SDK, developed by [Pure Storage, Inc](http://www.purestorage.com/). Documentations can be found at [purity-fb.readthedocs.io](http://purity-fb.readthedocs.io/).
  
      OpenAPI spec version: 1.7
      Contact: info@purestorage.com
      Generated by: https://github.com/swagger-api/swagger-codegen.git
  """
  
  
  from __future__ import absolute_import
  
  import sys
  import os
  import re
  
  # python 2 and python 3 compatibility library
  from six import iteritems
  
  from ..configuration import Configuration
  from ..api_client import ApiClient
  
  
  class FileSystemsApi(object):
      """
      NOTE: This class is auto generated by the swagger code generator program.
      Do not edit the class manually.
      Ref: https://github.com/swagger-api/swagger-codegen
      """
  
      def __init__(self, api_client=None):
          config = Configuration()
          if api_client:
              self.api_client = api_client
          else:
              if not config.api_client:
                  config.api_client = ApiClient()
              self.api_client = config.api_client
  
      def create_file_systems(self, file_system, **kwargs):
          """
          Create a new file system
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.create_file_systems(file_system, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param FileSystem file_system: the attribute map used to create the file system. (required)
          :return: FileSystemResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.create_file_systems_with_http_info(file_system, **kwargs)
          else:
              (data) = self.create_file_systems_with_http_info(file_system, **kwargs)
              return data
  
      def create_file_systems_with_http_info(self, file_system, **kwargs):
          """
          Create a new file system
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.create_file_systems_with_http_info(file_system, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param FileSystem file_system: the attribute map used to create the file system. (required)
          :return: FileSystemResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['file_system']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method create_file_systems" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'file_system' is set
          if ('file_system' not in params) or (params['file_system'] is None):
              raise ValueError("Missing the required parameter `file_system` when calling `create_file_systems`")
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'file_system' in params:
              body_params = params['file_system']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems', 'POST',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='FileSystemResponse',
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def create_filesystem_policies(self, **kwargs):
          """
          Create a connection between a file system and a policy
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.create_filesystem_policies(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] policy_names: A comma-separated list of policy names. This cannot be provided together with the policy ids query parameters.
          :param list[str] member_names: A comma-separated list of member names. This cannot be provided together with the member ids query parameters.
          :return: PolicyObjectsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.create_filesystem_policies_with_http_info(**kwargs)
          else:
              (data) = self.create_filesystem_policies_with_http_info(**kwargs)
              return data
  
      def create_filesystem_policies_with_http_info(self, **kwargs):
          """
          Create a connection between a file system and a policy
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.create_filesystem_policies_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] policy_names: A comma-separated list of policy names. This cannot be provided together with the policy ids query parameters.
          :param list[str] member_names: A comma-separated list of member names. This cannot be provided together with the member ids query parameters.
          :return: PolicyObjectsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['policy_names', 'member_names']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method create_filesystem_policies" % key
                  )
              params[key] = val
          del params['kwargs']
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'policy_names' in params:
              query_params.append(('policy_names', params['policy_names']))
              collection_formats['policy_names'] = 'csv'
          if 'member_names' in params:
              query_params.append(('member_names', params['member_names']))
              collection_formats['member_names'] = 'csv'
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems/policies', 'POST',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='PolicyObjectsResponse',
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def delete_file_systems(self, name, **kwargs):
          """
          Delete a file system
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.delete_file_systems(name, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str name: name of the file system to be deleted (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.delete_file_systems_with_http_info(name, **kwargs)
          else:
              (data) = self.delete_file_systems_with_http_info(name, **kwargs)
              return data
  
      def delete_file_systems_with_http_info(self, name, **kwargs):
          """
          Delete a file system
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.delete_file_systems_with_http_info(name, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str name: name of the file system to be deleted (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['name']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method delete_file_systems" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'name' is set
          if ('name' not in params) or (params['name'] is None):
              raise ValueError("Missing the required parameter `name` when calling `delete_file_systems`")
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'name' in params:
              query_params.append(('name', params['name']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems', 'DELETE',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type=None,
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def delete_filesystem_policies(self, **kwargs):
          """
          Delete a connection between a file system and a policy.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.delete_filesystem_policies(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] policy_names: A comma-separated list of policy names. This cannot be provided together with the policy ids query parameters.
          :param list[str] member_names: A comma-separated list of member names. This cannot be provided together with the member ids query parameters.
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.delete_filesystem_policies_with_http_info(**kwargs)
          else:
              (data) = self.delete_filesystem_policies_with_http_info(**kwargs)
              return data
  
      def delete_filesystem_policies_with_http_info(self, **kwargs):
          """
          Delete a connection between a file system and a policy.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.delete_filesystem_policies_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] policy_names: A comma-separated list of policy names. This cannot be provided together with the policy ids query parameters.
          :param list[str] member_names: A comma-separated list of member names. This cannot be provided together with the member ids query parameters.
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['policy_names', 'member_names']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method delete_filesystem_policies" % key
                  )
              params[key] = val
          del params['kwargs']
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'policy_names' in params:
              query_params.append(('policy_names', params['policy_names']))
              collection_formats['policy_names'] = 'csv'
          if 'member_names' in params:
              query_params.append(('member_names', params['member_names']))
              collection_formats['member_names'] = 'csv'
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems/policies', 'DELETE',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type=None,
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def list_file_systems(self, **kwargs):
          """
          List file systems
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.list_file_systems(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] names: A comma-separated list of resource names. This cannot be provided together with the ids query parameters.
          :param str filter: The filter to be used for query.
          :param str sort: The way to order the results.
          :param int start: start
          :param int limit: limit, should be >= 0
          :param str token: token
          :param bool total: Return a total object in addition to the other results.
          :param bool total_only: Return only the total object.
          :return: FileSystemResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.list_file_systems_with_http_info(**kwargs)
          else:
              (data) = self.list_file_systems_with_http_info(**kwargs)
              return data
  
      def list_file_systems_with_http_info(self, **kwargs):
          """
          List file systems
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.list_file_systems_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] names: A comma-separated list of resource names. This cannot be provided together with the ids query parameters.
          :param str filter: The filter to be used for query.
          :param str sort: The way to order the results.
          :param int start: start
          :param int limit: limit, should be >= 0
          :param str token: token
          :param bool total: Return a total object in addition to the other results.
          :param bool total_only: Return only the total object.
          :return: FileSystemResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['names', 'filter', 'sort', 'start', 'limit', 'token', 'total', 'total_only']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method list_file_systems" % key
                  )
              params[key] = val
          del params['kwargs']
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'names' in params:
              query_params.append(('names', params['names']))
              collection_formats['names'] = 'csv'
          if 'filter' in params:
              query_params.append(('filter', params['filter']))
          if 'sort' in params:
              query_params.append(('sort', params['sort']))
          if 'start' in params:
              query_params.append(('start', params['start']))
          if 'limit' in params:
              query_params.append(('limit', params['limit']))
          if 'token' in params:
              query_params.append(('token', params['token']))
          if 'total' in params:
              query_params.append(('total', params['total']))
          if 'total_only' in params:
              query_params.append(('total_only', params['total_only']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='FileSystemResponse',
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def list_file_systems_performance(self, **kwargs):
          """
          List instant or historical file system performance.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.list_file_systems_performance(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int resolution: sample frequency in milliseconds
          :param str protocol: to sample performance of a certain protocol
          :param int end_time: Time to end sample in milliseconds since epoch.
          :param str filter: The filter to be used for query.
          :param int limit: limit, should be >= 0
          :param list[str] names: A comma-separated list of resource names. This cannot be provided together with the ids query parameters.
          :param str sort: The way to order the results.
          :param int start_time: Time to start sample in milliseconds since epoch.
          :param int start: start
          :param str token: token
          :param bool total_only: Return only the total object.
          :return: FileSystemPerformanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.list_file_systems_performance_with_http_info(**kwargs)
          else:
              (data) = self.list_file_systems_performance_with_http_info(**kwargs)
              return data
  
      def list_file_systems_performance_with_http_info(self, **kwargs):
          """
          List instant or historical file system performance.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.list_file_systems_performance_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int resolution: sample frequency in milliseconds
          :param str protocol: to sample performance of a certain protocol
          :param int end_time: Time to end sample in milliseconds since epoch.
          :param str filter: The filter to be used for query.
          :param int limit: limit, should be >= 0
          :param list[str] names: A comma-separated list of resource names. This cannot be provided together with the ids query parameters.
          :param str sort: The way to order the results.
          :param int start_time: Time to start sample in milliseconds since epoch.
          :param int start: start
          :param str token: token
          :param bool total_only: Return only the total object.
          :return: FileSystemPerformanceResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['resolution', 'protocol', 'end_time', 'filter', 'limit', 'names', 'sort', 'start_time', 'start', 'token', 'total_only']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method list_file_systems_performance" % key
                  )
              params[key] = val
          del params['kwargs']
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'resolution' in params:
              query_params.append(('resolution', params['resolution']))
          if 'protocol' in params:
              query_params.append(('protocol', params['protocol']))
          if 'end_time' in params:
              query_params.append(('end_time', params['end_time']))
          if 'filter' in params:
              query_params.append(('filter', params['filter']))
          if 'limit' in params:
              query_params.append(('limit', params['limit']))
          if 'names' in params:
              query_params.append(('names', params['names']))
              collection_formats['names'] = 'csv'
          if 'sort' in params:
              query_params.append(('sort', params['sort']))
          if 'start_time' in params:
              query_params.append(('start_time', params['start_time']))
          if 'start' in params:
              query_params.append(('start', params['start']))
          if 'token' in params:
              query_params.append(('token', params['token']))
          if 'total_only' in params:
              query_params.append(('total_only', params['total_only']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems/performance', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='FileSystemPerformanceResponse',
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def list_filesystem_policies(self, **kwargs):
          """
          List policies attached to filesystems.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.list_filesystem_policies(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] policy_names: A comma-separated list of policy names. This cannot be provided together with the policy ids query parameters.
          :param list[str] member_names: A comma-separated list of member names. This cannot be provided together with the member ids query parameters.
          :param str filter: The filter to be used for query.
          :param str sort: The way to order the results.
          :param int start: start
          :param int limit: limit, should be >= 0
          :param str token: token
          :return: PolicyObjectsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.list_filesystem_policies_with_http_info(**kwargs)
          else:
              (data) = self.list_filesystem_policies_with_http_info(**kwargs)
              return data
  
      def list_filesystem_policies_with_http_info(self, **kwargs):
          """
          List policies attached to filesystems.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.list_filesystem_policies_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param list[str] policy_names: A comma-separated list of policy names. This cannot be provided together with the policy ids query parameters.
          :param list[str] member_names: A comma-separated list of member names. This cannot be provided together with the member ids query parameters.
          :param str filter: The filter to be used for query.
          :param str sort: The way to order the results.
          :param int start: start
          :param int limit: limit, should be >= 0
          :param str token: token
          :return: PolicyObjectsResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['policy_names', 'member_names', 'filter', 'sort', 'start', 'limit', 'token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method list_filesystem_policies" % key
                  )
              params[key] = val
          del params['kwargs']
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'policy_names' in params:
              query_params.append(('policy_names', params['policy_names']))
              collection_formats['policy_names'] = 'csv'
          if 'member_names' in params:
              query_params.append(('member_names', params['member_names']))
              collection_formats['member_names'] = 'csv'
          if 'filter' in params:
              query_params.append(('filter', params['filter']))
          if 'sort' in params:
              query_params.append(('sort', params['sort']))
          if 'start' in params:
              query_params.append(('start', params['start']))
          if 'limit' in params:
              query_params.append(('limit', params['limit']))
          if 'token' in params:
              query_params.append(('token', params['token']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems/policies', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='PolicyObjectsResponse',
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  
      def update_file_systems(self, name, attributes, **kwargs):
          """
          Update an existing file system
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.update_file_systems(name, attributes, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str name: the name of the file system to be updated (required)
          :param FileSystem attributes: the new attributes, only modifiable fields could be used. (required)
          :param bool ignore_usage: Allow update operations that lead to a hard_limit_enabled file system with usage over its provisioned size. The update can be either setting hard_limit_enabled when usage is higher than provisioned size, or resize provisioned size to a value under usage when hard_limit_enabled is True.
          :return: FileSystemResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.update_file_systems_with_http_info(name, attributes, **kwargs)
          else:
              (data) = self.update_file_systems_with_http_info(name, attributes, **kwargs)
              return data
  
      def update_file_systems_with_http_info(self, name, attributes, **kwargs):
          """
          Update an existing file system
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.update_file_systems_with_http_info(name, attributes, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str name: the name of the file system to be updated (required)
          :param FileSystem attributes: the new attributes, only modifiable fields could be used. (required)
          :param bool ignore_usage: Allow update operations that lead to a hard_limit_enabled file system with usage over its provisioned size. The update can be either setting hard_limit_enabled when usage is higher than provisioned size, or resize provisioned size to a value under usage when hard_limit_enabled is True.
          :return: FileSystemResponse
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['name', 'attributes', 'ignore_usage']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method update_file_systems" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'name' is set
          if ('name' not in params) or (params['name'] is None):
              raise ValueError("Missing the required parameter `name` when calling `update_file_systems`")
          # verify the required parameter 'attributes' is set
          if ('attributes' not in params) or (params['attributes'] is None):
              raise ValueError("Missing the required parameter `attributes` when calling `update_file_systems`")
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'name' in params:
              query_params.append(('name', params['name']))
          if 'ignore_usage' in params:
              query_params.append(('ignore_usage', params['ignore_usage']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'attributes' in params:
              body_params = params['attributes']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['AuthTokenHeader']
  
          return self.api_client.call_api('/1.7/file-systems', 'PATCH',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='FileSystemResponse',
                                          auth_settings=auth_settings,
                                          callback=params.get('callback'),
                                          _return_http_data_only=params.get('_return_http_data_only'),
                                          _preload_content=params.get('_preload_content', True),
                                          _request_timeout=params.get('_request_timeout'),
                                          collection_formats=collection_formats)
  