# import packages
import re
try:
  import httplib
except ImportError:
  # pylint: disable=F0401
  # http is a Python3 module, replacing httplib
  from http import client as httplib
import json
import urllib
import warnings

from predictionio.connection import Connection
from predictionio.connection import AsyncRequest
from predictionio.connection import PredictionIOAPIError

"""Error exception defined for this API

Should be handled by the user
"""


class ServerStatusError(PredictionIOAPIError):

  "Error happened when tried to get status of the API server"
  pass


class UserNotCreatedError(PredictionIOAPIError):

  "Error happened when tried to create user"
  pass


class UserNotFoundError(PredictionIOAPIError):

  "Error happened when tried to get user"
  pass


class UserNotDeletedError(PredictionIOAPIError):

  "Error happened when tried to delete user"
  pass


class ItemNotCreatedError(PredictionIOAPIError):

  "Error happened when tried to create item"
  pass


class ItemNotFoundError(PredictionIOAPIError):

  "Error happened when tried to get item"
  pass


class ItemNotDeletedError(PredictionIOAPIError):

  "Error happened when tried to delete item"
  pass


class U2IActionNotCreatedError(PredictionIOAPIError):

  "Error happened when tried to create user-to-item action"
  pass


class ItemRecNotFoundError(PredictionIOAPIError):

  "Error happened when tried to get item recommendation"
  pass


class ItemSimNotFoundError(PredictionIOAPIError):

  "Error happened when tried to get similar items"
  pass

class ItemRankNotFoundError(PredictionIOAPIError):

  "Error happened when treid to rank item"
  pass

class InvalidArgumentError(PredictionIOAPIError):

  "Arguments are not valid"
  pass

# map to API
LIKE_API = "like"
DISLIKE_API = "dislike"
VIEW_API = "view"
CONVERSION_API = "conversion"
RATE_API = "rate"


