# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Autogenerated by Thrift Compiler (0.12.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
from thrift.protocol.TProtocol import TProtocolException
from thrift.TRecursive import fix_spec

import sys
import logging
from .ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport
all_structs = []


class Iface(object):
    def login(self, principal, loginProperties):
        """
        Parameters:
         - principal
         - loginProperties

        """
        pass

    def addConstraint(self, login, tableName, constraintClassName):
        """
        Parameters:
         - login
         - tableName
         - constraintClassName

        """
        pass

    def addSplits(self, login, tableName, splits):
        """
        Parameters:
         - login
         - tableName
         - splits

        """
        pass

    def attachIterator(self, login, tableName, setting, scopes):
        """
        Parameters:
         - login
         - tableName
         - setting
         - scopes

        """
        pass

    def checkIteratorConflicts(self, login, tableName, setting, scopes):
        """
        Parameters:
         - login
         - tableName
         - setting
         - scopes

        """
        pass

    def clearLocatorCache(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def cloneTable(self, login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude):
        """
        Parameters:
         - login
         - tableName
         - newTableName
         - flush
         - propertiesToSet
         - propertiesToExclude

        """
        pass

    def compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow
         - iterators
         - flush
         - wait
         - compactionStrategy

        """
        pass

    def cancelCompaction(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def createTable(self, login, tableName, versioningIter, type):
        """
        Parameters:
         - login
         - tableName
         - versioningIter
         - type

        """
        pass

    def deleteTable(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def deleteRows(self, login, tableName, startRow, endRow):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow

        """
        pass

    def exportTable(self, login, tableName, exportDir):
        """
        Parameters:
         - login
         - tableName
         - exportDir

        """
        pass

    def flushTable(self, login, tableName, startRow, endRow, wait):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow
         - wait

        """
        pass

    def getDiskUsage(self, login, tables):
        """
        Parameters:
         - login
         - tables

        """
        pass

    def getLocalityGroups(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def getIteratorSetting(self, login, tableName, iteratorName, scope):
        """
        Parameters:
         - login
         - tableName
         - iteratorName
         - scope

        """
        pass

    def getMaxRow(self, login, tableName, auths, startRow, startInclusive, endRow, endInclusive):
        """
        Parameters:
         - login
         - tableName
         - auths
         - startRow
         - startInclusive
         - endRow
         - endInclusive

        """
        pass

    def getTableProperties(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def importDirectory(self, login, tableName, importDir, failureDir, setTime):
        """
        Parameters:
         - login
         - tableName
         - importDir
         - failureDir
         - setTime

        """
        pass

    def importTable(self, login, tableName, importDir):
        """
        Parameters:
         - login
         - tableName
         - importDir

        """
        pass

    def listSplits(self, login, tableName, maxSplits):
        """
        Parameters:
         - login
         - tableName
         - maxSplits

        """
        pass

    def listTables(self, login):
        """
        Parameters:
         - login

        """
        pass

    def listIterators(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def listConstraints(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def mergeTablets(self, login, tableName, startRow, endRow):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow

        """
        pass

    def offlineTable(self, login, tableName, wait):
        """
        Parameters:
         - login
         - tableName
         - wait

        """
        pass

    def onlineTable(self, login, tableName, wait):
        """
        Parameters:
         - login
         - tableName
         - wait

        """
        pass

    def removeConstraint(self, login, tableName, constraint):
        """
        Parameters:
         - login
         - tableName
         - constraint

        """
        pass

    def removeIterator(self, login, tableName, iterName, scopes):
        """
        Parameters:
         - login
         - tableName
         - iterName
         - scopes

        """
        pass

    def removeTableProperty(self, login, tableName, property):
        """
        Parameters:
         - login
         - tableName
         - property

        """
        pass

    def renameTable(self, login, oldTableName, newTableName):
        """
        Parameters:
         - login
         - oldTableName
         - newTableName

        """
        pass

    def setLocalityGroups(self, login, tableName, groups):
        """
        Parameters:
         - login
         - tableName
         - groups

        """
        pass

    def setTableProperty(self, login, tableName, property, value):
        """
        Parameters:
         - login
         - tableName
         - property
         - value

        """
        pass

    def splitRangeByTablets(self, login, tableName, range, maxSplits):
        """
        Parameters:
         - login
         - tableName
         - range
         - maxSplits

        """
        pass

    def tableExists(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        pass

    def tableIdMap(self, login):
        """
        Parameters:
         - login

        """
        pass

    def testTableClassLoad(self, login, tableName, className, asTypeName):
        """
        Parameters:
         - login
         - tableName
         - className
         - asTypeName

        """
        pass

    def pingTabletServer(self, login, tserver):
        """
        Parameters:
         - login
         - tserver

        """
        pass

    def getActiveScans(self, login, tserver):
        """
        Parameters:
         - login
         - tserver

        """
        pass

    def getActiveCompactions(self, login, tserver):
        """
        Parameters:
         - login
         - tserver

        """
        pass

    def getSiteConfiguration(self, login):
        """
        Parameters:
         - login

        """
        pass

    def getSystemConfiguration(self, login):
        """
        Parameters:
         - login

        """
        pass

    def getTabletServers(self, login):
        """
        Parameters:
         - login

        """
        pass

    def removeProperty(self, login, property):
        """
        Parameters:
         - login
         - property

        """
        pass

    def setProperty(self, login, property, value):
        """
        Parameters:
         - login
         - property
         - value

        """
        pass

    def testClassLoad(self, login, className, asTypeName):
        """
        Parameters:
         - login
         - className
         - asTypeName

        """
        pass

    def authenticateUser(self, login, user, properties):
        """
        Parameters:
         - login
         - user
         - properties

        """
        pass

    def changeUserAuthorizations(self, login, user, authorizations):
        """
        Parameters:
         - login
         - user
         - authorizations

        """
        pass

    def changeLocalUserPassword(self, login, user, password):
        """
        Parameters:
         - login
         - user
         - password

        """
        pass

    def createLocalUser(self, login, user, password):
        """
        Parameters:
         - login
         - user
         - password

        """
        pass

    def dropLocalUser(self, login, user):
        """
        Parameters:
         - login
         - user

        """
        pass

    def getUserAuthorizations(self, login, user):
        """
        Parameters:
         - login
         - user

        """
        pass

    def grantSystemPermission(self, login, user, perm):
        """
        Parameters:
         - login
         - user
         - perm

        """
        pass

    def grantTablePermission(self, login, user, table, perm):
        """
        Parameters:
         - login
         - user
         - table
         - perm

        """
        pass

    def hasSystemPermission(self, login, user, perm):
        """
        Parameters:
         - login
         - user
         - perm

        """
        pass

    def hasTablePermission(self, login, user, table, perm):
        """
        Parameters:
         - login
         - user
         - table
         - perm

        """
        pass

    def listLocalUsers(self, login):
        """
        Parameters:
         - login

        """
        pass

    def revokeSystemPermission(self, login, user, perm):
        """
        Parameters:
         - login
         - user
         - perm

        """
        pass

    def revokeTablePermission(self, login, user, table, perm):
        """
        Parameters:
         - login
         - user
         - table
         - perm

        """
        pass

    def grantNamespacePermission(self, login, user, namespaceName, perm):
        """
        Parameters:
         - login
         - user
         - namespaceName
         - perm

        """
        pass

    def hasNamespacePermission(self, login, user, namespaceName, perm):
        """
        Parameters:
         - login
         - user
         - namespaceName
         - perm

        """
        pass

    def revokeNamespacePermission(self, login, user, namespaceName, perm):
        """
        Parameters:
         - login
         - user
         - namespaceName
         - perm

        """
        pass

    def createBatchScanner(self, login, tableName, options):
        """
        Parameters:
         - login
         - tableName
         - options

        """
        pass

    def createScanner(self, login, tableName, options):
        """
        Parameters:
         - login
         - tableName
         - options

        """
        pass

    def hasNext(self, scanner):
        """
        Parameters:
         - scanner

        """
        pass

    def nextEntry(self, scanner):
        """
        Parameters:
         - scanner

        """
        pass

    def nextK(self, scanner, k):
        """
        Parameters:
         - scanner
         - k

        """
        pass

    def closeScanner(self, scanner):
        """
        Parameters:
         - scanner

        """
        pass

    def updateAndFlush(self, login, tableName, cells):
        """
        Parameters:
         - login
         - tableName
         - cells

        """
        pass

    def createWriter(self, login, tableName, opts):
        """
        Parameters:
         - login
         - tableName
         - opts

        """
        pass

    def update(self, writer, cells):
        """
        Parameters:
         - writer
         - cells

        """
        pass

    def flush(self, writer):
        """
        Parameters:
         - writer

        """
        pass

    def closeWriter(self, writer):
        """
        Parameters:
         - writer

        """
        pass

    def updateRowConditionally(self, login, tableName, row, updates):
        """
        Parameters:
         - login
         - tableName
         - row
         - updates

        """
        pass

    def createConditionalWriter(self, login, tableName, options):
        """
        Parameters:
         - login
         - tableName
         - options

        """
        pass

    def updateRowsConditionally(self, conditionalWriter, updates):
        """
        Parameters:
         - conditionalWriter
         - updates

        """
        pass

    def closeConditionalWriter(self, conditionalWriter):
        """
        Parameters:
         - conditionalWriter

        """
        pass

    def getRowRange(self, row):
        """
        Parameters:
         - row

        """
        pass

    def getFollowing(self, key, part):
        """
        Parameters:
         - key
         - part

        """
        pass

    def systemNamespace(self):
        pass

    def defaultNamespace(self):
        pass

    def listNamespaces(self, login):
        """
        Parameters:
         - login

        """
        pass

    def namespaceExists(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        pass

    def createNamespace(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        pass

    def deleteNamespace(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        pass

    def renameNamespace(self, login, oldNamespaceName, newNamespaceName):
        """
        Parameters:
         - login
         - oldNamespaceName
         - newNamespaceName

        """
        pass

    def setNamespaceProperty(self, login, namespaceName, property, value):
        """
        Parameters:
         - login
         - namespaceName
         - property
         - value

        """
        pass

    def removeNamespaceProperty(self, login, namespaceName, property):
        """
        Parameters:
         - login
         - namespaceName
         - property

        """
        pass

    def getNamespaceProperties(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        pass

    def namespaceIdMap(self, login):
        """
        Parameters:
         - login

        """
        pass

    def attachNamespaceIterator(self, login, namespaceName, setting, scopes):
        """
        Parameters:
         - login
         - namespaceName
         - setting
         - scopes

        """
        pass

    def removeNamespaceIterator(self, login, namespaceName, name, scopes):
        """
        Parameters:
         - login
         - namespaceName
         - name
         - scopes

        """
        pass

    def getNamespaceIteratorSetting(self, login, namespaceName, name, scope):
        """
        Parameters:
         - login
         - namespaceName
         - name
         - scope

        """
        pass

    def listNamespaceIterators(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        pass

    def checkNamespaceIteratorConflicts(self, login, namespaceName, setting, scopes):
        """
        Parameters:
         - login
         - namespaceName
         - setting
         - scopes

        """
        pass

    def addNamespaceConstraint(self, login, namespaceName, constraintClassName):
        """
        Parameters:
         - login
         - namespaceName
         - constraintClassName

        """
        pass

    def removeNamespaceConstraint(self, login, namespaceName, id):
        """
        Parameters:
         - login
         - namespaceName
         - id

        """
        pass

    def listNamespaceConstraints(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        pass

    def testNamespaceClassLoad(self, login, namespaceName, className, asTypeName):
        """
        Parameters:
         - login
         - namespaceName
         - className
         - asTypeName

        """
        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 login(self, principal, loginProperties):
        """
        Parameters:
         - principal
         - loginProperties

        """
        self.send_login(principal, loginProperties)
        return self.recv_login()

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

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

    def addConstraint(self, login, tableName, constraintClassName):
        """
        Parameters:
         - login
         - tableName
         - constraintClassName

        """
        self.send_addConstraint(login, tableName, constraintClassName)
        return self.recv_addConstraint()

    def send_addConstraint(self, login, tableName, constraintClassName):
        self._oprot.writeMessageBegin('addConstraint', TMessageType.CALL, self._seqid)
        args = addConstraint_args()
        args.login = login
        args.tableName = tableName
        args.constraintClassName = constraintClassName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_addConstraint(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = addConstraint_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "addConstraint failed: unknown result")

    def addSplits(self, login, tableName, splits):
        """
        Parameters:
         - login
         - tableName
         - splits

        """
        self.send_addSplits(login, tableName, splits)
        self.recv_addSplits()

    def send_addSplits(self, login, tableName, splits):
        self._oprot.writeMessageBegin('addSplits', TMessageType.CALL, self._seqid)
        args = addSplits_args()
        args.login = login
        args.tableName = tableName
        args.splits = splits
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_addSplits(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = addSplits_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def attachIterator(self, login, tableName, setting, scopes):
        """
        Parameters:
         - login
         - tableName
         - setting
         - scopes

        """
        self.send_attachIterator(login, tableName, setting, scopes)
        self.recv_attachIterator()

    def send_attachIterator(self, login, tableName, setting, scopes):
        self._oprot.writeMessageBegin('attachIterator', TMessageType.CALL, self._seqid)
        args = attachIterator_args()
        args.login = login
        args.tableName = tableName
        args.setting = setting
        args.scopes = scopes
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_attachIterator(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = attachIterator_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def checkIteratorConflicts(self, login, tableName, setting, scopes):
        """
        Parameters:
         - login
         - tableName
         - setting
         - scopes

        """
        self.send_checkIteratorConflicts(login, tableName, setting, scopes)
        self.recv_checkIteratorConflicts()

    def send_checkIteratorConflicts(self, login, tableName, setting, scopes):
        self._oprot.writeMessageBegin('checkIteratorConflicts', TMessageType.CALL, self._seqid)
        args = checkIteratorConflicts_args()
        args.login = login
        args.tableName = tableName
        args.setting = setting
        args.scopes = scopes
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_checkIteratorConflicts(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = checkIteratorConflicts_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def clearLocatorCache(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_clearLocatorCache(login, tableName)
        self.recv_clearLocatorCache()

    def send_clearLocatorCache(self, login, tableName):
        self._oprot.writeMessageBegin('clearLocatorCache', TMessageType.CALL, self._seqid)
        args = clearLocatorCache_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_clearLocatorCache(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = clearLocatorCache_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        return

    def cloneTable(self, login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude):
        """
        Parameters:
         - login
         - tableName
         - newTableName
         - flush
         - propertiesToSet
         - propertiesToExclude

        """
        self.send_cloneTable(login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude)
        self.recv_cloneTable()

    def send_cloneTable(self, login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude):
        self._oprot.writeMessageBegin('cloneTable', TMessageType.CALL, self._seqid)
        args = cloneTable_args()
        args.login = login
        args.tableName = tableName
        args.newTableName = newTableName
        args.flush = flush
        args.propertiesToSet = propertiesToSet
        args.propertiesToExclude = propertiesToExclude
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_cloneTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = cloneTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        if result.ouch4 is not None:
            raise result.ouch4
        return

    def compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow
         - iterators
         - flush
         - wait
         - compactionStrategy

        """
        self.send_compactTable(login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy)
        self.recv_compactTable()

    def send_compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy):
        self._oprot.writeMessageBegin('compactTable', TMessageType.CALL, self._seqid)
        args = compactTable_args()
        args.login = login
        args.tableName = tableName
        args.startRow = startRow
        args.endRow = endRow
        args.iterators = iterators
        args.flush = flush
        args.wait = wait
        args.compactionStrategy = compactionStrategy
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_compactTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = compactTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def cancelCompaction(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_cancelCompaction(login, tableName)
        self.recv_cancelCompaction()

    def send_cancelCompaction(self, login, tableName):
        self._oprot.writeMessageBegin('cancelCompaction', TMessageType.CALL, self._seqid)
        args = cancelCompaction_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_cancelCompaction(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = cancelCompaction_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def createTable(self, login, tableName, versioningIter, type):
        """
        Parameters:
         - login
         - tableName
         - versioningIter
         - type

        """
        self.send_createTable(login, tableName, versioningIter, type)
        self.recv_createTable()

    def send_createTable(self, login, tableName, versioningIter, type):
        self._oprot.writeMessageBegin('createTable', TMessageType.CALL, self._seqid)
        args = createTable_args()
        args.login = login
        args.tableName = tableName
        args.versioningIter = versioningIter
        args.type = type
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def deleteTable(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_deleteTable(login, tableName)
        self.recv_deleteTable()

    def send_deleteTable(self, login, tableName):
        self._oprot.writeMessageBegin('deleteTable', TMessageType.CALL, self._seqid)
        args = deleteTable_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_deleteTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = deleteTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def deleteRows(self, login, tableName, startRow, endRow):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow

        """
        self.send_deleteRows(login, tableName, startRow, endRow)
        self.recv_deleteRows()

    def send_deleteRows(self, login, tableName, startRow, endRow):
        self._oprot.writeMessageBegin('deleteRows', TMessageType.CALL, self._seqid)
        args = deleteRows_args()
        args.login = login
        args.tableName = tableName
        args.startRow = startRow
        args.endRow = endRow
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_deleteRows(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = deleteRows_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def exportTable(self, login, tableName, exportDir):
        """
        Parameters:
         - login
         - tableName
         - exportDir

        """
        self.send_exportTable(login, tableName, exportDir)
        self.recv_exportTable()

    def send_exportTable(self, login, tableName, exportDir):
        self._oprot.writeMessageBegin('exportTable', TMessageType.CALL, self._seqid)
        args = exportTable_args()
        args.login = login
        args.tableName = tableName
        args.exportDir = exportDir
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_exportTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = exportTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def flushTable(self, login, tableName, startRow, endRow, wait):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow
         - wait

        """
        self.send_flushTable(login, tableName, startRow, endRow, wait)
        self.recv_flushTable()

    def send_flushTable(self, login, tableName, startRow, endRow, wait):
        self._oprot.writeMessageBegin('flushTable', TMessageType.CALL, self._seqid)
        args = flushTable_args()
        args.login = login
        args.tableName = tableName
        args.startRow = startRow
        args.endRow = endRow
        args.wait = wait
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_flushTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = flushTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def getDiskUsage(self, login, tables):
        """
        Parameters:
         - login
         - tables

        """
        self.send_getDiskUsage(login, tables)
        return self.recv_getDiskUsage()

    def send_getDiskUsage(self, login, tables):
        self._oprot.writeMessageBegin('getDiskUsage', TMessageType.CALL, self._seqid)
        args = getDiskUsage_args()
        args.login = login
        args.tables = tables
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getDiskUsage(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getDiskUsage_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getDiskUsage failed: unknown result")

    def getLocalityGroups(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_getLocalityGroups(login, tableName)
        return self.recv_getLocalityGroups()

    def send_getLocalityGroups(self, login, tableName):
        self._oprot.writeMessageBegin('getLocalityGroups', TMessageType.CALL, self._seqid)
        args = getLocalityGroups_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getLocalityGroups(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getLocalityGroups_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getLocalityGroups failed: unknown result")

    def getIteratorSetting(self, login, tableName, iteratorName, scope):
        """
        Parameters:
         - login
         - tableName
         - iteratorName
         - scope

        """
        self.send_getIteratorSetting(login, tableName, iteratorName, scope)
        return self.recv_getIteratorSetting()

    def send_getIteratorSetting(self, login, tableName, iteratorName, scope):
        self._oprot.writeMessageBegin('getIteratorSetting', TMessageType.CALL, self._seqid)
        args = getIteratorSetting_args()
        args.login = login
        args.tableName = tableName
        args.iteratorName = iteratorName
        args.scope = scope
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getIteratorSetting(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getIteratorSetting_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getIteratorSetting failed: unknown result")

    def getMaxRow(self, login, tableName, auths, startRow, startInclusive, endRow, endInclusive):
        """
        Parameters:
         - login
         - tableName
         - auths
         - startRow
         - startInclusive
         - endRow
         - endInclusive

        """
        self.send_getMaxRow(login, tableName, auths, startRow, startInclusive, endRow, endInclusive)
        return self.recv_getMaxRow()

    def send_getMaxRow(self, login, tableName, auths, startRow, startInclusive, endRow, endInclusive):
        self._oprot.writeMessageBegin('getMaxRow', TMessageType.CALL, self._seqid)
        args = getMaxRow_args()
        args.login = login
        args.tableName = tableName
        args.auths = auths
        args.startRow = startRow
        args.startInclusive = startInclusive
        args.endRow = endRow
        args.endInclusive = endInclusive
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getMaxRow(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getMaxRow_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getMaxRow failed: unknown result")

    def getTableProperties(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_getTableProperties(login, tableName)
        return self.recv_getTableProperties()

    def send_getTableProperties(self, login, tableName):
        self._oprot.writeMessageBegin('getTableProperties', TMessageType.CALL, self._seqid)
        args = getTableProperties_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getTableProperties(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getTableProperties_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableProperties failed: unknown result")

    def importDirectory(self, login, tableName, importDir, failureDir, setTime):
        """
        Parameters:
         - login
         - tableName
         - importDir
         - failureDir
         - setTime

        """
        self.send_importDirectory(login, tableName, importDir, failureDir, setTime)
        self.recv_importDirectory()

    def send_importDirectory(self, login, tableName, importDir, failureDir, setTime):
        self._oprot.writeMessageBegin('importDirectory', TMessageType.CALL, self._seqid)
        args = importDirectory_args()
        args.login = login
        args.tableName = tableName
        args.importDir = importDir
        args.failureDir = failureDir
        args.setTime = setTime
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_importDirectory(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = importDirectory_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch3 is not None:
            raise result.ouch3
        if result.ouch4 is not None:
            raise result.ouch4
        return

    def importTable(self, login, tableName, importDir):
        """
        Parameters:
         - login
         - tableName
         - importDir

        """
        self.send_importTable(login, tableName, importDir)
        self.recv_importTable()

    def send_importTable(self, login, tableName, importDir):
        self._oprot.writeMessageBegin('importTable', TMessageType.CALL, self._seqid)
        args = importTable_args()
        args.login = login
        args.tableName = tableName
        args.importDir = importDir
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_importTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = importTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def listSplits(self, login, tableName, maxSplits):
        """
        Parameters:
         - login
         - tableName
         - maxSplits

        """
        self.send_listSplits(login, tableName, maxSplits)
        return self.recv_listSplits()

    def send_listSplits(self, login, tableName, maxSplits):
        self._oprot.writeMessageBegin('listSplits', TMessageType.CALL, self._seqid)
        args = listSplits_args()
        args.login = login
        args.tableName = tableName
        args.maxSplits = maxSplits
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listSplits(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listSplits_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listSplits failed: unknown result")

    def listTables(self, login):
        """
        Parameters:
         - login

        """
        self.send_listTables(login)
        return self.recv_listTables()

    def send_listTables(self, login):
        self._oprot.writeMessageBegin('listTables', TMessageType.CALL, self._seqid)
        args = listTables_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listTables(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listTables_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listTables failed: unknown result")

    def listIterators(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_listIterators(login, tableName)
        return self.recv_listIterators()

    def send_listIterators(self, login, tableName):
        self._oprot.writeMessageBegin('listIterators', TMessageType.CALL, self._seqid)
        args = listIterators_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listIterators(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listIterators_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listIterators failed: unknown result")

    def listConstraints(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_listConstraints(login, tableName)
        return self.recv_listConstraints()

    def send_listConstraints(self, login, tableName):
        self._oprot.writeMessageBegin('listConstraints', TMessageType.CALL, self._seqid)
        args = listConstraints_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listConstraints(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listConstraints_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listConstraints failed: unknown result")

    def mergeTablets(self, login, tableName, startRow, endRow):
        """
        Parameters:
         - login
         - tableName
         - startRow
         - endRow

        """
        self.send_mergeTablets(login, tableName, startRow, endRow)
        self.recv_mergeTablets()

    def send_mergeTablets(self, login, tableName, startRow, endRow):
        self._oprot.writeMessageBegin('mergeTablets', TMessageType.CALL, self._seqid)
        args = mergeTablets_args()
        args.login = login
        args.tableName = tableName
        args.startRow = startRow
        args.endRow = endRow
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_mergeTablets(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = mergeTablets_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def offlineTable(self, login, tableName, wait):
        """
        Parameters:
         - login
         - tableName
         - wait

        """
        self.send_offlineTable(login, tableName, wait)
        self.recv_offlineTable()

    def send_offlineTable(self, login, tableName, wait):
        self._oprot.writeMessageBegin('offlineTable', TMessageType.CALL, self._seqid)
        args = offlineTable_args()
        args.login = login
        args.tableName = tableName
        args.wait = wait
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_offlineTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = offlineTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def onlineTable(self, login, tableName, wait):
        """
        Parameters:
         - login
         - tableName
         - wait

        """
        self.send_onlineTable(login, tableName, wait)
        self.recv_onlineTable()

    def send_onlineTable(self, login, tableName, wait):
        self._oprot.writeMessageBegin('onlineTable', TMessageType.CALL, self._seqid)
        args = onlineTable_args()
        args.login = login
        args.tableName = tableName
        args.wait = wait
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_onlineTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = onlineTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def removeConstraint(self, login, tableName, constraint):
        """
        Parameters:
         - login
         - tableName
         - constraint

        """
        self.send_removeConstraint(login, tableName, constraint)
        self.recv_removeConstraint()

    def send_removeConstraint(self, login, tableName, constraint):
        self._oprot.writeMessageBegin('removeConstraint', TMessageType.CALL, self._seqid)
        args = removeConstraint_args()
        args.login = login
        args.tableName = tableName
        args.constraint = constraint
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeConstraint(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeConstraint_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def removeIterator(self, login, tableName, iterName, scopes):
        """
        Parameters:
         - login
         - tableName
         - iterName
         - scopes

        """
        self.send_removeIterator(login, tableName, iterName, scopes)
        self.recv_removeIterator()

    def send_removeIterator(self, login, tableName, iterName, scopes):
        self._oprot.writeMessageBegin('removeIterator', TMessageType.CALL, self._seqid)
        args = removeIterator_args()
        args.login = login
        args.tableName = tableName
        args.iterName = iterName
        args.scopes = scopes
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeIterator(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeIterator_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def removeTableProperty(self, login, tableName, property):
        """
        Parameters:
         - login
         - tableName
         - property

        """
        self.send_removeTableProperty(login, tableName, property)
        self.recv_removeTableProperty()

    def send_removeTableProperty(self, login, tableName, property):
        self._oprot.writeMessageBegin('removeTableProperty', TMessageType.CALL, self._seqid)
        args = removeTableProperty_args()
        args.login = login
        args.tableName = tableName
        args.property = property
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeTableProperty(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeTableProperty_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def renameTable(self, login, oldTableName, newTableName):
        """
        Parameters:
         - login
         - oldTableName
         - newTableName

        """
        self.send_renameTable(login, oldTableName, newTableName)
        self.recv_renameTable()

    def send_renameTable(self, login, oldTableName, newTableName):
        self._oprot.writeMessageBegin('renameTable', TMessageType.CALL, self._seqid)
        args = renameTable_args()
        args.login = login
        args.oldTableName = oldTableName
        args.newTableName = newTableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_renameTable(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = renameTable_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        if result.ouch4 is not None:
            raise result.ouch4
        return

    def setLocalityGroups(self, login, tableName, groups):
        """
        Parameters:
         - login
         - tableName
         - groups

        """
        self.send_setLocalityGroups(login, tableName, groups)
        self.recv_setLocalityGroups()

    def send_setLocalityGroups(self, login, tableName, groups):
        self._oprot.writeMessageBegin('setLocalityGroups', TMessageType.CALL, self._seqid)
        args = setLocalityGroups_args()
        args.login = login
        args.tableName = tableName
        args.groups = groups
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_setLocalityGroups(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = setLocalityGroups_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def setTableProperty(self, login, tableName, property, value):
        """
        Parameters:
         - login
         - tableName
         - property
         - value

        """
        self.send_setTableProperty(login, tableName, property, value)
        self.recv_setTableProperty()

    def send_setTableProperty(self, login, tableName, property, value):
        self._oprot.writeMessageBegin('setTableProperty', TMessageType.CALL, self._seqid)
        args = setTableProperty_args()
        args.login = login
        args.tableName = tableName
        args.property = property
        args.value = value
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_setTableProperty(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = setTableProperty_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def splitRangeByTablets(self, login, tableName, range, maxSplits):
        """
        Parameters:
         - login
         - tableName
         - range
         - maxSplits

        """
        self.send_splitRangeByTablets(login, tableName, range, maxSplits)
        return self.recv_splitRangeByTablets()

    def send_splitRangeByTablets(self, login, tableName, range, maxSplits):
        self._oprot.writeMessageBegin('splitRangeByTablets', TMessageType.CALL, self._seqid)
        args = splitRangeByTablets_args()
        args.login = login
        args.tableName = tableName
        args.range = range
        args.maxSplits = maxSplits
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_splitRangeByTablets(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = splitRangeByTablets_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "splitRangeByTablets failed: unknown result")

    def tableExists(self, login, tableName):
        """
        Parameters:
         - login
         - tableName

        """
        self.send_tableExists(login, tableName)
        return self.recv_tableExists()

    def send_tableExists(self, login, tableName):
        self._oprot.writeMessageBegin('tableExists', TMessageType.CALL, self._seqid)
        args = tableExists_args()
        args.login = login
        args.tableName = tableName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_tableExists(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = tableExists_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "tableExists failed: unknown result")

    def tableIdMap(self, login):
        """
        Parameters:
         - login

        """
        self.send_tableIdMap(login)
        return self.recv_tableIdMap()

    def send_tableIdMap(self, login):
        self._oprot.writeMessageBegin('tableIdMap', TMessageType.CALL, self._seqid)
        args = tableIdMap_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_tableIdMap(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = tableIdMap_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "tableIdMap failed: unknown result")

    def testTableClassLoad(self, login, tableName, className, asTypeName):
        """
        Parameters:
         - login
         - tableName
         - className
         - asTypeName

        """
        self.send_testTableClassLoad(login, tableName, className, asTypeName)
        return self.recv_testTableClassLoad()

    def send_testTableClassLoad(self, login, tableName, className, asTypeName):
        self._oprot.writeMessageBegin('testTableClassLoad', TMessageType.CALL, self._seqid)
        args = testTableClassLoad_args()
        args.login = login
        args.tableName = tableName
        args.className = className
        args.asTypeName = asTypeName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_testTableClassLoad(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = testTableClassLoad_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "testTableClassLoad failed: unknown result")

    def pingTabletServer(self, login, tserver):
        """
        Parameters:
         - login
         - tserver

        """
        self.send_pingTabletServer(login, tserver)
        self.recv_pingTabletServer()

    def send_pingTabletServer(self, login, tserver):
        self._oprot.writeMessageBegin('pingTabletServer', TMessageType.CALL, self._seqid)
        args = pingTabletServer_args()
        args.login = login
        args.tserver = tserver
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_pingTabletServer(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = pingTabletServer_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def getActiveScans(self, login, tserver):
        """
        Parameters:
         - login
         - tserver

        """
        self.send_getActiveScans(login, tserver)
        return self.recv_getActiveScans()

    def send_getActiveScans(self, login, tserver):
        self._oprot.writeMessageBegin('getActiveScans', TMessageType.CALL, self._seqid)
        args = getActiveScans_args()
        args.login = login
        args.tserver = tserver
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getActiveScans(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getActiveScans_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveScans failed: unknown result")

    def getActiveCompactions(self, login, tserver):
        """
        Parameters:
         - login
         - tserver

        """
        self.send_getActiveCompactions(login, tserver)
        return self.recv_getActiveCompactions()

    def send_getActiveCompactions(self, login, tserver):
        self._oprot.writeMessageBegin('getActiveCompactions', TMessageType.CALL, self._seqid)
        args = getActiveCompactions_args()
        args.login = login
        args.tserver = tserver
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getActiveCompactions(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getActiveCompactions_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveCompactions failed: unknown result")

    def getSiteConfiguration(self, login):
        """
        Parameters:
         - login

        """
        self.send_getSiteConfiguration(login)
        return self.recv_getSiteConfiguration()

    def send_getSiteConfiguration(self, login):
        self._oprot.writeMessageBegin('getSiteConfiguration', TMessageType.CALL, self._seqid)
        args = getSiteConfiguration_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getSiteConfiguration(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getSiteConfiguration_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getSiteConfiguration failed: unknown result")

    def getSystemConfiguration(self, login):
        """
        Parameters:
         - login

        """
        self.send_getSystemConfiguration(login)
        return self.recv_getSystemConfiguration()

    def send_getSystemConfiguration(self, login):
        self._oprot.writeMessageBegin('getSystemConfiguration', TMessageType.CALL, self._seqid)
        args = getSystemConfiguration_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getSystemConfiguration(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getSystemConfiguration_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getSystemConfiguration failed: unknown result")

    def getTabletServers(self, login):
        """
        Parameters:
         - login

        """
        self.send_getTabletServers(login)
        return self.recv_getTabletServers()

    def send_getTabletServers(self, login):
        self._oprot.writeMessageBegin('getTabletServers', TMessageType.CALL, self._seqid)
        args = getTabletServers_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getTabletServers(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getTabletServers_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getTabletServers failed: unknown result")

    def removeProperty(self, login, property):
        """
        Parameters:
         - login
         - property

        """
        self.send_removeProperty(login, property)
        self.recv_removeProperty()

    def send_removeProperty(self, login, property):
        self._oprot.writeMessageBegin('removeProperty', TMessageType.CALL, self._seqid)
        args = removeProperty_args()
        args.login = login
        args.property = property
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeProperty(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeProperty_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def setProperty(self, login, property, value):
        """
        Parameters:
         - login
         - property
         - value

        """
        self.send_setProperty(login, property, value)
        self.recv_setProperty()

    def send_setProperty(self, login, property, value):
        self._oprot.writeMessageBegin('setProperty', TMessageType.CALL, self._seqid)
        args = setProperty_args()
        args.login = login
        args.property = property
        args.value = value
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_setProperty(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = setProperty_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def testClassLoad(self, login, className, asTypeName):
        """
        Parameters:
         - login
         - className
         - asTypeName

        """
        self.send_testClassLoad(login, className, asTypeName)
        return self.recv_testClassLoad()

    def send_testClassLoad(self, login, className, asTypeName):
        self._oprot.writeMessageBegin('testClassLoad', TMessageType.CALL, self._seqid)
        args = testClassLoad_args()
        args.login = login
        args.className = className
        args.asTypeName = asTypeName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_testClassLoad(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = testClassLoad_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "testClassLoad failed: unknown result")

    def authenticateUser(self, login, user, properties):
        """
        Parameters:
         - login
         - user
         - properties

        """
        self.send_authenticateUser(login, user, properties)
        return self.recv_authenticateUser()

    def send_authenticateUser(self, login, user, properties):
        self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
        args = authenticateUser_args()
        args.login = login
        args.user = user
        args.properties = properties
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_authenticateUser(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = authenticateUser_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result")

    def changeUserAuthorizations(self, login, user, authorizations):
        """
        Parameters:
         - login
         - user
         - authorizations

        """
        self.send_changeUserAuthorizations(login, user, authorizations)
        self.recv_changeUserAuthorizations()

    def send_changeUserAuthorizations(self, login, user, authorizations):
        self._oprot.writeMessageBegin('changeUserAuthorizations', TMessageType.CALL, self._seqid)
        args = changeUserAuthorizations_args()
        args.login = login
        args.user = user
        args.authorizations = authorizations
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_changeUserAuthorizations(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = changeUserAuthorizations_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def changeLocalUserPassword(self, login, user, password):
        """
        Parameters:
         - login
         - user
         - password

        """
        self.send_changeLocalUserPassword(login, user, password)
        self.recv_changeLocalUserPassword()

    def send_changeLocalUserPassword(self, login, user, password):
        self._oprot.writeMessageBegin('changeLocalUserPassword', TMessageType.CALL, self._seqid)
        args = changeLocalUserPassword_args()
        args.login = login
        args.user = user
        args.password = password
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_changeLocalUserPassword(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = changeLocalUserPassword_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def createLocalUser(self, login, user, password):
        """
        Parameters:
         - login
         - user
         - password

        """
        self.send_createLocalUser(login, user, password)
        self.recv_createLocalUser()

    def send_createLocalUser(self, login, user, password):
        self._oprot.writeMessageBegin('createLocalUser', TMessageType.CALL, self._seqid)
        args = createLocalUser_args()
        args.login = login
        args.user = user
        args.password = password
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createLocalUser(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createLocalUser_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def dropLocalUser(self, login, user):
        """
        Parameters:
         - login
         - user

        """
        self.send_dropLocalUser(login, user)
        self.recv_dropLocalUser()

    def send_dropLocalUser(self, login, user):
        self._oprot.writeMessageBegin('dropLocalUser', TMessageType.CALL, self._seqid)
        args = dropLocalUser_args()
        args.login = login
        args.user = user
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_dropLocalUser(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = dropLocalUser_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def getUserAuthorizations(self, login, user):
        """
        Parameters:
         - login
         - user

        """
        self.send_getUserAuthorizations(login, user)
        return self.recv_getUserAuthorizations()

    def send_getUserAuthorizations(self, login, user):
        self._oprot.writeMessageBegin('getUserAuthorizations', TMessageType.CALL, self._seqid)
        args = getUserAuthorizations_args()
        args.login = login
        args.user = user
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getUserAuthorizations(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getUserAuthorizations_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserAuthorizations failed: unknown result")

    def grantSystemPermission(self, login, user, perm):
        """
        Parameters:
         - login
         - user
         - perm

        """
        self.send_grantSystemPermission(login, user, perm)
        self.recv_grantSystemPermission()

    def send_grantSystemPermission(self, login, user, perm):
        self._oprot.writeMessageBegin('grantSystemPermission', TMessageType.CALL, self._seqid)
        args = grantSystemPermission_args()
        args.login = login
        args.user = user
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_grantSystemPermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = grantSystemPermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def grantTablePermission(self, login, user, table, perm):
        """
        Parameters:
         - login
         - user
         - table
         - perm

        """
        self.send_grantTablePermission(login, user, table, perm)
        self.recv_grantTablePermission()

    def send_grantTablePermission(self, login, user, table, perm):
        self._oprot.writeMessageBegin('grantTablePermission', TMessageType.CALL, self._seqid)
        args = grantTablePermission_args()
        args.login = login
        args.user = user
        args.table = table
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_grantTablePermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = grantTablePermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def hasSystemPermission(self, login, user, perm):
        """
        Parameters:
         - login
         - user
         - perm

        """
        self.send_hasSystemPermission(login, user, perm)
        return self.recv_hasSystemPermission()

    def send_hasSystemPermission(self, login, user, perm):
        self._oprot.writeMessageBegin('hasSystemPermission', TMessageType.CALL, self._seqid)
        args = hasSystemPermission_args()
        args.login = login
        args.user = user
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_hasSystemPermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = hasSystemPermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "hasSystemPermission failed: unknown result")

    def hasTablePermission(self, login, user, table, perm):
        """
        Parameters:
         - login
         - user
         - table
         - perm

        """
        self.send_hasTablePermission(login, user, table, perm)
        return self.recv_hasTablePermission()

    def send_hasTablePermission(self, login, user, table, perm):
        self._oprot.writeMessageBegin('hasTablePermission', TMessageType.CALL, self._seqid)
        args = hasTablePermission_args()
        args.login = login
        args.user = user
        args.table = table
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_hasTablePermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = hasTablePermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "hasTablePermission failed: unknown result")

    def listLocalUsers(self, login):
        """
        Parameters:
         - login

        """
        self.send_listLocalUsers(login)
        return self.recv_listLocalUsers()

    def send_listLocalUsers(self, login):
        self._oprot.writeMessageBegin('listLocalUsers', TMessageType.CALL, self._seqid)
        args = listLocalUsers_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listLocalUsers(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listLocalUsers_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listLocalUsers failed: unknown result")

    def revokeSystemPermission(self, login, user, perm):
        """
        Parameters:
         - login
         - user
         - perm

        """
        self.send_revokeSystemPermission(login, user, perm)
        self.recv_revokeSystemPermission()

    def send_revokeSystemPermission(self, login, user, perm):
        self._oprot.writeMessageBegin('revokeSystemPermission', TMessageType.CALL, self._seqid)
        args = revokeSystemPermission_args()
        args.login = login
        args.user = user
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_revokeSystemPermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = revokeSystemPermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def revokeTablePermission(self, login, user, table, perm):
        """
        Parameters:
         - login
         - user
         - table
         - perm

        """
        self.send_revokeTablePermission(login, user, table, perm)
        self.recv_revokeTablePermission()

    def send_revokeTablePermission(self, login, user, table, perm):
        self._oprot.writeMessageBegin('revokeTablePermission', TMessageType.CALL, self._seqid)
        args = revokeTablePermission_args()
        args.login = login
        args.user = user
        args.table = table
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_revokeTablePermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = revokeTablePermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def grantNamespacePermission(self, login, user, namespaceName, perm):
        """
        Parameters:
         - login
         - user
         - namespaceName
         - perm

        """
        self.send_grantNamespacePermission(login, user, namespaceName, perm)
        self.recv_grantNamespacePermission()

    def send_grantNamespacePermission(self, login, user, namespaceName, perm):
        self._oprot.writeMessageBegin('grantNamespacePermission', TMessageType.CALL, self._seqid)
        args = grantNamespacePermission_args()
        args.login = login
        args.user = user
        args.namespaceName = namespaceName
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_grantNamespacePermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = grantNamespacePermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def hasNamespacePermission(self, login, user, namespaceName, perm):
        """
        Parameters:
         - login
         - user
         - namespaceName
         - perm

        """
        self.send_hasNamespacePermission(login, user, namespaceName, perm)
        return self.recv_hasNamespacePermission()

    def send_hasNamespacePermission(self, login, user, namespaceName, perm):
        self._oprot.writeMessageBegin('hasNamespacePermission', TMessageType.CALL, self._seqid)
        args = hasNamespacePermission_args()
        args.login = login
        args.user = user
        args.namespaceName = namespaceName
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_hasNamespacePermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = hasNamespacePermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "hasNamespacePermission failed: unknown result")

    def revokeNamespacePermission(self, login, user, namespaceName, perm):
        """
        Parameters:
         - login
         - user
         - namespaceName
         - perm

        """
        self.send_revokeNamespacePermission(login, user, namespaceName, perm)
        self.recv_revokeNamespacePermission()

    def send_revokeNamespacePermission(self, login, user, namespaceName, perm):
        self._oprot.writeMessageBegin('revokeNamespacePermission', TMessageType.CALL, self._seqid)
        args = revokeNamespacePermission_args()
        args.login = login
        args.user = user
        args.namespaceName = namespaceName
        args.perm = perm
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_revokeNamespacePermission(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = revokeNamespacePermission_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def createBatchScanner(self, login, tableName, options):
        """
        Parameters:
         - login
         - tableName
         - options

        """
        self.send_createBatchScanner(login, tableName, options)
        return self.recv_createBatchScanner()

    def send_createBatchScanner(self, login, tableName, options):
        self._oprot.writeMessageBegin('createBatchScanner', TMessageType.CALL, self._seqid)
        args = createBatchScanner_args()
        args.login = login
        args.tableName = tableName
        args.options = options
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createBatchScanner(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createBatchScanner_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "createBatchScanner failed: unknown result")

    def createScanner(self, login, tableName, options):
        """
        Parameters:
         - login
         - tableName
         - options

        """
        self.send_createScanner(login, tableName, options)
        return self.recv_createScanner()

    def send_createScanner(self, login, tableName, options):
        self._oprot.writeMessageBegin('createScanner', TMessageType.CALL, self._seqid)
        args = createScanner_args()
        args.login = login
        args.tableName = tableName
        args.options = options
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createScanner(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createScanner_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "createScanner failed: unknown result")

    def hasNext(self, scanner):
        """
        Parameters:
         - scanner

        """
        self.send_hasNext(scanner)
        return self.recv_hasNext()

    def send_hasNext(self, scanner):
        self._oprot.writeMessageBegin('hasNext', TMessageType.CALL, self._seqid)
        args = hasNext_args()
        args.scanner = scanner
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_hasNext(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = hasNext_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        raise TApplicationException(TApplicationException.MISSING_RESULT, "hasNext failed: unknown result")

    def nextEntry(self, scanner):
        """
        Parameters:
         - scanner

        """
        self.send_nextEntry(scanner)
        return self.recv_nextEntry()

    def send_nextEntry(self, scanner):
        self._oprot.writeMessageBegin('nextEntry', TMessageType.CALL, self._seqid)
        args = nextEntry_args()
        args.scanner = scanner
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_nextEntry(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = nextEntry_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "nextEntry failed: unknown result")

    def nextK(self, scanner, k):
        """
        Parameters:
         - scanner
         - k

        """
        self.send_nextK(scanner, k)
        return self.recv_nextK()

    def send_nextK(self, scanner, k):
        self._oprot.writeMessageBegin('nextK', TMessageType.CALL, self._seqid)
        args = nextK_args()
        args.scanner = scanner
        args.k = k
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_nextK(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = nextK_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "nextK failed: unknown result")

    def closeScanner(self, scanner):
        """
        Parameters:
         - scanner

        """
        self.send_closeScanner(scanner)
        self.recv_closeScanner()

    def send_closeScanner(self, scanner):
        self._oprot.writeMessageBegin('closeScanner', TMessageType.CALL, self._seqid)
        args = closeScanner_args()
        args.scanner = scanner
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_closeScanner(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = closeScanner_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        return

    def updateAndFlush(self, login, tableName, cells):
        """
        Parameters:
         - login
         - tableName
         - cells

        """
        self.send_updateAndFlush(login, tableName, cells)
        self.recv_updateAndFlush()

    def send_updateAndFlush(self, login, tableName, cells):
        self._oprot.writeMessageBegin('updateAndFlush', TMessageType.CALL, self._seqid)
        args = updateAndFlush_args()
        args.login = login
        args.tableName = tableName
        args.cells = cells
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_updateAndFlush(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = updateAndFlush_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.outch1 is not None:
            raise result.outch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        if result.ouch4 is not None:
            raise result.ouch4
        return

    def createWriter(self, login, tableName, opts):
        """
        Parameters:
         - login
         - tableName
         - opts

        """
        self.send_createWriter(login, tableName, opts)
        return self.recv_createWriter()

    def send_createWriter(self, login, tableName, opts):
        self._oprot.writeMessageBegin('createWriter', TMessageType.CALL, self._seqid)
        args = createWriter_args()
        args.login = login
        args.tableName = tableName
        args.opts = opts
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createWriter(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createWriter_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.outch1 is not None:
            raise result.outch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "createWriter failed: unknown result")

    def update(self, writer, cells):
        """
        Parameters:
         - writer
         - cells

        """
        self.send_update(writer, cells)

    def send_update(self, writer, cells):
        self._oprot.writeMessageBegin('update', TMessageType.ONEWAY, self._seqid)
        args = update_args()
        args.writer = writer
        args.cells = cells
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def flush(self, writer):
        """
        Parameters:
         - writer

        """
        self.send_flush(writer)
        self.recv_flush()

    def send_flush(self, writer):
        self._oprot.writeMessageBegin('flush', TMessageType.CALL, self._seqid)
        args = flush_args()
        args.writer = writer
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_flush(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = flush_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def closeWriter(self, writer):
        """
        Parameters:
         - writer

        """
        self.send_closeWriter(writer)
        self.recv_closeWriter()

    def send_closeWriter(self, writer):
        self._oprot.writeMessageBegin('closeWriter', TMessageType.CALL, self._seqid)
        args = closeWriter_args()
        args.writer = writer
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_closeWriter(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = closeWriter_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        return

    def updateRowConditionally(self, login, tableName, row, updates):
        """
        Parameters:
         - login
         - tableName
         - row
         - updates

        """
        self.send_updateRowConditionally(login, tableName, row, updates)
        return self.recv_updateRowConditionally()

    def send_updateRowConditionally(self, login, tableName, row, updates):
        self._oprot.writeMessageBegin('updateRowConditionally', TMessageType.CALL, self._seqid)
        args = updateRowConditionally_args()
        args.login = login
        args.tableName = tableName
        args.row = row
        args.updates = updates
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_updateRowConditionally(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = updateRowConditionally_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRowConditionally failed: unknown result")

    def createConditionalWriter(self, login, tableName, options):
        """
        Parameters:
         - login
         - tableName
         - options

        """
        self.send_createConditionalWriter(login, tableName, options)
        return self.recv_createConditionalWriter()

    def send_createConditionalWriter(self, login, tableName, options):
        self._oprot.writeMessageBegin('createConditionalWriter', TMessageType.CALL, self._seqid)
        args = createConditionalWriter_args()
        args.login = login
        args.tableName = tableName
        args.options = options
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createConditionalWriter(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createConditionalWriter_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "createConditionalWriter failed: unknown result")

    def updateRowsConditionally(self, conditionalWriter, updates):
        """
        Parameters:
         - conditionalWriter
         - updates

        """
        self.send_updateRowsConditionally(conditionalWriter, updates)
        return self.recv_updateRowsConditionally()

    def send_updateRowsConditionally(self, conditionalWriter, updates):
        self._oprot.writeMessageBegin('updateRowsConditionally', TMessageType.CALL, self._seqid)
        args = updateRowsConditionally_args()
        args.conditionalWriter = conditionalWriter
        args.updates = updates
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_updateRowsConditionally(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = updateRowsConditionally_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRowsConditionally failed: unknown result")

    def closeConditionalWriter(self, conditionalWriter):
        """
        Parameters:
         - conditionalWriter

        """
        self.send_closeConditionalWriter(conditionalWriter)
        self.recv_closeConditionalWriter()

    def send_closeConditionalWriter(self, conditionalWriter):
        self._oprot.writeMessageBegin('closeConditionalWriter', TMessageType.CALL, self._seqid)
        args = closeConditionalWriter_args()
        args.conditionalWriter = conditionalWriter
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

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

    def getRowRange(self, row):
        """
        Parameters:
         - row

        """
        self.send_getRowRange(row)
        return self.recv_getRowRange()

    def send_getRowRange(self, row):
        self._oprot.writeMessageBegin('getRowRange', TMessageType.CALL, self._seqid)
        args = getRowRange_args()
        args.row = row
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getRowRange(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getRowRange_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowRange failed: unknown result")

    def getFollowing(self, key, part):
        """
        Parameters:
         - key
         - part

        """
        self.send_getFollowing(key, part)
        return self.recv_getFollowing()

    def send_getFollowing(self, key, part):
        self._oprot.writeMessageBegin('getFollowing', TMessageType.CALL, self._seqid)
        args = getFollowing_args()
        args.key = key
        args.part = part
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getFollowing(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getFollowing_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getFollowing failed: unknown result")

    def systemNamespace(self):
        self.send_systemNamespace()
        return self.recv_systemNamespace()

    def send_systemNamespace(self):
        self._oprot.writeMessageBegin('systemNamespace', TMessageType.CALL, self._seqid)
        args = systemNamespace_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_systemNamespace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = systemNamespace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "systemNamespace failed: unknown result")

    def defaultNamespace(self):
        self.send_defaultNamespace()
        return self.recv_defaultNamespace()

    def send_defaultNamespace(self):
        self._oprot.writeMessageBegin('defaultNamespace', TMessageType.CALL, self._seqid)
        args = defaultNamespace_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_defaultNamespace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = defaultNamespace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "defaultNamespace failed: unknown result")

    def listNamespaces(self, login):
        """
        Parameters:
         - login

        """
        self.send_listNamespaces(login)
        return self.recv_listNamespaces()

    def send_listNamespaces(self, login):
        self._oprot.writeMessageBegin('listNamespaces', TMessageType.CALL, self._seqid)
        args = listNamespaces_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listNamespaces(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listNamespaces_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listNamespaces failed: unknown result")

    def namespaceExists(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        self.send_namespaceExists(login, namespaceName)
        return self.recv_namespaceExists()

    def send_namespaceExists(self, login, namespaceName):
        self._oprot.writeMessageBegin('namespaceExists', TMessageType.CALL, self._seqid)
        args = namespaceExists_args()
        args.login = login
        args.namespaceName = namespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_namespaceExists(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = namespaceExists_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "namespaceExists failed: unknown result")

    def createNamespace(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        self.send_createNamespace(login, namespaceName)
        self.recv_createNamespace()

    def send_createNamespace(self, login, namespaceName):
        self._oprot.writeMessageBegin('createNamespace', TMessageType.CALL, self._seqid)
        args = createNamespace_args()
        args.login = login
        args.namespaceName = namespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_createNamespace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = createNamespace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def deleteNamespace(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        self.send_deleteNamespace(login, namespaceName)
        self.recv_deleteNamespace()

    def send_deleteNamespace(self, login, namespaceName):
        self._oprot.writeMessageBegin('deleteNamespace', TMessageType.CALL, self._seqid)
        args = deleteNamespace_args()
        args.login = login
        args.namespaceName = namespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_deleteNamespace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = deleteNamespace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        if result.ouch4 is not None:
            raise result.ouch4
        return

    def renameNamespace(self, login, oldNamespaceName, newNamespaceName):
        """
        Parameters:
         - login
         - oldNamespaceName
         - newNamespaceName

        """
        self.send_renameNamespace(login, oldNamespaceName, newNamespaceName)
        self.recv_renameNamespace()

    def send_renameNamespace(self, login, oldNamespaceName, newNamespaceName):
        self._oprot.writeMessageBegin('renameNamespace', TMessageType.CALL, self._seqid)
        args = renameNamespace_args()
        args.login = login
        args.oldNamespaceName = oldNamespaceName
        args.newNamespaceName = newNamespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_renameNamespace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = renameNamespace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        if result.ouch4 is not None:
            raise result.ouch4
        return

    def setNamespaceProperty(self, login, namespaceName, property, value):
        """
        Parameters:
         - login
         - namespaceName
         - property
         - value

        """
        self.send_setNamespaceProperty(login, namespaceName, property, value)
        self.recv_setNamespaceProperty()

    def send_setNamespaceProperty(self, login, namespaceName, property, value):
        self._oprot.writeMessageBegin('setNamespaceProperty', TMessageType.CALL, self._seqid)
        args = setNamespaceProperty_args()
        args.login = login
        args.namespaceName = namespaceName
        args.property = property
        args.value = value
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_setNamespaceProperty(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = setNamespaceProperty_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def removeNamespaceProperty(self, login, namespaceName, property):
        """
        Parameters:
         - login
         - namespaceName
         - property

        """
        self.send_removeNamespaceProperty(login, namespaceName, property)
        self.recv_removeNamespaceProperty()

    def send_removeNamespaceProperty(self, login, namespaceName, property):
        self._oprot.writeMessageBegin('removeNamespaceProperty', TMessageType.CALL, self._seqid)
        args = removeNamespaceProperty_args()
        args.login = login
        args.namespaceName = namespaceName
        args.property = property
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeNamespaceProperty(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeNamespaceProperty_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def getNamespaceProperties(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        self.send_getNamespaceProperties(login, namespaceName)
        return self.recv_getNamespaceProperties()

    def send_getNamespaceProperties(self, login, namespaceName):
        self._oprot.writeMessageBegin('getNamespaceProperties', TMessageType.CALL, self._seqid)
        args = getNamespaceProperties_args()
        args.login = login
        args.namespaceName = namespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getNamespaceProperties(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getNamespaceProperties_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getNamespaceProperties failed: unknown result")

    def namespaceIdMap(self, login):
        """
        Parameters:
         - login

        """
        self.send_namespaceIdMap(login)
        return self.recv_namespaceIdMap()

    def send_namespaceIdMap(self, login):
        self._oprot.writeMessageBegin('namespaceIdMap', TMessageType.CALL, self._seqid)
        args = namespaceIdMap_args()
        args.login = login
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_namespaceIdMap(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = namespaceIdMap_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        raise TApplicationException(TApplicationException.MISSING_RESULT, "namespaceIdMap failed: unknown result")

    def attachNamespaceIterator(self, login, namespaceName, setting, scopes):
        """
        Parameters:
         - login
         - namespaceName
         - setting
         - scopes

        """
        self.send_attachNamespaceIterator(login, namespaceName, setting, scopes)
        self.recv_attachNamespaceIterator()

    def send_attachNamespaceIterator(self, login, namespaceName, setting, scopes):
        self._oprot.writeMessageBegin('attachNamespaceIterator', TMessageType.CALL, self._seqid)
        args = attachNamespaceIterator_args()
        args.login = login
        args.namespaceName = namespaceName
        args.setting = setting
        args.scopes = scopes
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_attachNamespaceIterator(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = attachNamespaceIterator_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def removeNamespaceIterator(self, login, namespaceName, name, scopes):
        """
        Parameters:
         - login
         - namespaceName
         - name
         - scopes

        """
        self.send_removeNamespaceIterator(login, namespaceName, name, scopes)
        self.recv_removeNamespaceIterator()

    def send_removeNamespaceIterator(self, login, namespaceName, name, scopes):
        self._oprot.writeMessageBegin('removeNamespaceIterator', TMessageType.CALL, self._seqid)
        args = removeNamespaceIterator_args()
        args.login = login
        args.namespaceName = namespaceName
        args.name = name
        args.scopes = scopes
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeNamespaceIterator(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeNamespaceIterator_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def getNamespaceIteratorSetting(self, login, namespaceName, name, scope):
        """
        Parameters:
         - login
         - namespaceName
         - name
         - scope

        """
        self.send_getNamespaceIteratorSetting(login, namespaceName, name, scope)
        return self.recv_getNamespaceIteratorSetting()

    def send_getNamespaceIteratorSetting(self, login, namespaceName, name, scope):
        self._oprot.writeMessageBegin('getNamespaceIteratorSetting', TMessageType.CALL, self._seqid)
        args = getNamespaceIteratorSetting_args()
        args.login = login
        args.namespaceName = namespaceName
        args.name = name
        args.scope = scope
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_getNamespaceIteratorSetting(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = getNamespaceIteratorSetting_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "getNamespaceIteratorSetting failed: unknown result")

    def listNamespaceIterators(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        self.send_listNamespaceIterators(login, namespaceName)
        return self.recv_listNamespaceIterators()

    def send_listNamespaceIterators(self, login, namespaceName):
        self._oprot.writeMessageBegin('listNamespaceIterators', TMessageType.CALL, self._seqid)
        args = listNamespaceIterators_args()
        args.login = login
        args.namespaceName = namespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listNamespaceIterators(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listNamespaceIterators_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listNamespaceIterators failed: unknown result")

    def checkNamespaceIteratorConflicts(self, login, namespaceName, setting, scopes):
        """
        Parameters:
         - login
         - namespaceName
         - setting
         - scopes

        """
        self.send_checkNamespaceIteratorConflicts(login, namespaceName, setting, scopes)
        self.recv_checkNamespaceIteratorConflicts()

    def send_checkNamespaceIteratorConflicts(self, login, namespaceName, setting, scopes):
        self._oprot.writeMessageBegin('checkNamespaceIteratorConflicts', TMessageType.CALL, self._seqid)
        args = checkNamespaceIteratorConflicts_args()
        args.login = login
        args.namespaceName = namespaceName
        args.setting = setting
        args.scopes = scopes
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_checkNamespaceIteratorConflicts(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = checkNamespaceIteratorConflicts_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def addNamespaceConstraint(self, login, namespaceName, constraintClassName):
        """
        Parameters:
         - login
         - namespaceName
         - constraintClassName

        """
        self.send_addNamespaceConstraint(login, namespaceName, constraintClassName)
        return self.recv_addNamespaceConstraint()

    def send_addNamespaceConstraint(self, login, namespaceName, constraintClassName):
        self._oprot.writeMessageBegin('addNamespaceConstraint', TMessageType.CALL, self._seqid)
        args = addNamespaceConstraint_args()
        args.login = login
        args.namespaceName = namespaceName
        args.constraintClassName = constraintClassName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_addNamespaceConstraint(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = addNamespaceConstraint_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "addNamespaceConstraint failed: unknown result")

    def removeNamespaceConstraint(self, login, namespaceName, id):
        """
        Parameters:
         - login
         - namespaceName
         - id

        """
        self.send_removeNamespaceConstraint(login, namespaceName, id)
        self.recv_removeNamespaceConstraint()

    def send_removeNamespaceConstraint(self, login, namespaceName, id):
        self._oprot.writeMessageBegin('removeNamespaceConstraint', TMessageType.CALL, self._seqid)
        args = removeNamespaceConstraint_args()
        args.login = login
        args.namespaceName = namespaceName
        args.id = id
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_removeNamespaceConstraint(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = removeNamespaceConstraint_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        return

    def listNamespaceConstraints(self, login, namespaceName):
        """
        Parameters:
         - login
         - namespaceName

        """
        self.send_listNamespaceConstraints(login, namespaceName)
        return self.recv_listNamespaceConstraints()

    def send_listNamespaceConstraints(self, login, namespaceName):
        self._oprot.writeMessageBegin('listNamespaceConstraints', TMessageType.CALL, self._seqid)
        args = listNamespaceConstraints_args()
        args.login = login
        args.namespaceName = namespaceName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_listNamespaceConstraints(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = listNamespaceConstraints_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "listNamespaceConstraints failed: unknown result")

    def testNamespaceClassLoad(self, login, namespaceName, className, asTypeName):
        """
        Parameters:
         - login
         - namespaceName
         - className
         - asTypeName

        """
        self.send_testNamespaceClassLoad(login, namespaceName, className, asTypeName)
        return self.recv_testNamespaceClassLoad()

    def send_testNamespaceClassLoad(self, login, namespaceName, className, asTypeName):
        self._oprot.writeMessageBegin('testNamespaceClassLoad', TMessageType.CALL, self._seqid)
        args = testNamespaceClassLoad_args()
        args.login = login
        args.namespaceName = namespaceName
        args.className = className
        args.asTypeName = asTypeName
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_testNamespaceClassLoad(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = testNamespaceClassLoad_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ouch1 is not None:
            raise result.ouch1
        if result.ouch2 is not None:
            raise result.ouch2
        if result.ouch3 is not None:
            raise result.ouch3
        raise TApplicationException(TApplicationException.MISSING_RESULT, "testNamespaceClassLoad failed: unknown result")


class Processor(Iface, TProcessor):
    def __init__(self, handler):
        self._handler = handler
        self._processMap = {}
        self._processMap["login"] = Processor.process_login
        self._processMap["addConstraint"] = Processor.process_addConstraint
        self._processMap["addSplits"] = Processor.process_addSplits
        self._processMap["attachIterator"] = Processor.process_attachIterator
        self._processMap["checkIteratorConflicts"] = Processor.process_checkIteratorConflicts
        self._processMap["clearLocatorCache"] = Processor.process_clearLocatorCache
        self._processMap["cloneTable"] = Processor.process_cloneTable
        self._processMap["compactTable"] = Processor.process_compactTable
        self._processMap["cancelCompaction"] = Processor.process_cancelCompaction
        self._processMap["createTable"] = Processor.process_createTable
        self._processMap["deleteTable"] = Processor.process_deleteTable
        self._processMap["deleteRows"] = Processor.process_deleteRows
        self._processMap["exportTable"] = Processor.process_exportTable
        self._processMap["flushTable"] = Processor.process_flushTable
        self._processMap["getDiskUsage"] = Processor.process_getDiskUsage
        self._processMap["getLocalityGroups"] = Processor.process_getLocalityGroups
        self._processMap["getIteratorSetting"] = Processor.process_getIteratorSetting
        self._processMap["getMaxRow"] = Processor.process_getMaxRow
        self._processMap["getTableProperties"] = Processor.process_getTableProperties
        self._processMap["importDirectory"] = Processor.process_importDirectory
        self._processMap["importTable"] = Processor.process_importTable
        self._processMap["listSplits"] = Processor.process_listSplits
        self._processMap["listTables"] = Processor.process_listTables
        self._processMap["listIterators"] = Processor.process_listIterators
        self._processMap["listConstraints"] = Processor.process_listConstraints
        self._processMap["mergeTablets"] = Processor.process_mergeTablets
        self._processMap["offlineTable"] = Processor.process_offlineTable
        self._processMap["onlineTable"] = Processor.process_onlineTable
        self._processMap["removeConstraint"] = Processor.process_removeConstraint
        self._processMap["removeIterator"] = Processor.process_removeIterator
        self._processMap["removeTableProperty"] = Processor.process_removeTableProperty
        self._processMap["renameTable"] = Processor.process_renameTable
        self._processMap["setLocalityGroups"] = Processor.process_setLocalityGroups
        self._processMap["setTableProperty"] = Processor.process_setTableProperty
        self._processMap["splitRangeByTablets"] = Processor.process_splitRangeByTablets
        self._processMap["tableExists"] = Processor.process_tableExists
        self._processMap["tableIdMap"] = Processor.process_tableIdMap
        self._processMap["testTableClassLoad"] = Processor.process_testTableClassLoad
        self._processMap["pingTabletServer"] = Processor.process_pingTabletServer
        self._processMap["getActiveScans"] = Processor.process_getActiveScans
        self._processMap["getActiveCompactions"] = Processor.process_getActiveCompactions
        self._processMap["getSiteConfiguration"] = Processor.process_getSiteConfiguration
        self._processMap["getSystemConfiguration"] = Processor.process_getSystemConfiguration
        self._processMap["getTabletServers"] = Processor.process_getTabletServers
        self._processMap["removeProperty"] = Processor.process_removeProperty
        self._processMap["setProperty"] = Processor.process_setProperty
        self._processMap["testClassLoad"] = Processor.process_testClassLoad
        self._processMap["authenticateUser"] = Processor.process_authenticateUser
        self._processMap["changeUserAuthorizations"] = Processor.process_changeUserAuthorizations
        self._processMap["changeLocalUserPassword"] = Processor.process_changeLocalUserPassword
        self._processMap["createLocalUser"] = Processor.process_createLocalUser
        self._processMap["dropLocalUser"] = Processor.process_dropLocalUser
        self._processMap["getUserAuthorizations"] = Processor.process_getUserAuthorizations
        self._processMap["grantSystemPermission"] = Processor.process_grantSystemPermission
        self._processMap["grantTablePermission"] = Processor.process_grantTablePermission
        self._processMap["hasSystemPermission"] = Processor.process_hasSystemPermission
        self._processMap["hasTablePermission"] = Processor.process_hasTablePermission
        self._processMap["listLocalUsers"] = Processor.process_listLocalUsers
        self._processMap["revokeSystemPermission"] = Processor.process_revokeSystemPermission
        self._processMap["revokeTablePermission"] = Processor.process_revokeTablePermission
        self._processMap["grantNamespacePermission"] = Processor.process_grantNamespacePermission
        self._processMap["hasNamespacePermission"] = Processor.process_hasNamespacePermission
        self._processMap["revokeNamespacePermission"] = Processor.process_revokeNamespacePermission
        self._processMap["createBatchScanner"] = Processor.process_createBatchScanner
        self._processMap["createScanner"] = Processor.process_createScanner
        self._processMap["hasNext"] = Processor.process_hasNext
        self._processMap["nextEntry"] = Processor.process_nextEntry
        self._processMap["nextK"] = Processor.process_nextK
        self._processMap["closeScanner"] = Processor.process_closeScanner
        self._processMap["updateAndFlush"] = Processor.process_updateAndFlush
        self._processMap["createWriter"] = Processor.process_createWriter
        self._processMap["update"] = Processor.process_update
        self._processMap["flush"] = Processor.process_flush
        self._processMap["closeWriter"] = Processor.process_closeWriter
        self._processMap["updateRowConditionally"] = Processor.process_updateRowConditionally
        self._processMap["createConditionalWriter"] = Processor.process_createConditionalWriter
        self._processMap["updateRowsConditionally"] = Processor.process_updateRowsConditionally
        self._processMap["closeConditionalWriter"] = Processor.process_closeConditionalWriter
        self._processMap["getRowRange"] = Processor.process_getRowRange
        self._processMap["getFollowing"] = Processor.process_getFollowing
        self._processMap["systemNamespace"] = Processor.process_systemNamespace
        self._processMap["defaultNamespace"] = Processor.process_defaultNamespace
        self._processMap["listNamespaces"] = Processor.process_listNamespaces
        self._processMap["namespaceExists"] = Processor.process_namespaceExists
        self._processMap["createNamespace"] = Processor.process_createNamespace
        self._processMap["deleteNamespace"] = Processor.process_deleteNamespace
        self._processMap["renameNamespace"] = Processor.process_renameNamespace
        self._processMap["setNamespaceProperty"] = Processor.process_setNamespaceProperty
        self._processMap["removeNamespaceProperty"] = Processor.process_removeNamespaceProperty
        self._processMap["getNamespaceProperties"] = Processor.process_getNamespaceProperties
        self._processMap["namespaceIdMap"] = Processor.process_namespaceIdMap
        self._processMap["attachNamespaceIterator"] = Processor.process_attachNamespaceIterator
        self._processMap["removeNamespaceIterator"] = Processor.process_removeNamespaceIterator
        self._processMap["getNamespaceIteratorSetting"] = Processor.process_getNamespaceIteratorSetting
        self._processMap["listNamespaceIterators"] = Processor.process_listNamespaceIterators
        self._processMap["checkNamespaceIteratorConflicts"] = Processor.process_checkNamespaceIteratorConflicts
        self._processMap["addNamespaceConstraint"] = Processor.process_addNamespaceConstraint
        self._processMap["removeNamespaceConstraint"] = Processor.process_removeNamespaceConstraint
        self._processMap["listNamespaceConstraints"] = Processor.process_listNamespaceConstraints
        self._processMap["testNamespaceClassLoad"] = Processor.process_testNamespaceClassLoad

    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_login(self, seqid, iprot, oprot):
        args = login_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = login_result()
        try:
            result.success = self._handler.login(args.principal, args.loginProperties)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("login", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_addConstraint(self, seqid, iprot, oprot):
        args = addConstraint_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = addConstraint_result()
        try:
            result.success = self._handler.addConstraint(args.login, args.tableName, args.constraintClassName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("addConstraint", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_addSplits(self, seqid, iprot, oprot):
        args = addSplits_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = addSplits_result()
        try:
            self._handler.addSplits(args.login, args.tableName, args.splits)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("addSplits", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_attachIterator(self, seqid, iprot, oprot):
        args = attachIterator_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = attachIterator_result()
        try:
            self._handler.attachIterator(args.login, args.tableName, args.setting, args.scopes)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloSecurityException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("attachIterator", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_checkIteratorConflicts(self, seqid, iprot, oprot):
        args = checkIteratorConflicts_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = checkIteratorConflicts_result()
        try:
            self._handler.checkIteratorConflicts(args.login, args.tableName, args.setting, args.scopes)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloSecurityException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("checkIteratorConflicts", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_clearLocatorCache(self, seqid, iprot, oprot):
        args = clearLocatorCache_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = clearLocatorCache_result()
        try:
            self._handler.clearLocatorCache(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TableNotFoundException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("clearLocatorCache", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_cloneTable(self, seqid, iprot, oprot):
        args = cloneTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = cloneTable_result()
        try:
            self._handler.cloneTable(args.login, args.tableName, args.newTableName, args.flush, args.propertiesToSet, args.propertiesToExclude)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TableExistsException as ouch4:
            msg_type = TMessageType.REPLY
            result.ouch4 = ouch4
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("cloneTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_compactTable(self, seqid, iprot, oprot):
        args = compactTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = compactTable_result()
        try:
            self._handler.compactTable(args.login, args.tableName, args.startRow, args.endRow, args.iterators, args.flush, args.wait, args.compactionStrategy)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloSecurityException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except TableNotFoundException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except AccumuloException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("compactTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_cancelCompaction(self, seqid, iprot, oprot):
        args = cancelCompaction_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = cancelCompaction_result()
        try:
            self._handler.cancelCompaction(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloSecurityException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except TableNotFoundException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except AccumuloException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("cancelCompaction", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createTable(self, seqid, iprot, oprot):
        args = createTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createTable_result()
        try:
            self._handler.createTable(args.login, args.tableName, args.versioningIter, args.type)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableExistsException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_deleteTable(self, seqid, iprot, oprot):
        args = deleteTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = deleteTable_result()
        try:
            self._handler.deleteTable(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("deleteTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_deleteRows(self, seqid, iprot, oprot):
        args = deleteRows_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = deleteRows_result()
        try:
            self._handler.deleteRows(args.login, args.tableName, args.startRow, args.endRow)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("deleteRows", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_exportTable(self, seqid, iprot, oprot):
        args = exportTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = exportTable_result()
        try:
            self._handler.exportTable(args.login, args.tableName, args.exportDir)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("exportTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_flushTable(self, seqid, iprot, oprot):
        args = flushTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = flushTable_result()
        try:
            self._handler.flushTable(args.login, args.tableName, args.startRow, args.endRow, args.wait)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("flushTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getDiskUsage(self, seqid, iprot, oprot):
        args = getDiskUsage_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getDiskUsage_result()
        try:
            result.success = self._handler.getDiskUsage(args.login, args.tables)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getDiskUsage", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getLocalityGroups(self, seqid, iprot, oprot):
        args = getLocalityGroups_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getLocalityGroups_result()
        try:
            result.success = self._handler.getLocalityGroups(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getLocalityGroups", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getIteratorSetting(self, seqid, iprot, oprot):
        args = getIteratorSetting_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getIteratorSetting_result()
        try:
            result.success = self._handler.getIteratorSetting(args.login, args.tableName, args.iteratorName, args.scope)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getIteratorSetting", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getMaxRow(self, seqid, iprot, oprot):
        args = getMaxRow_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getMaxRow_result()
        try:
            result.success = self._handler.getMaxRow(args.login, args.tableName, args.auths, args.startRow, args.startInclusive, args.endRow, args.endInclusive)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getMaxRow", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getTableProperties(self, seqid, iprot, oprot):
        args = getTableProperties_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getTableProperties_result()
        try:
            result.success = self._handler.getTableProperties(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getTableProperties", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_importDirectory(self, seqid, iprot, oprot):
        args = importDirectory_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = importDirectory_result()
        try:
            self._handler.importDirectory(args.login, args.tableName, args.importDir, args.failureDir, args.setTime)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TableNotFoundException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except AccumuloSecurityException as ouch4:
            msg_type = TMessageType.REPLY
            result.ouch4 = ouch4
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("importDirectory", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_importTable(self, seqid, iprot, oprot):
        args = importTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = importTable_result()
        try:
            self._handler.importTable(args.login, args.tableName, args.importDir)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TableExistsException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except AccumuloSecurityException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("importTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listSplits(self, seqid, iprot, oprot):
        args = listSplits_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listSplits_result()
        try:
            result.success = self._handler.listSplits(args.login, args.tableName, args.maxSplits)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listSplits", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listTables(self, seqid, iprot, oprot):
        args = listTables_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listTables_result()
        try:
            result.success = self._handler.listTables(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listTables", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listIterators(self, seqid, iprot, oprot):
        args = listIterators_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listIterators_result()
        try:
            result.success = self._handler.listIterators(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listIterators", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listConstraints(self, seqid, iprot, oprot):
        args = listConstraints_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listConstraints_result()
        try:
            result.success = self._handler.listConstraints(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listConstraints", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_mergeTablets(self, seqid, iprot, oprot):
        args = mergeTablets_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = mergeTablets_result()
        try:
            self._handler.mergeTablets(args.login, args.tableName, args.startRow, args.endRow)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("mergeTablets", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_offlineTable(self, seqid, iprot, oprot):
        args = offlineTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = offlineTable_result()
        try:
            self._handler.offlineTable(args.login, args.tableName, args.wait)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("offlineTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_onlineTable(self, seqid, iprot, oprot):
        args = onlineTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = onlineTable_result()
        try:
            self._handler.onlineTable(args.login, args.tableName, args.wait)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("onlineTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeConstraint(self, seqid, iprot, oprot):
        args = removeConstraint_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeConstraint_result()
        try:
            self._handler.removeConstraint(args.login, args.tableName, args.constraint)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeConstraint", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeIterator(self, seqid, iprot, oprot):
        args = removeIterator_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeIterator_result()
        try:
            self._handler.removeIterator(args.login, args.tableName, args.iterName, args.scopes)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeIterator", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeTableProperty(self, seqid, iprot, oprot):
        args = removeTableProperty_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeTableProperty_result()
        try:
            self._handler.removeTableProperty(args.login, args.tableName, args.property)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeTableProperty", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_renameTable(self, seqid, iprot, oprot):
        args = renameTable_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = renameTable_result()
        try:
            self._handler.renameTable(args.login, args.oldTableName, args.newTableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TableExistsException as ouch4:
            msg_type = TMessageType.REPLY
            result.ouch4 = ouch4
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("renameTable", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_setLocalityGroups(self, seqid, iprot, oprot):
        args = setLocalityGroups_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = setLocalityGroups_result()
        try:
            self._handler.setLocalityGroups(args.login, args.tableName, args.groups)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("setLocalityGroups", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_setTableProperty(self, seqid, iprot, oprot):
        args = setTableProperty_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = setTableProperty_result()
        try:
            self._handler.setTableProperty(args.login, args.tableName, args.property, args.value)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("setTableProperty", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_splitRangeByTablets(self, seqid, iprot, oprot):
        args = splitRangeByTablets_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = splitRangeByTablets_result()
        try:
            result.success = self._handler.splitRangeByTablets(args.login, args.tableName, args.range, args.maxSplits)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("splitRangeByTablets", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_tableExists(self, seqid, iprot, oprot):
        args = tableExists_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = tableExists_result()
        try:
            result.success = self._handler.tableExists(args.login, args.tableName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("tableExists", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_tableIdMap(self, seqid, iprot, oprot):
        args = tableIdMap_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = tableIdMap_result()
        try:
            result.success = self._handler.tableIdMap(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("tableIdMap", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_testTableClassLoad(self, seqid, iprot, oprot):
        args = testTableClassLoad_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = testTableClassLoad_result()
        try:
            result.success = self._handler.testTableClassLoad(args.login, args.tableName, args.className, args.asTypeName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("testTableClassLoad", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_pingTabletServer(self, seqid, iprot, oprot):
        args = pingTabletServer_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = pingTabletServer_result()
        try:
            self._handler.pingTabletServer(args.login, args.tserver)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("pingTabletServer", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getActiveScans(self, seqid, iprot, oprot):
        args = getActiveScans_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getActiveScans_result()
        try:
            result.success = self._handler.getActiveScans(args.login, args.tserver)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getActiveScans", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getActiveCompactions(self, seqid, iprot, oprot):
        args = getActiveCompactions_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getActiveCompactions_result()
        try:
            result.success = self._handler.getActiveCompactions(args.login, args.tserver)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getActiveCompactions", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getSiteConfiguration(self, seqid, iprot, oprot):
        args = getSiteConfiguration_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getSiteConfiguration_result()
        try:
            result.success = self._handler.getSiteConfiguration(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getSiteConfiguration", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getSystemConfiguration(self, seqid, iprot, oprot):
        args = getSystemConfiguration_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getSystemConfiguration_result()
        try:
            result.success = self._handler.getSystemConfiguration(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getSystemConfiguration", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getTabletServers(self, seqid, iprot, oprot):
        args = getTabletServers_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getTabletServers_result()
        try:
            result.success = self._handler.getTabletServers(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getTabletServers", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeProperty(self, seqid, iprot, oprot):
        args = removeProperty_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeProperty_result()
        try:
            self._handler.removeProperty(args.login, args.property)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeProperty", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_setProperty(self, seqid, iprot, oprot):
        args = setProperty_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = setProperty_result()
        try:
            self._handler.setProperty(args.login, args.property, args.value)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("setProperty", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_testClassLoad(self, seqid, iprot, oprot):
        args = testClassLoad_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = testClassLoad_result()
        try:
            result.success = self._handler.testClassLoad(args.login, args.className, args.asTypeName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("testClassLoad", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_authenticateUser(self, seqid, iprot, oprot):
        args = authenticateUser_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = authenticateUser_result()
        try:
            result.success = self._handler.authenticateUser(args.login, args.user, args.properties)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("authenticateUser", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_changeUserAuthorizations(self, seqid, iprot, oprot):
        args = changeUserAuthorizations_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = changeUserAuthorizations_result()
        try:
            self._handler.changeUserAuthorizations(args.login, args.user, args.authorizations)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("changeUserAuthorizations", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_changeLocalUserPassword(self, seqid, iprot, oprot):
        args = changeLocalUserPassword_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = changeLocalUserPassword_result()
        try:
            self._handler.changeLocalUserPassword(args.login, args.user, args.password)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("changeLocalUserPassword", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createLocalUser(self, seqid, iprot, oprot):
        args = createLocalUser_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createLocalUser_result()
        try:
            self._handler.createLocalUser(args.login, args.user, args.password)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createLocalUser", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_dropLocalUser(self, seqid, iprot, oprot):
        args = dropLocalUser_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = dropLocalUser_result()
        try:
            self._handler.dropLocalUser(args.login, args.user)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("dropLocalUser", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getUserAuthorizations(self, seqid, iprot, oprot):
        args = getUserAuthorizations_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getUserAuthorizations_result()
        try:
            result.success = self._handler.getUserAuthorizations(args.login, args.user)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getUserAuthorizations", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_grantSystemPermission(self, seqid, iprot, oprot):
        args = grantSystemPermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = grantSystemPermission_result()
        try:
            self._handler.grantSystemPermission(args.login, args.user, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("grantSystemPermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_grantTablePermission(self, seqid, iprot, oprot):
        args = grantTablePermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = grantTablePermission_result()
        try:
            self._handler.grantTablePermission(args.login, args.user, args.table, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("grantTablePermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_hasSystemPermission(self, seqid, iprot, oprot):
        args = hasSystemPermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = hasSystemPermission_result()
        try:
            result.success = self._handler.hasSystemPermission(args.login, args.user, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("hasSystemPermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_hasTablePermission(self, seqid, iprot, oprot):
        args = hasTablePermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = hasTablePermission_result()
        try:
            result.success = self._handler.hasTablePermission(args.login, args.user, args.table, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("hasTablePermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listLocalUsers(self, seqid, iprot, oprot):
        args = listLocalUsers_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listLocalUsers_result()
        try:
            result.success = self._handler.listLocalUsers(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listLocalUsers", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_revokeSystemPermission(self, seqid, iprot, oprot):
        args = revokeSystemPermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = revokeSystemPermission_result()
        try:
            self._handler.revokeSystemPermission(args.login, args.user, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("revokeSystemPermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_revokeTablePermission(self, seqid, iprot, oprot):
        args = revokeTablePermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = revokeTablePermission_result()
        try:
            self._handler.revokeTablePermission(args.login, args.user, args.table, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("revokeTablePermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_grantNamespacePermission(self, seqid, iprot, oprot):
        args = grantNamespacePermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = grantNamespacePermission_result()
        try:
            self._handler.grantNamespacePermission(args.login, args.user, args.namespaceName, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("grantNamespacePermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_hasNamespacePermission(self, seqid, iprot, oprot):
        args = hasNamespacePermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = hasNamespacePermission_result()
        try:
            result.success = self._handler.hasNamespacePermission(args.login, args.user, args.namespaceName, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("hasNamespacePermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_revokeNamespacePermission(self, seqid, iprot, oprot):
        args = revokeNamespacePermission_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = revokeNamespacePermission_result()
        try:
            self._handler.revokeNamespacePermission(args.login, args.user, args.namespaceName, args.perm)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("revokeNamespacePermission", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createBatchScanner(self, seqid, iprot, oprot):
        args = createBatchScanner_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createBatchScanner_result()
        try:
            result.success = self._handler.createBatchScanner(args.login, args.tableName, args.options)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createBatchScanner", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createScanner(self, seqid, iprot, oprot):
        args = createScanner_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createScanner_result()
        try:
            result.success = self._handler.createScanner(args.login, args.tableName, args.options)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createScanner", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_hasNext(self, seqid, iprot, oprot):
        args = hasNext_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = hasNext_result()
        try:
            result.success = self._handler.hasNext(args.scanner)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except UnknownScanner as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("hasNext", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_nextEntry(self, seqid, iprot, oprot):
        args = nextEntry_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = nextEntry_result()
        try:
            result.success = self._handler.nextEntry(args.scanner)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except NoMoreEntriesException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except UnknownScanner as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except AccumuloSecurityException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("nextEntry", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_nextK(self, seqid, iprot, oprot):
        args = nextK_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = nextK_result()
        try:
            result.success = self._handler.nextK(args.scanner, args.k)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except NoMoreEntriesException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except UnknownScanner as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except AccumuloSecurityException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("nextK", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_closeScanner(self, seqid, iprot, oprot):
        args = closeScanner_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = closeScanner_result()
        try:
            self._handler.closeScanner(args.scanner)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except UnknownScanner as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("closeScanner", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_updateAndFlush(self, seqid, iprot, oprot):
        args = updateAndFlush_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = updateAndFlush_result()
        try:
            self._handler.updateAndFlush(args.login, args.tableName, args.cells)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as outch1:
            msg_type = TMessageType.REPLY
            result.outch1 = outch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except MutationsRejectedException as ouch4:
            msg_type = TMessageType.REPLY
            result.ouch4 = ouch4
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("updateAndFlush", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createWriter(self, seqid, iprot, oprot):
        args = createWriter_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createWriter_result()
        try:
            result.success = self._handler.createWriter(args.login, args.tableName, args.opts)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as outch1:
            msg_type = TMessageType.REPLY
            result.outch1 = outch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createWriter", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_update(self, seqid, iprot, oprot):
        args = update_args()
        args.read(iprot)
        iprot.readMessageEnd()
        try:
            self._handler.update(args.writer, args.cells)
        except TTransport.TTransportException:
            raise
        except Exception:
            logging.exception('Exception in oneway handler')

    def process_flush(self, seqid, iprot, oprot):
        args = flush_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = flush_result()
        try:
            self._handler.flush(args.writer)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except UnknownWriter as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except MutationsRejectedException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("flush", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_closeWriter(self, seqid, iprot, oprot):
        args = closeWriter_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = closeWriter_result()
        try:
            self._handler.closeWriter(args.writer)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except UnknownWriter as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except MutationsRejectedException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("closeWriter", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_updateRowConditionally(self, seqid, iprot, oprot):
        args = updateRowConditionally_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = updateRowConditionally_result()
        try:
            result.success = self._handler.updateRowConditionally(args.login, args.tableName, args.row, args.updates)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("updateRowConditionally", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createConditionalWriter(self, seqid, iprot, oprot):
        args = createConditionalWriter_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createConditionalWriter_result()
        try:
            result.success = self._handler.createConditionalWriter(args.login, args.tableName, args.options)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TableNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createConditionalWriter", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_updateRowsConditionally(self, seqid, iprot, oprot):
        args = updateRowsConditionally_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = updateRowsConditionally_result()
        try:
            result.success = self._handler.updateRowsConditionally(args.conditionalWriter, args.updates)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except UnknownWriter as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except AccumuloSecurityException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("updateRowsConditionally", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_closeConditionalWriter(self, seqid, iprot, oprot):
        args = closeConditionalWriter_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = closeConditionalWriter_result()
        try:
            self._handler.closeConditionalWriter(args.conditionalWriter)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("closeConditionalWriter", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getRowRange(self, seqid, iprot, oprot):
        args = getRowRange_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getRowRange_result()
        try:
            result.success = self._handler.getRowRange(args.row)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getRowRange", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getFollowing(self, seqid, iprot, oprot):
        args = getFollowing_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getFollowing_result()
        try:
            result.success = self._handler.getFollowing(args.key, args.part)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getFollowing", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_systemNamespace(self, seqid, iprot, oprot):
        args = systemNamespace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = systemNamespace_result()
        try:
            result.success = self._handler.systemNamespace()
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("systemNamespace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_defaultNamespace(self, seqid, iprot, oprot):
        args = defaultNamespace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = defaultNamespace_result()
        try:
            result.success = self._handler.defaultNamespace()
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("defaultNamespace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listNamespaces(self, seqid, iprot, oprot):
        args = listNamespaces_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listNamespaces_result()
        try:
            result.success = self._handler.listNamespaces(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listNamespaces", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_namespaceExists(self, seqid, iprot, oprot):
        args = namespaceExists_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = namespaceExists_result()
        try:
            result.success = self._handler.namespaceExists(args.login, args.namespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("namespaceExists", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_createNamespace(self, seqid, iprot, oprot):
        args = createNamespace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = createNamespace_result()
        try:
            self._handler.createNamespace(args.login, args.namespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceExistsException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("createNamespace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_deleteNamespace(self, seqid, iprot, oprot):
        args = deleteNamespace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = deleteNamespace_result()
        try:
            self._handler.deleteNamespace(args.login, args.namespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except NamespaceNotEmptyException as ouch4:
            msg_type = TMessageType.REPLY
            result.ouch4 = ouch4
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("deleteNamespace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_renameNamespace(self, seqid, iprot, oprot):
        args = renameNamespace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = renameNamespace_result()
        try:
            self._handler.renameNamespace(args.login, args.oldNamespaceName, args.newNamespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except NamespaceExistsException as ouch4:
            msg_type = TMessageType.REPLY
            result.ouch4 = ouch4
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("renameNamespace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_setNamespaceProperty(self, seqid, iprot, oprot):
        args = setNamespaceProperty_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = setNamespaceProperty_result()
        try:
            self._handler.setNamespaceProperty(args.login, args.namespaceName, args.property, args.value)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("setNamespaceProperty", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeNamespaceProperty(self, seqid, iprot, oprot):
        args = removeNamespaceProperty_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeNamespaceProperty_result()
        try:
            self._handler.removeNamespaceProperty(args.login, args.namespaceName, args.property)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeNamespaceProperty", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getNamespaceProperties(self, seqid, iprot, oprot):
        args = getNamespaceProperties_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getNamespaceProperties_result()
        try:
            result.success = self._handler.getNamespaceProperties(args.login, args.namespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getNamespaceProperties", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_namespaceIdMap(self, seqid, iprot, oprot):
        args = namespaceIdMap_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = namespaceIdMap_result()
        try:
            result.success = self._handler.namespaceIdMap(args.login)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("namespaceIdMap", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_attachNamespaceIterator(self, seqid, iprot, oprot):
        args = attachNamespaceIterator_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = attachNamespaceIterator_result()
        try:
            self._handler.attachNamespaceIterator(args.login, args.namespaceName, args.setting, args.scopes)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("attachNamespaceIterator", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeNamespaceIterator(self, seqid, iprot, oprot):
        args = removeNamespaceIterator_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeNamespaceIterator_result()
        try:
            self._handler.removeNamespaceIterator(args.login, args.namespaceName, args.name, args.scopes)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeNamespaceIterator", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_getNamespaceIteratorSetting(self, seqid, iprot, oprot):
        args = getNamespaceIteratorSetting_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = getNamespaceIteratorSetting_result()
        try:
            result.success = self._handler.getNamespaceIteratorSetting(args.login, args.namespaceName, args.name, args.scope)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("getNamespaceIteratorSetting", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listNamespaceIterators(self, seqid, iprot, oprot):
        args = listNamespaceIterators_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listNamespaceIterators_result()
        try:
            result.success = self._handler.listNamespaceIterators(args.login, args.namespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listNamespaceIterators", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_checkNamespaceIteratorConflicts(self, seqid, iprot, oprot):
        args = checkNamespaceIteratorConflicts_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = checkNamespaceIteratorConflicts_result()
        try:
            self._handler.checkNamespaceIteratorConflicts(args.login, args.namespaceName, args.setting, args.scopes)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("checkNamespaceIteratorConflicts", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_addNamespaceConstraint(self, seqid, iprot, oprot):
        args = addNamespaceConstraint_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = addNamespaceConstraint_result()
        try:
            result.success = self._handler.addNamespaceConstraint(args.login, args.namespaceName, args.constraintClassName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("addNamespaceConstraint", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_removeNamespaceConstraint(self, seqid, iprot, oprot):
        args = removeNamespaceConstraint_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = removeNamespaceConstraint_result()
        try:
            self._handler.removeNamespaceConstraint(args.login, args.namespaceName, args.id)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("removeNamespaceConstraint", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_listNamespaceConstraints(self, seqid, iprot, oprot):
        args = listNamespaceConstraints_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = listNamespaceConstraints_result()
        try:
            result.success = self._handler.listNamespaceConstraints(args.login, args.namespaceName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("listNamespaceConstraints", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_testNamespaceClassLoad(self, seqid, iprot, oprot):
        args = testNamespaceClassLoad_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = testNamespaceClassLoad_result()
        try:
            result.success = self._handler.testNamespaceClassLoad(args.login, args.namespaceName, args.className, args.asTypeName)
            msg_type = TMessageType.REPLY
        except TTransport.TTransportException:
            raise
        except AccumuloException as ouch1:
            msg_type = TMessageType.REPLY
            result.ouch1 = ouch1
        except AccumuloSecurityException as ouch2:
            msg_type = TMessageType.REPLY
            result.ouch2 = ouch2
        except NamespaceNotFoundException as ouch3:
            msg_type = TMessageType.REPLY
            result.ouch3 = ouch3
        except TApplicationException as ex:
            logging.exception('TApplication exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = ex
        except Exception:
            logging.exception('Unexpected exception in handler')
            msg_type = TMessageType.EXCEPTION
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("testNamespaceClassLoad", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

# HELPER FUNCTIONS AND STRUCTURES


class login_args(object):
    """
    Attributes:
     - principal
     - loginProperties

    """


    def __init__(self, principal=None, loginProperties=None,):
        self.principal = principal
        self.loginProperties = loginProperties

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.principal = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.MAP:
                    self.loginProperties = {}
                    (_ktype145, _vtype146, _size144) = iprot.readMapBegin()
                    for _i148 in range(_size144):
                        _key149 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val150 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.loginProperties[_key149] = _val150
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('login_args')
        if self.principal is not None:
            oprot.writeFieldBegin('principal', TType.STRING, 1)
            oprot.writeString(self.principal.encode('utf-8') if sys.version_info[0] == 2 else self.principal)
            oprot.writeFieldEnd()
        if self.loginProperties is not None:
            oprot.writeFieldBegin('loginProperties', TType.MAP, 2)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.loginProperties))
            for kiter151, viter152 in self.loginProperties.items():
                oprot.writeString(kiter151.encode('utf-8') if sys.version_info[0] == 2 else kiter151)
                oprot.writeString(viter152.encode('utf-8') if sys.version_info[0] == 2 else viter152)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(login_args)
login_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'principal', 'UTF8', None, ),  # 1
    (2, TType.MAP, 'loginProperties', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 2
)


class login_result(object):
    """
    Attributes:
     - success
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('login_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeBinary(self.success)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 1)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(login_result)
login_result.thrift_spec = (
    (0, TType.STRING, 'success', 'BINARY', None, ),  # 0
    (1, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 1
)


class addConstraint_args(object):
    """
    Attributes:
     - login
     - tableName
     - constraintClassName

    """


    def __init__(self, login=None, tableName=None, constraintClassName=None,):
        self.login = login
        self.tableName = tableName
        self.constraintClassName = constraintClassName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.constraintClassName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('addConstraint_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.constraintClassName is not None:
            oprot.writeFieldBegin('constraintClassName', TType.STRING, 3)
            oprot.writeString(self.constraintClassName.encode('utf-8') if sys.version_info[0] == 2 else self.constraintClassName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(addConstraint_args)
addConstraint_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'constraintClassName', 'UTF8', None, ),  # 3
)


class addConstraint_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.I32:
                    self.success = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('addConstraint_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.I32, 0)
            oprot.writeI32(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(addConstraint_result)
addConstraint_result.thrift_spec = (
    (0, TType.I32, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class addSplits_args(object):
    """
    Attributes:
     - login
     - tableName
     - splits

    """


    def __init__(self, login=None, tableName=None, splits=None,):
        self.login = login
        self.tableName = tableName
        self.splits = splits

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.SET:
                    self.splits = set()
                    (_etype156, _size153) = iprot.readSetBegin()
                    for _i157 in range(_size153):
                        _elem158 = iprot.readBinary()
                        self.splits.add(_elem158)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('addSplits_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.splits is not None:
            oprot.writeFieldBegin('splits', TType.SET, 3)
            oprot.writeSetBegin(TType.STRING, len(self.splits))
            for iter159 in self.splits:
                oprot.writeBinary(iter159)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(addSplits_args)
addSplits_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.SET, 'splits', (TType.STRING, 'BINARY', False), None, ),  # 3
)


class addSplits_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('addSplits_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(addSplits_result)
addSplits_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class attachIterator_args(object):
    """
    Attributes:
     - login
     - tableName
     - setting
     - scopes

    """


    def __init__(self, login=None, tableName=None, setting=None, scopes=None,):
        self.login = login
        self.tableName = tableName
        self.setting = setting
        self.scopes = scopes

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.setting = IteratorSetting()
                    self.setting.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.SET:
                    self.scopes = set()
                    (_etype163, _size160) = iprot.readSetBegin()
                    for _i164 in range(_size160):
                        _elem165 = iprot.readI32()
                        self.scopes.add(_elem165)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('attachIterator_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.setting is not None:
            oprot.writeFieldBegin('setting', TType.STRUCT, 3)
            self.setting.write(oprot)
            oprot.writeFieldEnd()
        if self.scopes is not None:
            oprot.writeFieldBegin('scopes', TType.SET, 4)
            oprot.writeSetBegin(TType.I32, len(self.scopes))
            for iter166 in self.scopes:
                oprot.writeI32(iter166)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(attachIterator_args)
attachIterator_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'setting', [IteratorSetting, None], None, ),  # 3
    (4, TType.SET, 'scopes', (TType.I32, None, False), None, ),  # 4
)


class attachIterator_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloSecurityException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('attachIterator_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(attachIterator_result)
attachIterator_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloSecurityException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class checkIteratorConflicts_args(object):
    """
    Attributes:
     - login
     - tableName
     - setting
     - scopes

    """


    def __init__(self, login=None, tableName=None, setting=None, scopes=None,):
        self.login = login
        self.tableName = tableName
        self.setting = setting
        self.scopes = scopes

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.setting = IteratorSetting()
                    self.setting.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.SET:
                    self.scopes = set()
                    (_etype170, _size167) = iprot.readSetBegin()
                    for _i171 in range(_size167):
                        _elem172 = iprot.readI32()
                        self.scopes.add(_elem172)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('checkIteratorConflicts_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.setting is not None:
            oprot.writeFieldBegin('setting', TType.STRUCT, 3)
            self.setting.write(oprot)
            oprot.writeFieldEnd()
        if self.scopes is not None:
            oprot.writeFieldBegin('scopes', TType.SET, 4)
            oprot.writeSetBegin(TType.I32, len(self.scopes))
            for iter173 in self.scopes:
                oprot.writeI32(iter173)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(checkIteratorConflicts_args)
checkIteratorConflicts_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'setting', [IteratorSetting, None], None, ),  # 3
    (4, TType.SET, 'scopes', (TType.I32, None, False), None, ),  # 4
)


class checkIteratorConflicts_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloSecurityException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('checkIteratorConflicts_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(checkIteratorConflicts_result)
checkIteratorConflicts_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloSecurityException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class clearLocatorCache_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('clearLocatorCache_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(clearLocatorCache_args)
clearLocatorCache_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class clearLocatorCache_result(object):
    """
    Attributes:
     - ouch1

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = TableNotFoundException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('clearLocatorCache_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(clearLocatorCache_result)
clearLocatorCache_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [TableNotFoundException, None], None, ),  # 1
)


class cloneTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - newTableName
     - flush
     - propertiesToSet
     - propertiesToExclude

    """


    def __init__(self, login=None, tableName=None, newTableName=None, flush=None, propertiesToSet=None, propertiesToExclude=None,):
        self.login = login
        self.tableName = tableName
        self.newTableName = newTableName
        self.flush = flush
        self.propertiesToSet = propertiesToSet
        self.propertiesToExclude = propertiesToExclude

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.newTableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.flush = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.MAP:
                    self.propertiesToSet = {}
                    (_ktype175, _vtype176, _size174) = iprot.readMapBegin()
                    for _i178 in range(_size174):
                        _key179 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val180 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.propertiesToSet[_key179] = _val180
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.SET:
                    self.propertiesToExclude = set()
                    (_etype184, _size181) = iprot.readSetBegin()
                    for _i185 in range(_size181):
                        _elem186 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.propertiesToExclude.add(_elem186)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('cloneTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.newTableName is not None:
            oprot.writeFieldBegin('newTableName', TType.STRING, 3)
            oprot.writeString(self.newTableName.encode('utf-8') if sys.version_info[0] == 2 else self.newTableName)
            oprot.writeFieldEnd()
        if self.flush is not None:
            oprot.writeFieldBegin('flush', TType.BOOL, 4)
            oprot.writeBool(self.flush)
            oprot.writeFieldEnd()
        if self.propertiesToSet is not None:
            oprot.writeFieldBegin('propertiesToSet', TType.MAP, 5)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.propertiesToSet))
            for kiter187, viter188 in self.propertiesToSet.items():
                oprot.writeString(kiter187.encode('utf-8') if sys.version_info[0] == 2 else kiter187)
                oprot.writeString(viter188.encode('utf-8') if sys.version_info[0] == 2 else viter188)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.propertiesToExclude is not None:
            oprot.writeFieldBegin('propertiesToExclude', TType.SET, 6)
            oprot.writeSetBegin(TType.STRING, len(self.propertiesToExclude))
            for iter189 in self.propertiesToExclude:
                oprot.writeString(iter189.encode('utf-8') if sys.version_info[0] == 2 else iter189)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(cloneTable_args)
cloneTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'newTableName', 'UTF8', None, ),  # 3
    (4, TType.BOOL, 'flush', None, None, ),  # 4
    (5, TType.MAP, 'propertiesToSet', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 5
    (6, TType.SET, 'propertiesToExclude', (TType.STRING, 'UTF8', False), None, ),  # 6
)


class cloneTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3
     - ouch4

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None, ouch4=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3
        self.ouch4 = ouch4

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.ouch4 = TableExistsException()
                    self.ouch4.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('cloneTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch4 is not None:
            oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
            self.ouch4.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(cloneTable_result)
cloneTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
    (4, TType.STRUCT, 'ouch4', [TableExistsException, None], None, ),  # 4
)


class compactTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - startRow
     - endRow
     - iterators
     - flush
     - wait
     - compactionStrategy

    """


    def __init__(self, login=None, tableName=None, startRow=None, endRow=None, iterators=None, flush=None, wait=None, compactionStrategy=None,):
        self.login = login
        self.tableName = tableName
        self.startRow = startRow
        self.endRow = endRow
        self.iterators = iterators
        self.flush = flush
        self.wait = wait
        self.compactionStrategy = compactionStrategy

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.startRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.endRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.LIST:
                    self.iterators = []
                    (_etype193, _size190) = iprot.readListBegin()
                    for _i194 in range(_size190):
                        _elem195 = IteratorSetting()
                        _elem195.read(iprot)
                        self.iterators.append(_elem195)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.BOOL:
                    self.flush = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.BOOL:
                    self.wait = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.STRUCT:
                    self.compactionStrategy = CompactionStrategyConfig()
                    self.compactionStrategy.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('compactTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.startRow is not None:
            oprot.writeFieldBegin('startRow', TType.STRING, 3)
            oprot.writeBinary(self.startRow)
            oprot.writeFieldEnd()
        if self.endRow is not None:
            oprot.writeFieldBegin('endRow', TType.STRING, 4)
            oprot.writeBinary(self.endRow)
            oprot.writeFieldEnd()
        if self.iterators is not None:
            oprot.writeFieldBegin('iterators', TType.LIST, 5)
            oprot.writeListBegin(TType.STRUCT, len(self.iterators))
            for iter196 in self.iterators:
                iter196.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.flush is not None:
            oprot.writeFieldBegin('flush', TType.BOOL, 6)
            oprot.writeBool(self.flush)
            oprot.writeFieldEnd()
        if self.wait is not None:
            oprot.writeFieldBegin('wait', TType.BOOL, 7)
            oprot.writeBool(self.wait)
            oprot.writeFieldEnd()
        if self.compactionStrategy is not None:
            oprot.writeFieldBegin('compactionStrategy', TType.STRUCT, 8)
            self.compactionStrategy.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(compactTable_args)
compactTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'startRow', 'BINARY', None, ),  # 3
    (4, TType.STRING, 'endRow', 'BINARY', None, ),  # 4
    (5, TType.LIST, 'iterators', (TType.STRUCT, [IteratorSetting, None], False), None, ),  # 5
    (6, TType.BOOL, 'flush', None, None, ),  # 6
    (7, TType.BOOL, 'wait', None, None, ),  # 7
    (8, TType.STRUCT, 'compactionStrategy', [CompactionStrategyConfig, None], None, ),  # 8
)


class compactTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloSecurityException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = TableNotFoundException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('compactTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(compactTable_result)
compactTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloSecurityException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [TableNotFoundException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [AccumuloException, None], None, ),  # 3
)


class cancelCompaction_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('cancelCompaction_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(cancelCompaction_args)
cancelCompaction_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class cancelCompaction_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloSecurityException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = TableNotFoundException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('cancelCompaction_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(cancelCompaction_result)
cancelCompaction_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloSecurityException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [TableNotFoundException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [AccumuloException, None], None, ),  # 3
)


class createTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - versioningIter
     - type

    """


    def __init__(self, login=None, tableName=None, versioningIter=None, type=None,):
        self.login = login
        self.tableName = tableName
        self.versioningIter = versioningIter
        self.type = type

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.versioningIter = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.versioningIter is not None:
            oprot.writeFieldBegin('versioningIter', TType.BOOL, 3)
            oprot.writeBool(self.versioningIter)
            oprot.writeFieldEnd()
        if self.type is not None:
            oprot.writeFieldBegin('type', TType.I32, 4)
            oprot.writeI32(self.type)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createTable_args)
createTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.BOOL, 'versioningIter', None, None, ),  # 3
    (4, TType.I32, 'type', None, None, ),  # 4
)


class createTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableExistsException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createTable_result)
createTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableExistsException, None], None, ),  # 3
)


class deleteTable_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('deleteTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(deleteTable_args)
deleteTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class deleteTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('deleteTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(deleteTable_result)
deleteTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class deleteRows_args(object):
    """
    Attributes:
     - login
     - tableName
     - startRow
     - endRow

    """


    def __init__(self, login=None, tableName=None, startRow=None, endRow=None,):
        self.login = login
        self.tableName = tableName
        self.startRow = startRow
        self.endRow = endRow

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.startRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.endRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('deleteRows_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.startRow is not None:
            oprot.writeFieldBegin('startRow', TType.STRING, 3)
            oprot.writeBinary(self.startRow)
            oprot.writeFieldEnd()
        if self.endRow is not None:
            oprot.writeFieldBegin('endRow', TType.STRING, 4)
            oprot.writeBinary(self.endRow)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(deleteRows_args)
deleteRows_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'startRow', 'BINARY', None, ),  # 3
    (4, TType.STRING, 'endRow', 'BINARY', None, ),  # 4
)


class deleteRows_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('deleteRows_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(deleteRows_result)
deleteRows_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class exportTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - exportDir

    """


    def __init__(self, login=None, tableName=None, exportDir=None,):
        self.login = login
        self.tableName = tableName
        self.exportDir = exportDir

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.exportDir = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('exportTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.exportDir is not None:
            oprot.writeFieldBegin('exportDir', TType.STRING, 3)
            oprot.writeString(self.exportDir.encode('utf-8') if sys.version_info[0] == 2 else self.exportDir)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(exportTable_args)
exportTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'exportDir', 'UTF8', None, ),  # 3
)


class exportTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('exportTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(exportTable_result)
exportTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class flushTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - startRow
     - endRow
     - wait

    """


    def __init__(self, login=None, tableName=None, startRow=None, endRow=None, wait=None,):
        self.login = login
        self.tableName = tableName
        self.startRow = startRow
        self.endRow = endRow
        self.wait = wait

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.startRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.endRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.wait = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('flushTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.startRow is not None:
            oprot.writeFieldBegin('startRow', TType.STRING, 3)
            oprot.writeBinary(self.startRow)
            oprot.writeFieldEnd()
        if self.endRow is not None:
            oprot.writeFieldBegin('endRow', TType.STRING, 4)
            oprot.writeBinary(self.endRow)
            oprot.writeFieldEnd()
        if self.wait is not None:
            oprot.writeFieldBegin('wait', TType.BOOL, 5)
            oprot.writeBool(self.wait)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(flushTable_args)
flushTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'startRow', 'BINARY', None, ),  # 3
    (4, TType.STRING, 'endRow', 'BINARY', None, ),  # 4
    (5, TType.BOOL, 'wait', None, None, ),  # 5
)


class flushTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('flushTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(flushTable_result)
flushTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class getDiskUsage_args(object):
    """
    Attributes:
     - login
     - tables

    """


    def __init__(self, login=None, tables=None,):
        self.login = login
        self.tables = tables

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.SET:
                    self.tables = set()
                    (_etype200, _size197) = iprot.readSetBegin()
                    for _i201 in range(_size197):
                        _elem202 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.tables.add(_elem202)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getDiskUsage_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tables is not None:
            oprot.writeFieldBegin('tables', TType.SET, 2)
            oprot.writeSetBegin(TType.STRING, len(self.tables))
            for iter203 in self.tables:
                oprot.writeString(iter203.encode('utf-8') if sys.version_info[0] == 2 else iter203)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getDiskUsage_args)
getDiskUsage_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.SET, 'tables', (TType.STRING, 'UTF8', False), None, ),  # 2
)


class getDiskUsage_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype207, _size204) = iprot.readListBegin()
                    for _i208 in range(_size204):
                        _elem209 = DiskUsage()
                        _elem209.read(iprot)
                        self.success.append(_elem209)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getDiskUsage_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter210 in self.success:
                iter210.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getDiskUsage_result)
getDiskUsage_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT, [DiskUsage, None], False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class getLocalityGroups_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getLocalityGroups_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getLocalityGroups_args)
getLocalityGroups_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class getLocalityGroups_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype212, _vtype213, _size211) = iprot.readMapBegin()
                    for _i215 in range(_size211):
                        _key216 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val217 = set()
                        (_etype221, _size218) = iprot.readSetBegin()
                        for _i222 in range(_size218):
                            _elem223 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                            _val217.add(_elem223)
                        iprot.readSetEnd()
                        self.success[_key216] = _val217
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getLocalityGroups_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.SET, len(self.success))
            for kiter224, viter225 in self.success.items():
                oprot.writeString(kiter224.encode('utf-8') if sys.version_info[0] == 2 else kiter224)
                oprot.writeSetBegin(TType.STRING, len(viter225))
                for iter226 in viter225:
                    oprot.writeString(iter226.encode('utf-8') if sys.version_info[0] == 2 else iter226)
                oprot.writeSetEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getLocalityGroups_result)
getLocalityGroups_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.SET, (TType.STRING, 'UTF8', False), False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class getIteratorSetting_args(object):
    """
    Attributes:
     - login
     - tableName
     - iteratorName
     - scope

    """


    def __init__(self, login=None, tableName=None, iteratorName=None, scope=None,):
        self.login = login
        self.tableName = tableName
        self.iteratorName = iteratorName
        self.scope = scope

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.iteratorName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.scope = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getIteratorSetting_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.iteratorName is not None:
            oprot.writeFieldBegin('iteratorName', TType.STRING, 3)
            oprot.writeString(self.iteratorName.encode('utf-8') if sys.version_info[0] == 2 else self.iteratorName)
            oprot.writeFieldEnd()
        if self.scope is not None:
            oprot.writeFieldBegin('scope', TType.I32, 4)
            oprot.writeI32(self.scope)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getIteratorSetting_args)
getIteratorSetting_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'iteratorName', 'UTF8', None, ),  # 3
    (4, TType.I32, 'scope', None, None, ),  # 4
)


class getIteratorSetting_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = IteratorSetting()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getIteratorSetting_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getIteratorSetting_result)
getIteratorSetting_result.thrift_spec = (
    (0, TType.STRUCT, 'success', [IteratorSetting, None], None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class getMaxRow_args(object):
    """
    Attributes:
     - login
     - tableName
     - auths
     - startRow
     - startInclusive
     - endRow
     - endInclusive

    """


    def __init__(self, login=None, tableName=None, auths=None, startRow=None, startInclusive=None, endRow=None, endInclusive=None,):
        self.login = login
        self.tableName = tableName
        self.auths = auths
        self.startRow = startRow
        self.startInclusive = startInclusive
        self.endRow = endRow
        self.endInclusive = endInclusive

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.SET:
                    self.auths = set()
                    (_etype230, _size227) = iprot.readSetBegin()
                    for _i231 in range(_size227):
                        _elem232 = iprot.readBinary()
                        self.auths.add(_elem232)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.startRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.startInclusive = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.endRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.BOOL:
                    self.endInclusive = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getMaxRow_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.auths is not None:
            oprot.writeFieldBegin('auths', TType.SET, 3)
            oprot.writeSetBegin(TType.STRING, len(self.auths))
            for iter233 in self.auths:
                oprot.writeBinary(iter233)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        if self.startRow is not None:
            oprot.writeFieldBegin('startRow', TType.STRING, 4)
            oprot.writeBinary(self.startRow)
            oprot.writeFieldEnd()
        if self.startInclusive is not None:
            oprot.writeFieldBegin('startInclusive', TType.BOOL, 5)
            oprot.writeBool(self.startInclusive)
            oprot.writeFieldEnd()
        if self.endRow is not None:
            oprot.writeFieldBegin('endRow', TType.STRING, 6)
            oprot.writeBinary(self.endRow)
            oprot.writeFieldEnd()
        if self.endInclusive is not None:
            oprot.writeFieldBegin('endInclusive', TType.BOOL, 7)
            oprot.writeBool(self.endInclusive)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getMaxRow_args)
getMaxRow_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.SET, 'auths', (TType.STRING, 'BINARY', False), None, ),  # 3
    (4, TType.STRING, 'startRow', 'BINARY', None, ),  # 4
    (5, TType.BOOL, 'startInclusive', None, None, ),  # 5
    (6, TType.STRING, 'endRow', 'BINARY', None, ),  # 6
    (7, TType.BOOL, 'endInclusive', None, None, ),  # 7
)


