Remove tracks specified by `track_indices`.

        Parameters
        ----------
        track_indices : list
            The indices of the tracks to be removed.
4435
def remove_tracks(self, track_indices):
        
        if isinstance(track_indices, int):
            track_indices = [track_indices]
        self.tracks = [track for idx, track in enumerate(self.tracks)
                       if idx not in track_indices]
300315
public function deleteAllTrackingFailures()
    {
        if (Piwik::hasUserSuperUserAccess()) {
            $this->trackingFailures->deleteAllTrackingFailures();
        } else {
            Piwik::checkUserHasSomeAdminAccess();
            $idSites = Access::getInstance()->getSitesIdWithAdminAccess();
            Piwik::checkUserHasAdminAccess($idSites);
            $this->trackingFailures->deleteTrackingFailures($idSites);
        }
    }
75004
def rm(self, index):
        
        if self.model.exists(index):
            self.model.remove(index)
1348988
private void removeTracker(TaskTracker tracker) {
    String trackerName = tracker.getTrackerName();
    // Remove completely after marking the tasks as 'KILLED'
    lostTaskTracker(tracker);
    TaskTrackerStatus status = tracker.getStatus();

    // tracker is lost, and if it is blacklisted, remove
    // it from the count of blacklisted trackers in the cluster
    if (isBlacklisted(trackerName)) {
     faultyTrackers.decrBlackListedTrackers(1);
    }
    updateTaskTrackerStatus(trackerName, null);
    statistics.taskTrackerRemoved(trackerName);
    getInstrumentation().decTrackers(1);
  }
1231319
def delete_index(self):
        
        es = self._init_connection()
        if es.indices.exists(index=self.index):
            es.indices.delete(index=self.index)
550093
def _remove(self, rtracker):
        
        with self._lock:
            i = self._reference_queue.index(rtracker)
            self._reference_queue[i] = None
            self._size -= 1
152269
def remove_tracker(fei_sid_or_id, wfid=nil)

      tracker_id =
        if fei_sid_or_id.is_a?(String)
          fei_sid_or_id
        else
          Ruote.to_storage_id(fei_sid_or_id)
        end

      remove([ tracker_id ], wfid)
    end
892359
def clear(self):
        
        self.io.seek(0)
        self.io.truncate()
        for item in self.monitors:
            item[2] = 0
450061
def clear(self, clear_indices=False):
        ''
        super(MIMapping, self).clear()
        if clear_indices:
            self.indices.clear()
        else:
            for index_d in self.indices[1:]:
                index_d.clear()
593098
public void removePath(int pathIndex) {
		_verifyAllStreams();
		int pathCount = getPathCount();

		if (pathIndex < 0)
			pathIndex = pathCount - 1;

		if (pathIndex >= pathCount)
			throw new IllegalArgumentException();

		boolean bDirtyRingAreas2D = _hasDirtyFlag(DirtyFlags.DirtyRingAreas2D);

		int removedPathStart = getPathStart(pathIndex);
		int removedPathSize = getPathSize(pathIndex);

		// Remove the attribute values for the path
		for (int iattr = 0, nattr = m_description.getAttributeCount(); iattr < nattr; iattr++) {
			if (m_vertexAttributes[iattr] != null) {
				int semantics = m_description._getSemanticsImpl(iattr);
				int comp = VertexDescription.getComponentCount(semantics);
				m_vertexAttributes[iattr].eraseRange(comp * removedPathStart,
						comp * removedPathSize, comp * m_pointCount);
			}
		}

		// Change the start of each path after the removed path
		for (int i = pathIndex + 1; i <= pathCount; i++) {
			int istart = m_paths.read(i);
			m_paths.write(i - 1, istart - removedPathSize);
		}

		if (m_pathFlags == null) {
			for (int i = pathIndex + 1; i <= pathCount; i++) {
				byte flags = m_pathFlags.read(i);
				m_pathFlags.write(i - 1, flags);
			}
		}

		m_paths.resize(pathCount);
		m_pathFlags.resize(pathCount);
		m_pointCount -= removedPathSize;
		m_reservedPointCount -= removedPathSize;

		notifyModified(DirtyFlags.DirtyCoordinates);
	}
