#
# Autogenerated by Thrift Compiler (0.9.0-dev)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py:slots,dynamic
#

from thrift.Thrift import TType, TMessageType, TException
from ttypes import *
from thrift.Thrift import TProcessor
from thrift.protocol.TBase import TBase, TExceptionBase


class Iface(object):
  def getConfigValue(self, category, option, section):
    """
    Parameters:
     - category
     - option
     - section
    """
    pass

  def setConfigValue(self, category, option, value, section):
    """
    Parameters:
     - category
     - option
     - value
     - section
    """
    pass

  def getConfig(self, ):
    pass

  def getPluginConfig(self, ):
    pass

  def pauseServer(self, ):
    pass

  def unpauseServer(self, ):
    pass

  def togglePause(self, ):
    pass

  def statusServer(self, ):
    pass

  def freeSpace(self, ):
    pass

  def getServerVersion(self, ):
    pass

  def kill(self, ):
    pass

  def restart(self, ):
    pass

  def getLog(self, offset):
    """
    Parameters:
     - offset
    """
    pass

  def isTimeDownload(self, ):
    pass

  def isTimeReconnect(self, ):
    pass

  def toggleReconnect(self, ):
    pass

  def generatePackages(self, links):
    """
    Parameters:
     - links
    """
    pass

  def checkURLs(self, urls):
    """
    Parameters:
     - urls
    """
    pass

  def parseURLs(self, html, url):
    """
    Parameters:
     - html
     - url
    """
    pass

  def checkOnlineStatus(self, urls):
    """
    Parameters:
     - urls
    """
    pass

  def checkOnlineStatusContainer(self, urls, filename, data):
    """
    Parameters:
     - urls
     - filename
     - data
    """
    pass

  def pollResults(self, rid):
    """
    Parameters:
     - rid
    """
    pass

  def statusDownloads(self, ):
    pass

  def getPackageData(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def getPackageInfo(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def getFileData(self, fid):
    """
    Parameters:
     - fid
    """
    pass

  def getQueue(self, ):
    pass

  def getCollector(self, ):
    pass

  def getQueueData(self, ):
    pass

  def getCollectorData(self, ):
    pass

  def getPackageOrder(self, destination):
    """
    Parameters:
     - destination
    """
    pass

  def getFileOrder(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def generateAndAddPackages(self, links, dest):
    """
    Parameters:
     - links
     - dest
    """
    pass

  def addPackage(self, name, links, dest):
    """
    Parameters:
     - name
     - links
     - dest
    """
    pass

  def addFiles(self, pid, links):
    """
    Parameters:
     - pid
     - links
    """
    pass

  def uploadContainer(self, filename, data):
    """
    Parameters:
     - filename
     - data
    """
    pass

  def deleteFiles(self, fids):
    """
    Parameters:
     - fids
    """
    pass

  def deletePackages(self, pids):
    """
    Parameters:
     - pids
    """
    pass

  def pushToQueue(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def pullFromQueue(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def restartPackage(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def restartFile(self, fid):
    """
    Parameters:
     - fid
    """
    pass

  def recheckPackage(self, pid):
    """
    Parameters:
     - pid
    """
    pass

  def stopAllDownloads(self, ):
    pass

  def stopDownloads(self, fids):
    """
    Parameters:
     - fids
    """
    pass

  def setPackageName(self, pid, name):
    """
    Parameters:
     - pid
     - name
    """
    pass

  def movePackage(self, destination, pid):
    """
    Parameters:
     - destination
     - pid
    """
    pass

  def moveFiles(self, fids, pid):
    """
    Parameters:
     - fids
     - pid
    """
    pass

  def orderPackage(self, pid, position):
    """
    Parameters:
     - pid
     - position
    """
    pass

  def orderFile(self, fid, position):
    """
    Parameters:
     - fid
     - position
    """
    pass

  def setPackageData(self, pid, data):
    """
    Parameters:
     - pid
     - data
    """
    pass

  def deleteFinished(self, ):
    pass

  def restartFailed(self, ):
    pass

  def getEvents(self, uuid):
    """
    Parameters:
     - uuid
    """
    pass

  def getAccounts(self, refresh):
    """
    Parameters:
     - refresh
    """
    pass

  def getAccountTypes(self, ):
    pass

  def updateAccount(self, plugin, account, password, options):
    """
    Parameters:
     - plugin
     - account
     - password
     - options
    """
    pass

  def removeAccount(self, plugin, account):
    """
    Parameters:
     - plugin
     - account
    """
    pass

  def login(self, username, password):
    """
    Parameters:
     - username
     - password
    """
    pass

  def getUserData(self, username, password):
    """
    Parameters:
     - username
     - password
    """
    pass

  def getAllUserData(self, ):
    pass

  def getServices(self, ):
    pass

  def hasService(self, plugin, func):
    """
    Parameters:
     - plugin
     - func
    """
    pass

  def call(self, info):
    """
    Parameters:
     - info
    """
    pass

  def getAllInfo(self, ):
    pass

  def getInfoByPlugin(self, plugin):
    """
    Parameters:
     - plugin
    """
    pass

  def isCaptchaWaiting(self, ):
    pass

  def getCaptchaTask(self, exclusive):
    """
    Parameters:
     - exclusive
    """
    pass

  def getCaptchaTaskStatus(self, tid):
    """
    Parameters:
     - tid
    """
    pass

  def setCaptchaResult(self, tid, result):
    """
    Parameters:
     - tid
     - result
    """
    pass


class Client(Iface):
  def __init__(self, iprot, oprot=None):
    self._iprot = self._oprot = iprot
    if oprot is not None:
      self._oprot = oprot
    self._seqid = 0

  def getConfigValue(self, category, option, section):
    """
    Parameters:
     - category
     - option
     - section
    """
    self.send_getConfigValue(category, option, section)
    return self.recv_getConfigValue()

  def send_getConfigValue(self, category, option, section):
    self._oprot.writeMessageBegin('getConfigValue', TMessageType.CALL, self._seqid)
    args = getConfigValue_args()
    args.category = category
    args.option = option
    args.section = section
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getConfigValue(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getConfigValue_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfigValue failed: unknown result");

  def setConfigValue(self, category, option, value, section):
    """
    Parameters:
     - category
     - option
     - value
     - section
    """
    self.send_setConfigValue(category, option, value, section)
    self.recv_setConfigValue()

  def send_setConfigValue(self, category, option, value, section):
    self._oprot.writeMessageBegin('setConfigValue', TMessageType.CALL, self._seqid)
    args = setConfigValue_args()
    args.category = category
    args.option = option
    args.value = value
    args.section = section
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setConfigValue(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setConfigValue_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def getConfig(self, ):
    self.send_getConfig()
    return self.recv_getConfig()

  def send_getConfig(self, ):
    self._oprot.writeMessageBegin('getConfig', TMessageType.CALL, self._seqid)
    args = getConfig_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getConfig(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getConfig_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfig failed: unknown result");

  def getPluginConfig(self, ):
    self.send_getPluginConfig()
    return self.recv_getPluginConfig()

  def send_getPluginConfig(self, ):
    self._oprot.writeMessageBegin('getPluginConfig', TMessageType.CALL, self._seqid)
    args = getPluginConfig_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getPluginConfig(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getPluginConfig_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPluginConfig failed: unknown result");

  def pauseServer(self, ):
    self.send_pauseServer()
    self.recv_pauseServer()

  def send_pauseServer(self, ):
    self._oprot.writeMessageBegin('pauseServer', TMessageType.CALL, self._seqid)
    args = pauseServer_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_pauseServer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = pauseServer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def unpauseServer(self, ):
    self.send_unpauseServer()
    self.recv_unpauseServer()

  def send_unpauseServer(self, ):
    self._oprot.writeMessageBegin('unpauseServer', TMessageType.CALL, self._seqid)
    args = unpauseServer_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unpauseServer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = unpauseServer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def togglePause(self, ):
    self.send_togglePause()
    return self.recv_togglePause()

  def send_togglePause(self, ):
    self._oprot.writeMessageBegin('togglePause', TMessageType.CALL, self._seqid)
    args = togglePause_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_togglePause(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = togglePause_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "togglePause failed: unknown result");

  def statusServer(self, ):
    self.send_statusServer()
    return self.recv_statusServer()

  def send_statusServer(self, ):
    self._oprot.writeMessageBegin('statusServer', TMessageType.CALL, self._seqid)
    args = statusServer_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_statusServer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = statusServer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusServer failed: unknown result");

  def freeSpace(self, ):
    self.send_freeSpace()
    return self.recv_freeSpace()

  def send_freeSpace(self, ):
    self._oprot.writeMessageBegin('freeSpace', TMessageType.CALL, self._seqid)
    args = freeSpace_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_freeSpace(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = freeSpace_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "freeSpace failed: unknown result");

  def getServerVersion(self, ):
    self.send_getServerVersion()
    return self.recv_getServerVersion()

  def send_getServerVersion(self, ):
    self._oprot.writeMessageBegin('getServerVersion', TMessageType.CALL, self._seqid)
    args = getServerVersion_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getServerVersion(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getServerVersion_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServerVersion failed: unknown result");

  def kill(self, ):
    self.send_kill()
    self.recv_kill()

  def send_kill(self, ):
    self._oprot.writeMessageBegin('kill', TMessageType.CALL, self._seqid)
    args = kill_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_kill(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = kill_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def restart(self, ):
    self.send_restart()
    self.recv_restart()

  def send_restart(self, ):
    self._oprot.writeMessageBegin('restart', TMessageType.CALL, self._seqid)
    args = restart_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_restart(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = restart_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def getLog(self, offset):
    """
    Parameters:
     - offset
    """
    self.send_getLog(offset)
    return self.recv_getLog()

  def send_getLog(self, offset):
    self._oprot.writeMessageBegin('getLog', TMessageType.CALL, self._seqid)
    args = getLog_args()
    args.offset = offset
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getLog(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getLog_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLog failed: unknown result");

  def isTimeDownload(self, ):
    self.send_isTimeDownload()
    return self.recv_isTimeDownload()

  def send_isTimeDownload(self, ):
    self._oprot.writeMessageBegin('isTimeDownload', TMessageType.CALL, self._seqid)
    args = isTimeDownload_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_isTimeDownload(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = isTimeDownload_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTimeDownload failed: unknown result");

  def isTimeReconnect(self, ):
    self.send_isTimeReconnect()
    return self.recv_isTimeReconnect()

  def send_isTimeReconnect(self, ):
    self._oprot.writeMessageBegin('isTimeReconnect', TMessageType.CALL, self._seqid)
    args = isTimeReconnect_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_isTimeReconnect(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = isTimeReconnect_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTimeReconnect failed: unknown result");

  def toggleReconnect(self, ):
    self.send_toggleReconnect()
    return self.recv_toggleReconnect()

  def send_toggleReconnect(self, ):
    self._oprot.writeMessageBegin('toggleReconnect', TMessageType.CALL, self._seqid)
    args = toggleReconnect_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_toggleReconnect(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = toggleReconnect_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleReconnect failed: unknown result");

  def generatePackages(self, links):
    """
    Parameters:
     - links
    """
    self.send_generatePackages(links)
    return self.recv_generatePackages()

  def send_generatePackages(self, links):
    self._oprot.writeMessageBegin('generatePackages', TMessageType.CALL, self._seqid)
    args = generatePackages_args()
    args.links = links
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_generatePackages(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = generatePackages_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generatePackages failed: unknown result");

  def checkURLs(self, urls):
    """
    Parameters:
     - urls
    """
    self.send_checkURLs(urls)
    return self.recv_checkURLs()

  def send_checkURLs(self, urls):
    self._oprot.writeMessageBegin('checkURLs', TMessageType.CALL, self._seqid)
    args = checkURLs_args()
    args.urls = urls
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_checkURLs(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = checkURLs_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkURLs failed: unknown result");

  def parseURLs(self, html, url):
    """
    Parameters:
     - html
     - url
    """
    self.send_parseURLs(html, url)
    return self.recv_parseURLs()

  def send_parseURLs(self, html, url):
    self._oprot.writeMessageBegin('parseURLs', TMessageType.CALL, self._seqid)
    args = parseURLs_args()
    args.html = html
    args.url = url
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_parseURLs(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = parseURLs_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "parseURLs failed: unknown result");

  def checkOnlineStatus(self, urls):
    """
    Parameters:
     - urls
    """
    self.send_checkOnlineStatus(urls)
    return self.recv_checkOnlineStatus()

  def send_checkOnlineStatus(self, urls):
    self._oprot.writeMessageBegin('checkOnlineStatus', TMessageType.CALL, self._seqid)
    args = checkOnlineStatus_args()
    args.urls = urls
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_checkOnlineStatus(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = checkOnlineStatus_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOnlineStatus failed: unknown result");

  def checkOnlineStatusContainer(self, urls, filename, data):
    """
    Parameters:
     - urls
     - filename
     - data
    """
    self.send_checkOnlineStatusContainer(urls, filename, data)
    return self.recv_checkOnlineStatusContainer()

  def send_checkOnlineStatusContainer(self, urls, filename, data):
    self._oprot.writeMessageBegin('checkOnlineStatusContainer', TMessageType.CALL, self._seqid)
    args = checkOnlineStatusContainer_args()
    args.urls = urls
    args.filename = filename
    args.data = data
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_checkOnlineStatusContainer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = checkOnlineStatusContainer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOnlineStatusContainer failed: unknown result");

  def pollResults(self, rid):
    """
    Parameters:
     - rid
    """
    self.send_pollResults(rid)
    return self.recv_pollResults()

  def send_pollResults(self, rid):
    self._oprot.writeMessageBegin('pollResults', TMessageType.CALL, self._seqid)
    args = pollResults_args()
    args.rid = rid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_pollResults(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = pollResults_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "pollResults failed: unknown result");

  def statusDownloads(self, ):
    self.send_statusDownloads()
    return self.recv_statusDownloads()

  def send_statusDownloads(self, ):
    self._oprot.writeMessageBegin('statusDownloads', TMessageType.CALL, self._seqid)
    args = statusDownloads_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_statusDownloads(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = statusDownloads_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusDownloads failed: unknown result");

  def getPackageData(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_getPackageData(pid)
    return self.recv_getPackageData()

  def send_getPackageData(self, pid):
    self._oprot.writeMessageBegin('getPackageData', TMessageType.CALL, self._seqid)
    args = getPackageData_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getPackageData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getPackageData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.e is not None:
      raise result.e
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageData failed: unknown result");

  def getPackageInfo(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_getPackageInfo(pid)
    return self.recv_getPackageInfo()

  def send_getPackageInfo(self, pid):
    self._oprot.writeMessageBegin('getPackageInfo', TMessageType.CALL, self._seqid)
    args = getPackageInfo_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getPackageInfo(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getPackageInfo_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.e is not None:
      raise result.e
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageInfo failed: unknown result");

  def getFileData(self, fid):
    """
    Parameters:
     - fid
    """
    self.send_getFileData(fid)
    return self.recv_getFileData()

  def send_getFileData(self, fid):
    self._oprot.writeMessageBegin('getFileData', TMessageType.CALL, self._seqid)
    args = getFileData_args()
    args.fid = fid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getFileData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getFileData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.e is not None:
      raise result.e
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileData failed: unknown result");

  def getQueue(self, ):
    self.send_getQueue()
    return self.recv_getQueue()

  def send_getQueue(self, ):
    self._oprot.writeMessageBegin('getQueue', TMessageType.CALL, self._seqid)
    args = getQueue_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getQueue(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getQueue_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQueue failed: unknown result");

  def getCollector(self, ):
    self.send_getCollector()
    return self.recv_getCollector()

  def send_getCollector(self, ):
    self._oprot.writeMessageBegin('getCollector', TMessageType.CALL, self._seqid)
    args = getCollector_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCollector(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCollector_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollector failed: unknown result");

  def getQueueData(self, ):
    self.send_getQueueData()
    return self.recv_getQueueData()

  def send_getQueueData(self, ):
    self._oprot.writeMessageBegin('getQueueData', TMessageType.CALL, self._seqid)
    args = getQueueData_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getQueueData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getQueueData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQueueData failed: unknown result");

  def getCollectorData(self, ):
    self.send_getCollectorData()
    return self.recv_getCollectorData()

  def send_getCollectorData(self, ):
    self._oprot.writeMessageBegin('getCollectorData', TMessageType.CALL, self._seqid)
    args = getCollectorData_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCollectorData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCollectorData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollectorData failed: unknown result");

  def getPackageOrder(self, destination):
    """
    Parameters:
     - destination
    """
    self.send_getPackageOrder(destination)
    return self.recv_getPackageOrder()

  def send_getPackageOrder(self, destination):
    self._oprot.writeMessageBegin('getPackageOrder', TMessageType.CALL, self._seqid)
    args = getPackageOrder_args()
    args.destination = destination
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getPackageOrder(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getPackageOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageOrder failed: unknown result");

  def getFileOrder(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_getFileOrder(pid)
    return self.recv_getFileOrder()

  def send_getFileOrder(self, pid):
    self._oprot.writeMessageBegin('getFileOrder', TMessageType.CALL, self._seqid)
    args = getFileOrder_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getFileOrder(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getFileOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileOrder failed: unknown result");

  def generateAndAddPackages(self, links, dest):
    """
    Parameters:
     - links
     - dest
    """
    self.send_generateAndAddPackages(links, dest)
    return self.recv_generateAndAddPackages()

  def send_generateAndAddPackages(self, links, dest):
    self._oprot.writeMessageBegin('generateAndAddPackages', TMessageType.CALL, self._seqid)
    args = generateAndAddPackages_args()
    args.links = links
    args.dest = dest
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_generateAndAddPackages(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = generateAndAddPackages_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateAndAddPackages failed: unknown result");

  def addPackage(self, name, links, dest):
    """
    Parameters:
     - name
     - links
     - dest
    """
    self.send_addPackage(name, links, dest)
    return self.recv_addPackage()

  def send_addPackage(self, name, links, dest):
    self._oprot.writeMessageBegin('addPackage', TMessageType.CALL, self._seqid)
    args = addPackage_args()
    args.name = name
    args.links = links
    args.dest = dest
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_addPackage(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = addPackage_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPackage failed: unknown result");

  def addFiles(self, pid, links):
    """
    Parameters:
     - pid
     - links
    """
    self.send_addFiles(pid, links)
    self.recv_addFiles()

  def send_addFiles(self, pid, links):
    self._oprot.writeMessageBegin('addFiles', TMessageType.CALL, self._seqid)
    args = addFiles_args()
    args.pid = pid
    args.links = links
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_addFiles(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = addFiles_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def uploadContainer(self, filename, data):
    """
    Parameters:
     - filename
     - data
    """
    self.send_uploadContainer(filename, data)
    self.recv_uploadContainer()

  def send_uploadContainer(self, filename, data):
    self._oprot.writeMessageBegin('uploadContainer', TMessageType.CALL, self._seqid)
    args = uploadContainer_args()
    args.filename = filename
    args.data = data
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_uploadContainer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = uploadContainer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def deleteFiles(self, fids):
    """
    Parameters:
     - fids
    """
    self.send_deleteFiles(fids)
    self.recv_deleteFiles()

  def send_deleteFiles(self, fids):
    self._oprot.writeMessageBegin('deleteFiles', TMessageType.CALL, self._seqid)
    args = deleteFiles_args()
    args.fids = fids
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_deleteFiles(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = deleteFiles_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def deletePackages(self, pids):
    """
    Parameters:
     - pids
    """
    self.send_deletePackages(pids)
    self.recv_deletePackages()

  def send_deletePackages(self, pids):
    self._oprot.writeMessageBegin('deletePackages', TMessageType.CALL, self._seqid)
    args = deletePackages_args()
    args.pids = pids
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_deletePackages(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = deletePackages_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def pushToQueue(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_pushToQueue(pid)
    self.recv_pushToQueue()

  def send_pushToQueue(self, pid):
    self._oprot.writeMessageBegin('pushToQueue', TMessageType.CALL, self._seqid)
    args = pushToQueue_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_pushToQueue(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = pushToQueue_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def pullFromQueue(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_pullFromQueue(pid)
    self.recv_pullFromQueue()

  def send_pullFromQueue(self, pid):
    self._oprot.writeMessageBegin('pullFromQueue', TMessageType.CALL, self._seqid)
    args = pullFromQueue_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_pullFromQueue(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = pullFromQueue_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def restartPackage(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_restartPackage(pid)
    self.recv_restartPackage()

  def send_restartPackage(self, pid):
    self._oprot.writeMessageBegin('restartPackage', TMessageType.CALL, self._seqid)
    args = restartPackage_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_restartPackage(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = restartPackage_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def restartFile(self, fid):
    """
    Parameters:
     - fid
    """
    self.send_restartFile(fid)
    self.recv_restartFile()

  def send_restartFile(self, fid):
    self._oprot.writeMessageBegin('restartFile', TMessageType.CALL, self._seqid)
    args = restartFile_args()
    args.fid = fid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_restartFile(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = restartFile_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def recheckPackage(self, pid):
    """
    Parameters:
     - pid
    """
    self.send_recheckPackage(pid)
    self.recv_recheckPackage()

  def send_recheckPackage(self, pid):
    self._oprot.writeMessageBegin('recheckPackage', TMessageType.CALL, self._seqid)
    args = recheckPackage_args()
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_recheckPackage(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = recheckPackage_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def stopAllDownloads(self, ):
    self.send_stopAllDownloads()
    self.recv_stopAllDownloads()

  def send_stopAllDownloads(self, ):
    self._oprot.writeMessageBegin('stopAllDownloads', TMessageType.CALL, self._seqid)
    args = stopAllDownloads_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_stopAllDownloads(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = stopAllDownloads_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def stopDownloads(self, fids):
    """
    Parameters:
     - fids
    """
    self.send_stopDownloads(fids)
    self.recv_stopDownloads()

  def send_stopDownloads(self, fids):
    self._oprot.writeMessageBegin('stopDownloads', TMessageType.CALL, self._seqid)
    args = stopDownloads_args()
    args.fids = fids
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_stopDownloads(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = stopDownloads_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def setPackageName(self, pid, name):
    """
    Parameters:
     - pid
     - name
    """
    self.send_setPackageName(pid, name)
    self.recv_setPackageName()

  def send_setPackageName(self, pid, name):
    self._oprot.writeMessageBegin('setPackageName', TMessageType.CALL, self._seqid)
    args = setPackageName_args()
    args.pid = pid
    args.name = name
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setPackageName(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setPackageName_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def movePackage(self, destination, pid):
    """
    Parameters:
     - destination
     - pid
    """
    self.send_movePackage(destination, pid)
    self.recv_movePackage()

  def send_movePackage(self, destination, pid):
    self._oprot.writeMessageBegin('movePackage', TMessageType.CALL, self._seqid)
    args = movePackage_args()
    args.destination = destination
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_movePackage(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = movePackage_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def moveFiles(self, fids, pid):
    """
    Parameters:
     - fids
     - pid
    """
    self.send_moveFiles(fids, pid)
    self.recv_moveFiles()

  def send_moveFiles(self, fids, pid):
    self._oprot.writeMessageBegin('moveFiles', TMessageType.CALL, self._seqid)
    args = moveFiles_args()
    args.fids = fids
    args.pid = pid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_moveFiles(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = moveFiles_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def orderPackage(self, pid, position):
    """
    Parameters:
     - pid
     - position
    """
    self.send_orderPackage(pid, position)
    self.recv_orderPackage()

  def send_orderPackage(self, pid, position):
    self._oprot.writeMessageBegin('orderPackage', TMessageType.CALL, self._seqid)
    args = orderPackage_args()
    args.pid = pid
    args.position = position
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_orderPackage(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = orderPackage_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def orderFile(self, fid, position):
    """
    Parameters:
     - fid
     - position
    """
    self.send_orderFile(fid, position)
    self.recv_orderFile()

  def send_orderFile(self, fid, position):
    self._oprot.writeMessageBegin('orderFile', TMessageType.CALL, self._seqid)
    args = orderFile_args()
    args.fid = fid
    args.position = position
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_orderFile(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = orderFile_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def setPackageData(self, pid, data):
    """
    Parameters:
     - pid
     - data
    """
    self.send_setPackageData(pid, data)
    self.recv_setPackageData()

  def send_setPackageData(self, pid, data):
    self._oprot.writeMessageBegin('setPackageData', TMessageType.CALL, self._seqid)
    args = setPackageData_args()
    args.pid = pid
    args.data = data
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setPackageData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setPackageData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.e is not None:
      raise result.e
    return

  def deleteFinished(self, ):
    self.send_deleteFinished()
    return self.recv_deleteFinished()

  def send_deleteFinished(self, ):
    self._oprot.writeMessageBegin('deleteFinished', TMessageType.CALL, self._seqid)
    args = deleteFinished_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_deleteFinished(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = deleteFinished_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFinished failed: unknown result");

  def restartFailed(self, ):
    self.send_restartFailed()
    self.recv_restartFailed()

  def send_restartFailed(self, ):
    self._oprot.writeMessageBegin('restartFailed', TMessageType.CALL, self._seqid)
    args = restartFailed_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_restartFailed(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = restartFailed_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def getEvents(self, uuid):
    """
    Parameters:
     - uuid
    """
    self.send_getEvents(uuid)
    return self.recv_getEvents()

  def send_getEvents(self, uuid):
    self._oprot.writeMessageBegin('getEvents', TMessageType.CALL, self._seqid)
    args = getEvents_args()
    args.uuid = uuid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getEvents(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getEvents_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEvents failed: unknown result");

  def getAccounts(self, refresh):
    """
    Parameters:
     - refresh
    """
    self.send_getAccounts(refresh)
    return self.recv_getAccounts()

  def send_getAccounts(self, refresh):
    self._oprot.writeMessageBegin('getAccounts', TMessageType.CALL, self._seqid)
    args = getAccounts_args()
    args.refresh = refresh
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAccounts(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAccounts_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAccounts failed: unknown result");

  def getAccountTypes(self, ):
    self.send_getAccountTypes()
    return self.recv_getAccountTypes()

  def send_getAccountTypes(self, ):
    self._oprot.writeMessageBegin('getAccountTypes', TMessageType.CALL, self._seqid)
    args = getAccountTypes_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAccountTypes(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAccountTypes_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAccountTypes failed: unknown result");

  def updateAccount(self, plugin, account, password, options):
    """
    Parameters:
     - plugin
     - account
     - password
     - options
    """
    self.send_updateAccount(plugin, account, password, options)
    self.recv_updateAccount()

  def send_updateAccount(self, plugin, account, password, options):
    self._oprot.writeMessageBegin('updateAccount', TMessageType.CALL, self._seqid)
    args = updateAccount_args()
    args.plugin = plugin
    args.account = account
    args.password = password
    args.options = options
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateAccount(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = updateAccount_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def removeAccount(self, plugin, account):
    """
    Parameters:
     - plugin
     - account
    """
    self.send_removeAccount(plugin, account)
    self.recv_removeAccount()

  def send_removeAccount(self, plugin, account):
    self._oprot.writeMessageBegin('removeAccount', TMessageType.CALL, self._seqid)
    args = removeAccount_args()
    args.plugin = plugin
    args.account = account
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_removeAccount(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = removeAccount_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def login(self, username, password):
    """
    Parameters:
     - username
     - password
    """
    self.send_login(username, password)
    return self.recv_login()

  def send_login(self, username, password):
    self._oprot.writeMessageBegin('login', TMessageType.CALL, self._seqid)
    args = login_args()
    args.username = username
    args.password = password
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_login(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = login_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "login failed: unknown result");

  def getUserData(self, username, password):
    """
    Parameters:
     - username
     - password
    """
    self.send_getUserData(username, password)
    return self.recv_getUserData()

  def send_getUserData(self, username, password):
    self._oprot.writeMessageBegin('getUserData', TMessageType.CALL, self._seqid)
    args = getUserData_args()
    args.username = username
    args.password = password
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getUserData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getUserData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserData failed: unknown result");

  def getAllUserData(self, ):
    self.send_getAllUserData()
    return self.recv_getAllUserData()

  def send_getAllUserData(self, ):
    self._oprot.writeMessageBegin('getAllUserData', TMessageType.CALL, self._seqid)
    args = getAllUserData_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAllUserData(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAllUserData_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserData failed: unknown result");

  def getServices(self, ):
    self.send_getServices()
    return self.recv_getServices()

  def send_getServices(self, ):
    self._oprot.writeMessageBegin('getServices', TMessageType.CALL, self._seqid)
    args = getServices_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getServices(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getServices_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServices failed: unknown result");

  def hasService(self, plugin, func):
    """
    Parameters:
     - plugin
     - func
    """
    self.send_hasService(plugin, func)
    return self.recv_hasService()

  def send_hasService(self, plugin, func):
    self._oprot.writeMessageBegin('hasService', TMessageType.CALL, self._seqid)
    args = hasService_args()
    args.plugin = plugin
    args.func = func
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_hasService(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = hasService_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "hasService failed: unknown result");

  def call(self, info):
    """
    Parameters:
     - info
    """
    self.send_call(info)
    return self.recv_call()

  def send_call(self, info):
    self._oprot.writeMessageBegin('call', TMessageType.CALL, self._seqid)
    args = call_args()
    args.info = info
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_call(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = call_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    if result.e is not None:
      raise result.e
    raise TApplicationException(TApplicationException.MISSING_RESULT, "call failed: unknown result");

  def getAllInfo(self, ):
    self.send_getAllInfo()
    return self.recv_getAllInfo()

  def send_getAllInfo(self, ):
    self._oprot.writeMessageBegin('getAllInfo', TMessageType.CALL, self._seqid)
    args = getAllInfo_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAllInfo(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAllInfo_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInfo failed: unknown result");

  def getInfoByPlugin(self, plugin):
    """
    Parameters:
     - plugin
    """
    self.send_getInfoByPlugin(plugin)
    return self.recv_getInfoByPlugin()

  def send_getInfoByPlugin(self, plugin):
    self._oprot.writeMessageBegin('getInfoByPlugin', TMessageType.CALL, self._seqid)
    args = getInfoByPlugin_args()
    args.plugin = plugin
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInfoByPlugin(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInfoByPlugin_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInfoByPlugin failed: unknown result");

  def isCaptchaWaiting(self, ):
    self.send_isCaptchaWaiting()
    return self.recv_isCaptchaWaiting()

  def send_isCaptchaWaiting(self, ):
    self._oprot.writeMessageBegin('isCaptchaWaiting', TMessageType.CALL, self._seqid)
    args = isCaptchaWaiting_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_isCaptchaWaiting(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = isCaptchaWaiting_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCaptchaWaiting failed: unknown result");

  def getCaptchaTask(self, exclusive):
    """
    Parameters:
     - exclusive
    """
    self.send_getCaptchaTask(exclusive)
    return self.recv_getCaptchaTask()

  def send_getCaptchaTask(self, exclusive):
    self._oprot.writeMessageBegin('getCaptchaTask', TMessageType.CALL, self._seqid)
    args = getCaptchaTask_args()
    args.exclusive = exclusive
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCaptchaTask(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCaptchaTask_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCaptchaTask failed: unknown result");

  def getCaptchaTaskStatus(self, tid):
    """
    Parameters:
     - tid
    """
    self.send_getCaptchaTaskStatus(tid)
    return self.recv_getCaptchaTaskStatus()

  def send_getCaptchaTaskStatus(self, tid):
    self._oprot.writeMessageBegin('getCaptchaTaskStatus', TMessageType.CALL, self._seqid)
    args = getCaptchaTaskStatus_args()
    args.tid = tid
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCaptchaTaskStatus(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCaptchaTaskStatus_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCaptchaTaskStatus failed: unknown result");

  def setCaptchaResult(self, tid, result):
    """
    Parameters:
     - tid
     - result
    """
    self.send_setCaptchaResult(tid, result)
    self.recv_setCaptchaResult()

  def send_setCaptchaResult(self, tid, result):
    self._oprot.writeMessageBegin('setCaptchaResult', TMessageType.CALL, self._seqid)
    args = setCaptchaResult_args()
    args.tid = tid
    args.result = result
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setCaptchaResult(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setCaptchaResult_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return


class Processor(Iface, TProcessor):
  def __init__(self, handler):
    self._handler = handler
    self._processMap = {}
    self._processMap["getConfigValue"] = Processor.process_getConfigValue
    self._processMap["setConfigValue"] = Processor.process_setConfigValue
    self._processMap["getConfig"] = Processor.process_getConfig
    self._processMap["getPluginConfig"] = Processor.process_getPluginConfig
    self._processMap["pauseServer"] = Processor.process_pauseServer
    self._processMap["unpauseServer"] = Processor.process_unpauseServer
    self._processMap["togglePause"] = Processor.process_togglePause
    self._processMap["statusServer"] = Processor.process_statusServer
    self._processMap["freeSpace"] = Processor.process_freeSpace
    self._processMap["getServerVersion"] = Processor.process_getServerVersion
    self._processMap["kill"] = Processor.process_kill
    self._processMap["restart"] = Processor.process_restart
    self._processMap["getLog"] = Processor.process_getLog
    self._processMap["isTimeDownload"] = Processor.process_isTimeDownload
    self._processMap["isTimeReconnect"] = Processor.process_isTimeReconnect
    self._processMap["toggleReconnect"] = Processor.process_toggleReconnect
    self._processMap["generatePackages"] = Processor.process_generatePackages
    self._processMap["checkURLs"] = Processor.process_checkURLs
    self._processMap["parseURLs"] = Processor.process_parseURLs
    self._processMap["checkOnlineStatus"] = Processor.process_checkOnlineStatus
    self._processMap["checkOnlineStatusContainer"] = Processor.process_checkOnlineStatusContainer
    self._processMap["pollResults"] = Processor.process_pollResults
    self._processMap["statusDownloads"] = Processor.process_statusDownloads
    self._processMap["getPackageData"] = Processor.process_getPackageData
    self._processMap["getPackageInfo"] = Processor.process_getPackageInfo
    self._processMap["getFileData"] = Processor.process_getFileData
    self._processMap["getQueue"] = Processor.process_getQueue
    self._processMap["getCollector"] = Processor.process_getCollector
    self._processMap["getQueueData"] = Processor.process_getQueueData
    self._processMap["getCollectorData"] = Processor.process_getCollectorData
    self._processMap["getPackageOrder"] = Processor.process_getPackageOrder
    self._processMap["getFileOrder"] = Processor.process_getFileOrder
    self._processMap["generateAndAddPackages"] = Processor.process_generateAndAddPackages
    self._processMap["addPackage"] = Processor.process_addPackage
    self._processMap["addFiles"] = Processor.process_addFiles
    self._processMap["uploadContainer"] = Processor.process_uploadContainer
    self._processMap["deleteFiles"] = Processor.process_deleteFiles
    self._processMap["deletePackages"] = Processor.process_deletePackages
    self._processMap["pushToQueue"] = Processor.process_pushToQueue
    self._processMap["pullFromQueue"] = Processor.process_pullFromQueue
    self._processMap["restartPackage"] = Processor.process_restartPackage
    self._processMap["restartFile"] = Processor.process_restartFile
    self._processMap["recheckPackage"] = Processor.process_recheckPackage
    self._processMap["stopAllDownloads"] = Processor.process_stopAllDownloads
    self._processMap["stopDownloads"] = Processor.process_stopDownloads
    self._processMap["setPackageName"] = Processor.process_setPackageName
    self._processMap["movePackage"] = Processor.process_movePackage
    self._processMap["moveFiles"] = Processor.process_moveFiles
    self._processMap["orderPackage"] = Processor.process_orderPackage
    self._processMap["orderFile"] = Processor.process_orderFile
    self._processMap["setPackageData"] = Processor.process_setPackageData
    self._processMap["deleteFinished"] = Processor.process_deleteFinished
    self._processMap["restartFailed"] = Processor.process_restartFailed
    self._processMap["getEvents"] = Processor.process_getEvents
    self._processMap["getAccounts"] = Processor.process_getAccounts
    self._processMap["getAccountTypes"] = Processor.process_getAccountTypes
    self._processMap["updateAccount"] = Processor.process_updateAccount
    self._processMap["removeAccount"] = Processor.process_removeAccount
    self._processMap["login"] = Processor.process_login
    self._processMap["getUserData"] = Processor.process_getUserData
    self._processMap["getAllUserData"] = Processor.process_getAllUserData
    self._processMap["getServices"] = Processor.process_getServices
    self._processMap["hasService"] = Processor.process_hasService
    self._processMap["call"] = Processor.process_call
    self._processMap["getAllInfo"] = Processor.process_getAllInfo
    self._processMap["getInfoByPlugin"] = Processor.process_getInfoByPlugin
    self._processMap["isCaptchaWaiting"] = Processor.process_isCaptchaWaiting
    self._processMap["getCaptchaTask"] = Processor.process_getCaptchaTask
    self._processMap["getCaptchaTaskStatus"] = Processor.process_getCaptchaTaskStatus
    self._processMap["setCaptchaResult"] = Processor.process_setCaptchaResult

  def process(self, iprot, oprot):
    (name, type, seqid) = iprot.readMessageBegin()
    if name not in self._processMap:
      iprot.skip(TType.STRUCT)
      iprot.readMessageEnd()
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
      x.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
      return
    else:
      self._processMap[name](self, seqid, iprot, oprot)
    return True

  def process_getConfigValue(self, seqid, iprot, oprot):
    args = getConfigValue_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getConfigValue_result()
    result.success = self._handler.getConfigValue(args.category, args.option, args.section)
    oprot.writeMessageBegin("getConfigValue", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setConfigValue(self, seqid, iprot, oprot):
    args = setConfigValue_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setConfigValue_result()
    self._handler.setConfigValue(args.category, args.option, args.value, args.section)
    oprot.writeMessageBegin("setConfigValue", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getConfig(self, seqid, iprot, oprot):
    args = getConfig_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getConfig_result()
    result.success = self._handler.getConfig()
    oprot.writeMessageBegin("getConfig", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getPluginConfig(self, seqid, iprot, oprot):
    args = getPluginConfig_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getPluginConfig_result()
    result.success = self._handler.getPluginConfig()
    oprot.writeMessageBegin("getPluginConfig", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_pauseServer(self, seqid, iprot, oprot):
    args = pauseServer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = pauseServer_result()
    self._handler.pauseServer()
    oprot.writeMessageBegin("pauseServer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unpauseServer(self, seqid, iprot, oprot):
    args = unpauseServer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unpauseServer_result()
    self._handler.unpauseServer()
    oprot.writeMessageBegin("unpauseServer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_togglePause(self, seqid, iprot, oprot):
    args = togglePause_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = togglePause_result()
    result.success = self._handler.togglePause()
    oprot.writeMessageBegin("togglePause", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_statusServer(self, seqid, iprot, oprot):
    args = statusServer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = statusServer_result()
    result.success = self._handler.statusServer()
    oprot.writeMessageBegin("statusServer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_freeSpace(self, seqid, iprot, oprot):
    args = freeSpace_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = freeSpace_result()
    result.success = self._handler.freeSpace()
    oprot.writeMessageBegin("freeSpace", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getServerVersion(self, seqid, iprot, oprot):
    args = getServerVersion_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getServerVersion_result()
    result.success = self._handler.getServerVersion()
    oprot.writeMessageBegin("getServerVersion", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_kill(self, seqid, iprot, oprot):
    args = kill_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = kill_result()
    self._handler.kill()
    oprot.writeMessageBegin("kill", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_restart(self, seqid, iprot, oprot):
    args = restart_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = restart_result()
    self._handler.restart()
    oprot.writeMessageBegin("restart", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getLog(self, seqid, iprot, oprot):
    args = getLog_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getLog_result()
    result.success = self._handler.getLog(args.offset)
    oprot.writeMessageBegin("getLog", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_isTimeDownload(self, seqid, iprot, oprot):
    args = isTimeDownload_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = isTimeDownload_result()
    result.success = self._handler.isTimeDownload()
    oprot.writeMessageBegin("isTimeDownload", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_isTimeReconnect(self, seqid, iprot, oprot):
    args = isTimeReconnect_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = isTimeReconnect_result()
    result.success = self._handler.isTimeReconnect()
    oprot.writeMessageBegin("isTimeReconnect", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_toggleReconnect(self, seqid, iprot, oprot):
    args = toggleReconnect_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = toggleReconnect_result()
    result.success = self._handler.toggleReconnect()
    oprot.writeMessageBegin("toggleReconnect", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_generatePackages(self, seqid, iprot, oprot):
    args = generatePackages_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = generatePackages_result()
    result.success = self._handler.generatePackages(args.links)
    oprot.writeMessageBegin("generatePackages", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_checkURLs(self, seqid, iprot, oprot):
    args = checkURLs_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = checkURLs_result()
    result.success = self._handler.checkURLs(args.urls)
    oprot.writeMessageBegin("checkURLs", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_parseURLs(self, seqid, iprot, oprot):
    args = parseURLs_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = parseURLs_result()
    result.success = self._handler.parseURLs(args.html, args.url)
    oprot.writeMessageBegin("parseURLs", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_checkOnlineStatus(self, seqid, iprot, oprot):
    args = checkOnlineStatus_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = checkOnlineStatus_result()
    result.success = self._handler.checkOnlineStatus(args.urls)
    oprot.writeMessageBegin("checkOnlineStatus", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_checkOnlineStatusContainer(self, seqid, iprot, oprot):
    args = checkOnlineStatusContainer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = checkOnlineStatusContainer_result()
    result.success = self._handler.checkOnlineStatusContainer(args.urls, args.filename, args.data)
    oprot.writeMessageBegin("checkOnlineStatusContainer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_pollResults(self, seqid, iprot, oprot):
    args = pollResults_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = pollResults_result()
    result.success = self._handler.pollResults(args.rid)
    oprot.writeMessageBegin("pollResults", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_statusDownloads(self, seqid, iprot, oprot):
    args = statusDownloads_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = statusDownloads_result()
    result.success = self._handler.statusDownloads()
    oprot.writeMessageBegin("statusDownloads", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getPackageData(self, seqid, iprot, oprot):
    args = getPackageData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getPackageData_result()
    try:
      result.success = self._handler.getPackageData(args.pid)
    except PackageDoesNotExists, e:
      result.e = e
    oprot.writeMessageBegin("getPackageData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getPackageInfo(self, seqid, iprot, oprot):
    args = getPackageInfo_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getPackageInfo_result()
    try:
      result.success = self._handler.getPackageInfo(args.pid)
    except PackageDoesNotExists, e:
      result.e = e
    oprot.writeMessageBegin("getPackageInfo", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getFileData(self, seqid, iprot, oprot):
    args = getFileData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getFileData_result()
    try:
      result.success = self._handler.getFileData(args.fid)
    except FileDoesNotExists, e:
      result.e = e
    oprot.writeMessageBegin("getFileData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getQueue(self, seqid, iprot, oprot):
    args = getQueue_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getQueue_result()
    result.success = self._handler.getQueue()
    oprot.writeMessageBegin("getQueue", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCollector(self, seqid, iprot, oprot):
    args = getCollector_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCollector_result()
    result.success = self._handler.getCollector()
    oprot.writeMessageBegin("getCollector", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getQueueData(self, seqid, iprot, oprot):
    args = getQueueData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getQueueData_result()
    result.success = self._handler.getQueueData()
    oprot.writeMessageBegin("getQueueData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCollectorData(self, seqid, iprot, oprot):
    args = getCollectorData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCollectorData_result()
    result.success = self._handler.getCollectorData()
    oprot.writeMessageBegin("getCollectorData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getPackageOrder(self, seqid, iprot, oprot):
    args = getPackageOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getPackageOrder_result()
    result.success = self._handler.getPackageOrder(args.destination)
    oprot.writeMessageBegin("getPackageOrder", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getFileOrder(self, seqid, iprot, oprot):
    args = getFileOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getFileOrder_result()
    result.success = self._handler.getFileOrder(args.pid)
    oprot.writeMessageBegin("getFileOrder", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_generateAndAddPackages(self, seqid, iprot, oprot):
    args = generateAndAddPackages_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = generateAndAddPackages_result()
    result.success = self._handler.generateAndAddPackages(args.links, args.dest)
    oprot.writeMessageBegin("generateAndAddPackages", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_addPackage(self, seqid, iprot, oprot):
    args = addPackage_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = addPackage_result()
    result.success = self._handler.addPackage(args.name, args.links, args.dest)
    oprot.writeMessageBegin("addPackage", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_addFiles(self, seqid, iprot, oprot):
    args = addFiles_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = addFiles_result()
    self._handler.addFiles(args.pid, args.links)
    oprot.writeMessageBegin("addFiles", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_uploadContainer(self, seqid, iprot, oprot):
    args = uploadContainer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = uploadContainer_result()
    self._handler.uploadContainer(args.filename, args.data)
    oprot.writeMessageBegin("uploadContainer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_deleteFiles(self, seqid, iprot, oprot):
    args = deleteFiles_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = deleteFiles_result()
    self._handler.deleteFiles(args.fids)
    oprot.writeMessageBegin("deleteFiles", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_deletePackages(self, seqid, iprot, oprot):
    args = deletePackages_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = deletePackages_result()
    self._handler.deletePackages(args.pids)
    oprot.writeMessageBegin("deletePackages", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_pushToQueue(self, seqid, iprot, oprot):
    args = pushToQueue_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = pushToQueue_result()
    self._handler.pushToQueue(args.pid)
    oprot.writeMessageBegin("pushToQueue", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_pullFromQueue(self, seqid, iprot, oprot):
    args = pullFromQueue_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = pullFromQueue_result()
    self._handler.pullFromQueue(args.pid)
    oprot.writeMessageBegin("pullFromQueue", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_restartPackage(self, seqid, iprot, oprot):
    args = restartPackage_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = restartPackage_result()
    self._handler.restartPackage(args.pid)
    oprot.writeMessageBegin("restartPackage", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_restartFile(self, seqid, iprot, oprot):
    args = restartFile_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = restartFile_result()
    self._handler.restartFile(args.fid)
    oprot.writeMessageBegin("restartFile", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_recheckPackage(self, seqid, iprot, oprot):
    args = recheckPackage_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = recheckPackage_result()
    self._handler.recheckPackage(args.pid)
    oprot.writeMessageBegin("recheckPackage", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_stopAllDownloads(self, seqid, iprot, oprot):
    args = stopAllDownloads_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = stopAllDownloads_result()
    self._handler.stopAllDownloads()
    oprot.writeMessageBegin("stopAllDownloads", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_stopDownloads(self, seqid, iprot, oprot):
    args = stopDownloads_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = stopDownloads_result()
    self._handler.stopDownloads(args.fids)
    oprot.writeMessageBegin("stopDownloads", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setPackageName(self, seqid, iprot, oprot):
    args = setPackageName_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setPackageName_result()
    self._handler.setPackageName(args.pid, args.name)
    oprot.writeMessageBegin("setPackageName", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_movePackage(self, seqid, iprot, oprot):
    args = movePackage_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = movePackage_result()
    self._handler.movePackage(args.destination, args.pid)
    oprot.writeMessageBegin("movePackage", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_moveFiles(self, seqid, iprot, oprot):
    args = moveFiles_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = moveFiles_result()
    self._handler.moveFiles(args.fids, args.pid)
    oprot.writeMessageBegin("moveFiles", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_orderPackage(self, seqid, iprot, oprot):
    args = orderPackage_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = orderPackage_result()
    self._handler.orderPackage(args.pid, args.position)
    oprot.writeMessageBegin("orderPackage", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_orderFile(self, seqid, iprot, oprot):
    args = orderFile_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = orderFile_result()
    self._handler.orderFile(args.fid, args.position)
    oprot.writeMessageBegin("orderFile", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setPackageData(self, seqid, iprot, oprot):
    args = setPackageData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setPackageData_result()
    try:
      self._handler.setPackageData(args.pid, args.data)
    except PackageDoesNotExists, e:
      result.e = e
    oprot.writeMessageBegin("setPackageData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_deleteFinished(self, seqid, iprot, oprot):
    args = deleteFinished_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = deleteFinished_result()
    result.success = self._handler.deleteFinished()
    oprot.writeMessageBegin("deleteFinished", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_restartFailed(self, seqid, iprot, oprot):
    args = restartFailed_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = restartFailed_result()
    self._handler.restartFailed()
    oprot.writeMessageBegin("restartFailed", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getEvents(self, seqid, iprot, oprot):
    args = getEvents_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getEvents_result()
    result.success = self._handler.getEvents(args.uuid)
    oprot.writeMessageBegin("getEvents", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAccounts(self, seqid, iprot, oprot):
    args = getAccounts_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAccounts_result()
    result.success = self._handler.getAccounts(args.refresh)
    oprot.writeMessageBegin("getAccounts", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAccountTypes(self, seqid, iprot, oprot):
    args = getAccountTypes_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAccountTypes_result()
    result.success = self._handler.getAccountTypes()
    oprot.writeMessageBegin("getAccountTypes", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateAccount(self, seqid, iprot, oprot):
    args = updateAccount_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateAccount_result()
    self._handler.updateAccount(args.plugin, args.account, args.password, args.options)
    oprot.writeMessageBegin("updateAccount", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_removeAccount(self, seqid, iprot, oprot):
    args = removeAccount_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = removeAccount_result()
    self._handler.removeAccount(args.plugin, args.account)
    oprot.writeMessageBegin("removeAccount", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_login(self, seqid, iprot, oprot):
    args = login_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = login_result()
    result.success = self._handler.login(args.username, args.password)
    oprot.writeMessageBegin("login", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getUserData(self, seqid, iprot, oprot):
    args = getUserData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getUserData_result()
    result.success = self._handler.getUserData(args.username, args.password)
    oprot.writeMessageBegin("getUserData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAllUserData(self, seqid, iprot, oprot):
    args = getAllUserData_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAllUserData_result()
    result.success = self._handler.getAllUserData()
    oprot.writeMessageBegin("getAllUserData", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getServices(self, seqid, iprot, oprot):
    args = getServices_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getServices_result()
    result.success = self._handler.getServices()
    oprot.writeMessageBegin("getServices", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_hasService(self, seqid, iprot, oprot):
    args = hasService_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = hasService_result()
    result.success = self._handler.hasService(args.plugin, args.func)
    oprot.writeMessageBegin("hasService", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_call(self, seqid, iprot, oprot):
    args = call_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = call_result()
    try:
      result.success = self._handler.call(args.info)
    except ServiceDoesNotExists, ex:
      result.ex = ex
    except ServiceException, e:
      result.e = e
    oprot.writeMessageBegin("call", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAllInfo(self, seqid, iprot, oprot):
    args = getAllInfo_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAllInfo_result()
    result.success = self._handler.getAllInfo()
    oprot.writeMessageBegin("getAllInfo", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInfoByPlugin(self, seqid, iprot, oprot):
    args = getInfoByPlugin_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInfoByPlugin_result()
    result.success = self._handler.getInfoByPlugin(args.plugin)
    oprot.writeMessageBegin("getInfoByPlugin", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_isCaptchaWaiting(self, seqid, iprot, oprot):
    args = isCaptchaWaiting_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = isCaptchaWaiting_result()
    result.success = self._handler.isCaptchaWaiting()
    oprot.writeMessageBegin("isCaptchaWaiting", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCaptchaTask(self, seqid, iprot, oprot):
    args = getCaptchaTask_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCaptchaTask_result()
    result.success = self._handler.getCaptchaTask(args.exclusive)
    oprot.writeMessageBegin("getCaptchaTask", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCaptchaTaskStatus(self, seqid, iprot, oprot):
    args = getCaptchaTaskStatus_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCaptchaTaskStatus_result()
    result.success = self._handler.getCaptchaTaskStatus(args.tid)
    oprot.writeMessageBegin("getCaptchaTaskStatus", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setCaptchaResult(self, seqid, iprot, oprot):
    args = setCaptchaResult_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setCaptchaResult_result()
    self._handler.setCaptchaResult(args.tid, args.result)
    oprot.writeMessageBegin("setCaptchaResult", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()


# HELPER FUNCTIONS AND STRUCTURES

class getConfigValue_args(TBase):
  """
  Attributes:
   - category
   - option
   - section
  """

  __slots__ = [ 
    'category',
    'option',
    'section',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'category', None, None, ), # 1
    (2, TType.STRING, 'option', None, None, ), # 2
    (3, TType.STRING, 'section', None, None, ), # 3
  )

  def __init__(self, category=None, option=None, section=None,):
    self.category = category
    self.option = option
    self.section = section


class getConfigValue_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class setConfigValue_args(TBase):
  """
  Attributes:
   - category
   - option
   - value
   - section
  """

  __slots__ = [ 
    'category',
    'option',
    'value',
    'section',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'category', None, None, ), # 1
    (2, TType.STRING, 'option', None, None, ), # 2
    (3, TType.STRING, 'value', None, None, ), # 3
    (4, TType.STRING, 'section', None, None, ), # 4
  )

  def __init__(self, category=None, option=None, value=None, section=None,):
    self.category = category
    self.option = option
    self.value = value
    self.section = section


class setConfigValue_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getConfig_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getConfig_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getPluginConfig_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getPluginConfig_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class pauseServer_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class pauseServer_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class unpauseServer_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class unpauseServer_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class togglePause_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class togglePause_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class statusServer_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class statusServer_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (ServerStatus, ServerStatus.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class freeSpace_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class freeSpace_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getServerVersion_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getServerVersion_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class kill_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class kill_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class restart_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class restart_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getLog_args(TBase):
  """
  Attributes:
   - offset
  """

  __slots__ = [ 
    'offset',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'offset', None, None, ), # 1
  )

  def __init__(self, offset=None,):
    self.offset = offset


class getLog_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class isTimeDownload_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class isTimeDownload_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class isTimeReconnect_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class isTimeReconnect_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class toggleReconnect_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class toggleReconnect_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class generatePackages_args(TBase):
  """
  Attributes:
   - links
  """

  __slots__ = [ 
    'links',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, links=None,):
    self.links = links


class generatePackages_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class checkURLs_args(TBase):
  """
  Attributes:
   - urls
  """

  __slots__ = [ 
    'urls',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'urls', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, urls=None,):
    self.urls = urls


class checkURLs_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class parseURLs_args(TBase):
  """
  Attributes:
   - html
   - url
  """

  __slots__ = [ 
    'html',
    'url',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'html', None, None, ), # 1
    (2, TType.STRING, 'url', None, None, ), # 2
  )

  def __init__(self, html=None, url=None,):
    self.html = html
    self.url = url


class parseURLs_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class checkOnlineStatus_args(TBase):
  """
  Attributes:
   - urls
  """

  __slots__ = [ 
    'urls',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'urls', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, urls=None,):
    self.urls = urls


class checkOnlineStatus_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (OnlineCheck, OnlineCheck.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class checkOnlineStatusContainer_args(TBase):
  """
  Attributes:
   - urls
   - filename
   - data
  """

  __slots__ = [ 
    'urls',
    'filename',
    'data',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'urls', (TType.STRING,None), None, ), # 1
    (2, TType.STRING, 'filename', None, None, ), # 2
    (3, TType.STRING, 'data', None, None, ), # 3
  )

  def __init__(self, urls=None, filename=None, data=None,):
    self.urls = urls
    self.filename = filename
    self.data = data


class checkOnlineStatusContainer_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (OnlineCheck, OnlineCheck.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class pollResults_args(TBase):
  """
  Attributes:
   - rid
  """

  __slots__ = [ 
    'rid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'rid', None, None, ), # 1
  )

  def __init__(self, rid=None,):
    self.rid = rid


class pollResults_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (OnlineCheck, OnlineCheck.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class statusDownloads_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class statusDownloads_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(DownloadInfo, DownloadInfo.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getPackageData_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class getPackageData_result(TBase):
  """
  Attributes:
   - success
   - e
  """

  __slots__ = [ 
    'success',
    'e',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (PackageData, PackageData.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, e=None,):
    self.success = success
    self.e = e


class getPackageInfo_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class getPackageInfo_result(TBase):
  """
  Attributes:
   - success
   - e
  """

  __slots__ = [ 
    'success',
    'e',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (PackageData, PackageData.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, e=None,):
    self.success = success
    self.e = e


class getFileData_args(TBase):
  """
  Attributes:
   - fid
  """

  __slots__ = [ 
    'fid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'fid', None, None, ), # 1
  )

  def __init__(self, fid=None,):
    self.fid = fid


class getFileData_result(TBase):
  """
  Attributes:
   - success
   - e
  """

  __slots__ = [ 
    'success',
    'e',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (FileData, FileData.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'e', (FileDoesNotExists, FileDoesNotExists.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, e=None,):
    self.success = success
    self.e = e


class getQueue_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getQueue_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getCollector_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getCollector_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getQueueData_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getQueueData_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getCollectorData_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getCollectorData_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getPackageOrder_args(TBase):
  """
  Attributes:
   - destination
  """

  __slots__ = [ 
    'destination',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'destination', None, None, ), # 1
  )

  def __init__(self, destination=None,):
    self.destination = destination


class getPackageOrder_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.I16,None,TType.I32,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getFileOrder_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class getFileOrder_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.I16,None,TType.I32,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class generateAndAddPackages_args(TBase):
  """
  Attributes:
   - links
   - dest
  """

  __slots__ = [ 
    'links',
    'dest',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
    (2, TType.I32, 'dest', None, None, ), # 2
  )

  def __init__(self, links=None, dest=None,):
    self.links = links
    self.dest = dest


class generateAndAddPackages_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class addPackage_args(TBase):
  """
  Attributes:
   - name
   - links
   - dest
  """

  __slots__ = [ 
    'name',
    'links',
    'dest',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'name', None, None, ), # 1
    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
    (3, TType.I32, 'dest', None, None, ), # 3
  )

  def __init__(self, name=None, links=None, dest=None,):
    self.name = name
    self.links = links
    self.dest = dest


class addPackage_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.I32, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class addFiles_args(TBase):
  """
  Attributes:
   - pid
   - links
  """

  __slots__ = [ 
    'pid',
    'links',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
  )

  def __init__(self, pid=None, links=None,):
    self.pid = pid
    self.links = links


class addFiles_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class uploadContainer_args(TBase):
  """
  Attributes:
   - filename
   - data
  """

  __slots__ = [ 
    'filename',
    'data',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'filename', None, None, ), # 1
    (2, TType.STRING, 'data', None, None, ), # 2
  )

  def __init__(self, filename=None, data=None,):
    self.filename = filename
    self.data = data


class uploadContainer_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class deleteFiles_args(TBase):
  """
  Attributes:
   - fids
  """

  __slots__ = [ 
    'fids',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
  )

  def __init__(self, fids=None,):
    self.fids = fids


class deleteFiles_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class deletePackages_args(TBase):
  """
  Attributes:
   - pids
  """

  __slots__ = [ 
    'pids',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'pids', (TType.I32,None), None, ), # 1
  )

  def __init__(self, pids=None,):
    self.pids = pids


class deletePackages_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class pushToQueue_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class pushToQueue_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class pullFromQueue_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class pullFromQueue_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class restartPackage_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class restartPackage_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class restartFile_args(TBase):
  """
  Attributes:
   - fid
  """

  __slots__ = [ 
    'fid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'fid', None, None, ), # 1
  )

  def __init__(self, fid=None,):
    self.fid = fid


class restartFile_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class recheckPackage_args(TBase):
  """
  Attributes:
   - pid
  """

  __slots__ = [ 
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
  )

  def __init__(self, pid=None,):
    self.pid = pid


class recheckPackage_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class stopAllDownloads_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class stopAllDownloads_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class stopDownloads_args(TBase):
  """
  Attributes:
   - fids
  """

  __slots__ = [ 
    'fids',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
  )

  def __init__(self, fids=None,):
    self.fids = fids


class stopDownloads_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class setPackageName_args(TBase):
  """
  Attributes:
   - pid
   - name
  """

  __slots__ = [ 
    'pid',
    'name',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
    (2, TType.STRING, 'name', None, None, ), # 2
  )

  def __init__(self, pid=None, name=None,):
    self.pid = pid
    self.name = name


class setPackageName_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class movePackage_args(TBase):
  """
  Attributes:
   - destination
   - pid
  """

  __slots__ = [ 
    'destination',
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'destination', None, None, ), # 1
    (2, TType.I32, 'pid', None, None, ), # 2
  )

  def __init__(self, destination=None, pid=None,):
    self.destination = destination
    self.pid = pid


class movePackage_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class moveFiles_args(TBase):
  """
  Attributes:
   - fids
   - pid
  """

  __slots__ = [ 
    'fids',
    'pid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
    (2, TType.I32, 'pid', None, None, ), # 2
  )

  def __init__(self, fids=None, pid=None,):
    self.fids = fids
    self.pid = pid


class moveFiles_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class orderPackage_args(TBase):
  """
  Attributes:
   - pid
   - position
  """

  __slots__ = [ 
    'pid',
    'position',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
    (2, TType.I16, 'position', None, None, ), # 2
  )

  def __init__(self, pid=None, position=None,):
    self.pid = pid
    self.position = position


class orderPackage_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class orderFile_args(TBase):
  """
  Attributes:
   - fid
   - position
  """

  __slots__ = [ 
    'fid',
    'position',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'fid', None, None, ), # 1
    (2, TType.I16, 'position', None, None, ), # 2
  )

  def __init__(self, fid=None, position=None,):
    self.fid = fid
    self.position = position


class orderFile_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class setPackageData_args(TBase):
  """
  Attributes:
   - pid
   - data
  """

  __slots__ = [ 
    'pid',
    'data',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'pid', None, None, ), # 1
    (2, TType.MAP, 'data', (TType.STRING,None,TType.STRING,None), None, ), # 2
  )

  def __init__(self, pid=None, data=None,):
    self.pid = pid
    self.data = data


class setPackageData_result(TBase):
  """
  Attributes:
   - e
  """

  __slots__ = [ 
    'e',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
  )

  def __init__(self, e=None,):
    self.e = e


class deleteFinished_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class deleteFinished_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class restartFailed_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class restartFailed_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getEvents_args(TBase):
  """
  Attributes:
   - uuid
  """

  __slots__ = [ 
    'uuid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'uuid', None, None, ), # 1
  )

  def __init__(self, uuid=None,):
    self.uuid = uuid


class getEvents_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(EventInfo, EventInfo.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getAccounts_args(TBase):
  """
  Attributes:
   - refresh
  """

  __slots__ = [ 
    'refresh',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.BOOL, 'refresh', None, None, ), # 1
  )

  def __init__(self, refresh=None,):
    self.refresh = refresh


class getAccounts_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(AccountInfo, AccountInfo.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getAccountTypes_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getAccountTypes_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class updateAccount_args(TBase):
  """
  Attributes:
   - plugin
   - account
   - password
   - options
  """

  __slots__ = [ 
    'plugin',
    'account',
    'password',
    'options',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'plugin', None, None, ), # 1
    (2, TType.STRING, 'account', None, None, ), # 2
    (3, TType.STRING, 'password', None, None, ), # 3
    (4, TType.MAP, 'options', (TType.STRING,None,TType.STRING,None), None, ), # 4
  )

  def __init__(self, plugin=None, account=None, password=None, options=None,):
    self.plugin = plugin
    self.account = account
    self.password = password
    self.options = options


class updateAccount_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class removeAccount_args(TBase):
  """
  Attributes:
   - plugin
   - account
  """

  __slots__ = [ 
    'plugin',
    'account',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'plugin', None, None, ), # 1
    (2, TType.STRING, 'account', None, None, ), # 2
  )

  def __init__(self, plugin=None, account=None,):
    self.plugin = plugin
    self.account = account


class removeAccount_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class login_args(TBase):
  """
  Attributes:
   - username
   - password
  """

  __slots__ = [ 
    'username',
    'password',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'username', None, None, ), # 1
    (2, TType.STRING, 'password', None, None, ), # 2
  )

  def __init__(self, username=None, password=None,):
    self.username = username
    self.password = password


class login_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getUserData_args(TBase):
  """
  Attributes:
   - username
   - password
  """

  __slots__ = [ 
    'username',
    'password',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'username', None, None, ), # 1
    (2, TType.STRING, 'password', None, None, ), # 2
  )

  def __init__(self, username=None, password=None,):
    self.username = username
    self.password = password


class getUserData_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (UserData, UserData.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getAllUserData_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getAllUserData_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(UserData, UserData.thrift_spec)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getServices_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getServices_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class hasService_args(TBase):
  """
  Attributes:
   - plugin
   - func
  """

  __slots__ = [ 
    'plugin',
    'func',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'plugin', None, None, ), # 1
    (2, TType.STRING, 'func', None, None, ), # 2
  )

  def __init__(self, plugin=None, func=None,):
    self.plugin = plugin
    self.func = func


class hasService_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class call_args(TBase):
  """
  Attributes:
   - info
  """

  __slots__ = [ 
    'info',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'info', (ServiceCall, ServiceCall.thrift_spec), None, ), # 1
  )

  def __init__(self, info=None,):
    self.info = info


class call_result(TBase):
  """
  Attributes:
   - success
   - ex
   - e
  """

  __slots__ = [ 
    'success',
    'ex',
    'e',
   ]

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ex', (ServiceDoesNotExists, ServiceDoesNotExists.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'e', (ServiceException, ServiceException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ex=None, e=None,):
    self.success = success
    self.ex = ex
    self.e = e


class getAllInfo_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class getAllInfo_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getInfoByPlugin_args(TBase):
  """
  Attributes:
   - plugin
  """

  __slots__ = [ 
    'plugin',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'plugin', None, None, ), # 1
  )

  def __init__(self, plugin=None,):
    self.plugin = plugin


class getInfoByPlugin_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class isCaptchaWaiting_args(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )


class isCaptchaWaiting_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getCaptchaTask_args(TBase):
  """
  Attributes:
   - exclusive
  """

  __slots__ = [ 
    'exclusive',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.BOOL, 'exclusive', None, None, ), # 1
  )

  def __init__(self, exclusive=None,):
    self.exclusive = exclusive


class getCaptchaTask_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRUCT, 'success', (CaptchaTask, CaptchaTask.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class getCaptchaTaskStatus_args(TBase):
  """
  Attributes:
   - tid
  """

  __slots__ = [ 
    'tid',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'tid', None, None, ), # 1
  )

  def __init__(self, tid=None,):
    self.tid = tid


class getCaptchaTaskStatus_result(TBase):
  """
  Attributes:
   - success
  """

  __slots__ = [ 
    'success',
   ]

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success


class setCaptchaResult_args(TBase):
  """
  Attributes:
   - tid
   - result
  """

  __slots__ = [ 
    'tid',
    'result',
   ]

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'tid', None, None, ), # 1
    (2, TType.STRING, 'result', None, None, ), # 2
  )

  def __init__(self, tid=None, result=None,):
    self.tid = tid
    self.result = result


class setCaptchaResult_result(TBase):

  __slots__ = [ 
   ]

  thrift_spec = (
  )