class getMaxRow_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getMaxRow_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeBinary(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getMaxRow_result)
getMaxRow_result.thrift_spec = (
    (0, TType.STRING, 'success', 'BINARY', None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class getTableProperties_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getTableProperties_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getTableProperties_args)
getTableProperties_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class getTableProperties_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype235, _vtype236, _size234) = iprot.readMapBegin()
                    for _i238 in range(_size234):
                        _key239 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val240 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key239] = _val240
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getTableProperties_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter241, viter242 in self.success.items():
                oprot.writeString(kiter241.encode('utf-8') if sys.version_info[0] == 2 else kiter241)
                oprot.writeString(viter242.encode('utf-8') if sys.version_info[0] == 2 else viter242)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getTableProperties_result)
getTableProperties_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class importDirectory_args(object):
    """
    Attributes:
     - login
     - tableName
     - importDir
     - failureDir
     - setTime

    """


    def __init__(self, login=None, tableName=None, importDir=None, failureDir=None, setTime=None,):
        self.login = login
        self.tableName = tableName
        self.importDir = importDir
        self.failureDir = failureDir
        self.setTime = setTime

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.importDir = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.failureDir = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.setTime = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('importDirectory_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.importDir is not None:
            oprot.writeFieldBegin('importDir', TType.STRING, 3)
            oprot.writeString(self.importDir.encode('utf-8') if sys.version_info[0] == 2 else self.importDir)
            oprot.writeFieldEnd()
        if self.failureDir is not None:
            oprot.writeFieldBegin('failureDir', TType.STRING, 4)
            oprot.writeString(self.failureDir.encode('utf-8') if sys.version_info[0] == 2 else self.failureDir)
            oprot.writeFieldEnd()
        if self.setTime is not None:
            oprot.writeFieldBegin('setTime', TType.BOOL, 5)
            oprot.writeBool(self.setTime)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(importDirectory_args)
importDirectory_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'importDir', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'failureDir', 'UTF8', None, ),  # 4
    (5, TType.BOOL, 'setTime', None, None, ),  # 5
)


