Clears the end date.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
358207
def clear_end_date(self):
        
        if (self.get_end_date_metadata().is_read_only() or
                self.get_end_date_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['endDate'] = self._mdata['end_date']['default_date_time_values'][0]
1268065
def clear_description(self):
        
        if (self.get_domain_metadata().is_read_only() or
                self.get_domain_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['domain'] = self._domain_metadata['default_string_values'][0]
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
1158646
def clear_title(self):
        
        metadata = Metadata(**settings.METADATA['title'])
        if metadata.is_read_only() or metadata.is_required():
            raise NoAccess()
        self._my_map['title']['text'] = ''
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
1247025
def clear_completion(self):
        
        # Implemented from template for osid.grading.GradeSystemForm.clear_lowest_numeric_score
        if (self.get_completion_metadata().is_read_only() or
                self.get_completion_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['completion'] = self._completion_default
185702
public void clear() {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isEntryEnabled()) {
            Tr.entry(tc, "clear");
        }

        clearAllHeaders();
        this.eohPosition = HeaderStorage.NOTSET;
        this.currentElem = null;
        this.stateOfParsing = PARSING_CRLF;
        this.binaryParsingState = GenericConstants.PARSING_HDR_FLAG;
        this.parsedToken = null;
        this.parsedTokenLength = 0;
        this.bytePosition = 0;
        this.byteLimit = 0;
        this.currentReadBB = null;
        clearBuffers();
        this.debugContext = this;
        this.numCRLFs = 0;
        this.bIsMultiLine = false;
        this.lastCRLFBufferIndex = HeaderStorage.NOTSET;
        this.lastCRLFPosition = HeaderStorage.NOTSET;
        this.lastCRLFisCR = false;
        this.headerChangeCount = 0;
        this.headerAddCount = 0;
        this.bOverChangeLimit = false;
        this.compactHeaderFlag = false;
        this.table = null;
        this.isPushPromise = false;
        this.processedXForwardedHeader = false;
        this.processedForwardedHeader = false;
        this.forwardHeaderErrorState = false;
        this.forwardedByList = null;
        this.forwardedForList = null;
        this.forwardedHost = null;
        this.forwardedPort = null;
        this.forwardedProto = null;

        if (bTrace && tc.isEntryEnabled()) {
            Tr.exit(tc, "clear");
        }
    }
128528
def clear_created_date(self):
        
        # Implemented from template for osid.assessment.AssessmentOfferedForm.clear_start_time_template
        if (self.get_created_date_metadata().is_read_only() or
                self.get_created_date_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['createdDate'] = self._created_date_default
1150263
def clear(self):
        """"""

        if self.default_value is None:
            self.current_value = bytearray()
        else:
            self.current_value = bytearray(self.default_value)
855550
def end(self):
        """"""
        if self._properties.get("endMs") is None:
            return None
        return _helpers._datetime_from_microseconds(
            int(self._properties.get("endMs")) * 1000.0
        )
670942
def end_datetime(self) -> Optional[datetime.datetime]:
        
        if not self.intervals:
            return None
        return max([x.end for x in self.intervals])
294923
public function clear()
    {
        $now = Carbon::now('UTC');

        if ($handle = opendir(SettingsFile::TEMP_FOLDER)) {
            while (false !== ($file = readdir($handle))) {
                if ($file !== '.' && $file !== '..') {
                    $file_path = SettingsFile::TEMP_FOLDER . $file;
                    $file_time = filemtime($file_path);
                    $file_date = Carbon::createFromTimestamp($file_time, 'UTC');

                    if ($file_date->diffInDays($now) >= SettingsFile::OUTDATED_FILE_DAYS) {
                        @unlink($file_path);
                    }
                }
            }

            closedir($handle);
        }
    }
999947
def clear(self):
        
        self.__values.clear()
        self.__access_keys = []
        self.__modified_times.clear()
1258686
def clear_priority(self):
        
        # Implemented from template for osid.logging.LogEntryForm.clear_priority_template
        if (self.get_priority_metadata().is_read_only() or
                self.get_priority_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['priority'] = self._priority_default
1337251
def _clear(self, wait):
        
        i = 0
        t1 = time.time()
        for k in self.bucket.get_keys():
            i += 1
            self.bucket.get(k).delete()
        print("\nDELETION TOOK: %s" % round(time.time() - t1, 2))
        if wait:
            while self._model_class.objects.count():
                time.sleep(0.3)
        return i
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()
1334989
def clear_sequestered(self):
        
        if (self.get_sequestered_metadata().is_read_only() or
                self.get_sequestered_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['sequestered'] = self._sequestered_default