def UnRegisterObjectChangeHandler(self, callback):
     try:
         del self.objectChangeHandlers[callback]
     except ReferenceError as e:
         sys.exc_clear()
     except KeyError as e:
         sys.exc_clear()

    def nb_write(fd, buf):
        """
        Write some number of bytes from buffer *buf* to file
        descriptor *fd*. Return the number of bytes written, which may
        be less than the length of *buf*.

        The file descriptor must be in non-blocking mode.
        """
        hub = None
        event = None
        try:
            while 1:
                try:
                    result = _write(fd, buf)
                    return result
                except OSError as e:
                    if e.errno not in ignored_errors:
                        raise
                    if not PY3:
                        sys.exc_clear()
                if hub is None:
                    hub = get_hub()
                    event = hub.loop.io(fd, 2)
                hub.wait(event)
        finally:
            if event is not None:
                event.close()
                event = None
                hub = None

 def send(self, data, flags=0, timeout=timeout_default):
     sock = self._sock
     if timeout is timeout_default:
         timeout = self.timeout
     try:
         return sock.send(data, flags)
     except error:
         ex = sys.exc_info()[1]
         if ex.args[0] != EWOULDBLOCK or timeout == 0.0:
             raise
         sys.exc_clear()
         try:
             self._wait(self._write_event)
         except error:
             ex = sys.exc_info()[1]
             if ex.args[0] == EBADF:
                 return 0
             raise
         try:
             return sock.send(data, flags)
         except error:
             ex2 = sys.exc_info()[1]
             if ex2.args[0] == EWOULDBLOCK:
                 return 0
             raise

    def _job_store_checker(self):
        while not self._stopped:
            LOG.debug(
                "Starting Scheduler Job Store checker [scheduler=%s]...", self
            )

            try:
                self._process_store_jobs()
            except Exception:
                LOG.exception(
                    "Scheduler failed to process delayed calls"
                    " due to unexpected exception."
                )

                # For some mysterious reason (probably eventlet related)
                # the exception is not cleared from the context automatically.
                # This results in subsequent log.warning calls to show invalid
                # info.
                if sys.version_info < (3,):
                    sys.exc_clear()

            eventlet.sleep(
                self._fixed_delay +
                random.Random().randint(0, self._random_delay * 1000) * 0.001
            )

 def __iowait(self, io_func, *args, **kwargs):
     timeout = self._sock.gettimeout() or 0.1
     fd = self._sock.fileno()
     time_start = time.time()
     while True:
         try:
             return io_func(*args, **kwargs)
         except (OpenSSL.SSL.WantReadError, OpenSSL.SSL.WantX509LookupError):
             sys.exc_clear()
             _, _, errors = select.select([fd], [], [fd], timeout)
             if errors:
                 raise
             time_now = time.time()
             if time_now - time_start > timeout:
                 break
         except OpenSSL.SSL.WantWriteError:
             sys.exc_clear()
             _, _, errors = select.select([], [fd], [fd], timeout)
             if errors:
                 raise
             time_now = time.time()
             if time_now - time_start > timeout:
                 break
         except Exception as e:
             #xlog.exception("e:%r", e)
             raise e

  def _writePhase(self, args):
    # defaults
    q = {
       'fname' : 'phase.xml',
      'sensor' : 'MSI',
       'bands' : '1, 2, 3, 4, 5, 6, 7, 8, 9, 10'
    }
    for a in args:
      q[a] = args[a]
    pdata = '''
<?xml version="1.0" encoding="UTF-8"?>
<DartFile version="5.4.3">
    <Phase expertMode="0">
        <DartInputParameters calculatorMethod="0">
            <nodefluxtracking gaussSiedelAcceleratingTechnique="1" numberOfIteration="4"/>
            <SpectralDomainTir temperatureMode="0">
                <Atmosphere_1 SKYLForTemperatureAssignation="0.0"/>
            </SpectralDomainTir>
            <SpectralIntervals>
                <SpectralIntervalsProperties bandNumber="0"
                    deltaLambda="0.005493" meanLambda="0.56925"
                    radiativeBudgetProducts="0" spectralDartMode="0"/>
            </SpectralIntervals>
            <ExpertModeZone albedoThreshold="1.0E-5"
                illuminationRepartitionMode="2"
                lightPropagationThreshold="1.0E-4"
                nbRandomPointsPerInteceptionAtmosphere="10"
                nbSubSubcenterTurbidEmission="40"
                nbSubcenterIllumination="10" nbSubcenterVolume="2"/>
            <nodeIlluminationMode illuminationMode="0" irradianceMode="1">
                <irradianceDatabaseNode irradianceDatabase="TOASolarIrradiance.txt"/>
            </nodeIlluminationMode>
        </DartInputParameters>
        <DartProduct>
            <dartModuleProducts allIterationsProducts="0"
                brfProducts="1" lidarProducts="0"
                order1Products="0" radiativeBudgetProducts="0">
                <BrfProductsProperties brfProduct="1" extrapolation="1"
                    horizontalOversampling="1" image="1"
                    luminanceProducts="1" maximalThetaImages="0.1"
                    nb_scene="1" outputHapkeFile="0" projection="1"
                    sensorOversampling="1" sensorPlaneprojection="0">
                    <ExpertModeZone_Etalement etalement="2"/>
                    <ExpertModeZone_maskProjection mask_projection="0"/>
                </BrfProductsProperties>
            </dartModuleProducts>
            <maketModuleProducts MNEProducts="0" areaMaketProducts="0"
                coverRateProducts="0" laiProducts="0"/>
        </DartProduct>
    </Phase>
</DartFile>
'''[1:-1] % ()
    try:
      VLAB.copyfile(q['fname'], '%s_%s' % (q['fname'], time.time()))
    except Exception:
      if not sys.platform.startswith('java'):
        sys.exc_clear()
    fp = open(q['fname'], 'w')
    fp.write(pdata)
    fp.close()

    def close(self, reason = None):
        try:
            self.socket.close()
        except socket.error as e:
            sys.exc_clear()

        self.socket = None

    def Reprocess(self, items, activeShipID):
        fromLocation = self._GetFromLocationID(items)
        itemIDs = []
        try:
            for item in items:
                itemID = item.itemID
                self._CheckIsRefiningShip(activeShipID, itemID)
                if not self._IsInSameLocation(fromLocation, item):
                    continue
                self._LockItem(item, itemIDs)

            try:
                if len(itemIDs):
                    ownerID, flag = session.charid, invconst.flagHangar
                    skipChecks = []
                    while True:
                        try:
                            self._DoReprocess(itemIDs, ownerID, fromLocation, flag, skipChecks)
                        except UserError as e:
                            sys.exc_clear()
                            if self.AskToContinue(e):
                                skipChecks.append(e.msg)
                                continue

                        break

            except:
                sys.exc_clear()

        finally:
            self._UnlockItems(itemIDs)