class importDirectory_result(object):
    """
    Attributes:
     - ouch1
     - ouch3
     - ouch4

    """


    def __init__(self, ouch1=None, ouch3=None, ouch4=None,):
        self.ouch1 = ouch1
        self.ouch3 = ouch3
        self.ouch4 = ouch4

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = TableNotFoundException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch4 = AccumuloSecurityException()
                    self.ouch4.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('importDirectory_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 2)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch4 is not None:
            oprot.writeFieldBegin('ouch4', TType.STRUCT, 3)
            self.ouch4.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(importDirectory_result)
importDirectory_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [TableNotFoundException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch3', [AccumuloException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch4', [AccumuloSecurityException, None], None, ),  # 3
)


class importTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - importDir

    """


    def __init__(self, login=None, tableName=None, importDir=None,):
        self.login = login
        self.tableName = tableName
        self.importDir = importDir

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.importDir = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('importTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.importDir is not None:
            oprot.writeFieldBegin('importDir', TType.STRING, 3)
            oprot.writeString(self.importDir.encode('utf-8') if sys.version_info[0] == 2 else self.importDir)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(importTable_args)
importTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'importDir', 'UTF8', None, ),  # 3
)


class importTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = TableExistsException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloSecurityException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('importTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(importTable_result)
importTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [TableExistsException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [AccumuloSecurityException, None], None, ),  # 3
)


class listSplits_args(object):
    """
    Attributes:
     - login
     - tableName
     - maxSplits

    """


    def __init__(self, login=None, tableName=None, maxSplits=None,):
        self.login = login
        self.tableName = tableName
        self.maxSplits = maxSplits

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.maxSplits = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listSplits_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.maxSplits is not None:
            oprot.writeFieldBegin('maxSplits', TType.I32, 3)
            oprot.writeI32(self.maxSplits)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listSplits_args)
listSplits_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.I32, 'maxSplits', None, None, ),  # 3
)


class listSplits_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype246, _size243) = iprot.readListBegin()
                    for _i247 in range(_size243):
                        _elem248 = iprot.readBinary()
                        self.success.append(_elem248)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listSplits_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRING, len(self.success))
            for iter249 in self.success:
                oprot.writeBinary(iter249)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listSplits_result)
listSplits_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING, 'BINARY', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class listTables_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listTables_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listTables_args)
listTables_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class listTables_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.SET:
                    self.success = set()
                    (_etype253, _size250) = iprot.readSetBegin()
                    for _i254 in range(_size250):
                        _elem255 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success.add(_elem255)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listTables_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.SET, 0)
            oprot.writeSetBegin(TType.STRING, len(self.success))
            for iter256 in self.success:
                oprot.writeString(iter256.encode('utf-8') if sys.version_info[0] == 2 else iter256)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listTables_result)
listTables_result.thrift_spec = (
    (0, TType.SET, 'success', (TType.STRING, 'UTF8', False), None, ),  # 0
)


class listIterators_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listIterators_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listIterators_args)
listIterators_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class listIterators_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype258, _vtype259, _size257) = iprot.readMapBegin()
                    for _i261 in range(_size257):
                        _key262 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val263 = set()
                        (_etype267, _size264) = iprot.readSetBegin()
                        for _i268 in range(_size264):
                            _elem269 = iprot.readI32()
                            _val263.add(_elem269)
                        iprot.readSetEnd()
                        self.success[_key262] = _val263
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listIterators_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.SET, len(self.success))
            for kiter270, viter271 in self.success.items():
                oprot.writeString(kiter270.encode('utf-8') if sys.version_info[0] == 2 else kiter270)
                oprot.writeSetBegin(TType.I32, len(viter271))
                for iter272 in viter271:
                    oprot.writeI32(iter272)
                oprot.writeSetEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listIterators_result)
listIterators_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.SET, (TType.I32, None, False), False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class listConstraints_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listConstraints_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listConstraints_args)
listConstraints_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class listConstraints_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype274, _vtype275, _size273) = iprot.readMapBegin()
                    for _i277 in range(_size273):
                        _key278 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val279 = iprot.readI32()
                        self.success[_key278] = _val279
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listConstraints_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
            for kiter280, viter281 in self.success.items():
                oprot.writeString(kiter280.encode('utf-8') if sys.version_info[0] == 2 else kiter280)
                oprot.writeI32(viter281)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listConstraints_result)
listConstraints_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.I32, None, False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class mergeTablets_args(object):
    """
    Attributes:
     - login
     - tableName
     - startRow
     - endRow

    """


    def __init__(self, login=None, tableName=None, startRow=None, endRow=None,):
        self.login = login
        self.tableName = tableName
        self.startRow = startRow
        self.endRow = endRow

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.startRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.endRow = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('mergeTablets_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.startRow is not None:
            oprot.writeFieldBegin('startRow', TType.STRING, 3)
            oprot.writeBinary(self.startRow)
            oprot.writeFieldEnd()
        if self.endRow is not None:
            oprot.writeFieldBegin('endRow', TType.STRING, 4)
            oprot.writeBinary(self.endRow)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(mergeTablets_args)
mergeTablets_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'startRow', 'BINARY', None, ),  # 3
    (4, TType.STRING, 'endRow', 'BINARY', None, ),  # 4
)


class mergeTablets_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('mergeTablets_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(mergeTablets_result)
mergeTablets_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class offlineTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - wait

    """


    def __init__(self, login=None, tableName=None, wait=False,):
        self.login = login
        self.tableName = tableName
        self.wait = wait

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.wait = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('offlineTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.wait is not None:
            oprot.writeFieldBegin('wait', TType.BOOL, 3)
            oprot.writeBool(self.wait)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(offlineTable_args)
offlineTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.BOOL, 'wait', None, False, ),  # 3
)


class offlineTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('offlineTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(offlineTable_result)
offlineTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class onlineTable_args(object):
    """
    Attributes:
     - login
     - tableName
     - wait

    """


    def __init__(self, login=None, tableName=None, wait=False,):
        self.login = login
        self.tableName = tableName
        self.wait = wait

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.wait = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('onlineTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.wait is not None:
            oprot.writeFieldBegin('wait', TType.BOOL, 3)
            oprot.writeBool(self.wait)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(onlineTable_args)
onlineTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.BOOL, 'wait', None, False, ),  # 3
)


class onlineTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('onlineTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(onlineTable_result)
onlineTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class removeConstraint_args(object):
    """
    Attributes:
     - login
     - tableName
     - constraint

    """


    def __init__(self, login=None, tableName=None, constraint=None,):
        self.login = login
        self.tableName = tableName
        self.constraint = constraint

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.constraint = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeConstraint_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.constraint is not None:
            oprot.writeFieldBegin('constraint', TType.I32, 3)
            oprot.writeI32(self.constraint)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeConstraint_args)
removeConstraint_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.I32, 'constraint', None, None, ),  # 3
)


class removeConstraint_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeConstraint_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeConstraint_result)
removeConstraint_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class removeIterator_args(object):
    """
    Attributes:
     - login
     - tableName
     - iterName
     - scopes

    """


    def __init__(self, login=None, tableName=None, iterName=None, scopes=None,):
        self.login = login
        self.tableName = tableName
        self.iterName = iterName
        self.scopes = scopes

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.iterName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.SET:
                    self.scopes = set()
                    (_etype285, _size282) = iprot.readSetBegin()
                    for _i286 in range(_size282):
                        _elem287 = iprot.readI32()
                        self.scopes.add(_elem287)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeIterator_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.iterName is not None:
            oprot.writeFieldBegin('iterName', TType.STRING, 3)
            oprot.writeString(self.iterName.encode('utf-8') if sys.version_info[0] == 2 else self.iterName)
            oprot.writeFieldEnd()
        if self.scopes is not None:
            oprot.writeFieldBegin('scopes', TType.SET, 4)
            oprot.writeSetBegin(TType.I32, len(self.scopes))
            for iter288 in self.scopes:
                oprot.writeI32(iter288)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeIterator_args)
