Remove a 'constraint' from the bundle

        :parameter str twig: twig to filter for the constraint
        :parameter **kwargs: any other tags to do the filter
            (except twig or context)
347996
def remove_constraint(self, twig=None, **kwargs):
        
        # let's run delayed constraints first to ensure that we get the same
        # results in interactive and non-interactive modes as well as to make
        # sure we don't have delayed constraints for the constraint we're
        #  about to remove.  This could perhaps be optimized by searching
        #  for this/these constraints and only running/removing those, but
        #  probably isn't worth the savings.
        changed_params = self.run_delayed_constraints()

        kwargs['twig'] = twig
        redo_kwargs = deepcopy(kwargs)

        kwargs['context'] = 'constraint'

        # we'll get the constraint so that we can undo the bookkeeping
        # and also reproduce an undo command
        constraint = self.get_parameter(**kwargs)

        # undo parameter bookkeeping
        constraint._remove_bookkeeping()

        # and finally remove it
        self.remove_parameter(**kwargs)


        undo_kwargs = {k: v for k, v in constraint.to_dict().items()
                       if v is not None and
                       k not in ['uniqueid', 'uniquetwig', 'twig',
                                 'Class', 'context']}
        self._add_history(redo_func='remove_constraint',
                          redo_kwargs=redo_kwargs,
                          undo_func='add_constraint',
                          undo_kwargs=undo_kwargs)
504137
def filter(self, *LayoutClasses, **kwargs):
        
        self._check_layout()
        max_level = kwargs.pop('max_level', 0)
        greedy = kwargs.pop('greedy', False)
        filtered_layout_objects = self.layout.get_layout_objects(LayoutClasses, max_level=max_level, greedy=greedy)

        return LayoutSlice(self.layout, filtered_layout_objects)
555435
def remove_constraint(self,name):
        
        constraints = self.constraints
        hidden_constraints = self.hidden_constraints
        my_distribution_skip = self.distribution_skip
        my_selectfrac_skip = self.selectfrac_skip

        if name in constraints:
            hidden_constraints[name] = constraints[name]
            del constraints[name]
            if name in self.distribution_skip:
                my_distribution_skip.remove(name)
            if name in self.selectfrac_skip:
                my_selectfrac_skip.remove(name)
            #self._apply_all_constraints()
        else:
            logging.warning('Constraint {} does not exist.'.format(name))

        self.constraints = constraints
        self.hidden_constraints = hidden_constraints
        self.selectfrac_skip = my_selectfrac_skip
        self.distribution_skip = my_distribution_skip
1309378
def remove_constraint(self,*names):
        
        for name in names:
            for pop in self.poplist:
                if name in pop.constraints:
                    pop.remove_constraint(name)
                else:
                    logging.info('%s model does not have %s constraint' % (pop.model,name))
            if name in self.constraints:
                self.constraints.remove(name)
423906
def remove(self, filter_=None, **kwargs):
        
        if isinstance(filter_, dict) and filter_ == {}:
            raise ValueError('not allowed remove all documents')

        if filter_ is None:
            raise ValueError('not allowed remove all documents')

        if kwargs.pop('multi', False) is True:
            return self.__collect.delete_many(filter_, **kwargs)
        else:
            return self.__collect.delete_one(filter_, **kwargs)
730496
def _delete(self, tree):
        
        tablename = tree.table
        table = self.describe(tablename, require=True)
        kwargs = {}
        visitor = Visitor(self.reserved_words)
        if tree.where:
            constraints = ConstraintExpression.from_where(tree.where)
            kwargs["condition"] = constraints.build(visitor)
        kwargs["expr_values"] = visitor.expression_values
        kwargs["alias"] = visitor.attribute_names
        return self._query_and_op(tree, table, "delete_item", kwargs)
520689
def _constraint(self, params):
        
        if (params["spin1x"]**2 + params["spin1y"]**2 +
                params["spin1z"]**2)**2 > 1:
            return False
        elif (params["spin2x"]**2 + params["spin2y"]**2 +
                  params["spin2z"]**2)**2 > 1:
            return False
        else:
            return True
243784
def remove_parameter(self, name):
		
		spec = self.__specs[name] if name in self.__specs else None
		if spec is not None and spec.optional() is False:
			raise ValueError('Unable to remove a required parameter "%s"' % name)

		WURIQuery.remove_parameter(self, name)
381342
def removeConstraint(self, login, tableName, constraint):
    
    self.send_removeConstraint(login, tableName, constraint)
    self.recv_removeConstraint()
1228859
def remove(*objects, &block)
      if block
        types = objects
        conjunction = Query::Connective::Conjunction.new
        if types.length == 1
          conjunction.add_positive_restriction(TypeField.instance, Query::Restriction::EqualTo, types.first)
        else
          conjunction.add_positive_restriction(TypeField.instance, Query::Restriction::AnyOf, types)
        end
        dsl = DSL::Scope.new(conjunction, setup_for_types(types))
        Util.instance_eval_or_call(dsl, &block)
        indexer.remove_by_scope(conjunction)
      else
        objects.flatten!
        @deletes += objects.length
        objects.each do |object|
          indexer.remove(object)
        end
      end
    end
83339
public boolean removeValidationConstraint(String type, String field, String constraintName) {
		if (!StringUtils.isBlank(type) && !StringUtils.isBlank(field) && constraintName != null) {
			Map<String, Map<String, Map<String, ?>>> fieldsMap = getValidationConstraints().get(type);
			if (fieldsMap != null && fieldsMap.containsKey(field)) {
				if (fieldsMap.get(field).containsKey(constraintName)) {
					fieldsMap.get(field).remove(constraintName);
				}
				if (fieldsMap.get(field).isEmpty()) {
					getValidationConstraints().get(type).remove(field);
				}
				if (getValidationConstraints().get(type).isEmpty()) {
					getValidationConstraints().remove(type);
				}
				return true;
			}
		}
		return false;
	}
1680
def filter_by(self, **kwargs):
        
        query = self._copy()
        for field, value in kwargs.items():
            query.domain.append(
                (field, '=', value)
            )
        return query
1210910
def _remove(self, client_kwargs):
        
        with _handle_client_exception():
            # Object
            if 'obj' in client_kwargs:
                return self.client.delete_object(
                    client_kwargs['container'], client_kwargs['obj'])

            # Container
            return self.client.delete_container(client_kwargs['container'])
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
323353
def filter(self, **kwargs):
        
        self._filters.append(ReadsAlignmentsFilter(**kwargs).filter)
        return self
789597
def exclude(self, *args, **kwargs) -> "QuerySet":
        
        return self._filter_or_exclude(negate=True, *args, **kwargs)
813453
def remove(self, *args):
        '''
        
        '''
        return Plan(reduce(lambda m,k: m.remove(k), args, self.nodes))