def _actual_start():
  """Another layer in the starting stack."""
  # Get raw traceback
  tb = None
  try:
    raise ZeroDivisionError('')
  except ZeroDivisionError:
    tb = sys.exc_info()[2]
  assert tb

  # Look at previous stack frame's previous stack frame (previous
  # frame is run() or start(); the frame before that should be the
  # frame of the original caller, which should be __main__ or appcommands
  prev_prev_frame = tb.tb_frame.f_back.f_back
  if not prev_prev_frame:
    return
  prev_prev_name = prev_prev_frame.f_globals.get('__name__', None)
  if (prev_prev_name != '__main__'
      and not prev_prev_name.endswith('.appcommands')):
    return
  # just in case there's non-trivial stuff happening in __main__
  del tb
  sys.exc_clear()

  try:
    really_start()
  except SystemExit, e:
    raise

	def run(self):
		self.logger.info("Starting Snort alert processor main thread...")
		
		try:
			os.setuid(int(self.options.uid))
		except OSError:
			self.logger.error("Could not change user for Snort alert processor")
			return
		
		try:
			os.remove(self.options.unsock)
		except OSError:
			pass
		
		self.queue_processor.start()
		
		self.logger.debug("Binding UNIX socket for Snort alerts at " + self.options.unsock)
		
		try:
			self.server = SnortAlertServer(self.logger, self.options.unsock, SnortAlertHandler)
			self.server.serve_forever()
		except:
			self.logger.error("Could not start Snort processor (detailed log message follows):")
			self.logger.error(sys.exc_info())
			sys.exc_clear()
			self.stop()