removeIterator_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'iterName', 'UTF8', None, ),  # 3
    (4, TType.SET, 'scopes', (TType.I32, None, False), None, ),  # 4
)


class removeIterator_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeIterator_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeIterator_result)
removeIterator_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class removeTableProperty_args(object):
    """
    Attributes:
     - login
     - tableName
     - property

    """


    def __init__(self, login=None, tableName=None, property=None,):
        self.login = login
        self.tableName = tableName
        self.property = property

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.property = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeTableProperty_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.property is not None:
            oprot.writeFieldBegin('property', TType.STRING, 3)
            oprot.writeString(self.property.encode('utf-8') if sys.version_info[0] == 2 else self.property)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeTableProperty_args)
removeTableProperty_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'property', 'UTF8', None, ),  # 3
)


class removeTableProperty_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeTableProperty_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeTableProperty_result)
removeTableProperty_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class renameTable_args(object):
    """
    Attributes:
     - login
     - oldTableName
     - newTableName

    """


    def __init__(self, login=None, oldTableName=None, newTableName=None,):
        self.login = login
        self.oldTableName = oldTableName
        self.newTableName = newTableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.oldTableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.newTableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('renameTable_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.oldTableName is not None:
            oprot.writeFieldBegin('oldTableName', TType.STRING, 2)
            oprot.writeString(self.oldTableName.encode('utf-8') if sys.version_info[0] == 2 else self.oldTableName)
            oprot.writeFieldEnd()
        if self.newTableName is not None:
            oprot.writeFieldBegin('newTableName', TType.STRING, 3)
            oprot.writeString(self.newTableName.encode('utf-8') if sys.version_info[0] == 2 else self.newTableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(renameTable_args)
renameTable_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'oldTableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'newTableName', 'UTF8', None, ),  # 3
)


class renameTable_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3
     - ouch4

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None, ouch4=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3
        self.ouch4 = ouch4

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.ouch4 = TableExistsException()
                    self.ouch4.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('renameTable_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch4 is not None:
            oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
            self.ouch4.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(renameTable_result)
renameTable_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
    (4, TType.STRUCT, 'ouch4', [TableExistsException, None], None, ),  # 4
)


class setLocalityGroups_args(object):
    """
    Attributes:
     - login
     - tableName
     - groups

    """


    def __init__(self, login=None, tableName=None, groups=None,):
        self.login = login
        self.tableName = tableName
        self.groups = groups

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.MAP:
                    self.groups = {}
                    (_ktype290, _vtype291, _size289) = iprot.readMapBegin()
                    for _i293 in range(_size289):
                        _key294 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val295 = set()
                        (_etype299, _size296) = iprot.readSetBegin()
                        for _i300 in range(_size296):
                            _elem301 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                            _val295.add(_elem301)
                        iprot.readSetEnd()
                        self.groups[_key294] = _val295
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setLocalityGroups_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.groups is not None:
            oprot.writeFieldBegin('groups', TType.MAP, 3)
            oprot.writeMapBegin(TType.STRING, TType.SET, len(self.groups))
            for kiter302, viter303 in self.groups.items():
                oprot.writeString(kiter302.encode('utf-8') if sys.version_info[0] == 2 else kiter302)
                oprot.writeSetBegin(TType.STRING, len(viter303))
                for iter304 in viter303:
                    oprot.writeString(iter304.encode('utf-8') if sys.version_info[0] == 2 else iter304)
                oprot.writeSetEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setLocalityGroups_args)
