text: # coding: utf-8
  
  """
      Apache NiFi Registry REST API
  
      The REST API provides an interface to a registry with operations for saving, versioning, reading NiFi flows and components.
  
      OpenAPI spec version: 0.5.0
      Contact: dev@nifi.apache.org
      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 PoliciesApi(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_access_policy(self, body, **kwargs):
          """
          Create access 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_access_policy(body, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param AccessPolicy body: The access policy configuration details. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.create_access_policy_with_http_info(body, **kwargs)
          else:
              (data) = self.create_access_policy_with_http_info(body, **kwargs)
              return data
  
      def create_access_policy_with_http_info(self, body, **kwargs):
          """
          Create access 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_access_policy_with_http_info(body, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param AccessPolicy body: The access policy configuration details. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['body']
          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_access_policy" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'body' is set
          if ('body' not in params) or (params['body'] is None):
              raise ValueError("Missing the required parameter `body` when calling `create_access_policy`")
  
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # 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 = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies', 'POST',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='AccessPolicy',
                                          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 get_access_policies(self, **kwargs):
          """
          Get all access policies
          
          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.get_access_policies(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :return: list[AccessPolicy]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_access_policies_with_http_info(**kwargs)
          else:
              (data) = self.get_access_policies_with_http_info(**kwargs)
              return data
  
      def get_access_policies_with_http_info(self, **kwargs):
          """
          Get all access policies
          
          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.get_access_policies_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :return: list[AccessPolicy]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = []
          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 get_access_policies" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          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(['*/*'])
  
          # Authentication setting
          auth_settings = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='list[AccessPolicy]',
                                          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 get_access_policy(self, id, **kwargs):
          """
          Get access 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.get_access_policy(id, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id: The access policy id. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_access_policy_with_http_info(id, **kwargs)
          else:
              (data) = self.get_access_policy_with_http_info(id, **kwargs)
              return data
  
      def get_access_policy_with_http_info(self, id, **kwargs):
          """
          Get access 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.get_access_policy_with_http_info(id, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id: The access policy id. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['id']
          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 get_access_policy" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'id' is set
          if ('id' not in params) or (params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `get_access_policy`")
  
  
          collection_formats = {}
  
          path_params = {}
          if 'id' in params:
              path_params['id'] = params['id']
  
          query_params = []
  
          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(['*/*'])
  
          # Authentication setting
          auth_settings = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies/{id}', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='AccessPolicy',
                                          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 get_access_policy_for_resource(self, action, resource, **kwargs):
          """
          Get access policy for resource
          Gets an access policy for the specified action and resource
          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.get_access_policy_for_resource(action, resource, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str action: The request action. (required)
          :param str resource: The resource of the policy. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_access_policy_for_resource_with_http_info(action, resource, **kwargs)
          else:
              (data) = self.get_access_policy_for_resource_with_http_info(action, resource, **kwargs)
              return data
  
      def get_access_policy_for_resource_with_http_info(self, action, resource, **kwargs):
          """
          Get access policy for resource
          Gets an access policy for the specified action and resource
          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.get_access_policy_for_resource_with_http_info(action, resource, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str action: The request action. (required)
          :param str resource: The resource of the policy. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['action', 'resource']
          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 get_access_policy_for_resource" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'action' is set
          if ('action' not in params) or (params['action'] is None):
              raise ValueError("Missing the required parameter `action` when calling `get_access_policy_for_resource`")
          # verify the required parameter 'resource' is set
          if ('resource' not in params) or (params['resource'] is None):
              raise ValueError("Missing the required parameter `resource` when calling `get_access_policy_for_resource`")
  
          if 'resource' in params and not re.search('.+', params['resource']):
              raise ValueError("Invalid value for parameter `resource` when calling `get_access_policy_for_resource`, must conform to the pattern `/.+/`")
  
          collection_formats = {}
  
          path_params = {}
          if 'action' in params:
              path_params['action'] = params['action']
          if 'resource' in params:
              path_params['resource'] = params['resource']
  
          query_params = []
  
          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(['*/*'])
  
          # Authentication setting
          auth_settings = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies/{action}/{resource}', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='AccessPolicy',
                                          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 get_resources(self, **kwargs):
          """
          Get available resources
          Gets the available resources that support access/authorization policies
          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.get_resources(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :return: list[Resource]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_resources_with_http_info(**kwargs)
          else:
              (data) = self.get_resources_with_http_info(**kwargs)
              return data
  
      def get_resources_with_http_info(self, **kwargs):
          """
          Get available resources
          Gets the available resources that support access/authorization policies
          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.get_resources_with_http_info(callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :return: list[Resource]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = []
          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 get_resources" % key
                  )
              params[key] = val
          del params['kwargs']
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          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(['*/*'])
  
          # Authentication setting
          auth_settings = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies/resources', 'GET',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='list[Resource]',
                                          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 remove_access_policy(self, id, **kwargs):
          """
          Delete access 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.remove_access_policy(id, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id: The access policy id. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.remove_access_policy_with_http_info(id, **kwargs)
          else:
              (data) = self.remove_access_policy_with_http_info(id, **kwargs)
              return data
  
      def remove_access_policy_with_http_info(self, id, **kwargs):
          """
          Delete access 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.remove_access_policy_with_http_info(id, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id: The access policy id. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['id']
          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 remove_access_policy" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'id' is set
          if ('id' not in params) or (params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `remove_access_policy`")
  
  
          collection_formats = {}
  
          path_params = {}
          if 'id' in params:
              path_params['id'] = params['id']
  
          query_params = []
  
          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(['*/*'])
  
          # Authentication setting
          auth_settings = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies/{id}', 'DELETE',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='AccessPolicy',
                                          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_access_policy(self, id, body, **kwargs):
          """
          Update access 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.update_access_policy(id, body, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id: The access policy id. (required)
          :param AccessPolicy body: The access policy configuration details. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.update_access_policy_with_http_info(id, body, **kwargs)
          else:
              (data) = self.update_access_policy_with_http_info(id, body, **kwargs)
              return data
  
      def update_access_policy_with_http_info(self, id, body, **kwargs):
          """
          Update access 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.update_access_policy_with_http_info(id, body, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id: The access policy id. (required)
          :param AccessPolicy body: The access policy configuration details. (required)
          :return: AccessPolicy
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['id', 'body']
          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_access_policy" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'id' is set
          if ('id' not in params) or (params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `update_access_policy`")
          # verify the required parameter 'body' is set
          if ('body' not in params) or (params['body'] is None):
              raise ValueError("Missing the required parameter `body` when calling `update_access_policy`")
  
  
          collection_formats = {}
  
          path_params = {}
          if 'id' in params:
              path_params['id'] = params['id']
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'body' in params:
              body_params = params['body']
          # 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 = ['tokenAuth', 'Authorization']
  
          return self.api_client.call_api('/policies/{id}', 'PUT',
                                          path_params,
                                          query_params,
                                          header_params,
                                          body=body_params,
                                          post_params=form_params,
                                          files=local_var_files,
                                          response_type='AccessPolicy',
                                          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)
  