def NameValueListToDict(name_value_list):
  """
  Takes an array of strings of the form 'NAME=VALUE' and creates a dictionary
  of the pairs. If a string is simply NAME, then the value in the dictionary
  is set to True. If VALUE can be converted to a boolean or integer, it is.
  """
  result = {}
  for item in name_value_list:
    tokens = item.split('=', 1)
    if len(tokens) == 2:
      token_value = tokens[1]
      if token_value.lower() == 'true':
        token_value = True
      elif token_value.lower() == 'false':
        token_value = False
      else:
        # If we can make it an int, use that, otherwise, use the string.
        try:
          token_value = int(token_value)
        except ValueError:
          sys.exc_clear()
      # Set the variable to the supplied value.
      result[tokens[0]] = token_value
    else:
      # No value supplied, treat it as a boolean and set it.
      result[tokens[0]] = True
  return result

 def send(self,raw_data,retry_timeout=1):
     """ Writes raw outgoing data. Blocks until done.
         If supplied data is unicode string, encodes it to utf-8 before send."""
     if type(raw_data)==type(u''): raw_data = raw_data.encode('utf-8')
     elif type(raw_data)<>type(''): raw_data = ustr(raw_data).encode('utf-8')
     try:
         sent = 0
         while not sent:
             try:
                 self._send(raw_data)
                 sent = 1
             except socket.sslerror, e:
                 if e[0]==socket.SSL_ERROR_WANT_READ:
                     sys.exc_clear()
                     self.DEBUG("SSL_WANT_READ while sending data, wating to retry",'warn')
                     select.select([self._sock],[],[],retry_timeout)
                     continue
                 if e[0]==socket.SSL_ERROR_WANT_WRITE:
                     sys.exc_clear()
                     self.DEBUG("SSL_WANT_WRITE while sending data, waiting to retry",'warn')
                     select.select([],[self._sock],[],retry_timeout)
                     continue
                 raise
         # Avoid printing messages that are empty keepalive packets.
         if raw_data.strip():
             self.DEBUG(raw_data,'sent')
             if hasattr(self._owner, 'Dispatcher'): # HTTPPROXYsocket will send data before we have a Dispatcher
                 self._owner.Dispatcher.Event('', DATA_SENT, raw_data)

  def testMemoryIsFreed(self):
    # Note: we use `set` values for components and metadata because we need
    # to construct weakrefs to them.  Other builtin types, such as `list` and
    # `tuple`, do not support weakrefs.
    ct1 = CT(set([1, 2]), set(['no', 'leaks']))
    ct2 = CT(set([3, 4]), set(['no', 'leaks']))
    ct3 = CT(set([5, 6]), set(['other', 'metadata']))

    # Note: map_structure exercises flatten, pack_sequence_as, and
    # assert_same_structure.
    func = lambda x, y: x | y
    ct4 = nest.map_structure(func, ct1, ct2, expand_composites=True)

    # Check that the exception-raising path in assert_same_structure
    # doesn't leak any objects.
    with self.assertRaisesRegexp(ValueError,
                                 ".*don't have the same nested structure.*"):
      nest.map_structure(func, ct2, ct3, expand_composites=True)
    if hasattr(sys, 'exc_clear'):
      sys.exc_clear()  # Remove any references in exception stack traces.

    refs = []
    for ct in [ct1, ct2, ct3, ct4]:
      refs.append(weakref.ref(ct))
      refs.append(weakref.ref(ct.components))
      refs.append(weakref.ref(ct.metadata))
    del ct  # pylint: disable=undefined-loop-variable

    for ref in refs:
      self.assertIsNotNone(ref())

    del ct1, ct2, ct3, ct4
    gc.collect()
    for ref in refs:
      self.assertIsNone(ref())

