Stop tracing from here
335178
def stop_trace(self, frame=None):
        """"""
        self.tracing = False
        self.full = False
        frame = frame or sys._getframe().f_back
        while frame:
            del frame.f_trace
            frame = frame.f_back
        sys.settrace(None)
        log.info('Stopping trace')
686172
public final void stopTrack(Flag track) {
      setTrack(track, false);
      if (!trackStateTransfer && !trackXSiteStateTransfer) {
         if (trace) {
            log.tracef("Tracking is disabled. Clear tracker: %s", tracker);
         }
         tracker.clear();
      } else {
         for (Iterator<Map.Entry<Object, DiscardPolicy>> iterator = tracker.entrySet().iterator();
              iterator.hasNext(); ) {
            if (iterator.next().getValue().update(trackStateTransfer, trackXSiteStateTransfer)) {
               iterator.remove();
            }
         }
      }
   }
1010359
public void stop() {

    this.stop = true;

    if (this.thread != null && this.thread.isAlive()) {
      this.thread.interrupt();

      for (TrackerClient client : this.clients.values()) {
        client.close();
      }

      try {
        this.thread.join();
      } catch (InterruptedException ie) {
        // Ignore
      }
    }
    this.myPeers.clear();

    this.thread = null;
  }
700714
public void stop() {
    this.stop = true;

    try {
      this.connection.close();
      logger.info("BitTorrent tracker closed.");
    } catch (IOException ioe) {
      logger.error("Could not stop the tracker: {}!", ioe.getMessage());
    }

    if (myPeerCollectorThread != null && myPeerCollectorThread.isAlive()) {
      myPeerCollectorThread.interrupt();
      try {
        myPeerCollectorThread.join();
      } catch (InterruptedException e) {
        //
      }
      logger.info("Peer collection terminated.");
    }
  }
559089
def stop(self) -> None:
        """"""
        if self._stop and not self._posted_kork:
            self._stop()
            self._stop = None
1185088
def stop(self):
        
        for p in self.primitives[:]:
            p.stop()

        StoppableLoopThread.stop(self)
1071199
def stop_tracing_process(self, pid):
        
        for thread in self.system.get_process(pid).iter_threads():
            self.__stop_tracing(thread)
619264
def stop(self):
        
        self.debug("()")
        try:
            self.unjoin()
            time.sleep(2)
        except:
            self.exception("Failed to leave audience")
        super(SensorClient, self).stop()
12847
def stop(self):
        """"""
        if not self.stopped:
            self.stopped = True
            if self.pendingHeartbeat is not None:
                self.pendingHeartbeat.cancel()
                self.pendingHeartbeat = None
1312192
def stop(self):
        
        self.stopped_by_interrupt = True

        if self.executor:
            self.executor.stop()
408740
def stop(self):
        """"""
        self._presubs.remove(self._sdk_presub_params)
        if self._immediacy == FirstValue.on_value_update:
            self._unsubscribe_all_matching()
        super(ResourceValues, self).stop()
333110
def stop(self):
        
        if not self.active:
            return
        self.removeHandler(self.handlers[-1])
        self.active = False
        return
826070
def right_stop(self):
        """"""
        self.board.digital_write(R_CTRL_1, 0)
        self.board.digital_write(R_CTRL_2, 0)
        self.board.analog_write(PWM_R, 0)
1343251
public void stop()
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "stop");
        ivIsInitialized = false;
        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "stop");
    }
430745
public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }
668908
def stop(self):
        

        if self.original_handler is not None:
            signal.signal(signal.SIGWINCH, self.original_handler)
658413
def stop(self):
        
        if self.is_alive():
            self._can_run = False
            self._stop_event.set()
            self._profiler.total_time += time() - self._start_time
            self._start_time = None