Remove the operator whose onnx_name is the input onnx_name
438308
def delete_local_operator(self, onnx_name):
        '''
        
        '''
        if onnx_name not in self.onnx_operator_names or onnx_name not in self.operators:
            raise RuntimeError('The operator to be removed not found')
        self.onnx_operator_names.discard(onnx_name)
        del self.operators[onnx_name]
880252
def removeCodedValue(self, name):
        """"""
        for i in self._codedValues:
            if i['name'] == name:
                self._codedValues.remove(i)
                return True
        return False
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
804636
def remove_index_from_handle(handle_with_index):
    '''
    
    '''

    split = handle_with_index.split(':')
    if len(split) == 2:
        split[0] = int(split[0])
        return split
    elif len(split) == 1:
        return (None, handle_with_index)
    elif len(split) > 2:
        raise handleexceptions.HandleSyntaxError(
            msg='Too many colons',
            handle=handle_with_index,
            expected_syntax='index:prefix/suffix')
607814
def del_option_by_name(self, name):
        
        for o in list(self._options):
            assert isinstance(o, Option)
            if o.name == name:
                self._options.remove(o)
1341536
def _replace_nan(a, val):
    
    mask = isnull(a)
    return where_method(val, mask, a), mask
161983
def uncheck_all(self, name):
        
        for option in self.form.find_all("input", {"name": name}):
            if "checked" in option.attrs:
                del option.attrs["checked"]
843996
def remove_event_handler(self, handler, event_name):
        
        if event_name not in self._event_handlers:
            raise ValueError("Input event name '{}' does not exist".format(event_name))

        new_event_handlers = [(h, args, kwargs) for h, args, kwargs in self._event_handlers[event_name]
                              if h != handler]
        if len(new_event_handlers) == len(self._event_handlers[event_name]):
            raise ValueError("Input handler '{}' is not found among registered event handlers".format(handler))
        self._event_handlers[event_name] = new_event_handlers
438529
def _remove_builtin_prefix(name):
    """"""
    if name.startswith('builtins.'):
        return name[len('builtins.'):]
    elif name.startswith('__builtin__.'):
        return name[len('__builtin__.'):]
    return name
670444
def _remove_column(self, name):
        
        self._columns = filter(lambda c: c.name != name, self._columns)

        return self
596728
def t_op(self, s):
        '

        # Operators need to be further classified since the grammar requires this
        if s in ('<', '>', '==', '>=', '<=', '<>', '!='):
            self.add_token('COMP_OP', s)
        elif s in ('+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', '**=',
                   '//='):
            self.add_token('AUGASSIGN', s)
        elif s in self.UNOP2NAME.keys():
            self.add_token(self.UNOP2NAME[s], s)
        elif s in ('|', '^', '&', '<<', '>>', '**', '/', '%', '//'):
            # These are  *ONLY* binary operators. Operators which are exclusively or
            # can be unary operators were handled previously
            self.add_token('BINOP', s)
        elif s == '=':
            self.add_token('EQUAL', s)
        else:
            print("Internal error: Unknown operator %s" % s)
            raise SystemExit
407386
public void removeName(int i)
   {
      Object name = indexes.remove(i);
      names.remove(name);
      dirty = true;
   }
854341
function removeOne(str, isPi) {
  if (str === '1') {
    return isPi ? 'π' : '';
  }
  if (isPi && str === '-1') {
    return '-π';
  }
  return isPi ? str + 'π' : str;
}
1196724
def remove_bad():
    
    for line in sys.stdin:
        parts = line.strip().split("\t")
        if len(parts) == 1 and len(line.strip().split()) > 1:
            parts = line.strip().split()
        if line.strip() and len(parts) > 2 and int(parts[2]) > int(parts[1]):
            sys.stdout.write("\t".join(parts) + "\n")
328490
def remove_argument(self, name):
        
        for index, arg in enumerate(self.args[:]):
            if name == arg.name:
                del self.args[index]
                break
        return self
895167
def removeInput(self, key_id, input_type='key'):
        
        root = self.etree
        t_inputs = root.find('inputs')

        if not t_inputs:
            return False

        keys = t_inputs.findall(input_type)

        key = [ key for key in keys if key.get('id') == key_id ]

        try:
            t_inputs.remove(key[0])
            return True
        except (Exception,) as e:
            print(e)

        return False
598048
def remove_variable(self, name):
        """"""
        index = self._get_var_index(name)
        # Remove from matrix
        self._A = np.delete(self.A, index, 1)
        # Remove from bounds
        del self.bounds[name]
        # Remove from var list
        del self._variables[name]
        self._update_variable_indices()
        self._reset_solution()