Clears the highest numeric score.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
556902
def clear_highest_numeric_score(self):
        
        # Implemented from template for osid.grading.GradeSystemForm.clear_lowest_numeric_score
        if (self.get_highest_numeric_score_metadata().is_read_only() or
                self.get_highest_numeric_score_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['highestNumericScore'] = self._highest_numeric_score_default
1274683
def clear_end_date(self):
        
        if (self.get_end_date_metadata().is_read_only() or
                self.get_end_date_metadata().is_required()):
            raise NoAccess()
        self.my_osid_object_form._my_map['endDate'] = \
            DateTime(**self._end_date_metadata['default_date_time_values'][0])
738953
def remove(self, item):
        ''''''
        score = self._dict.pop(item, None)
        if score is not None:
            self._sl.remove(score)
            return score
1202012
def clear(self):
        
        self._lock = None
        self._ipopo_instance = None
        self._context = None
        self.requirement = None
        self._value = None
        self._field = None
277619
def cleared=(cleared)
      validator = EnumAttributeValidator.new('String', ['cleared', 'uncleared', 'reconciled'])
      unless validator.valid?(cleared)
        fail ArgumentError, 'invalid value for "cleared", must be one of #{validator.allowable_values}.'
      end
      @cleared = cleared
    end
284674
def clear_score_system(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_avatar_template
        if (self.get_score_system_metadata().is_read_only() or
                self.get_score_system_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['scoreSystemId'] = self._score_system_default
305788
def above_score_threshold(new_data, old_data, strict=False, threshold=PYLINT_SCORE_THRESHOLD):
    
    success = True
    score = 0
    message = ''
    if strict:
        for fscore, fname in new_data['scores']:
            if fscore < threshold:
                success = False
                score = -1
                message += "File {} score ({}) below threshold {}\n".format(fname, fscore, threshold)

        return success, score, message

    else:
        if new_data['average'] < threshold:
            success = False
            message = "Failed! Average pylint score ({})" \
                      " below threshold (9)!".format(new_data['average'])
            score = -1

    return success, score, message
335634
def clear_input_score_end_range(self):
        
        # Implemented from template for osid.grading.GradeSystemForm.clear_lowest_numeric_score
        if (self.get_input_score_end_range_metadata().is_read_only() or
                self.get_input_score_end_range_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['inputScoreEndRange'] = self._input_score_end_range_default
833455
public void clearCounts() {
		myReadCount.set(0L);
		myUpdateCount.set(0L);
		myCreateCount.set(0L);
		myDeleteCount.set(0L);
		mySearchCount.set(0L);
	}
687991
def clear(self):
        

        for order in range(0, MAX_ORDER + 1):
            self._orders[order].clear()

        self._normalized = True
29128
public function clear()
    {
        if (null !== $this->aPlayer) {
            $this->aPlayer->removeRecord($this);
        }
        $this->id = null;
        $this->mapuid = null;
        $this->nblaps = null;
        $this->score = null;
        $this->nbfinish = null;
        $this->avgscore = null;
        $this->checkpoints = null;
        $this->player_id = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
703119
def clear(self):
    """"""
    value = self._sum / tf.cast(self._count, self._dtype)
    with tf.control_dependencies([value]):
      reset_value = self._sum.assign(tf.zeros_like(self._sum))
      reset_count = self._count.assign(0)
    with tf.control_dependencies([reset_value, reset_count]):
      return tf.identity(value)
785867
def bestScore(expPath, suite):
  
  maxValidationAccuracy = -1.0
  maxTestAccuracy = -1.0
  maxTotalAccuracy = -1.0
  maxBGAccuracy = -1.0
  maxIter = -1
  try:
    headers=["testResults", "validation", "bgResults", "elapsedTime", "totalCorrect"]
    result = suite.get_value(expPath, 0, headers, "all")
    for i,v in enumerate(zip(result["testResults"], result["validation"],
                             result["bgResults"], result["elapsedTime"],
                             result["totalCorrect"])):
      if v[1]["testerror"] > maxValidationAccuracy:
        maxValidationAccuracy = v[1]["testerror"]
        maxTestAccuracy = v[0]["testerror"]
        maxBGAccuracy = v[2]["testerror"]
        if v[4] is not None:
          maxTotalAccuracy = v[4]
        maxIter = i

    # print("Max validation score =", maxValidationAccuracy, " at iteration", maxIter)
    # print("Test score at that iteration =", maxTestAccuracy)
    # print("BG score at that iteration =", maxBGAccuracy)
    return maxTestAccuracy, maxValidationAccuracy, maxBGAccuracy, maxIter, maxTotalAccuracy
  except:
    print("Couldn't load experiment",expPath)
    return None, None, None, None, None
758821
def clear(self):
        """"""
        self.country_code = None
        self.national_number = None
        self.extension = None
        self.italian_leading_zero = None
        self.number_of_leading_zeros = None
        self.raw_input = None
        self.country_code_source = CountryCodeSource.UNSPECIFIED
        self.preferred_domestic_carrier_code = None
1205385
def validate(self):
        
        super(NumericFilterBase, self).validate()

        self.not_null = False

        if self._value.startswith('+'):
            self._cmp = operator.gt
            self._rt_cmp = 'greater'
            self._value = self._value[1:]
        elif self._value.startswith('-'):
            self._cmp = operator.lt
            self._rt_cmp = 'less'
            self._value = self._value[1:]
        else:
            self._cmp = operator.eq
            self._rt_cmp = 'equal'
949935
def clear(self):
        
        # The del_binfo() call here isn't necessary for normal execution,
        # but is for interactive mode, where we might rebuild the same
        # target and need to start from scratch.
        self.del_binfo()
        self.clear_memoized_values()
        self.ninfo = self.new_ninfo()
        self.executor_cleanup()
        try:
            delattr(self, '_calculated_sig')
        except AttributeError:
            pass
        self.includes = None
1154029
def clear_display_name(self):
        
        if (self.get_display_name_metadata().is_read_only() or
                self.get_display_name_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['displayName'] = self._display_name_metadata['default_string_values'][0]