setLocalityGroups_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.MAP, 'groups', (TType.STRING, 'UTF8', TType.SET, (TType.STRING, 'UTF8', False), False), None, ),  # 3
)


class setLocalityGroups_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setLocalityGroups_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setLocalityGroups_result)
setLocalityGroups_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class setTableProperty_args(object):
    """
    Attributes:
     - login
     - tableName
     - property
     - value

    """


    def __init__(self, login=None, tableName=None, property=None, value=None,):
        self.login = login
        self.tableName = tableName
        self.property = property
        self.value = value

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.property = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.value = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setTableProperty_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.property is not None:
            oprot.writeFieldBegin('property', TType.STRING, 3)
            oprot.writeString(self.property.encode('utf-8') if sys.version_info[0] == 2 else self.property)
            oprot.writeFieldEnd()
        if self.value is not None:
            oprot.writeFieldBegin('value', TType.STRING, 4)
            oprot.writeString(self.value.encode('utf-8') if sys.version_info[0] == 2 else self.value)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setTableProperty_args)
setTableProperty_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'property', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'value', 'UTF8', None, ),  # 4
)


class setTableProperty_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setTableProperty_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setTableProperty_result)
setTableProperty_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class splitRangeByTablets_args(object):
    """
    Attributes:
     - login
     - tableName
     - range
     - maxSplits

    """


    def __init__(self, login=None, tableName=None, range=None, maxSplits=None,):
        self.login = login
        self.tableName = tableName
        self.range = range
        self.maxSplits = maxSplits

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.range = Range()
                    self.range.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.maxSplits = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('splitRangeByTablets_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.range is not None:
            oprot.writeFieldBegin('range', TType.STRUCT, 3)
            self.range.write(oprot)
            oprot.writeFieldEnd()
        if self.maxSplits is not None:
            oprot.writeFieldBegin('maxSplits', TType.I32, 4)
            oprot.writeI32(self.maxSplits)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(splitRangeByTablets_args)
splitRangeByTablets_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'range', [Range, None], None, ),  # 3
    (4, TType.I32, 'maxSplits', None, None, ),  # 4
)


class splitRangeByTablets_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.SET:
                    self.success = set()
                    (_etype308, _size305) = iprot.readSetBegin()
                    for _i309 in range(_size305):
                        _elem310 = Range()
                        _elem310.read(iprot)
                        self.success.add(_elem310)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('splitRangeByTablets_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.SET, 0)
            oprot.writeSetBegin(TType.STRUCT, len(self.success))
            for iter311 in self.success:
                iter311.write(oprot)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(splitRangeByTablets_result)
splitRangeByTablets_result.thrift_spec = (
    (0, TType.SET, 'success', (TType.STRUCT, [Range, None], False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class tableExists_args(object):
    """
    Attributes:
     - login
     - tableName

    """


    def __init__(self, login=None, tableName=None,):
        self.login = login
        self.tableName = tableName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('tableExists_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(tableExists_args)
tableExists_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
)


class tableExists_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('tableExists_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(tableExists_result)
tableExists_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
)


class tableIdMap_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('tableIdMap_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(tableIdMap_args)
tableIdMap_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class tableIdMap_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype313, _vtype314, _size312) = iprot.readMapBegin()
                    for _i316 in range(_size312):
                        _key317 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val318 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key317] = _val318
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('tableIdMap_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter319, viter320 in self.success.items():
                oprot.writeString(kiter319.encode('utf-8') if sys.version_info[0] == 2 else kiter319)
                oprot.writeString(viter320.encode('utf-8') if sys.version_info[0] == 2 else viter320)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(tableIdMap_result)
tableIdMap_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
)


class testTableClassLoad_args(object):
    """
    Attributes:
     - login
     - tableName
     - className
     - asTypeName

    """


    def __init__(self, login=None, tableName=None, className=None, asTypeName=None,):
        self.login = login
        self.tableName = tableName
        self.className = className
        self.asTypeName = asTypeName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.className = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.asTypeName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('testTableClassLoad_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.className is not None:
            oprot.writeFieldBegin('className', TType.STRING, 3)
            oprot.writeString(self.className.encode('utf-8') if sys.version_info[0] == 2 else self.className)
            oprot.writeFieldEnd()
        if self.asTypeName is not None:
            oprot.writeFieldBegin('asTypeName', TType.STRING, 4)
            oprot.writeString(self.asTypeName.encode('utf-8') if sys.version_info[0] == 2 else self.asTypeName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(testTableClassLoad_args)
testTableClassLoad_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'className', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'asTypeName', 'UTF8', None, ),  # 4
)


class testTableClassLoad_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('testTableClassLoad_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(testTableClassLoad_result)
testTableClassLoad_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class pingTabletServer_args(object):
    """
    Attributes:
     - login
     - tserver

    """


    def __init__(self, login=None, tserver=None,):
        self.login = login
        self.tserver = tserver

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tserver = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('pingTabletServer_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tserver is not None:
            oprot.writeFieldBegin('tserver', TType.STRING, 2)
            oprot.writeString(self.tserver.encode('utf-8') if sys.version_info[0] == 2 else self.tserver)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(pingTabletServer_args)
pingTabletServer_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tserver', 'UTF8', None, ),  # 2
)


class pingTabletServer_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('pingTabletServer_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(pingTabletServer_result)
pingTabletServer_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class getActiveScans_args(object):
    """
    Attributes:
     - login
     - tserver

    """


    def __init__(self, login=None, tserver=None,):
        self.login = login
        self.tserver = tserver

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tserver = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getActiveScans_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tserver is not None:
            oprot.writeFieldBegin('tserver', TType.STRING, 2)
            oprot.writeString(self.tserver.encode('utf-8') if sys.version_info[0] == 2 else self.tserver)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getActiveScans_args)
getActiveScans_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tserver', 'UTF8', None, ),  # 2
)


class getActiveScans_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype324, _size321) = iprot.readListBegin()
                    for _i325 in range(_size321):
                        _elem326 = ActiveScan()
                        _elem326.read(iprot)
                        self.success.append(_elem326)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getActiveScans_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter327 in self.success:
                iter327.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getActiveScans_result)
getActiveScans_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT, [ActiveScan, None], False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class getActiveCompactions_args(object):
    """
    Attributes:
     - login
     - tserver

    """


    def __init__(self, login=None, tserver=None,):
        self.login = login
        self.tserver = tserver

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tserver = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getActiveCompactions_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tserver is not None:
            oprot.writeFieldBegin('tserver', TType.STRING, 2)
            oprot.writeString(self.tserver.encode('utf-8') if sys.version_info[0] == 2 else self.tserver)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getActiveCompactions_args)
getActiveCompactions_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tserver', 'UTF8', None, ),  # 2
)


class getActiveCompactions_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype331, _size328) = iprot.readListBegin()
                    for _i332 in range(_size328):
                        _elem333 = ActiveCompaction()
                        _elem333.read(iprot)
                        self.success.append(_elem333)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getActiveCompactions_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter334 in self.success:
                iter334.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getActiveCompactions_result)
getActiveCompactions_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT, [ActiveCompaction, None], False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class getSiteConfiguration_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getSiteConfiguration_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getSiteConfiguration_args)
getSiteConfiguration_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class getSiteConfiguration_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype336, _vtype337, _size335) = iprot.readMapBegin()
                    for _i339 in range(_size335):
                        _key340 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val341 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key340] = _val341
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getSiteConfiguration_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter342, viter343 in self.success.items():
                oprot.writeString(kiter342.encode('utf-8') if sys.version_info[0] == 2 else kiter342)
                oprot.writeString(viter343.encode('utf-8') if sys.version_info[0] == 2 else viter343)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getSiteConfiguration_result)
getSiteConfiguration_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class getSystemConfiguration_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getSystemConfiguration_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getSystemConfiguration_args)
getSystemConfiguration_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class getSystemConfiguration_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype345, _vtype346, _size344) = iprot.readMapBegin()
                    for _i348 in range(_size344):
                        _key349 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val350 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key349] = _val350
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getSystemConfiguration_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter351, viter352 in self.success.items():
                oprot.writeString(kiter351.encode('utf-8') if sys.version_info[0] == 2 else kiter351)
                oprot.writeString(viter352.encode('utf-8') if sys.version_info[0] == 2 else viter352)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getSystemConfiguration_result)
getSystemConfiguration_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class getTabletServers_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getTabletServers_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getTabletServers_args)
getTabletServers_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class getTabletServers_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype356, _size353) = iprot.readListBegin()
                    for _i357 in range(_size353):
                        _elem358 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success.append(_elem358)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getTabletServers_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRING, len(self.success))
            for iter359 in self.success:
                oprot.writeString(iter359.encode('utf-8') if sys.version_info[0] == 2 else iter359)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getTabletServers_result)
getTabletServers_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ),  # 0
)


class removeProperty_args(object):
    """
    Attributes:
     - login
     - property

    """


    def __init__(self, login=None, property=None,):
        self.login = login
        self.property = property

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.property = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeProperty_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.property is not None:
            oprot.writeFieldBegin('property', TType.STRING, 2)
            oprot.writeString(self.property.encode('utf-8') if sys.version_info[0] == 2 else self.property)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeProperty_args)
removeProperty_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'property', 'UTF8', None, ),  # 2
)


