Delete initial recurrence rules.
436058
def backwards(apps, schema_editor):
    
    RecurrenceRule = apps.get_model('icekit_events', 'RecurrenceRule')
    descriptions = [d for d, rr in RULES]
    RecurrenceRule.objects.filter(description__in=descriptions).delete()
1329111
def _clean(self):
        """"""
        if self._workers:
            for w in self._workers:
                if w.is_finished():
                    self._workers.remove(w)
        else:
            self._current_worker = None
            self._timer.stop()
1184562
def _reset(self):
        """"""
        self.nr_of_executed_insns = 0
        self.begin = None
        self.end = None
        self.coverage = {}
191493
def delFromTimeInv(self,*params):
        '''
        
        '''
        for param in params:
            if param in self.time_inv:
                self.time_inv.remove(param)
622346
private function unsetMagicConstants(): void
  {
    unset($this->replace['__FILE__']);
    unset($this->replace['__ROUTINE__']);
    unset($this->replace['__DIR__']);
    unset($this->replace['__LINE__']);
  }
1263771
def cleanup(first_I, first_Z):
    
    cont = 0
    Nmin = len(first_I)
    if len(first_Z) < Nmin:
        Nmin = len(first_Z)
    for kk in range(Nmin):
        if first_I[kk][0] != first_Z[kk][0]:
            print("\n WARNING: ")
            if first_I[kk] < first_Z[kk]:
                del first_I[kk]
            else:
                del first_Z[kk]
            print("Unmatched step number: ", kk + 1, '  ignored')
            cont = 1
        if cont == 1:
            return first_I, first_Z, cont
    return first_I, first_Z, cont
74546
def remove_rules(self, description):
        '''
        
        '''
        rm = []
        description = description.lower()

        for i in range(0, len(self.extract_rules)):
            if self.extract_rules[i]['regex'].search(description):
                rm.append(i)

        for i in rm:
            self.extract_rules.pop(i)

        return len(rm)
150376
private static void removeRecursive(
        Object object, PropertyChangeListener propertyChangeListener)
    {
        removeRecursive(object, propertyChangeListener, 
            new LinkedHashSet<Object>());
    }
557525
private void performInitialCleanup() {
        listeEinsortieren.removeIf(f -> !f.arr[DatenFilm.FILM_URL].toLowerCase().startsWith("http"));
        listeEinsortieren.removeIf(f -> {
            String groesse = f.arr[DatenFilm.FILM_GROESSE];
            if (groesse.isEmpty())
                return false;
            else {
                return Long.parseLong(groesse) < MIN_SIZE_ADD_OLD;
            }

        });
    }
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
378178
def clean_jobs(self, recursive=False):
        """"""
        self._interface.clean_jobs(self.scatter_link,
                                   clean_all=recursive)
60158
def clearData(self):
        """"""
        self._counts = np.zeros_like(self._bins)
        self.histo.setOpts(height=self._counts)
415142
def shrink (self):
        """"""
        trim = int(0.05*len(self))
        if trim:
            items = super(LFUCache, self).items()
            # sorting function for items
            keyfunc = lambda x: x[1][0]
            values = sorted(items, key=keyfunc)
            for item in values[0:trim]:
                del self[item[0]]
1290043
def _pre_run(self, pre_run=None):
        "  "
        if pre_run:
            pre_run()

        # Process registered "pre_run_callables" and clear list.
        for c in self.pre_run_callables:
            c()
        del self.pre_run_callables[:]
268373
def reset(self):
        
        self.remaining_cycles = self.initial_training_cycles
        self.needle_index = random.randrange(self.input_size)
405453
def reset(self, T):
        """
        self.__init__(self.shape, self.stds, T,
                      self.mass, self.detuning_knob, self.k,
                      self.omega_level, self.xi, self.theta, self.unfolding,
                      self.axes,
                      self.matrix_form)
937110
def clear_cycles(self):
        """"""
        if self.rater is None:
            raise IndexError('You need to have at least one rater')

        cycles = self.rater.find('cycles')
        for cyc in list(cycles):
            cycles.remove(cyc)

        self.save()