the remove patch operation for a list of (path, value) tuples on an ApiKey resource list path
499714
def _api_key_patch_remove(conn, apiKey, pvlist):
    '''
    
    '''
    response = conn.update_api_key(apiKey=apiKey,
                                   patchOperations=_api_key_patchops('remove', pvlist))
    return response
1354305
def _get_resources_to_remove(resource, template):
    
    type_ids = [tmpltype.id for tmpltype in template.templatetypes]

    node_attr_ids = dict([(ra.attr_id, ra) for ra in resource.attributes])
    attrs_to_remove = []
    attrs_to_keep   = []
    for nt in resource.types:
        if nt.templatetype.id in type_ids:
            for ta in nt.templatetype.typeattrs:
                if node_attr_ids.get(ta.attr_id):
                    attrs_to_remove.append(node_attr_ids[ta.attr_id])
        else:
            for ta in nt.templatetype.typeattrs:
                if node_attr_ids.get(ta.attr_id):
                    attrs_to_keep.append(node_attr_ids[ta.attr_id])
    #remove any of the attributes marked for deletion as they are
    #marked for keeping based on being in another type.
    final_attrs_to_remove = set(attrs_to_remove) - set(attrs_to_keep)

    return list(final_attrs_to_remove)
1130729
def remove(self, rel_path, propagate=False):
        ''''''

        key = self._get_boto_key(rel_path)
        if key:
            key.delete()
1301633
def _api_delete(path, data, server=None):
    '''
    
    '''
    server = _get_server(server)
    response = requests.delete(
            url=_get_url(server['ssl'], server['url'], server['port'], path),
            auth=_get_auth(server['user'], server['password']),
            headers=_get_headers(),
            params=data,
            verify=False
    )
    return _api_response(response)
4899
def remove_resource(self, path):
        

        path = path.strip("/")
        paths = path.split("/")
        actual_path = ""
        i = 0
        for p in paths:
            i += 1
            actual_path += "/" + p
        try:
            res = self.root[actual_path]
        except KeyError:
            res = None
        if res is not None:
            del(self.root[actual_path])
        return res
272418
def remove_patch(cls, patch_name):
        
        try:
            os.unlink(cls._get_patch_path(patch_name))
        except:
            raise StashException("patch '%s' does not exist" % patch_name)
487399
function removeSubKeyFromList(list, sub, key, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (a4p.isDefined(list[i][sub]) && (list[i][sub][key] == value)) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
476541
def remove(self, key):
        
        self._find_lt(key)
        node = self._path[0][2]
        if node is self._tail or key < node[0]:
            raise KeyError('{!r} is not in list'.format(key))
        self._remove(node)
891041
def remove_input(urls, preserves, verbose = False):
	
	for path in map(url2path, urls):
		if any(os.path.samefile(path, preserve) for preserve in preserves):
			continue
		if verbose:
			print >>sys.stderr, "removing \"%s\" ..." % path
		try:
			os.remove(path)
		except:
			pass
210765
def file_del(self, key, paths=None):
        
        if paths is None:
            paths = []
            for path in self._file_event_map:
                if key in self._file_event_map[path]:
                    paths.append(path)
        elif not isinstance(paths, list):
            paths = [paths]
        for path in paths:
            if key in self._file_event_map[path]:
                del self._file_event_map[path][key]
            if path in self._file_event_map and not self._file_event_map[path]:
                self._watch_files.remove(path)
                del self._file_event_map[path]
933411
def strip_prefix_from_list(list, strip):
    
    for i in range(len(list)):
        list[i] = strip_prefix(list[i], strip)
368098
def opt_strip(prefix, opts):
    

    ret = {}
    for opt_name, opt_value in opts.items():
        # remove prefix
        if opt_name.startswith(prefix):
            opt_name = opt_name[len(prefix):]

        ret[opt_name] = opt_value

    return ret
425616
def remove(self, path, recursive=True, skip_trash=True):
        
        if recursive:
            to_delete = []
            for s in self.get_all_data().keys():
                if s.startswith(path):
                    to_delete.append(s)
            for s in to_delete:
                self.get_all_data().pop(s)
        else:
            self.get_all_data().pop(path)
564402
def remove(parent, idx):
  """"""
  if isinstance(parent, dict):
    del parent[idx]
  elif isinstance(parent, list):
    del parent[int(idx)]
  else:
    raise JSONPathError("Invalid path for operation")
630016
def delete(self):
        
        uris = [obj["resource_uri"] for obj in self.results()]
        data = self.resource._meta.api.resource_serialize({"objects": [], "deleted_objects": uris})
        self.resource._meta.api.http_resource("PATCH", self.resource._meta.resource_name, data=data)

        return len(uris)
839650
def _prune_kwargs(kwargs):
    
    allowed_keys = [
        'corner_mask', 'alpha', 'locator', 'extend', 'xunits',
        'yunits', 'antialiased', 'nchunk', 'hatches', 'zorder']
    ignored = [key for key in kwargs.keys() if key not in allowed_keys]
    for key in ignored:
        _warn(
            '{}={} is not an allowed optional parameter and will'
            ' be ignored'.format(key, kwargs[key]))
        kwargs.pop(key, None)
    return kwargs
980159
function notGetOrPost(tuple) {
        var v = tuple[0].toLowerCase()
        if (v === 'get') return false
        if (v === 'post') return false
        if (v === 'put') return false
        if (v === 'patch') return false
        if (v === 'delete') return false
        return true
      }