720856
def get_empty_tracks(self):
        
        empty_track_indices = [idx for idx, track in enumerate(self.tracks)
                               if not np.any(track.pianoroll)]
        return empty_track_indices
81843
def remove(self, *args):
        

        key = self.get_storage_key(*args)
        pk = self.instance.pk.get()
        logger.debug("removing %s from index %s" % (pk, key))
        self.connection.srem(key, pk)
        self._deindexed_values.add(tuple(args))
370564
def track_list(self,*args):
        '''
        
        '''
        noargs = len(args) == 0
        return np.unique(self.track) if noargs else np.unique(self.track.compress(args[0]))
558939
public void removeTrack(int playlistIndex) {
        checkState();
        SoundCloudTrack currentTrack = mPlayerPlaylist.getCurrentTrack();
        SoundCloudTrack removedTrack = mPlayerPlaylist.remove(playlistIndex);

        if (removedTrack == null) {
            // nothing removed
            return;
        }

        if (mPlayerPlaylist.isEmpty()) {
            // playlist empty after deletion, stop player;
            PlaybackService.stop(getContext(), mClientKey);
        } else if (currentTrack != null && currentTrack.equals(removedTrack) && mState == STATE_PLAYING) {
            // play next track if removed one was the current and playing
            play(mPlayerPlaylist.getCurrentTrackIndex());
        }

        for (CheerleaderPlaylistListener listener : mCheerleaderPlaylistListeners) {
            listener.onTrackRemoved(removedTrack, mPlayerPlaylist.isEmpty());
        }
    }
59033
def remove(self, event=None):
        
        observers = self._pool.get(event)
        if observers:
            self._pool[event] = []
407562
def remove_sites(self, indices):
        
        self._sites = [self._sites[i] for i in range(len(self._sites))
                       if i not in indices]
797985
async def remove(self, index=""):
        

        if not self.state == 'ready':
            logger.debug("Trying to remove from wrong state '{}'".format(self.state))
            return

        if index == "":
            self.statuslog.error("Must provide index to remove")
            return
        elif index == "all":
            self.queue = []
            self.update_queue()
            self.statuslog.info("Removed all songs")
            return

        indexes = index.split("-")
        self.logger.debug("Removing {}".format(indexes))

        try:
            if len(indexes) == 0:
                self.statuslog.error("Remove must specify an index or range")
                return
            elif len(indexes) == 1:
                num_lower = int(indexes[0]) - 1
                num_upper = num_lower + 1
            elif len(indexes) == 2:
                num_lower = int(indexes[0]) - 1
                num_upper = int(indexes[1])
            else:
                self.statuslog.error("Cannot have more than 2 indexes for remove range")
                return
        except TypeError:
            self.statuslog.error("Remove index must be a number")
            return
        except ValueError:
            self.statuslog.error("Remove index must be a number")
            return

        if num_lower < 0 or num_lower >= len(self.queue) or num_upper > len(self.queue):
            if len(self.queue) == 0:
                self.statuslog.warning("No songs in queue")
            elif len(self.queue) == 1:
                self.statuslog.error("Remove index must be 1 (only 1 song in queue)")
            else:
                self.statuslog.error("Remove index must be between 1 and {}".format(len(self.queue)))
            return

        if num_upper <= num_lower:
            self.statuslog.error("Second index in range must be greater than first")
            return

        lower_songname = self.queue[num_lower][1]
        for num in range(0, num_upper - num_lower):
            self.logger.debug("Removed {}".format(self.queue[num_lower][1]))
            self.queue.pop(num_lower)

        if len(indexes) == 1:
            self.statuslog.info("Removed {}".format(lower_songname))
        else:
            self.statuslog.info("Removed songs {}-{}".format(num_lower + 1, num_upper))

        self.update_queue()