class removeProperty_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeProperty_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeProperty_result)
removeProperty_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class setProperty_args(object):
    """
    Attributes:
     - login
     - property
     - value

    """


    def __init__(self, login=None, property=None, value=None,):
        self.login = login
        self.property = property
        self.value = value

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.property = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.value = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setProperty_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.property is not None:
            oprot.writeFieldBegin('property', TType.STRING, 2)
            oprot.writeString(self.property.encode('utf-8') if sys.version_info[0] == 2 else self.property)
            oprot.writeFieldEnd()
        if self.value is not None:
            oprot.writeFieldBegin('value', TType.STRING, 3)
            oprot.writeString(self.value.encode('utf-8') if sys.version_info[0] == 2 else self.value)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setProperty_args)
setProperty_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'property', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'value', 'UTF8', None, ),  # 3
)


class setProperty_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setProperty_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setProperty_result)
setProperty_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class testClassLoad_args(object):
    """
    Attributes:
     - login
     - className
     - asTypeName

    """


    def __init__(self, login=None, className=None, asTypeName=None,):
        self.login = login
        self.className = className
        self.asTypeName = asTypeName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.className = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.asTypeName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('testClassLoad_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.className is not None:
            oprot.writeFieldBegin('className', TType.STRING, 2)
            oprot.writeString(self.className.encode('utf-8') if sys.version_info[0] == 2 else self.className)
            oprot.writeFieldEnd()
        if self.asTypeName is not None:
            oprot.writeFieldBegin('asTypeName', TType.STRING, 3)
            oprot.writeString(self.asTypeName.encode('utf-8') if sys.version_info[0] == 2 else self.asTypeName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(testClassLoad_args)
testClassLoad_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'className', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'asTypeName', 'UTF8', None, ),  # 3
)


class testClassLoad_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('testClassLoad_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(testClassLoad_result)
testClassLoad_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class authenticateUser_args(object):
    """
    Attributes:
     - login
     - user
     - properties

    """


    def __init__(self, login=None, user=None, properties=None,):
        self.login = login
        self.user = user
        self.properties = properties

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.MAP:
                    self.properties = {}
                    (_ktype361, _vtype362, _size360) = iprot.readMapBegin()
                    for _i364 in range(_size360):
                        _key365 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val366 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.properties[_key365] = _val366
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('authenticateUser_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.properties is not None:
            oprot.writeFieldBegin('properties', TType.MAP, 3)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
            for kiter367, viter368 in self.properties.items():
                oprot.writeString(kiter367.encode('utf-8') if sys.version_info[0] == 2 else kiter367)
                oprot.writeString(viter368.encode('utf-8') if sys.version_info[0] == 2 else viter368)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(authenticateUser_args)
authenticateUser_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.MAP, 'properties', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 3
)


class authenticateUser_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('authenticateUser_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(authenticateUser_result)
authenticateUser_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class changeUserAuthorizations_args(object):
    """
    Attributes:
     - login
     - user
     - authorizations

    """


    def __init__(self, login=None, user=None, authorizations=None,):
        self.login = login
        self.user = user
        self.authorizations = authorizations

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.SET:
                    self.authorizations = set()
                    (_etype372, _size369) = iprot.readSetBegin()
                    for _i373 in range(_size369):
                        _elem374 = iprot.readBinary()
                        self.authorizations.add(_elem374)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('changeUserAuthorizations_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.authorizations is not None:
            oprot.writeFieldBegin('authorizations', TType.SET, 3)
            oprot.writeSetBegin(TType.STRING, len(self.authorizations))
            for iter375 in self.authorizations:
                oprot.writeBinary(iter375)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(changeUserAuthorizations_args)
changeUserAuthorizations_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.SET, 'authorizations', (TType.STRING, 'BINARY', False), None, ),  # 3
)


class changeUserAuthorizations_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('changeUserAuthorizations_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(changeUserAuthorizations_result)
changeUserAuthorizations_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class changeLocalUserPassword_args(object):
    """
    Attributes:
     - login
     - user
     - password

    """


    def __init__(self, login=None, user=None, password=None,):
        self.login = login
        self.user = user
        self.password = password

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.password = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('changeLocalUserPassword_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.password is not None:
            oprot.writeFieldBegin('password', TType.STRING, 3)
            oprot.writeBinary(self.password)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(changeLocalUserPassword_args)
changeLocalUserPassword_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'password', 'BINARY', None, ),  # 3
)


class changeLocalUserPassword_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('changeLocalUserPassword_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(changeLocalUserPassword_result)
changeLocalUserPassword_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class createLocalUser_args(object):
    """
    Attributes:
     - login
     - user
     - password

    """


    def __init__(self, login=None, user=None, password=None,):
        self.login = login
        self.user = user
        self.password = password

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.password = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createLocalUser_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.password is not None:
            oprot.writeFieldBegin('password', TType.STRING, 3)
            oprot.writeBinary(self.password)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createLocalUser_args)
createLocalUser_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'password', 'BINARY', None, ),  # 3
)


class createLocalUser_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createLocalUser_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createLocalUser_result)
createLocalUser_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class dropLocalUser_args(object):
    """
    Attributes:
     - login
     - user

    """


    def __init__(self, login=None, user=None,):
        self.login = login
        self.user = user

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('dropLocalUser_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(dropLocalUser_args)
dropLocalUser_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
)


class dropLocalUser_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('dropLocalUser_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(dropLocalUser_result)
dropLocalUser_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class getUserAuthorizations_args(object):
    """
    Attributes:
     - login
     - user

    """


    def __init__(self, login=None, user=None,):
        self.login = login
        self.user = user

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getUserAuthorizations_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getUserAuthorizations_args)
getUserAuthorizations_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
)


class getUserAuthorizations_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype379, _size376) = iprot.readListBegin()
                    for _i380 in range(_size376):
                        _elem381 = iprot.readBinary()
                        self.success.append(_elem381)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getUserAuthorizations_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRING, len(self.success))
            for iter382 in self.success:
                oprot.writeBinary(iter382)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getUserAuthorizations_result)
getUserAuthorizations_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING, 'BINARY', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class grantSystemPermission_args(object):
    """
    Attributes:
     - login
     - user
     - perm

    """


    def __init__(self, login=None, user=None, perm=None,):
        self.login = login
        self.user = user
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('grantSystemPermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 3)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(grantSystemPermission_args)
grantSystemPermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.I32, 'perm', None, None, ),  # 3
)


class grantSystemPermission_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('grantSystemPermission_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(grantSystemPermission_result)
grantSystemPermission_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class grantTablePermission_args(object):
    """
    Attributes:
     - login
     - user
     - table
     - perm

    """


    def __init__(self, login=None, user=None, table=None, perm=None,):
        self.login = login
        self.user = user
        self.table = table
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.table = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('grantTablePermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.table is not None:
            oprot.writeFieldBegin('table', TType.STRING, 3)
            oprot.writeString(self.table.encode('utf-8') if sys.version_info[0] == 2 else self.table)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 4)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(grantTablePermission_args)
grantTablePermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'table', 'UTF8', None, ),  # 3
    (4, TType.I32, 'perm', None, None, ),  # 4
)


class grantTablePermission_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('grantTablePermission_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(grantTablePermission_result)
grantTablePermission_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class hasSystemPermission_args(object):
    """
    Attributes:
     - login
     - user
     - perm

    """


    def __init__(self, login=None, user=None, perm=None,):
        self.login = login
        self.user = user
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasSystemPermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 3)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasSystemPermission_args)
hasSystemPermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.I32, 'perm', None, None, ),  # 3
)


class hasSystemPermission_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasSystemPermission_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasSystemPermission_result)
hasSystemPermission_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class hasTablePermission_args(object):
    """
    Attributes:
     - login
     - user
     - table
     - perm

    """


    def __init__(self, login=None, user=None, table=None, perm=None,):
        self.login = login
        self.user = user
        self.table = table
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.table = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasTablePermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.table is not None:
            oprot.writeFieldBegin('table', TType.STRING, 3)
            oprot.writeString(self.table.encode('utf-8') if sys.version_info[0] == 2 else self.table)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 4)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasTablePermission_args)
hasTablePermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'table', 'UTF8', None, ),  # 3
    (4, TType.I32, 'perm', None, None, ),  # 4
)


class hasTablePermission_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasTablePermission_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasTablePermission_result)
hasTablePermission_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class listLocalUsers_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listLocalUsers_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listLocalUsers_args)
listLocalUsers_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class listLocalUsers_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.SET:
                    self.success = set()
                    (_etype386, _size383) = iprot.readSetBegin()
                    for _i387 in range(_size383):
                        _elem388 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success.add(_elem388)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listLocalUsers_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.SET, 0)
            oprot.writeSetBegin(TType.STRING, len(self.success))
            for iter389 in self.success:
                oprot.writeString(iter389.encode('utf-8') if sys.version_info[0] == 2 else iter389)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listLocalUsers_result)
listLocalUsers_result.thrift_spec = (
    (0, TType.SET, 'success', (TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class revokeSystemPermission_args(object):
    """
    Attributes:
     - login
     - user
     - perm

    """


    def __init__(self, login=None, user=None, perm=None,):
        self.login = login
        self.user = user
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('revokeSystemPermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 3)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(revokeSystemPermission_args)
revokeSystemPermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.I32, 'perm', None, None, ),  # 3
)


class revokeSystemPermission_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('revokeSystemPermission_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(revokeSystemPermission_result)
revokeSystemPermission_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class revokeTablePermission_args(object):
    """
    Attributes:
     - login
     - user
     - table
     - perm

    """


    def __init__(self, login=None, user=None, table=None, perm=None,):
        self.login = login
        self.user = user
        self.table = table
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.table = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('revokeTablePermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.table is not None:
            oprot.writeFieldBegin('table', TType.STRING, 3)
            oprot.writeString(self.table.encode('utf-8') if sys.version_info[0] == 2 else self.table)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 4)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(revokeTablePermission_args)
revokeTablePermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'table', 'UTF8', None, ),  # 3
    (4, TType.I32, 'perm', None, None, ),  # 4
)


class revokeTablePermission_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('revokeTablePermission_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(revokeTablePermission_result)
revokeTablePermission_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class grantNamespacePermission_args(object):
    """
    Attributes:
     - login
     - user
     - namespaceName
     - perm

    """


    def __init__(self, login=None, user=None, namespaceName=None, perm=None,):
        self.login = login
        self.user = user
        self.namespaceName = namespaceName
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('grantNamespacePermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 3)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 4)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(grantNamespacePermission_args)
grantNamespacePermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 3
    (4, TType.I32, 'perm', None, None, ),  # 4
)


class grantNamespacePermission_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('grantNamespacePermission_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(grantNamespacePermission_result)
grantNamespacePermission_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class hasNamespacePermission_args(object):
    """
    Attributes:
     - login
     - user
     - namespaceName
     - perm

    """


    def __init__(self, login=None, user=None, namespaceName=None, perm=None,):
        self.login = login
        self.user = user
        self.namespaceName = namespaceName
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasNamespacePermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 3)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 4)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasNamespacePermission_args)
hasNamespacePermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 3
    (4, TType.I32, 'perm', None, None, ),  # 4
)


class hasNamespacePermission_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasNamespacePermission_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasNamespacePermission_result)
hasNamespacePermission_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class revokeNamespacePermission_args(object):
    """
    Attributes:
     - login
     - user
     - namespaceName
     - perm

    """


    def __init__(self, login=None, user=None, namespaceName=None, perm=None,):
        self.login = login
        self.user = user
        self.namespaceName = namespaceName
        self.perm = perm

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.perm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('revokeNamespacePermission_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 2)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 3)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.perm is not None:
            oprot.writeFieldBegin('perm', TType.I32, 4)
            oprot.writeI32(self.perm)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(revokeNamespacePermission_args)
revokeNamespacePermission_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'user', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 3
    (4, TType.I32, 'perm', None, None, ),  # 4
)


class revokeNamespacePermission_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('revokeNamespacePermission_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(revokeNamespacePermission_result)
revokeNamespacePermission_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class createBatchScanner_args(object):
    """
    Attributes:
     - login
     - tableName
     - options

    """


    def __init__(self, login=None, tableName=None, options=None,):
        self.login = login
        self.tableName = tableName
        self.options = options

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.options = BatchScanOptions()
                    self.options.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createBatchScanner_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.options is not None:
            oprot.writeFieldBegin('options', TType.STRUCT, 3)
            self.options.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createBatchScanner_args)
createBatchScanner_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'options', [BatchScanOptions, None], None, ),  # 3
)


class createBatchScanner_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createBatchScanner_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createBatchScanner_result)
createBatchScanner_result.thrift_spec = (
    (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class createScanner_args(object):
    """
    Attributes:
     - login
     - tableName
     - options

    """


    def __init__(self, login=None, tableName=None, options=None,):
        self.login = login
        self.tableName = tableName
        self.options = options

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.options = ScanOptions()
                    self.options.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createScanner_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.options is not None:
            oprot.writeFieldBegin('options', TType.STRUCT, 3)
            self.options.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createScanner_args)
createScanner_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'options', [ScanOptions, None], None, ),  # 3
)


class createScanner_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createScanner_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createScanner_result)
createScanner_result.thrift_spec = (
    (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class hasNext_args(object):
    """
    Attributes:
     - scanner

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.scanner = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasNext_args')
        if self.scanner is not None:
            oprot.writeFieldBegin('scanner', TType.STRING, 1)
            oprot.writeString(self.scanner.encode('utf-8') if sys.version_info[0] == 2 else self.scanner)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasNext_args)
hasNext_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'scanner', 'UTF8', None, ),  # 1
)


class hasNext_result(object):
    """
    Attributes:
     - success
     - ouch1

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = UnknownScanner()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('hasNext_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(hasNext_result)
hasNext_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [UnknownScanner, None], None, ),  # 1
)


class nextEntry_args(object):
    """
    Attributes:
     - scanner

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.scanner = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('nextEntry_args')
        if self.scanner is not None:
            oprot.writeFieldBegin('scanner', TType.STRING, 1)
            oprot.writeString(self.scanner.encode('utf-8') if sys.version_info[0] == 2 else self.scanner)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(nextEntry_args)
nextEntry_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'scanner', 'UTF8', None, ),  # 1
)


class nextEntry_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = KeyValueAndPeek()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = NoMoreEntriesException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = UnknownScanner()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloSecurityException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('nextEntry_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(nextEntry_result)
nextEntry_result.thrift_spec = (
    (0, TType.STRUCT, 'success', [KeyValueAndPeek, None], None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [NoMoreEntriesException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [UnknownScanner, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [AccumuloSecurityException, None], None, ),  # 3
)


class nextK_args(object):
    """
    Attributes:
     - scanner
     - k

    """


    def __init__(self, scanner=None, k=None,):
        self.scanner = scanner
        self.k = k

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.scanner = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.k = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('nextK_args')
        if self.scanner is not None:
            oprot.writeFieldBegin('scanner', TType.STRING, 1)
            oprot.writeString(self.scanner.encode('utf-8') if sys.version_info[0] == 2 else self.scanner)
            oprot.writeFieldEnd()
        if self.k is not None:
            oprot.writeFieldBegin('k', TType.I32, 2)
            oprot.writeI32(self.k)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(nextK_args)
nextK_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'scanner', 'UTF8', None, ),  # 1
    (2, TType.I32, 'k', None, None, ),  # 2
)


class nextK_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ScanResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = NoMoreEntriesException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = UnknownScanner()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloSecurityException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('nextK_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(nextK_result)
nextK_result.thrift_spec = (
    (0, TType.STRUCT, 'success', [ScanResult, None], None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [NoMoreEntriesException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [UnknownScanner, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [AccumuloSecurityException, None], None, ),  # 3
)


class closeScanner_args(object):
    """
    Attributes:
     - scanner

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.scanner = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('closeScanner_args')
        if self.scanner is not None:
            oprot.writeFieldBegin('scanner', TType.STRING, 1)
            oprot.writeString(self.scanner.encode('utf-8') if sys.version_info[0] == 2 else self.scanner)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(closeScanner_args)
closeScanner_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'scanner', 'UTF8', None, ),  # 1
)


class closeScanner_result(object):
    """
    Attributes:
     - ouch1

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = UnknownScanner()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('closeScanner_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(closeScanner_result)
closeScanner_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [UnknownScanner, None], None, ),  # 1
)


class updateAndFlush_args(object):
    """
    Attributes:
     - login
     - tableName
     - cells

    """


    def __init__(self, login=None, tableName=None, cells=None,):
        self.login = login
        self.tableName = tableName
        self.cells = cells

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.MAP:
                    self.cells = {}
                    (_ktype391, _vtype392, _size390) = iprot.readMapBegin()
                    for _i394 in range(_size390):
                        _key395 = iprot.readBinary()
                        _val396 = []
                        (_etype400, _size397) = iprot.readListBegin()
                        for _i401 in range(_size397):
                            _elem402 = ColumnUpdate()
                            _elem402.read(iprot)
                            _val396.append(_elem402)
                        iprot.readListEnd()
                        self.cells[_key395] = _val396
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('updateAndFlush_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.cells is not None:
            oprot.writeFieldBegin('cells', TType.MAP, 3)
            oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.cells))
            for kiter403, viter404 in self.cells.items():
                oprot.writeBinary(kiter403)
                oprot.writeListBegin(TType.STRUCT, len(viter404))
                for iter405 in viter404:
                    iter405.write(oprot)
                oprot.writeListEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(updateAndFlush_args)
updateAndFlush_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.MAP, 'cells', (TType.STRING, 'BINARY', TType.LIST, (TType.STRUCT, [ColumnUpdate, None], False), False), None, ),  # 3
)


class updateAndFlush_result(object):
    """
    Attributes:
     - outch1
     - ouch2
     - ouch3
     - ouch4

    """


    def __init__(self, outch1=None, ouch2=None, ouch3=None, ouch4=None,):
        self.outch1 = outch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3
        self.ouch4 = ouch4

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.outch1 = AccumuloException()
                    self.outch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.ouch4 = MutationsRejectedException()
                    self.ouch4.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('updateAndFlush_result')
        if self.outch1 is not None:
            oprot.writeFieldBegin('outch1', TType.STRUCT, 1)
            self.outch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch4 is not None:
            oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
            self.ouch4.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(updateAndFlush_result)
updateAndFlush_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'outch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
    (4, TType.STRUCT, 'ouch4', [MutationsRejectedException, None], None, ),  # 4
)


class createWriter_args(object):
    """
    Attributes:
     - login
     - tableName
     - opts

    """


    def __init__(self, login=None, tableName=None, opts=None,):
        self.login = login
        self.tableName = tableName
        self.opts = opts

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.opts = WriterOptions()
                    self.opts.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createWriter_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.opts is not None:
            oprot.writeFieldBegin('opts', TType.STRUCT, 3)
            self.opts.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createWriter_args)
createWriter_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'opts', [WriterOptions, None], None, ),  # 3
)


class createWriter_result(object):
    """
    Attributes:
     - success
     - outch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, outch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.outch1 = outch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.outch1 = AccumuloException()
                    self.outch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createWriter_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.outch1 is not None:
            oprot.writeFieldBegin('outch1', TType.STRUCT, 1)
            self.outch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createWriter_result)
createWriter_result.thrift_spec = (
    (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    (1, TType.STRUCT, 'outch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class update_args(object):
    """
    Attributes:
     - writer
     - cells

    """


    def __init__(self, writer=None, cells=None,):
        self.writer = writer
        self.cells = cells

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.writer = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.MAP:
                    self.cells = {}
                    (_ktype407, _vtype408, _size406) = iprot.readMapBegin()
                    for _i410 in range(_size406):
                        _key411 = iprot.readBinary()
                        _val412 = []
                        (_etype416, _size413) = iprot.readListBegin()
                        for _i417 in range(_size413):
                            _elem418 = ColumnUpdate()
                            _elem418.read(iprot)
                            _val412.append(_elem418)
                        iprot.readListEnd()
                        self.cells[_key411] = _val412
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('update_args')
        if self.writer is not None:
            oprot.writeFieldBegin('writer', TType.STRING, 1)
            oprot.writeString(self.writer.encode('utf-8') if sys.version_info[0] == 2 else self.writer)
            oprot.writeFieldEnd()
        if self.cells is not None:
            oprot.writeFieldBegin('cells', TType.MAP, 2)
            oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.cells))
            for kiter419, viter420 in self.cells.items():
                oprot.writeBinary(kiter419)
                oprot.writeListBegin(TType.STRUCT, len(viter420))
                for iter421 in viter420:
                    iter421.write(oprot)
                oprot.writeListEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(update_args)
update_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'writer', 'UTF8', None, ),  # 1
    (2, TType.MAP, 'cells', (TType.STRING, 'BINARY', TType.LIST, (TType.STRUCT, [ColumnUpdate, None], False), False), None, ),  # 2
)


class flush_args(object):
    """
    Attributes:
     - writer

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.writer = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('flush_args')
        if self.writer is not None:
            oprot.writeFieldBegin('writer', TType.STRING, 1)
            oprot.writeString(self.writer.encode('utf-8') if sys.version_info[0] == 2 else self.writer)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(flush_args)
flush_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'writer', 'UTF8', None, ),  # 1
)


class flush_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = UnknownWriter()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = MutationsRejectedException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('flush_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(flush_result)
flush_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [UnknownWriter, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [MutationsRejectedException, None], None, ),  # 2
)


class closeWriter_args(object):
    """
    Attributes:
     - writer

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.writer = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('closeWriter_args')
        if self.writer is not None:
            oprot.writeFieldBegin('writer', TType.STRING, 1)
            oprot.writeString(self.writer.encode('utf-8') if sys.version_info[0] == 2 else self.writer)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(closeWriter_args)
closeWriter_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'writer', 'UTF8', None, ),  # 1
)


class closeWriter_result(object):
    """
    Attributes:
     - ouch1
     - ouch2

    """


    def __init__(self, ouch1=None, ouch2=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = UnknownWriter()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = MutationsRejectedException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('closeWriter_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(closeWriter_result)
closeWriter_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [UnknownWriter, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [MutationsRejectedException, None], None, ),  # 2
)


class updateRowConditionally_args(object):
    """
    Attributes:
     - login
     - tableName
     - row
     - updates

    """


    def __init__(self, login=None, tableName=None, row=None, updates=None,):
        self.login = login
        self.tableName = tableName
        self.row = row
        self.updates = updates

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.row = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.updates = ConditionalUpdates()
                    self.updates.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('updateRowConditionally_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.row is not None:
            oprot.writeFieldBegin('row', TType.STRING, 3)
            oprot.writeBinary(self.row)
            oprot.writeFieldEnd()
        if self.updates is not None:
            oprot.writeFieldBegin('updates', TType.STRUCT, 4)
            self.updates.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(updateRowConditionally_args)
updateRowConditionally_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'row', 'BINARY', None, ),  # 3
    (4, TType.STRUCT, 'updates', [ConditionalUpdates, None], None, ),  # 4
)