def _chunk_read(response, chunk_size=32768, report_hook=None, filename=None):
    file_data = []
    if response.info().has_key('Content-Length'):
        total_size = response.info().getheader('Content-Length').strip()
        total_size = int(total_size)
    else:
        # No size
        total_size = None
        if report_hook:
            print '* Warning: No total file size available.'
    if (filename == None) and (response.info().has_key('Content-Disposition')):
        # If the response has Content-Disposition, we take file name from it
        try:
            filename = response.info()['Content-Disposition'].split('filename=')[1]
            if filename[0] == '"' or filename[0] == "'":
                filename = filename[1:-1]
        except Exception:
            sys.exc_clear()
            filename = 'output'
    if (filename == None):
        if report_hook:
            print "* No detected filename, using 'output'"
        filename = 'output'
    bytes_so_far = 0
    while True:
        chunk = response.read(chunk_size)
        bytes_so_far += len(chunk)
        if not chunk:
            break
        else:
            file_data.append(chunk)
        report_hook(bytes_so_far, chunk_size, total_size)
    return (file_data, filename)

    def _request(self, url, data=None, referrer='http://google.com/', ajax=False):
        handlers = [self.cookie_handler]
        if self.proxy:
            handlers.append(self.proxy)
        opener = urllib.request.build_opener(*handlers)
        self._add_headers(opener, referrer, ajax)

        html = ''
        try:
            req = urllib.request.Request(url, data)
            res = opener.open(req, timeout=30)
            html = res.read()
        except Exception as e:
            print("Something went terribly wrong {e}".format(e=e))
            return False, {}, {}

        headers = res.info()
        if ('Content-Encoding' in list(headers.keys()) and headers['Content-Encoding'] == 'gzip') or \
                ('content-encoding' in list(headers.keys()) and headers['content-encoding'] == 'gzip'):
            data = io.BytesIO(html)
            gzipper = gzip.GzipFile(fileobj=data)
            try:
                html_unzipped = gzipper.read()
            except Exception:
                sys.exc_clear()
            else:
                html = html_unzipped

        cookies = {cookie.name: cookie.value for cookie in self.cookie_jar}
        self.csrf_token = cookies['csrftoken']

        return html, headers, cookies

    def iter_messages(self):
        """ Yields tuples of (watcher, subtopic, stat)"""
        recv = self.pubsub_socket.recv_multipart
        with self:
            while True:
                try:
                    events = dict(self.poller.poll(self.timeout * 1000))
                except zmq.ZMQError as e:
                    if e.errno == errno.EINTR:
                        continue
                    raise

                if len(events) == 0:
                    continue

                try:
                    topic, stat = recv()
                except zmq.core.error.ZMQError as e:
                    if e.errno != errno.EINTR:
                        raise
                    else:
                        try:
                            sys.exc_clear()
                        except Exception:
                            pass
                        continue

                topic = s(topic).split('.')
                if len(topic) == 3:
                    __, watcher, subtopic = topic
                    yield watcher, subtopic, json.loads(stat)
                elif len(topic) == 2:
                    __, watcher = topic
                    yield watcher, None, json.loads(stat)

  def _writeDirections(self, args):
    # defaults
    q = {
   'fname' : 'directions.xml',
      'sz' : '27.1',
      'sa' : '32.6'
    }
    for a in args:
      q[a] = args[a]
    ddata = '''
<DartFile version="5.4.3">
    <Directions exactDate="2" ifCosWeighted="1" numberOfPropagationDirections="100">
        <ExpertModeZone numberOfAngularSector="10" numberOfLayers="0"/>
        <SunViewingAngles sunViewingAzimuthAngle="%s" sunViewingZenithAngle="%s"/>
        <HotSpotProperties hotSpotParallelPlane="0"
            hotSpotPerpendicularPlane="0" oversampleDownwardRegion="0" oversampleUpwardRegion="0"/>
        <AddedDirections directionType="0" ifSquareShape="1" imageDirection="1">
            <ZenithAzimuth directionAzimuthalAngle="207.2" directionZenithalAngle="5.75"/>
            <Square widthDefinition="0">
                <DefineOmega omega="0.0010"/>
            </Square>
        </AddedDirections>
    </Directions>
</DartFile>
'''[1:-1] % (q['sa'], q['sz'])
    try:
      VLAB.copyfile(q['fname'], '%s_%s' % (q['fname'], time.time()))
    except Exception:
      if not sys.platform.startswith('java'):
        sys.exc_clear()
    fp = open(q['fname'], 'w')
    fp.write(ddata)
    fp.close()

 def send(self, data, flags=0, timeout=timeout_default):
     if timeout is timeout_default:
         timeout = self.timeout
     if self._sslobj:
         if flags != 0:
             raise ValueError(
                 "non-zero flags not allowed in calls to send() on %s" %
                 self.__class__)
         while True:
             try:
                 v = self._sslobj.write(data)
             except SSLError as x:
                 if x.args[0] == SSL_ERROR_WANT_READ:
                     if self.timeout == 0.0:
                         return 0
                     sys.exc_clear()
                     self._wait(self._read_event)
                 elif x.args[0] == SSL_ERROR_WANT_WRITE:
                     if self.timeout == 0.0:
                         return 0
                     sys.exc_clear()
                     self._wait(self._write_event)
                 else:
                     raise
             else:
                 return v
     else:
         return socket.send(self, data, flags, timeout)

    def handle(self, conn, _address): # pylint: disable=method-hidden
        """
        Interact with one remote user.

        .. versionchanged:: 1.1b2 Each connection gets its own
            ``locals`` dictionary. Previously they were shared in a
            potentially unsafe manner.
        """
        fobj = conn.makefile(mode="rw")
        fobj = _fileobject(conn, fobj, self.stderr)
        getcurrent()._fileobj = fobj

        getcurrent().switch_in()
        try:
            console = InteractiveConsole(self._create_interactive_locals())
            if sys.version_info[:3] >= (3, 6, 0):
                # Beginning in 3.6, the console likes to print "now exiting <class>"
                # but probably our socket is already closed, so this just causes problems.
                console.interact(banner=self.banner, exitmsg='') # pylint:disable=unexpected-keyword-arg
            else:
                console.interact(banner=self.banner)
        except SystemExit:  # raised by quit()
            if hasattr(sys, 'exc_clear'): # py2
                sys.exc_clear()
        finally:
            conn.close()
            fobj.close()

 def recv_into(self, buffer, nbytes=None, flags=0):
     if buffer and (nbytes is None):
         nbytes = len(buffer)
     elif nbytes is None:
         nbytes = 1024
     if self._sslobj:
         if flags != 0:
             raise ValueError(
                 "non-zero flags not allowed in calls to recv_into() on %s" %
                 self.__class__)
         while True:
             try:
                 tmp_buffer = self.read(nbytes)
                 v = len(tmp_buffer)
                 buffer[:v] = tmp_buffer
                 return v
             except SSLError as x:
                 if x.args[0] == SSL_ERROR_WANT_READ:
                     if self.timeout == 0.0:
                         raise
                     sys.exc_clear()
                     self._wait(self._read_event)
                     continue
                 else:
                     raise
     else:
         return socket.recv_into(self, buffer, nbytes, flags)