class Client(object):

  """PredictionIO client object.

  This is an object representing a PredictionIO's client. This object
  provides methods for making PredictionIO API requests.

  :param appkey: the App Key provided by PredictionIO.
  :param threads: number of threads to handle PredictionIO API requests.
          Must be >= 1.
  :param apiurl: the PredictionIO API URL path.
  :param apiversion: the PredictionIO API version. (optional)
       (eg. "", or "/v1")
  :param qsize: the max size of the request queue (optional).
      The asynchronous request becomes blocking once this size has been
      reached, until the queued requests are handled.
      Default value is 0, which means infinite queue size.
  :param timeout: timeout for HTTP connection attempts and requests in
    seconds (optional).
    Default value is 5.

  """

  def __init__(self, appkey, threads=1, apiurl="http://localhost:8000",
         apiversion="", qsize=0, timeout=5):
    """Constructor of Client object.

    """
    warnings.warn("predictionio.Client is deprecated. " + 
      "Please consider upgrading to our latest version.")

    self.appkey = appkey
    self.threads = threads
    self.apiurl = apiurl
    self.apiversion = apiversion
    self.qsize = qsize
    self.timeout = timeout

    # check connection type
    https_pattern = r'^https://(.*)'
    http_pattern = r'^http://(.*)'
    m = re.match(https_pattern, apiurl)
    self.https = True
    if m is None:  # not matching https
      m = re.match(http_pattern, apiurl)
      self.https = False
      if m is None:  # not matching http either
        raise InvalidArgumentError("apiurl is not valid: %s" % apiurl)
    self.host = m.group(1)

    self._uid = None  # identified uid
    self._connection = Connection(host=self.host, threads=self.threads,
                    qsize=self.qsize, https=self.https,
                    timeout=self.timeout)

  def close(self):
    """Close this client and the connection.

    Call this method when you want to completely terminate the connection
    with PredictionIO.
    It will wait for all pending requests to finish.
    """
    self._connection.close()

  def pending_requests(self):
    """Return the number of pending requests.

    :returns:
      The number of pending requests of this client.
    """
    return self._connection.pending_requests()

  def identify(self, uid):
    """Identify the uid

    :param uid: user id. type str.
    """
    self._uid = uid

  def get_status(self):
    """Get the status of the PredictionIO API Server

    :returns:
      status message.

    :raises:
      ServerStatusError.
    """
    path = "/"
    request = AsyncRequest("GET", path)
    request.set_rfunc(self._aget_status_resp)
    self._connection.make_request(request)
    result = self.aresp(request)
    return result

  def _aget_status_resp(self, response):
    """Handle the AsyncResponse of get status request"""
    if response.error is not None:
      raise ServerStatusError("Exception happened: %s for request %s" %
                  (response.error, response.request))
    elif response.status != httplib.OK:
      raise ServerStatusError("request: %s status: %s body: %s" %
                  (response.request, response.status,
                   response.body))

    # data = json.loads(response.body) # convert json string to dict
    return response.body

  def acreate_user(self, uid, params={}):
    """Asynchronously create a user.

    :param uid: user id. type str.
    :param params: optional attributes. type dictionary.
        For example,
        { 'custom': 'value', 'pio_inactive' : True,
        'pio_latlng': [4.5,67.8] }

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.

    """

    if "pio_latlng" in params:
      params["pio_latlng"] = ",".join(map(str, params["pio_latlng"]))
    if "pio_inactive" in params:
      params["pio_inactive"] = str(params["pio_inactive"]).lower()

    path = "%s/users.json" % self.apiversion
    request = AsyncRequest(
      "POST", path, pio_appkey=self.appkey, pio_uid=uid, **params)
    request.set_rfunc(self._acreate_user_resp)
    self._connection.make_request(request)

    return request

  def _acreate_user_resp(self, response):
    """Private function to handle the AsyncResponse of the acreate_user
    request.

    :param response: AsyncResponse object.

    :returns:
      None.

    :raises:
      UserNotCreatedError.

    """
    if response.error is not None:
      raise UserNotCreatedError("Exception happened: %s for request %s" %
                    (response.error, response.request))
    elif response.status != httplib.CREATED:
      raise UserNotCreatedError("request: %s status: %s body: %s" %
                    (response.request, response.status,
                     response.body))

    return None

  def aget_user(self, uid):
    """Asynchronously get user.

    :param uid: user id. type str.

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    enc_uid = urllib.quote(uid, "")  # replace special char with %xx
    path = "%s/users/%s.json" % (self.apiversion, enc_uid)
    request = AsyncRequest("GET", path, pio_appkey=self.appkey)
    request.set_rfunc(self._aget_user_resp)
    self._connection.make_request(request)

    return request

  def _aget_user_resp(self, response):
    """Private function to handle the AsyncResponse of the aget_user
    request .

    :param response: AsyncResponse object.

    :returns:
      User data in Dictionary format.

    :rasies:
      UserNotFoundError.

    """
    if response.error is not None:
      raise UserNotFoundError("Exception happened: %s for request %s" %
                  (response.error, response.request))
    elif response.status != httplib.OK:
      raise UserNotFoundError("request: %s status: %s body: %s" %
                  (response.request, response.status,
                   response.body))

    data = json.loads(response.body)  # convert json string to dict
    return data

  def adelete_user(self, uid):
    """Asynchronously delete user.

    :param uid: user id. type str.

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    enc_uid = urllib.quote(uid, "")  # replace special char with %xx
    path = "%s/users/%s.json" % (self.apiversion, enc_uid)
    request = AsyncRequest("DELETE", path, pio_appkey=self.appkey)
    request.set_rfunc(self._adelete_user_resp)
    self._connection.make_request(request)

    return request

  def _adelete_user_resp(self, response):
    """Private function to handle the AsyncResponse of the adelete_user
    request.

    :param response: AsyncResponse object.

    :returns:
      None.

    :raises:
      UserNotDeletedError.

    """
    if response.error is not None:
      raise UserNotDeletedError("Exception happened: %s for request %s" %
                    (response.error, response.request))
    elif response.status != httplib.OK:
      raise UserNotDeletedError("request: %s status: %s body: %s" %
                    (response.request, response.status,
                     response.body))
    return None

  def acreate_item(self, iid, itypes, params={}):
    """Asynchronously create item.

    :param iid: item id. type str.
    :param itypes: item types. Tuple of Str.
        For example, if this item belongs to item types "t1", "t2",
        "t3", "t4",then itypes=("t1", "t2", "t3", "t4").
        NOTE: if this item belongs to only one itype, use tuple of one
        element, eg. itypes=("t1",)
    :param params: optional attributes. type dictionary.
        For example,
        { 'custom': 'value', 'pio_inactive' : True,
        'pio_latlng': [4.5,67.8] }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    itypes_str = ",".join(itypes)  # join items with ","

    if "pio_latlng" in params:
      params["pio_latlng"] = ",".join(map(str, params["pio_latlng"]))
    if "pio_inactive" in params:
      params["pio_inactive"] = str(params["pio_inactive"]).lower()

    path = "%s/items.json" % self.apiversion
    request = AsyncRequest("POST", path, pio_appkey=self.appkey,
                 pio_iid=iid, pio_itypes=itypes_str, **params)
    request.set_rfunc(self._acreate_item_resp)
    self._connection.make_request(request)
    return request

  def _acreate_item_resp(self, response):
    """Private function to handle the AsyncResponse of the acreate_item
    request

    :param response: AsyncResponse object.

    :returns:
      None
    :raises:
      ItemNotCreatedError

    """
    if response.error is not None:
      raise ItemNotCreatedError("Exception happened: %s for request %s" %
                    (response.error, response.request))
    elif response.status != httplib.CREATED:
      raise ItemNotCreatedError("request: %s status: %s body: %s" %
                    (response.request, response.status,
                     response.body))
    return None

  def aget_item(self, iid):
    """Asynchronously get item

    :param iid: item id. type str.

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    enc_iid = urllib.quote(iid, "")
    path = "%s/items/%s.json" % (self.apiversion, enc_iid)
    request = AsyncRequest("GET", path, pio_appkey=self.appkey)
    request.set_rfunc(self._aget_item_resp)
    self._connection.make_request(request)
    return request

  def _aget_item_resp(self, response):
    """Private function to handle the AsyncResponse of the aget_item
    request

    :param response: AsyncResponse object.

    :returns:
      item data in dictionary format.

    :raises:
      ItemNotFoundError.

    """
    if response.error is not None:
      raise ItemNotFoundError("Exception happened: %s for request %s" %
                  (response.error, response.request))
    elif response.status != httplib.OK:
      raise ItemNotFoundError("request: %s status: %s body: %s" %
                  (response.request, response.status,
                   response.body))

    data = json.loads(response.body)  # convert json string to dict
    if "pio_itypes" in data:
      # convert from list to tuple
      data["pio_itypes"] = tuple(data["pio_itypes"])

    return data

  def adelete_item(self, iid):
    """Asynchronously delete item

    :param iid: item id. type str.

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    enc_iid = urllib.quote(iid, "")
    path = "%s/items/%s.json" % (self.apiversion, enc_iid)
    request = AsyncRequest("DELETE", path, pio_appkey=self.appkey)
    request.set_rfunc(self._adelete_item_resp)
    self._connection.make_request(request)
    return request

  def _adelete_item_resp(self, response):
    """Private function to handle the AsyncResponse of the adelete_item
    request

    :param response: AsyncResponse object

    :returns:
      None

    :raises:
      ItemNotDeletedError
    """
    if response.error is not None:
      raise ItemNotDeletedError("Exception happened: %s for request %s" %
                    (response.error, response.request))
    elif response.status != httplib.OK:
      raise ItemNotDeletedError("request: %s status: %s body: %s" %
                    (response.request, response.status,
                     response.body))
    return None

  def _aget_user_itemrec_topn(self, engine, uid, n, params={}):
    """Private function to asynchronously get recommendations for user

    :param engine: name of the prediction engine. type str.
    :param uid: user id. type str.
    :param n: number of recommendation. type int.
    :param params: optional parameters. type dictionary
        For example, { 'pio_itypes' : ("t1","t2") }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    if "pio_itypes" in params:
      params["pio_itypes"] = ",".join(params["pio_itypes"])
    if "pio_latlng" in params:
      params["pio_latlng"] = ",".join(map(str, params["pio_latlng"]))
    if "pio_attributes" in params:
      params["pio_attributes"] = ",".join(params["pio_attributes"])

    path = "%s/engines/itemrec/%s/topn.json" % (self.apiversion, engine)
    request = AsyncRequest("GET", path, pio_appkey=self.appkey,
                 pio_uid=uid, pio_n=n, **params)
    request.set_rfunc(self._aget_user_itemrec_topn_resp)
    self._connection.make_request(request)
    return request

  def _aget_user_itemrec_topn_resp(self, response):
    """Private function to handle the AsyncResponse of the aget_itemrec
    request

    :param response: AsyncResponse object

    :returns:
      data in dictionary format.

    :raises:
      ItemRecNotFoundError.
    """
    if response.error is not None:
      raise ItemRecNotFoundError(
        "Exception happened: %s for request %s" %
        (response.error, response.request))
    elif response.status != httplib.OK:
      raise ItemRecNotFoundError("request: %s status: %s body: %s" %
                    (response.request, response.status,
                     response.body))

    data = json.loads(response.body)  # convert json string to dict
    return data

  def aget_itemrec_topn(self, engine, n, params={}):
    """Asynchronously get recommendations for the identified user

    :param engine: name of the prediction engine. type str.
    :param n: number of recommendation. type int.
    :param params: optional parameters. type dictionary
        For example, { 'pio_itypes' : ("t1",) }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    if self._uid is None:
      raise InvalidArgumentError(
        "uid is not identified. Please call identify(uid) first.")

    request = self._aget_user_itemrec_topn(engine, self._uid, n, params)
    return request

  def aget_itemrec(self, uid, n, engine, **params):
    """Deprecated. Asynchronously get recommendations

    :param uid: user id. type str.
    :param n: number of recommendation. type int.
    :param engine: name of the prediction engine. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng="123.4, 56.7"
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    request = self._aget_user_itemrec_topn(engine, uid, n, params)
    return request

  def _aget_itemsim_topn(self, engine, iid, n, params={}):
    """Private function to asynchronously get top n similar items of the
    item

    :param engine: name of the prediction engine. type str.
    :param iid: item id. type str.
    :param n: number of similar items. type int.
    :param params: optional parameters. type dictionary
        For example, { 'pio_itypes' : ("t1","t2") }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    if "pio_itypes" in params:
      params["pio_itypes"] = ",".join(params["pio_itypes"])
    if "pio_latlng" in params:
      params["pio_latlng"] = ",".join(map(str, params["pio_latlng"]))
    if "pio_attributes" in params:
      params["pio_attributes"] = ",".join(params["pio_attributes"])

    path = "%s/engines/itemsim/%s/topn.json" % (self.apiversion, engine)
    request = AsyncRequest("GET", path, pio_appkey=self.appkey,
                 pio_iid=iid, pio_n=n, **params)
    request.set_rfunc(self._aget_itemsim_topn_resp)
    self._connection.make_request(request)
    return request

  def _aget_itemsim_topn_resp(self, response):
    """Private function to handle the AsyncResponse of the aget_itemsim
    request

    :param response: AsyncResponse object

    :returns:
      data in dictionary format.

    :raises:
      ItemSimNotFoundError.
    """
    if response.error is not None:
      raise ItemSimNotFoundError(
        "Exception happened: %s for request %s" %
        (response.error, response.request))
    elif response.status != httplib.OK:
      raise ItemSimNotFoundError("request: %s status: %s body: %s" %
                    (response.request, response.status,
                     response.body))

    data = json.loads(response.body)  # convert json string to dict
    return data

  def aget_itemsim_topn(self, engine, iid, n, params={}):
    """Asynchronously get top n similar items of the item

    :param engine: name of the prediction engine. type str.
    :param iid: item id. type str.
    :param n: number of similar items. type int.
    :param params: optional parameters. type dictionary
        For example, { 'pio_itypes' : ("t1",) }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    request = self._aget_itemsim_topn(engine, iid, n, params)
    return request

  def _aget_user_itemrank_ranked(self, engine, uid, iids, params={}):
    """Private function to asynchronously get ranked item for user

    :param engine: name of the prediction engine. type str.
    :param uid: user id. type str.
    :param iids: items to be ranked. type list of item ids.
      For example, ["i0", "i1", "i2"]
    :param params: optional parameters. type dictionary
      For example. { 'pio_attributes' : "name" }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    if "pio_attributes" in params:
      params["pio_attributes"] = ",".join(params["pio_attributes"])

    pio_iids = ",".join(iids)

    path = "%s/engines/itemrank/%s/ranked.json" % \
      (self.apiversion, engine)
    request = AsyncRequest("GET", path, pio_appkey=self.appkey,
                           pio_uid=uid, pio_iids=pio_iids, **params)
    request.set_rfunc(self._aget_user_itemrank_ranked_resp)
    self._connection.make_request(request)
    return request

  def _aget_user_itemrank_ranked_resp(self, response):
    """Private function to handle the AsyncResponse of the aget_itemreoder
      request

    :param response: AsyncResponse object

    :returns:
      data in dictionary format.

    :raises:
      ItemRankNotFoundError.
    """
    if response.error is not None:
      raise ItemRankNotFoundError(
        "Exception happened: %s for request %s" %
        (response.error, response.request))
    elif response.status != httplib.OK:
      raise ItemRankNotFoundError("request: %s status: %s body: %s" %
                                  (response.request, response.status,
                                   response.body))

    data = json.loads(response.body)  # convert json string to dict
    return data

  def aget_itemrank_ranked(self, engine, iids, params={}):
    """Asynchronously get ranked item for user

    :param engine: name of the prediction engine. type str.
    :param iids: items to be ranked. type list of item ids.
      For example, ["i0", "i1", "i2"]
    :param params: optional parameters. type dictionary
      For example. { 'pio_attributes' : "name" }
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    if self._uid is None:
      raise InvalidArgumentError(
        "uid is not identified. Please call identify(uid) first.")

    request = self._aget_user_itemrank_ranked(engine,
      self._uid, iids, params)
    return request

  def _auser_action_on_item(self, action, uid, iid, params):
    """Private function to asynchronously create an user action on an item

    :param action: action type. type str. ("like", "dislike", "conversion",
                         "rate", "view")
    :param uid: user id. type str or int.
    :param iid: item id. type str or int.
    :param params: optional attributes. type dictionary.
        For example, { 'pio_rate' : 4, 'pio_latlng' : [1.23,4.56] }
        NOTE: For "rate" action, pio_rate attribute is required.
            integer value of 1-5 (1 is least preferred and 5 is most
            preferred)

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    if "pio_latlng" in params:
      params["pio_latlng"] = ",".join(map(str, params["pio_latlng"]))

    path = "%s/actions/u2i.json" % (self.apiversion)
    request = AsyncRequest("POST", path, pio_appkey=self.appkey,
                 pio_action=action, pio_uid=uid, pio_iid=iid,
                 **params)
    request.set_rfunc(self._auser_action_on_item_resp)
    self._connection.make_request(request)
    return request

  def _auser_action_on_item_resp(self, response):
    """Private function to handle the AsyncResponse of the
    _auser_action_on_item request

    :param response: AsyncResponse object

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    if response.error is not None:
      raise U2IActionNotCreatedError(
        "Exception happened: %s for request %s" %
        (response.error, response.request))
    elif response.status != httplib.CREATED:
      raise U2IActionNotCreatedError("request: %s status: %s body: %s" %
                       (response.request, response.status,
                      response.body))
    return None

  def arecord_action_on_item(self, action, iid, params={}):
    """Asynchronously create action on item

    :param action: action name. type String. For example, "rate", "like",
             etc
    :param iid: item id. type str or int.
    :param params: optional attributes. type dictionary.
        For example, { 'pio_rate' : 4, 'pio_latlng': [4.5,67.8] }
        NOTE: For "rate" action, pio_rate attribute is required.
        integer value of 1-5 (1 is least preferred and 5 is most
        preferred)

    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.

    :raises:
      U2IActionNotCreatedError
    """

    if self._uid is None:
      raise InvalidArgumentError(
        "uid is not identified. Please call identify(uid) first.")

    request = self._auser_action_on_item(action, self._uid, iid, params)
    return request

  def auser_conversion_item(self, uid, iid, **params):
    """Deprecated. Asynchronously create an user conversion action on an
    item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    request = self._auser_action_on_item(CONVERSION_API, uid, iid, params)
    return request

  def auser_dislike_item(self, uid, iid, **params):
    """Deprecated. Asynchronously create an user dislike action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    request = self._auser_action_on_item(DISLIKE_API, uid, iid, params)
    return request

  def auser_like_item(self, uid, iid, **params):
    """Deprecated. Asynchronously create an user like action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    request = self._auser_action_on_item(LIKE_API, uid, iid, params)
    return request

  def auser_rate_item(self, uid, iid, rate, **params):
    """Deprecated. Asynchronously create an user rate action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param rate: rating. integer value of 1-5 (1 is least preferred and 5
           is most preferred)
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """

    params['pio_rate'] = rate
    request = self._auser_action_on_item(RATE_API, uid, iid, params)
    return request

  def auser_view_item(self, uid, iid, **params):
    """Deprecated. Asynchronously create an user view action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]
    :returns:
      AsyncRequest object. You should call the aresp() method using this
      AsyncRequest object as argument to get the final result or status
      of this asynchronous request.
    """
    request = self._auser_action_on_item(VIEW_API, uid, iid, params)
    return request

  def aresp(self, request):
    """Get the result of the asynchronous request

    :param request: AsyncRequest object. This object must be returned by
            the asynchronous request function
            For example, to get the result of a aget_user()
            request, call this aresp() with the argument of
            AsyncRequest object returned by aget_user().

    :returns:
      The result of this AsyncRequest. The return type is the same as
      the return type of corresponding blocking request.

      For example,

      Calling aresp() with acreate_user() AsyncRequest returns the same
      type as create_user(), which is None.

      Calling aresp() with aget_user() AsyncRequest returns the same
      type as get_user(), which is dictionary data.

    :raises:
      Exception may be raised if there is error happened. The type of
      exception is the same as exception type of the correspdoning
      blocking request.

      For example,

      Calling aresp() with acreate_user() AsyncRequest may raise
      UserNotCreatedError exception.

      Calling aresp() with aget_user() AsyncRequest may raise
      UserNotFoundError exception.

    """
    response = request.get_response()
    result = request.rfunc(response)
    return result

  def create_user(self, uid, params={}):
    """Blocking request to create user

    :param uid: user id. type str.
    :param params: optional attributes. type dictionary.
      For example, { 'custom': 'value', 'pio_inactive' : True,
      'pio_latlng': [4.5,67.8] }

    :returns:
      None.

    :raises:
      UserNotCreatedError.

    """
    request = self.acreate_user(uid, params)
    result = self.aresp(request)
    return result

  def get_user(self, uid):
    """Blocking request to get user

    :param uid: user id. type str or int.

    :returns:
      User data in Dictionary format.

    :rasies:
      UserNotFoundError.

    """
    request = self.aget_user(uid)
    result = self.aresp(request)
    return result

  def delete_user(self, uid):
    """Blocking request to delete the user

    :param uid: user id. type str.

    :returns:
      None.

    :raises:
      UserNotDeletedError.

    """
    request = self.adelete_user(uid)
    result = self.aresp(request)
    return result

  def create_item(self, iid, itypes, params={}):
    """Blocking request to create item

    :param iid: item id. type str.
    :param itypes: item types. Tuple of Str.
        For example, if this item belongs to item types "t1", "t2",
        "t3", "t4", then itypes=("t1", "t2", "t3", "t4").
        NOTE: if this item belongs to only one itype, use tuple of one
        element, eg. itypes=("t1",)
    :param params: optional attributes. type dictionary.
        For example,
        { 'custom': 'value', 'pio_inactive' : True,
        'pio_latlng': [4.5,67.8] }

    :returns:
      None

    :raises:
      ItemNotCreatedError

    """
    request = self.acreate_item(iid, itypes, params)
    result = self.aresp(request)
    return result

  def get_item(self, iid):
    """Blocking request to get item

    :param iid: item id. type str.

    :returns:
      item data in dictionary format.

    :raises:
      ItemNotFoundError.

    """
    request = self.aget_item(iid)
    result = self.aresp(request)
    return result

  def delete_item(self, iid):
    """Blocking request to delete item

    :param iid: item id. type str.

    :returns:
      None

    :raises:
      ItemNotDeletedError

    """
    request = self.adelete_item(iid)
    result = self.aresp(request)
    return result

  def get_itemrec_topn(self, engine, n, params={}):
    """Blocking request to get recommendations for the identified user

    :param engine: name of the prediction engine. type str.
    :param n: number of recommendation. type int.
    :param params: optional parameters. type dictionary
        For example, { 'pio_itypes' : ("t1", "t2") }
    :returns:
      data in dictionary format.

    :raises:
      ItemRecNotFoundError.
    """
    request = self.aget_itemrec_topn(engine, n, params)
    result = self.aresp(request)
    return result

  def get_itemrec(self, uid, n, engine, **params):
    """Deprecated. Blocking request to get recommendations

    :param uid: user id. type str or int.
    :param n: number of recommendation. type int.
    :param engine: name of the prediction engine. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]

    :returns:
      data in dictionary format.

    :raises:
      ItemRecNotFoundError.

    """
    request = self.aget_itemrec(uid, n, engine, **params)
    result = self.aresp(request)
    return result

  def get_itemsim_topn(self, engine, iid, n, params={}):
    """Blocking request to get top n similar items of the item

    :param engine: name of the prediction engine. type str.
    :param iid: item id. type str.
    :param n: number of similar items. type int.
    :param params: optional parameters. type dictionary
        For example, { 'pio_itypes' : ("t1",) }
    :returns:
      data in dictionary format.

    :raises:
      ItemSimNotFoundError.
    """

    request = self.aget_itemsim_topn(engine, iid, n, params)
    result = self.aresp(request)
    return result

  def get_itemrank_ranked(self, engine, iids, params={}):
    """Blocking request to get ranked item for user

    :param engine: name of the prediction engine. type str.
    :param iids: items to be ranked. type list of item ids.
        For example, ["i0", "i1", "i2"]
    :param params: optional parameters. type dictionary
        For example. { 'pio_attributes' : "name" }
    :returns:
      data in dictionary format.

    :raises:
      ItemRankNotFoundError.
    """
    request = self.aget_itemrank_ranked(engine, iids, params)
    result = self.aresp(request)
    return result

  def record_action_on_item(self, action, iid, params={}):
    """Blocking request to create action on an item

    :param action: action name. type String. For example, "rate", "like",
             etc
    :param iid: item id. type str.
    :param params: optional attributes. type dictionary.
        For example, { 'pio_rate' : 4, 'pio_latlng' : [1.23,4.56] }
        NOTE: For "rate" action, pio_rate attribute is required.
        integer value of 1-5 (1 is least preferred and 5 is most
        preferred)

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    request = self.arecord_action_on_item(action, iid, params)
    result = self.aresp(request)
    return result

  def user_conversion_item(self, uid, iid, **params):
    """Deprecated. Blocking request to create user conversion action on an
     item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    request = self.auser_conversion_item(uid, iid, **params)
    result = self.aresp(request)
    return result

  def user_dislike_item(self, uid, iid, **params):
    """Deprecated. Blocking request to create user dislike action on an
     item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    request = self.auser_dislike_item(uid, iid, **params)
    result = self.aresp(request)
    return result

  def user_like_item(self, uid, iid, **params):
    """Deprecated. Blocking request to create user like action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    request = self.auser_like_item(uid, iid, **params)
    result = self.aresp(request)
    return result

  def user_rate_item(self, uid, iid, rate, **params):
    """Deprecated. Blocking request to create user rate action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param rate: rating. integer value of 1-5 (1 is least preferred and 5
           is most preferred)
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    request = self.auser_rate_item(uid, iid, rate, **params)
    result = self.aresp(request)
    return result

  def user_view_item(self, uid, iid, **params):
    """Deprecated. Blocking request to create user view action on an item

    :param uid: user id. type str.
    :param iid: item id. type str.
    :param params: keyword arguments for optional attributes.
        For example, pio_latlng=[123.4, 56.7]

    :returns:
      None

    :raises:
      U2IActionNotCreatedError
    """
    request = self.auser_view_item(uid, iid, **params)
    result = self.aresp(request)
    return result