removes the raw unprocessed data
495072
def rm_raw(ctx, dataset, kwargs):
    ""

    kwargs = parse_kwargs(kwargs)
    data(dataset, **ctx.obj).rm_raw(**kwargs)
345215
def remove_raw_jobs(self, params_list):
        

        if len(params_list) == 0:
            return

        # ZSET
        if self.is_sorted:
            context.connections.redis.zrem(self.redis_key, *iter(params_list))

        # SET
        elif self.is_set:
            context.connections.redis.srem(self.redis_key, *params_list)

        else:
            # O(n)! Use with caution.
            for k in params_list:
                context.connections.redis.lrem(self.redis_key, 1, k)

        context.metric("queues.%s.removed" % self.id, len(params_list))
        context.metric("queues.all.removed", len(params_list))
204099
def clean(self):

        """"""

        for s in self.visible_files.values():
            s.clean()
        for s in [sub[1][x] for sub in self.avail_files.values() for x in sub[1]]: # Double list comprehensions aren't very
            s.clean()
242292
def clean_up(self):
        """"""
        self.action_buffer = []
        self.sources = {}
        self.doc_to_get = {}
        self.doc_to_update = []
956825
def cleanup(self):
        """"""
        try:
            os.remove(self.pid_file)
        except OSError as exc:
            logger.critical("Could not remove pid_file: %s", exc)

        # Save the final status of the flow.
        self.flow.pickle_dump()
1012695
def clean(self, algorithm=None):
        ''''''
        # all dates
        original_dates = list(self.dates())
        series = []
        all_dates = set()
        for serie in self.series():
            dstart, dend, vend = None, None, None
            new_dates = []
            new_values = []
            missings = []
            values = {}
            for d, v in zip(original_dates, serie):
                if v == v:
                    if dstart is None:
                        dstart = d
                    if missings:
                        for dx, vx in algorithm(dend, vend, d, v, missings):
                            new_dates.append(dx)
                            new_values.append(vx)
                        missings = []
                    dend = d
                    vend = v
                    values[d] = v
                elif dstart is not None and algorithm:
                    missings.append((dt, v))
            if missings:
                for dx, vx in algorithm(dend, vend, None, None, missings):
                    new_dates.append(dx)
                    new_values.append(vx)
                    dend = dx
            series.append((dstart, dend, values))
            all_dates = all_dates.union(values)
        cdate = []
        cdata = []
        for dt in sorted(all_dates):
            cross = []
            for start, end, values in series:
                if start is None or (dt >= start and dt <= end):
                    value = values.get(dt)
                    if value is None:
                        cross = None
                        break
                else:
                    value = nan
                cross.append(value)
            if cross:
                cdate.append(dt)
                cdata.append(cross)
        return self.clone(date=cdate, data=cdata)
1167727
def clean_data(data):
    
    new_data = []
    VALID = 'abcdefghijklmnopqrstuvwxyz123456789"\'?!.,:; '
    for sample in data:
        new_sample = []
        for char in sample[1].lower():  # Just grab the string, not the label
            if char in VALID:
                new_sample.append(char)
            else:
                new_sample.append('UNK')

        new_data.append(new_sample)
    return new_data
498258
def clear(self):
    """"""
    for i in range(len(self.sample)):
      self.sample[i] = 0.0
    self.count = 0
1034962
def clear_data(self):
        '''
         '''
        if self.forest.verbose > 1:
            print('clearing up stuff')
        self.S = None
        self.Uy = None
        self.U = None
237236
def unpad(cls, data):
        
        if sys.version_info > (3, 0):
            return data[:-ord(data[len(data)-1:])].decode()
        else:
            return data[:-ord(data[len(data)-1:])]
378495
def wipe_results(self):
        
        # Clean results table
        self.db.purge_table('results')

        # Get rid of contents of data dir
        map(shutil.rmtree, glob.glob(os.path.join(self.get_data_dir(), '*.*')))
943945
def clean_data(data: dict) -> dict:
    """"""
    new_data = {}
    for key, value in data.items():
        # Verify that only explicitly passed args get passed on
        if not isinstance(value, bool) and not value:
            continue

        # Multiple choice command are passed as tuples, convert to list to match schema
        if isinstance(value, tuple):
            value = list(value)
        new_data[key] = value
    return new_data
1283855
def _cleanup(self):
        
        self.device = None
        self.doc = None
        self.parser = None
        self.resmgr = None
        self.interpreter = None
485955
def cleanup(self):
        
        try:
            self.unload_lime()
        except AttributeError as ex:
            pass
        self.tunnel.cleanup()
        self.shell.cleanup()
1210071
function() {
        var items = _utils.getArgArray(arguments);
        if (items.length === 0) {
            throw new Error('no files specified to clean up');
        }
        items.forEach(function(item) {
            try {
                var path = (typeof item === 'string') ? item : item.path;
                _fs.unlinkSync(path);
            } catch (e) {
                // Eat the exception.
            }
        });
    }
417692
public function clearAllPersistentData ()
    {
        $filename = $this->config->get('file_directory').DIRECTORY_SEPARATOR.$this->config->get('file_name');
        unlink ($filename);
    }
1105463
def clean(self, data):
        
        try:
            value = data[self.column_name]
        except KeyError:
            raise KeyError("Column '%s' not found in dataset. Available "
                           "columns are: %s" % (self.column_name, list(data)))

        # If ValueError is raised here, import_obj() will handle it
        value = self.widget.clean(value, row=data)

        if value in self.empty_values and self.default != NOT_PROVIDED:
            if callable(self.default):
                return self.default()
            return self.default

        return value