Ends tracking of attributes changes.
        Returns the changes that occurred to the attributes.
          Only the final state of each attribute is obtained
764754
def track_end(self):
        
        self.__tracking = False
        changes = self.__changes
        self.__changes = {}
        return changes
557470
def changes(self):
        
        try:
            return self.added, self.removed
        finally:
            self.added = list()
            self.removed = list()
1095391
def changes(self):
        
        report = {}
        for k, k_changes in self._changes.items():
            if len(k_changes) == 1:
                report[k] = k_changes[0]
            else:
                first = k_changes[0]
                last = k_changes[-1]
                if first.old_value != last.new_value or first.old_raw_str_value != last.new_raw_str_value:
                    report[k] = _Change(
                        first.old_value,
                        last.new_value,
                        first.old_raw_str_value,
                        last.new_raw_str_value,
                    )
        return report
1332298
def ended(self):
        """"""
        self._end_time = time.time()

        if setting(key='memory_profile', expected_type=bool):
            self._end_memory = get_free_memory()
460843
private int dropUnusedTracks() {

		List<PointTrack> all = tracker.getAllTracks(null);
		int num = 0;

		for (PointTrack t : all) {
			VoTrack p = t.getCookie();
			if (tick - p.lastInlier > thresholdRetire) {
				tracker.dropTrack(t);
				num++;
			}
		}

		return num;
	}
1191115
def modifications
      @accessed.each_pair do |field, value|
        current = @attributes[field]
        if current != value || (current.is_a?(Array) &&
            current.any? { |v| v.respond_to?(:changed?) && v.changed? })
          @modifications[field] = [ value, current ]
        end
      end
      @accessed.clear
      @modifications
    end
1333734
def ended(self):
        
        statistics = self._properties.get("statistics")
        if statistics is not None:
            millis = statistics.get("endTime")
            if millis is not None:
                return _helpers._datetime_from_microseconds(millis * 1000.0)
593080
public function getUnchangedAttributes()
    {
        $output = array();

        foreach ($this->attributes as $name => $value) {
            if (!$this->hasChanged($name)) {
                $output[$name] = $value;
            }
        }

        return $output;
    }
444632
def clear_attributes(self):
        
        for sample in self.metadata:
            try:
                delattr(sample[self.analysistype], 'record_dict')
                delattr(sample[self.analysistype], 'contig_lengths')
                delattr(sample[self.analysistype], 'longest_contig')
            except AttributeError:
                pass
658946
def end_policy_update(self):
        
        if self.time_policy_update_start:
            self.delta_policy_update = time() - self.time_policy_update_start
        else:
            self.delta_policy_update = 0
        delta_train_start = time() - self.time_training_start
        LOGGER.debug(" Policy Update Training Metrics for {}: "
                     "\n\t\tTime to update Policy: {:0.3f} s \n"
                     "\t\tTime elapsed since training: {:0.3f} s \n"
                     "\t\tTime for experience collection: {:0.3f} s \n"
                     "\t\tBuffer Length: {} \n"
                     "\t\tReturns : {:0.3f}\n"
                     .format(self.brain_name, self.delta_policy_update,
                             delta_train_start, self.delta_last_experience_collection,
                             self.last_buffer_length, self.last_mean_return))
        self._add_row(delta_train_start)
1127241
boolean checkForChanges()
    {
        // initialize with last checked files
        final Map<File, byte[]> presents = new HashMap<>(fingerprints);
        boolean modified = traverseDirectory(location, new IFileVisitor()
        {
            @Override
            public boolean visitFile(File file)
            {
                return modified(presents.remove(file), file);
            }

            @Override
            public boolean visitDir(File dir)
            {
                return modified(presents.remove(dir), dir);
            }
        });
        // if some files remain, that means they have been deleted since last scan
        return modified || !presents.isEmpty();
    }
392745
function () {
                    // If we don't have a state key for the shape attributes, consider this state key to be invalid.
                    if (!this._attributesStateKey) {
                        // Update the state key for the appropriate attributes for future
                        if (this._highlighted) {
                            if (!!this._highlightAttributes) {
                                this._attributesStateKey = this._highlightAttributes.stateKey;
                            }
                        } else {
                            if (!!this._attributes) {
                                this._attributesStateKey = this._attributes.stateKey;
                            }
                        }

                        // If we now actually have a state key for the attributes, it was previously invalid.
                        if (!!this._attributesStateKey) {
                            this.stateKeyInvalid = true;
                        }
                    } else {
                        // Detect a change in the appropriate attributes.
                        var currentAttributesStateKey = null;

                        if (this._highlighted) {
                            // If there are highlight attributes associated with this shape, ...
                            if (!!this._highlightAttributes) {
                                currentAttributesStateKey = this._highlightAttributes.stateKey;
                            }
                        } else {
                            if (!!this._attributes) {
                                currentAttributesStateKey = this._attributes.stateKey;
                            }
                        }

                        // If the attributes state key changed, ...
                        if (currentAttributesStateKey != this._attributesStateKey) {
                            this._attributesStateKey = currentAttributesStateKey;
                            this.stateKeyInvalid = true;
                        }
                    }

                    if (this.stateKeyInvalid) {
                        this._stateKey = this.computeStateKey();
                    }

                    return this._stateKey;
                }
848465
public EndState getEndState() {
        EndState result = EndState.PASSED;
        for ( ScenarioToken s : scenarios) {
            if ( s.getEndState() == EndState.FAILED) {
                result = EndState.FAILED;
                break;
            }
        }

        if ( result != EndState.FAILED) {
            for ( ScenarioToken s : scenarios) {
                if ( s.getEndState() == EndState.PENDING) {
                    result = EndState.PENDING;
                }
            }
        }
        return result;
    }
816247
def undo_changes!
      Petra.current_transaction.current_section.log_attribute_change_veto(object,
                                                                          attribute:      attribute,
                                                                          external_value: external_value)
    end
952655
def _track_changes(self):
        
        if self._field and getattr(self._parent, '_track_changes',
                                   None) is not None:
            self._parent._track_changes.add(self._field)
354981
def get_last_metrics(self):
        
        read_up_to = self._logged_metrics.qsize()
        messages = []
        for i in range(read_up_to):
            try:
                messages.append(self._logged_metrics.get_nowait())
            except Empty:
                pass
        return messages
1024693
def attributes(self):
        

        overridden_attrs = self._attributes
        sortmap = {"neutral": 1, "positive": 2,
                   "negative": 3}

        sortedattrs = list(overridden_attrs.values())
        sortedattrs.sort(key=operator.itemgetter("defindex"))
        sortedattrs.sort(key=lambda t: sortmap.get(t.get("effect_type",
                                                         "neutral"), 99))
        return [item_attribute(theattr) for theattr in sortedattrs]