class updateRowConditionally_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.I32:
                    self.success = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('updateRowConditionally_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.I32, 0)
            oprot.writeI32(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(updateRowConditionally_result)
updateRowConditionally_result.thrift_spec = (
    (0, TType.I32, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class createConditionalWriter_args(object):
    """
    Attributes:
     - login
     - tableName
     - options

    """


    def __init__(self, login=None, tableName=None, options=None,):
        self.login = login
        self.tableName = tableName
        self.options = options

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.tableName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.options = ConditionalWriterOptions()
                    self.options.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createConditionalWriter_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.tableName is not None:
            oprot.writeFieldBegin('tableName', TType.STRING, 2)
            oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
            oprot.writeFieldEnd()
        if self.options is not None:
            oprot.writeFieldBegin('options', TType.STRUCT, 3)
            self.options.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createConditionalWriter_args)
createConditionalWriter_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'tableName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'options', [ConditionalWriterOptions, None], None, ),  # 3
)


class createConditionalWriter_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = TableNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createConditionalWriter_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createConditionalWriter_result)
createConditionalWriter_result.thrift_spec = (
    (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [TableNotFoundException, None], None, ),  # 3
)


class updateRowsConditionally_args(object):
    """
    Attributes:
     - conditionalWriter
     - updates

    """


    def __init__(self, conditionalWriter=None, updates=None,):
        self.conditionalWriter = conditionalWriter
        self.updates = updates

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.conditionalWriter = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.MAP:
                    self.updates = {}
                    (_ktype423, _vtype424, _size422) = iprot.readMapBegin()
                    for _i426 in range(_size422):
                        _key427 = iprot.readBinary()
                        _val428 = ConditionalUpdates()
                        _val428.read(iprot)
                        self.updates[_key427] = _val428
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('updateRowsConditionally_args')
        if self.conditionalWriter is not None:
            oprot.writeFieldBegin('conditionalWriter', TType.STRING, 1)
            oprot.writeString(self.conditionalWriter.encode('utf-8') if sys.version_info[0] == 2 else self.conditionalWriter)
            oprot.writeFieldEnd()
        if self.updates is not None:
            oprot.writeFieldBegin('updates', TType.MAP, 2)
            oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.updates))
            for kiter429, viter430 in self.updates.items():
                oprot.writeBinary(kiter429)
                viter430.write(oprot)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(updateRowsConditionally_args)
updateRowsConditionally_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'conditionalWriter', 'UTF8', None, ),  # 1
    (2, TType.MAP, 'updates', (TType.STRING, 'BINARY', TType.STRUCT, [ConditionalUpdates, None], False), None, ),  # 2
)


class updateRowsConditionally_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype432, _vtype433, _size431) = iprot.readMapBegin()
                    for _i435 in range(_size431):
                        _key436 = iprot.readBinary()
                        _val437 = iprot.readI32()
                        self.success[_key436] = _val437
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = UnknownWriter()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = AccumuloSecurityException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('updateRowsConditionally_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
            for kiter438, viter439 in self.success.items():
                oprot.writeBinary(kiter438)
                oprot.writeI32(viter439)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(updateRowsConditionally_result)
updateRowsConditionally_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'BINARY', TType.I32, None, False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [UnknownWriter, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [AccumuloSecurityException, None], None, ),  # 3
)


class closeConditionalWriter_args(object):
    """
    Attributes:
     - conditionalWriter

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.conditionalWriter = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('closeConditionalWriter_args')
        if self.conditionalWriter is not None:
            oprot.writeFieldBegin('conditionalWriter', TType.STRING, 1)
            oprot.writeString(self.conditionalWriter.encode('utf-8') if sys.version_info[0] == 2 else self.conditionalWriter)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(closeConditionalWriter_args)
closeConditionalWriter_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'conditionalWriter', 'UTF8', None, ),  # 1
)


class closeConditionalWriter_result(object):


    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('closeConditionalWriter_result')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(closeConditionalWriter_result)
closeConditionalWriter_result.thrift_spec = (
)


class getRowRange_args(object):
    """
    Attributes:
     - row

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.row = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getRowRange_args')
        if self.row is not None:
            oprot.writeFieldBegin('row', TType.STRING, 1)
            oprot.writeBinary(self.row)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getRowRange_args)
getRowRange_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'row', 'BINARY', None, ),  # 1
)


class getRowRange_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = Range()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getRowRange_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getRowRange_result)
getRowRange_result.thrift_spec = (
    (0, TType.STRUCT, 'success', [Range, None], None, ),  # 0
)


class getFollowing_args(object):
    """
    Attributes:
     - key
     - part

    """


    def __init__(self, key=None, part=None,):
        self.key = key
        self.part = part

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.key = Key()
                    self.key.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.part = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getFollowing_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRUCT, 1)
            self.key.write(oprot)
            oprot.writeFieldEnd()
        if self.part is not None:
            oprot.writeFieldBegin('part', TType.I32, 2)
            oprot.writeI32(self.part)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getFollowing_args)
getFollowing_args.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'key', [Key, None], None, ),  # 1
    (2, TType.I32, 'part', None, None, ),  # 2
)


class getFollowing_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = Key()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getFollowing_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getFollowing_result)
getFollowing_result.thrift_spec = (
    (0, TType.STRUCT, 'success', [Key, None], None, ),  # 0
)


class systemNamespace_args(object):


    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('systemNamespace_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(systemNamespace_args)
systemNamespace_args.thrift_spec = (
)


class systemNamespace_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('systemNamespace_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(systemNamespace_result)
systemNamespace_result.thrift_spec = (
    (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
)


class defaultNamespace_args(object):


    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('defaultNamespace_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(defaultNamespace_args)
defaultNamespace_args.thrift_spec = (
)


class defaultNamespace_result(object):
    """
    Attributes:
     - success

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('defaultNamespace_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(defaultNamespace_result)
defaultNamespace_result.thrift_spec = (
    (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
)


class listNamespaces_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listNamespaces_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listNamespaces_args)
listNamespaces_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class listNamespaces_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype443, _size440) = iprot.readListBegin()
                    for _i444 in range(_size440):
                        _elem445 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success.append(_elem445)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listNamespaces_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRING, len(self.success))
            for iter446 in self.success:
                oprot.writeString(iter446.encode('utf-8') if sys.version_info[0] == 2 else iter446)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listNamespaces_result)
listNamespaces_result.thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class namespaceExists_args(object):
    """
    Attributes:
     - login
     - namespaceName

    """


    def __init__(self, login=None, namespaceName=None,):
        self.login = login
        self.namespaceName = namespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('namespaceExists_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(namespaceExists_args)
namespaceExists_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
)


class namespaceExists_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('namespaceExists_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(namespaceExists_result)
namespaceExists_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class createNamespace_args(object):
    """
    Attributes:
     - login
     - namespaceName

    """


    def __init__(self, login=None, namespaceName=None,):
        self.login = login
        self.namespaceName = namespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createNamespace_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createNamespace_args)
createNamespace_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
)


class createNamespace_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceExistsException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('createNamespace_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(createNamespace_result)
createNamespace_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceExistsException, None], None, ),  # 3
)


class deleteNamespace_args(object):
    """
    Attributes:
     - login
     - namespaceName

    """


    def __init__(self, login=None, namespaceName=None,):
        self.login = login
        self.namespaceName = namespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('deleteNamespace_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(deleteNamespace_args)
deleteNamespace_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
)


class deleteNamespace_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3
     - ouch4

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None, ouch4=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3
        self.ouch4 = ouch4

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.ouch4 = NamespaceNotEmptyException()
                    self.ouch4.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('deleteNamespace_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch4 is not None:
            oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
            self.ouch4.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(deleteNamespace_result)
deleteNamespace_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
    (4, TType.STRUCT, 'ouch4', [NamespaceNotEmptyException, None], None, ),  # 4
)


class renameNamespace_args(object):
    """
    Attributes:
     - login
     - oldNamespaceName
     - newNamespaceName

    """


    def __init__(self, login=None, oldNamespaceName=None, newNamespaceName=None,):
        self.login = login
        self.oldNamespaceName = oldNamespaceName
        self.newNamespaceName = newNamespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.oldNamespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.newNamespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('renameNamespace_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.oldNamespaceName is not None:
            oprot.writeFieldBegin('oldNamespaceName', TType.STRING, 2)
            oprot.writeString(self.oldNamespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.oldNamespaceName)
            oprot.writeFieldEnd()
        if self.newNamespaceName is not None:
            oprot.writeFieldBegin('newNamespaceName', TType.STRING, 3)
            oprot.writeString(self.newNamespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.newNamespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(renameNamespace_args)
renameNamespace_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'oldNamespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'newNamespaceName', 'UTF8', None, ),  # 3
)


class renameNamespace_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3
     - ouch4

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None, ouch4=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3
        self.ouch4 = ouch4

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.ouch4 = NamespaceExistsException()
                    self.ouch4.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('renameNamespace_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch4 is not None:
            oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
            self.ouch4.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(renameNamespace_result)
renameNamespace_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
    (4, TType.STRUCT, 'ouch4', [NamespaceExistsException, None], None, ),  # 4
)


class setNamespaceProperty_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - property
     - value

    """


    def __init__(self, login=None, namespaceName=None, property=None, value=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.property = property
        self.value = value

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.property = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.value = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setNamespaceProperty_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.property is not None:
            oprot.writeFieldBegin('property', TType.STRING, 3)
            oprot.writeString(self.property.encode('utf-8') if sys.version_info[0] == 2 else self.property)
            oprot.writeFieldEnd()
        if self.value is not None:
            oprot.writeFieldBegin('value', TType.STRING, 4)
            oprot.writeString(self.value.encode('utf-8') if sys.version_info[0] == 2 else self.value)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setNamespaceProperty_args)
setNamespaceProperty_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'property', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'value', 'UTF8', None, ),  # 4
)


class setNamespaceProperty_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('setNamespaceProperty_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(setNamespaceProperty_result)
setNamespaceProperty_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class removeNamespaceProperty_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - property

    """


    def __init__(self, login=None, namespaceName=None, property=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.property = property

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.property = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeNamespaceProperty_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.property is not None:
            oprot.writeFieldBegin('property', TType.STRING, 3)
            oprot.writeString(self.property.encode('utf-8') if sys.version_info[0] == 2 else self.property)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeNamespaceProperty_args)
removeNamespaceProperty_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'property', 'UTF8', None, ),  # 3
)


class removeNamespaceProperty_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeNamespaceProperty_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeNamespaceProperty_result)
removeNamespaceProperty_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class getNamespaceProperties_args(object):
    """
    Attributes:
     - login
     - namespaceName

    """


    def __init__(self, login=None, namespaceName=None,):
        self.login = login
        self.namespaceName = namespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getNamespaceProperties_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getNamespaceProperties_args)
getNamespaceProperties_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
)


class getNamespaceProperties_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype448, _vtype449, _size447) = iprot.readMapBegin()
                    for _i451 in range(_size447):
                        _key452 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val453 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key452] = _val453
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getNamespaceProperties_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter454, viter455 in self.success.items():
                oprot.writeString(kiter454.encode('utf-8') if sys.version_info[0] == 2 else kiter454)
                oprot.writeString(viter455.encode('utf-8') if sys.version_info[0] == 2 else viter455)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getNamespaceProperties_result)
getNamespaceProperties_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class namespaceIdMap_args(object):
    """
    Attributes:
     - login

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('namespaceIdMap_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(namespaceIdMap_args)
namespaceIdMap_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
)


class namespaceIdMap_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype457, _vtype458, _size456) = iprot.readMapBegin()
                    for _i460 in range(_size456):
                        _key461 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val462 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key461] = _val462
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('namespaceIdMap_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter463, viter464 in self.success.items():
                oprot.writeString(kiter463.encode('utf-8') if sys.version_info[0] == 2 else kiter463)
                oprot.writeString(viter464.encode('utf-8') if sys.version_info[0] == 2 else viter464)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(namespaceIdMap_result)
namespaceIdMap_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
)


class attachNamespaceIterator_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - setting
     - scopes

    """


    def __init__(self, login=None, namespaceName=None, setting=None, scopes=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.setting = setting
        self.scopes = scopes

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.setting = IteratorSetting()
                    self.setting.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.SET:
                    self.scopes = set()
                    (_etype468, _size465) = iprot.readSetBegin()
                    for _i469 in range(_size465):
                        _elem470 = iprot.readI32()
                        self.scopes.add(_elem470)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('attachNamespaceIterator_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.setting is not None:
            oprot.writeFieldBegin('setting', TType.STRUCT, 3)
            self.setting.write(oprot)
            oprot.writeFieldEnd()
        if self.scopes is not None:
            oprot.writeFieldBegin('scopes', TType.SET, 4)
            oprot.writeSetBegin(TType.I32, len(self.scopes))
            for iter471 in self.scopes:
                oprot.writeI32(iter471)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(attachNamespaceIterator_args)
attachNamespaceIterator_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'setting', [IteratorSetting, None], None, ),  # 3
    (4, TType.SET, 'scopes', (TType.I32, None, False), None, ),  # 4
)


class attachNamespaceIterator_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('attachNamespaceIterator_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(attachNamespaceIterator_result)
attachNamespaceIterator_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class removeNamespaceIterator_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - name
     - scopes

    """


    def __init__(self, login=None, namespaceName=None, name=None, scopes=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.name = name
        self.scopes = scopes

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.name = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.SET:
                    self.scopes = set()
                    (_etype475, _size472) = iprot.readSetBegin()
                    for _i476 in range(_size472):
                        _elem477 = iprot.readI32()
                        self.scopes.add(_elem477)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeNamespaceIterator_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.name is not None:
            oprot.writeFieldBegin('name', TType.STRING, 3)
            oprot.writeString(self.name.encode('utf-8') if sys.version_info[0] == 2 else self.name)
            oprot.writeFieldEnd()
        if self.scopes is not None:
            oprot.writeFieldBegin('scopes', TType.SET, 4)
            oprot.writeSetBegin(TType.I32, len(self.scopes))
            for iter478 in self.scopes:
                oprot.writeI32(iter478)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeNamespaceIterator_args)
removeNamespaceIterator_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'name', 'UTF8', None, ),  # 3
    (4, TType.SET, 'scopes', (TType.I32, None, False), None, ),  # 4
)


class removeNamespaceIterator_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeNamespaceIterator_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeNamespaceIterator_result)
removeNamespaceIterator_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class getNamespaceIteratorSetting_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - name
     - scope

    """


    def __init__(self, login=None, namespaceName=None, name=None, scope=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.name = name
        self.scope = scope

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.name = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.scope = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getNamespaceIteratorSetting_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.name is not None:
            oprot.writeFieldBegin('name', TType.STRING, 3)
            oprot.writeString(self.name.encode('utf-8') if sys.version_info[0] == 2 else self.name)
            oprot.writeFieldEnd()
        if self.scope is not None:
            oprot.writeFieldBegin('scope', TType.I32, 4)
            oprot.writeI32(self.scope)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getNamespaceIteratorSetting_args)
getNamespaceIteratorSetting_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'name', 'UTF8', None, ),  # 3
    (4, TType.I32, 'scope', None, None, ),  # 4
)


class getNamespaceIteratorSetting_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = IteratorSetting()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('getNamespaceIteratorSetting_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(getNamespaceIteratorSetting_result)
getNamespaceIteratorSetting_result.thrift_spec = (
    (0, TType.STRUCT, 'success', [IteratorSetting, None], None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class listNamespaceIterators_args(object):
    """
    Attributes:
     - login
     - namespaceName

    """


    def __init__(self, login=None, namespaceName=None,):
        self.login = login
        self.namespaceName = namespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listNamespaceIterators_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listNamespaceIterators_args)
listNamespaceIterators_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
)


class listNamespaceIterators_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype480, _vtype481, _size479) = iprot.readMapBegin()
                    for _i483 in range(_size479):
                        _key484 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val485 = set()
                        (_etype489, _size486) = iprot.readSetBegin()
                        for _i490 in range(_size486):
                            _elem491 = iprot.readI32()
                            _val485.add(_elem491)
                        iprot.readSetEnd()
                        self.success[_key484] = _val485
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listNamespaceIterators_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.SET, len(self.success))
            for kiter492, viter493 in self.success.items():
                oprot.writeString(kiter492.encode('utf-8') if sys.version_info[0] == 2 else kiter492)
                oprot.writeSetBegin(TType.I32, len(viter493))
                for iter494 in viter493:
                    oprot.writeI32(iter494)
                oprot.writeSetEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listNamespaceIterators_result)
listNamespaceIterators_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.SET, (TType.I32, None, False), False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class checkNamespaceIteratorConflicts_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - setting
     - scopes

    """


    def __init__(self, login=None, namespaceName=None, setting=None, scopes=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.setting = setting
        self.scopes = scopes

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.setting = IteratorSetting()
                    self.setting.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.SET:
                    self.scopes = set()
                    (_etype498, _size495) = iprot.readSetBegin()
                    for _i499 in range(_size495):
                        _elem500 = iprot.readI32()
                        self.scopes.add(_elem500)
                    iprot.readSetEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('checkNamespaceIteratorConflicts_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.setting is not None:
            oprot.writeFieldBegin('setting', TType.STRUCT, 3)
            self.setting.write(oprot)
            oprot.writeFieldEnd()
        if self.scopes is not None:
            oprot.writeFieldBegin('scopes', TType.SET, 4)
            oprot.writeSetBegin(TType.I32, len(self.scopes))
            for iter501 in self.scopes:
                oprot.writeI32(iter501)
            oprot.writeSetEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(checkNamespaceIteratorConflicts_args)
checkNamespaceIteratorConflicts_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRUCT, 'setting', [IteratorSetting, None], None, ),  # 3
    (4, TType.SET, 'scopes', (TType.I32, None, False), None, ),  # 4
)


class checkNamespaceIteratorConflicts_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('checkNamespaceIteratorConflicts_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(checkNamespaceIteratorConflicts_result)
checkNamespaceIteratorConflicts_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class addNamespaceConstraint_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - constraintClassName

    """


    def __init__(self, login=None, namespaceName=None, constraintClassName=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.constraintClassName = constraintClassName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.constraintClassName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('addNamespaceConstraint_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.constraintClassName is not None:
            oprot.writeFieldBegin('constraintClassName', TType.STRING, 3)
            oprot.writeString(self.constraintClassName.encode('utf-8') if sys.version_info[0] == 2 else self.constraintClassName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(addNamespaceConstraint_args)
addNamespaceConstraint_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'constraintClassName', 'UTF8', None, ),  # 3
)


class addNamespaceConstraint_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.I32:
                    self.success = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('addNamespaceConstraint_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.I32, 0)
            oprot.writeI32(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(addNamespaceConstraint_result)
addNamespaceConstraint_result.thrift_spec = (
    (0, TType.I32, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class removeNamespaceConstraint_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - id

    """


    def __init__(self, login=None, namespaceName=None, id=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.id = id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeNamespaceConstraint_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.id is not None:
            oprot.writeFieldBegin('id', TType.I32, 3)
            oprot.writeI32(self.id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeNamespaceConstraint_args)
removeNamespaceConstraint_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.I32, 'id', None, None, ),  # 3
)


class removeNamespaceConstraint_result(object):
    """
    Attributes:
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('removeNamespaceConstraint_result')
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(removeNamespaceConstraint_result)
removeNamespaceConstraint_result.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class listNamespaceConstraints_args(object):
    """
    Attributes:
     - login
     - namespaceName

    """


    def __init__(self, login=None, namespaceName=None,):
        self.login = login
        self.namespaceName = namespaceName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listNamespaceConstraints_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listNamespaceConstraints_args)
listNamespaceConstraints_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
)


class listNamespaceConstraints_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype503, _vtype504, _size502) = iprot.readMapBegin()
                    for _i506 in range(_size502):
                        _key507 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val508 = iprot.readI32()
                        self.success[_key507] = _val508
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('listNamespaceConstraints_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
            for kiter509, viter510 in self.success.items():
                oprot.writeString(kiter509.encode('utf-8') if sys.version_info[0] == 2 else kiter509)
                oprot.writeI32(viter510)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(listNamespaceConstraints_result)
listNamespaceConstraints_result.thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.I32, None, False), None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)


class testNamespaceClassLoad_args(object):
    """
    Attributes:
     - login
     - namespaceName
     - className
     - asTypeName

    """


    def __init__(self, login=None, namespaceName=None, className=None, asTypeName=None,):
        self.login = login
        self.namespaceName = namespaceName
        self.className = className
        self.asTypeName = asTypeName

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.login = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.namespaceName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.className = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.asTypeName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('testNamespaceClassLoad_args')
        if self.login is not None:
            oprot.writeFieldBegin('login', TType.STRING, 1)
            oprot.writeBinary(self.login)
            oprot.writeFieldEnd()
        if self.namespaceName is not None:
            oprot.writeFieldBegin('namespaceName', TType.STRING, 2)
            oprot.writeString(self.namespaceName.encode('utf-8') if sys.version_info[0] == 2 else self.namespaceName)
            oprot.writeFieldEnd()
        if self.className is not None:
            oprot.writeFieldBegin('className', TType.STRING, 3)
            oprot.writeString(self.className.encode('utf-8') if sys.version_info[0] == 2 else self.className)
            oprot.writeFieldEnd()
        if self.asTypeName is not None:
            oprot.writeFieldBegin('asTypeName', TType.STRING, 4)
            oprot.writeString(self.asTypeName.encode('utf-8') if sys.version_info[0] == 2 else self.asTypeName)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(testNamespaceClassLoad_args)
testNamespaceClassLoad_args.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'login', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'namespaceName', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'className', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'asTypeName', 'UTF8', None, ),  # 4
)


class testNamespaceClassLoad_result(object):
    """
    Attributes:
     - success
     - ouch1
     - ouch2
     - ouch3

    """


    def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
        self.success = success
        self.ouch1 = ouch1
        self.ouch2 = ouch2
        self.ouch3 = ouch3

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ouch1 = AccumuloException()
                    self.ouch1.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ouch2 = AccumuloSecurityException()
                    self.ouch2.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ouch3 = NamespaceNotFoundException()
                    self.ouch3.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('testNamespaceClassLoad_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 0)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.ouch1 is not None:
            oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
            self.ouch1.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch2 is not None:
            oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
            self.ouch2.write(oprot)
            oprot.writeFieldEnd()
        if self.ouch3 is not None:
            oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
            self.ouch3.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(testNamespaceClassLoad_result)
testNamespaceClassLoad_result.thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ),  # 0
    (1, TType.STRUCT, 'ouch1', [AccumuloException, None], None, ),  # 1
    (2, TType.STRUCT, 'ouch2', [AccumuloSecurityException, None], None, ),  # 2
    (3, TType.STRUCT, 'ouch3', [NamespaceNotFoundException, None], None, ),  # 3
)
fix_spec(all_structs)
del all_structs