text: #
  # Autogenerated by Thrift Compiler (0.10.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
  import sys
  import logging
  from .ttypes import *
  from thrift.Thrift import TProcessor
  from thrift.transport import TTransport
  
  
  class Iface(object):
      def notify(self, event):
          """
          Parameters:
           - event
          """
          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 notify(self, event):
          """
          Parameters:
           - event
          """
          self.send_notify(event)
          self.recv_notify()
  
      def send_notify(self, event):
          self._oprot.writeMessageBegin('notify', TMessageType.CALL, self._seqid)
          args = notify_args()
          args.event = event
          args.write(self._oprot)
          self._oprot.writeMessageEnd()
          self._oprot.trans.flush()
  
      def recv_notify(self):
          iprot = self._iprot
          (fname, mtype, rseqid) = iprot.readMessageBegin()
          if mtype == TMessageType.EXCEPTION:
              x = TApplicationException()
              x.read(iprot)
              iprot.readMessageEnd()
              raise x
          result = notify_result()
          result.read(iprot)
          iprot.readMessageEnd()
          if result.e is not None:
              raise result.e
          return
  
  
  class Processor(Iface, TProcessor):
      def __init__(self, handler):
          self._handler = handler
          self._processMap = {}
          self._processMap["notify"] = Processor.process_notify
  
      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_notify(self, seqid, iprot, oprot):
          args = notify_args()
          args.read(iprot)
          iprot.readMessageEnd()
          result = notify_result()
          try:
              self._handler.notify(args.event)
              msg_type = TMessageType.REPLY
          except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
              raise
          except UniversalNotificationServiceException as e:
              msg_type = TMessageType.REPLY
              result.e = e
          except Exception as ex:
              msg_type = TMessageType.EXCEPTION
              logging.exception(ex)
              result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
          oprot.writeMessageBegin("notify", msg_type, seqid)
          result.write(oprot)
          oprot.writeMessageEnd()
          oprot.trans.flush()
  
  # HELPER FUNCTIONS AND STRUCTURES
  
  
  class notify_args(object):
      """
      Attributes:
       - event
      """
  
      thrift_spec = (
          None,  # 0
          None,  # 1
          (2, TType.STRUCT, 'event', (GlobalEvent, GlobalEvent.thrift_spec), None, ),  # 2
      )
  
      def __init__(self, event=None,):
          self.event = event
  
      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 == 2:
                  if ftype == TType.STRUCT:
                      self.event = GlobalEvent()
                      self.event.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('notify_args')
          if self.event is not None:
              oprot.writeFieldBegin('event', TType.STRUCT, 2)
              self.event.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)
  
  
  class notify_result(object):
      """
      Attributes:
       - e
      """
  
      thrift_spec = (
          None,  # 0
          (1, TType.STRUCT, 'e', (UniversalNotificationServiceException, UniversalNotificationServiceException.thrift_spec), None, ),  # 1
      )
  
      def __init__(self, e=None,):
          self.e = e
  
      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.e = UniversalNotificationServiceException()
                      self.e.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('notify_result')
          if self.e is not None:
              oprot.writeFieldBegin('e', TType.STRUCT, 1)
              self.e.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)
  