Clears the input score start.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
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
927076
def clear_deadline(self):
        
        # Implemented from template for osid.assessment.AssessmentOfferedForm.clear_start_time_template
        if (self.get_deadline_metadata().is_read_only() or
                self.get_deadline_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['deadline'] = self._deadline_default
1197227
def clear( self ):
        
        self._minimum   = None
        self._maximum   = None
        self._step      = None
        self._notches   = None
        self._format    = None
        self._formatter = None
        self._padEnd    = 0
        self._padStart  = 0
772856
def clear_based_on_grades(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_group_template
        if (self.get_based_on_grades_metadata().is_read_only() or
                self.get_based_on_grades_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['basedOnGrades'] = self._based_on_grades_default
286997
def clear(self):
        
        # mark this task as incomplete
        self.mark_incomplete()

        # Delete the indicator metadata, this also deletes values by cascading.
        #
        # NOTE: calling 'delete()' on the query (instead of on the queried object,
        # as done here), would NOT work! For a query, there is no in-Python cascading
        # of delete statements in sqlalchemy, so the associated values would not
        # be deleted e.g. for SQLite databases.
        try:
            indicator = self.session.query(models.EuroStatIndicator) \
                .filter(models.EuroStatIndicator.number == self.number) \
                .one()
            self.session.delete(indicator)
        except NoResultFound:
            # Data didn't exist yet, no problem
            pass

        self.close_session()
790506
public function clear()
    {
        $this->currentOutput = '';
        $this->accruedInput = '';
        $this->accruedInputWithoutFormatting = '';
        $this->formattingTemplate = '';
        $this->lastMatchPosition = 0;
        $this->currentFormattingPattern = '';
        $this->prefixBeforeNationalNumber = '';
        $this->extractedNationalPrefix = '';
        $this->nationalNumber = '';
        $this->ableToFormat = true;
        $this->inputHasFormatting = false;
        $this->positionToRemember = 0;
        $this->originalPosition = 0;
        $this->isCompleteNumber = false;
        $this->isExpectingCountryCallingCode = false;
        $this->possibleFormats = array();
        $this->shouldAddSpaceAfterNationalPrefix = false;
        if ($this->currentMetadata !== $this->defaultMetadata) {
            $this->currentMetadata = $this->getMetadataForRegion($this->defaultCountry);
        }
    }
1331321
public void clearInput() {
        Log.v(TAG, "Input cleared and validation errors removed");
        input.setText("");
        hasValidInput = true;
        updateBorder();
        showPasswordToggle.setChecked(false);
    }
421939
def clear_assessments(self):
        
        # Implemented from template for osid.learning.ActivityForm.clear_assets_template
        if (self.get_assessments_metadata().is_read_only() or
                self.get_assessments_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['assessmentIds'] = self._assessments_default
277985
def reset(self):
        """"""
        if self.parallel:
            from pyannote.metrics import manager_
            self.accumulated_ = manager_.dict()
            self.results_ = manager_.list()
            self.uris_ = manager_.dict()
        else:
            self.accumulated_ = dict()
            self.results_ = list()
            self.uris_ = dict()
        for value in self.components_:
            self.accumulated_[value] = 0.
329064
def clear(self) -> None:
        
        self._best_so_far = None
        self._epochs_with_no_improvement = 0
        self._is_best_so_far = True
        self._epoch_number = 0
        self.best_epoch = None
1046883
def _clear(self):
        """"""
        self._current_output = U_EMPTY_STRING
        self._accrued_input = U_EMPTY_STRING
        self._accrued_input_without_formatting = U_EMPTY_STRING
        self._formatting_template = U_EMPTY_STRING
        self._last_match_position = 0

        # The pattern from number_format that is currently used to create
        # formatting_template.
        self._current_formatting_pattern = U_EMPTY_STRING
        # This contains anything that has been entered so far preceding the
        # national significant number, and it is formatted (e.g. with space
        # inserted). For example, this can contain IDD, country code, and/or
        # NDD, etc.
        self._prefix_before_national_number = U_EMPTY_STRING
        self._should_add_space_after_national_prefix = False
        # This contains the national prefix that has been extracted. It
        # contains only digits without formatting.
        self._extracted_national_prefix = U_EMPTY_STRING
        self._national_number = U_EMPTY_STRING
        # This indicates whether AsYouTypeFormatter is currently doing the
        # formatting.
        self._able_to_format = True
        # Set to true when users enter their own
        # formatting. AsYouTypeFormatter will do no formatting at all when
        # this is set to True.
        self._input_has_formatting = False
        # The position of a digit upon which input_digit(remember_position=True) is
        # most recently invoked, as found in accrued_input_without_formatting.
        self._position_to_remember = 0
        # The position of a digit upon which input_digit(remember_position=True) is
        # most recently invoked, as found in the original sequence of
        # characters the user entered.
        self._original_position = 0
        # This is set to true when we know the user is entering a full
        # national significant number, since we have either detected a
        # national prefix or an international dialing prefix. When this is
        # true, we will no longer use local number formatting patterns.
        self._is_complete_number = False
        self._is_expecting_country_calling_code = False
        self._possible_formats = []
1280734
def clear(self):
        
        self.mark_incomplete()
        session = client.get_client().create_session()

        movies = session.query(models.Movie)
        movies.update({'budget_inflation_adjusted': None})

        session.commit()
        session.close()
180161
def clear(self):
        
        self.states[:] = 0
        self.actions[:] = 0
        self.rewards[:] = 0
        self.terminate_flags[:] = 0
        self.top = 0
        self.size = 0
113480
final void clear () {

        immediateFlag = false;
        operationCode = OperationCode.LOGIN_REQUEST;
        finalFlag = false;

        totalAHSLength = 0x00;
        dataSegmentLength = 0x00000000;
        initiatorTaskTag = 0x00000000;

        parser = null;
    }
924237
def clear_taker(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_avatar_template
        if (self.get_taker_metadata().is_read_only() or
                self.get_taker_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['takerId'] = self._taker_default
1228852
def clear_input(self):
        """"""
        for item in listdir(self.input_dir):
            item_path = path.join(self.input_dir, item)
            if path.isfile(item_path):
                remove(item_path)
                logger.debug('Removed input %s.' % item_path)
        return
691036
def clear_display_label(self):
        
        if (self.get_display_label_metadata().is_read_only() or
                self.get_display_label_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['displayLabel'] = self._display_label_metadata['default_string_values'][0]