Re-apply constraint that had been removed

        :param name:
            Name of constraint to replace

        :param selectfrac_skip,distribution_skip: (optional)
            Same as :func:`StarPopulation.apply_constraint`
344585
def replace_constraint(self,name,selectfrac_skip=False,distribution_skip=False):
        
        hidden_constraints = self.hidden_constraints
        if name in hidden_constraints:
            c = hidden_constraints[name]
            self.apply_constraint(c,selectfrac_skip=selectfrac_skip,
                                  distribution_skip=distribution_skip)
            del hidden_constraints[name]
        else:
            logging.warning('Constraint {} not available for replacement.'.format(name))

        self.hidden_constraints = hidden_constraints
479526
def select_param(param_name, default=None):
    

    def select_param(_value, _context, **params):
        return params.pop(param_name, default)

    return select_param
1317540
def _should_ignore(self, name):
        
        _name = name.lower()
        return (_name.startswith("deprecated") or
                _name.startswith("_") or
                _name in ("remote", "reserved",
                          "dialogs_py", "dialogs_ipy", "dialogs_jy"))
414584
def where(name)
      # Must define the attributes before constraining them
      raise ArgumentError, "Unknown attribute: #{name}" unless @attributes.include? name
      @constraints[name] = AttributeConstraint.new(name)
    end
94841
def Update(self,name):
		

		r = clc.v2.API.Call('PUT','antiAffinityPolicies/%s/%s' % (self.alias,self.id),{'name': name},session=self.session)
		self.name = name
596111
def removeLayer(self, name):
        
        name = normalizers.normalizeLayerName(name)
        if name not in self.layerOrder:
            raise ValueError("No layer with the name '%s' exists." % name)
        self._removeLayer(name)
1294297
def set_missing_value_policy(self, policy, target_attr_name=None):
        
        assert policy in MISSING_VALUE_POLICIES, \
            "Unknown policy: %s" % (policy,)
        for attr_name in self.data.attribute_names:
            if target_attr_name is not None and target_attr_name != attr_name:
                continue
            self.missing_value_policy[attr_name] = policy
963090
def select_model(self, name):
        
        if name not in self._parent:
            raise KeyError('model "{}" not present'.format(name))
        self._current_model_group = name
786756
def absent(name):
    '''
    
    '''
    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}

    # Make name all Uppers since make.conf uses all Upper vars
    upper_name = name.upper()

    old_value = __salt__['makeconf.get_var'](upper_name)

    if old_value is None:
        msg = 'Variable {0} is already absent from make.conf'
        ret['comment'] = msg.format(name)
    else:
        if __opts__['test']:
            msg = 'Variable {0} is set to be removed from make.conf'
            ret['comment'] = msg.format(name)
            ret['result'] = None
        else:
            __salt__['makeconf.remove_var'](upper_name)

            new_value = __salt__['makeconf.get_var'](upper_name)
            if new_value is not None:
                msg = 'Variable {0} failed to be removed from make.conf'
                ret['comment'] = msg.format(name)
                ret['result'] = False
            else:
                msg = 'Variable {0} was removed from make.conf'
                ret['comment'] = msg.format(name)
                ret['result'] = True
    return ret
1297882
public void skippedEntity(String name) throws SAXException
  {

    if (DEBUG)
      System.out.println("TransformerHandlerImpl#skippedEntity: " + name);

    if (m_contentHandler != null)
    {
      m_contentHandler.skippedEntity(name);
    }
  }
975071
def removed(name):
    '''
    
    '''
    ret = {'name': name, 'result': None, 'comment': '', 'changes': {}}
    if name not in __salt__['pecl.list']():
        ret['result'] = True
        ret['comment'] = 'Pecl extension {0} is not installed.'.format(name)
        return ret

    if __opts__['test']:
        ret['comment'] = ('Pecl extension {0} would have been removed'
                          .format(name))
        return ret
    if __salt__['pecl.uninstall'](name):
        ret['result'] = True
        ret['changes'][name] = 'Removed'
        ret['comment'] = ('Pecl extension {0} was successfully removed.'
                          .format(name))
    else:
        ret['result'] = False
        ret['comment'] = 'Could not remove pecl extension {0}.'.format(name)
    return ret
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)
845160
def drop_index(self, name):
        
        name = self._normalize_identifier(name)
        if not self.has_index(name):
            raise IndexDoesNotExist(name, self._name)

        del self._indexes[name]
922641
def absent(name, exports='/etc/exports'):
    '''
    
    '''

    path = name
    ret = {'name': name,
           'changes': {},
           'result': None,
           'comment': ''}

    old = __salt__['nfs3.list_exports'](exports)
    if path in old:
        if __opts__['test']:
            ret['comment'] = 'Export {0} would be removed'.format(path)
            ret['changes'][path] = old[path]
            ret['result'] = None
            return ret

        __salt__['nfs3.del_export'](exports, path)
        try_reload = __salt__['nfs3.reload_exports']()
        if not try_reload['result']:
            ret['comment'] = try_reload['stderr']
        else:
            ret['comment'] = 'Export {0} removed'.format(path)

        ret['result'] = try_reload['result']
        ret['changes'][path] = old[path]
    else:
        ret['comment'] = 'Export {0} already absent'.format(path)
        ret['result'] = True

    return ret
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
517810
def apply_default_constraints(self):
        
        try:
            self.apply_secthresh(pipeline_weaksec(self.koi))
        except NoWeakSecondaryError:
            logging.warning('No secondary eclipse threshold set for {}'.format(self.koi))
        self.set_maxrad(default_r_exclusion(self.koi))
597260
def countok(self):
        
        ok = np.ones(len(self.stars)).astype(bool)
        for name in self.constraints:
            c = self.constraints[name]
            if c.name not in self.selectfrac_skip:
                ok &= c.ok
        return ok