Remove VRF.

            Maps to the function :py:func:`nipap.backend.Nipap.remove_vrf` in
            the backend. Please see the documentation for the backend function
            for information regarding input arguments and return values.
343671
def remove(self):
        

        xmlrpc = XMLRPCConnection()
        try:
            xmlrpc.connection.remove_vrf(
                {
                    'vrf': { 'id': self.id },
                    'auth': self._auth_opts.options
                })
        except xmlrpclib.Fault as xml_fault:
            raise _fault_to_exception(xml_fault)
        if self.id in _cache['VRF']:
            del(_cache['VRF'][self.id])
431265
def remove(self, func):
        """"""
        if not self.data['name'].startswith(self.prefix):
            return
        parent = self.get_parent(self.get_log())
        _, sink_path, _ = self.get_sink()
        client = self.session.client(
            'logging', 'v2', '%s.sinks' % (parent.split('/', 1)[0]))
        try:
            client.execute_command(
                'delete', {'sinkName': sink_path})
        except HttpError as e:
            if e.resp.status != 404:
                raise
1184152
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/vrf/%s/', ids)

        return super(ApiVrf, self).delete(url)
1120147
def remove_plugin(self, f):
        
        if f.endswith('.py'):
            plugin_name = os.path.splitext(os.path.basename(f))[0]
            print '- %s %sREMOVED' % (plugin_name, color.Red)
            print '\t%sNote: still in memory, restart Workbench to remove...%s' % \
                  (color.Yellow, color.Normal)
1051649
def del_method(self, m):
        
        if isinstance(m, types.FunctionType) and not iscoroutinefunction(m):
            wrkey = ('function', id(m))
        else:
            f, obj = get_method_vars(m)
            wrkey = (f, id(obj))
        if wrkey in self:
            del self[wrkey]
256497
def remove(self, force=False):
        
        if force:
            _fs, filename = opener.parse(self.uri)
            _fs.remove(filename)
        self.uri = None
788300
def remove(self):
        
        self.canvas.get_first_view().unselect_item(self)

        for child in self.canvas.get_children(self)[:]:
            child.remove()

        self.remove_income()
        for outcome_v in self.outcomes[:]:
            self.remove_outcome(outcome_v)
        for input_port_v in self.inputs[:]:
            self.remove_input_port(input_port_v)
        for output_port_v in self.outputs[:]:
            self.remove_output_port(output_port_v)
        for scoped_variable_port_v in self.scoped_variables[:]:
            self.remove_scoped_variable(scoped_variable_port_v)

        self.remove_keep_rect_within_constraint_from_parent()
        for constraint in self._constraints[:]:
            self.canvas.solver.remove_constraint(constraint)
            self._constraints.remove(constraint)
        self.canvas.remove(self)
879474
def remove_params(self, *args):
        
        for a in args:
            self._orig_kwargs.pop(a)
        self.kwargs = self._orig_kwargs.copy()
529759
def _remove_parameter(self, param):
        
        # TODO: check to see if protected (required by a current constraint or
        # by a backend)
        self._params = [p for p in self._params if p != param]
1062828
def _remove_links_to_vrf_table(self, vrf_table):
        """"""
        assert vrf_table
        vrf_conf = vrf_table.vrf_conf
        self._remove_links_to_vrf_table_for_rts(vrf_table,
                                                vrf_conf.import_rts)
561198
function removeVendorHelper() {
  if (this.options.zip && this.options.cleanupZipHelper) {
    if (this.serverless.service.package.individually) {
      return BbPromise.resolve(this.targetFuncs)
        .map(f => {
          if (!get(f, 'module')) {
            set(f, ['module'], '.');
          }
          return f;
        })
        .then(funcs => uniqBy(funcs, f => f.module))
        .map(f => {
          this.serverless.cli.log(
            `Removing Python requirements helper from ${f.module}...`
          );
          return fse.removeAsync(
            path.join(this.servicePath, f.module, 'unzip_requirements.py')
          );
        });
    } else {
      this.serverless.cli.log('Removing Python requirements helper...');
      return fse.removeAsync(
        path.join(this.servicePath, 'unzip_requirements.py')
      );
    }
  }
}
777146
def complete_vrf(arg):
    

    search_string = ''
    if arg is not None:
        search_string = '^%s' % arg

    res = VRF.search({
        'operator': 'regex_match',
        'val1': 'rt',
        'val2':  search_string
        }, { 'max_result': 100000 } )

    ret = []

    for v in res['result']:
        ret.append(v.rt)
    if re.match(search_string, 'none'):
        ret.append('none')

    return ret
1151642
private void removeUnreferencedFunctionArgs(Scope fparamScope) {
    // Notice that removing unreferenced function args breaks
    // Function.prototype.length. In advanced mode, we don't really care
    // about this: we consider "length" the equivalent of reflecting on
    // the function's lexical source.
    //
    // Rather than create a new option for this, we assume that if the user
    // is removing globals, then it's OK to remove unused function args.
    //
    // See http://blickly.github.io/closure-compiler-issues/#253
    if (!removeGlobals) {
      return;
    }

    Node function = fparamScope.getRootNode();
    checkState(function.isFunction());
    if (NodeUtil.isGetOrSetKey(function.getParent())) {
      // The parameters object literal setters can not be removed.
      return;
    }

    Node argList = NodeUtil.getFunctionParameters(function);
    // Strip as many unreferenced args off the end of the function declaration as possible.
    maybeRemoveUnusedTrailingParameters(argList, fparamScope);

    // Mark any remaining unused parameters are unused to OptimizeParameters can try to remove
    // them.
    markUnusedParameters(argList, fparamScope);
  }
850148
def remove_filter_function(self, name):
        
        if name in self._filter_functions.keys():
            del self._filter_functions[name]
            self.invalidateFilter()
412836
public K removeValue(V _val) {
        checkParms(_val);
        K removedKey = inverseMap.remove(_val);
        if (removedKey != null) {
            map.remove(removedKey);
        }
        return removedKey;
    }
639086
def delete_show_function(self, show_name):
        
        if self.get_show_function(show_name) is None:
            return

        self.shows.__delitem__(show_name)
1079169
def remove(self, w):
        ''''''
        self.wpoints.remove(w)
        self.last_change = time.time()
        self.reindex()