Re-enable a previously disabled user.
761939
async def enable_user(self, username):
        
        user_facade = client.UserManagerFacade.from_connection(
            self.connection())
        entity = client.Entity(tag.user(username))
        return await user_facade.EnableUser([entity])
233002
def access(self, user):
        """"""
        if self.denyusers:
            if user in self.denyusers:
                return False
        if self.allowusers:
            if not user in self.allowusers:
                return False
        return True
958925
def enable(name, **kwargs):
    '''
    
    '''
    cmd = '/usr/sbin/svcadm enable {0}'.format(name)
    return not __salt__['cmd.retcode'](cmd, python_shell=False)
144110
public void actionUnlockUser() throws Exception {

        CmsUUID userId = new CmsUUID(m_paramUserId);
        CmsObject cms = getCms();
        CmsUser user = cms.readUser(userId);
        OpenCms.getLoginManager().unlockUser(getCms(), user);
        actionCloseDialog();
    }
445902
def expand_user(path, user=None):
    """"""

    def _replace(m):
        m_user = m.group(1) or user
        return pwd.getpwnam(m_user).pw_dir if m_user else pwd.getpwuid(os.getuid()).pw_dir

    return re.sub(r'~(\w*)', _replace, path)
958018
def enable(
        self, cmd="enable", pattern=r"(ssword|User Name)", re_flags=re.IGNORECASE
    ):
        
        output = ""
        if not self.check_enable_mode():
            count = 4
            i = 1
            while i < count:
                self.write_channel(self.normalize_cmd(cmd))
                new_data = self.read_until_prompt_or_pattern(
                    pattern=pattern, re_flags=re_flags
                )
                output += new_data
                if "User Name" in new_data:
                    self.write_channel(self.normalize_cmd(self.username))
                    new_data = self.read_until_prompt_or_pattern(
                        pattern=pattern, re_flags=re_flags
                    )
                    output += new_data
                if "ssword" in new_data:
                    self.write_channel(self.normalize_cmd(self.secret))
                    output += self.read_until_prompt()
                    return output
                time.sleep(1)
                i += 1

        if not self.check_enable_mode():
            msg = (
                "Failed to enter enable mode. Please ensure you pass "
                "the 'secret' argument to ConnectHandler."
            )
            raise ValueError(msg)
487500
function reset() {
  const oldOptions = options()
  options({
    wishes: [],
    noWishMerge: true,
    previousId: 0,
    enteredMagicWords: {},
    context: _defaultContext,
    previousContext: _defaultContext,
    enabled: true,
  })
  return oldOptions
}
862287
def retries_disabled(self):
        
        self.os.retries_enabled = False
        yield
        self.os.retries_enabled = True
1357128
def reactivate(self):
        
        self._protocol.connectionLost(None)
        self._protocol = None
        self.terminal.reset()
        self._window.filthy()
        self._window.repaint()
36410
def allow(self, privilege):
        """"""
        assert privilege in PERMISSIONS['user'].keys()
        reading = PERMISSIONS['user'][privilege] + PERMISSIONS['group'][privilege] + PERMISSIONS['other'][privilege]
        os.chmod(self.file_path, reading)
1094278
def guest_unpause(self, userid):
        
        action = "unpause guest '%s'" % userid
        with zvmutils.log_and_reraise_sdkbase_error(action):
            self._vmops.guest_unpause(userid)
687760
def enable():
    '''
    
    '''
    puppet = _Puppet()

    if os.path.isfile(puppet.disabled_lockfile):
        try:
            os.remove(puppet.disabled_lockfile)
        except (IOError, OSError) as exc:
            msg = 'Failed to enable: {0}'.format(exc)
            log.error(msg)
            raise CommandExecutionError(msg)
        else:
            return True
    return False
365111
def _enable_session_activity(self, app):
        """"""
        user_logged_in.connect(login_listener, app)
        user_logged_out.connect(logout_listener, app)
        from .views.settings import blueprint
        from .views.security import security, revoke_session
        blueprint.route('/security/', methods=['GET'])(security)
        blueprint.route('/sessions/revoke/', methods=['POST'])(revoke_session)
411270
def temporarily_enabled(self):
        
        old_setting = self.options.enabled
        self.enable()
        try:
            yield
        finally:
            self.options.enabled = old_setting
500642
def enable(self, cmd="enable-admin", pattern="ssword", re_flags=re.IGNORECASE):
        """"""
        return super(AlcatelSrosSSH, self).enable(
            cmd=cmd, pattern=pattern, re_flags=re_flags
        )
108149
def enable(self):
        """"""
        ret = self.get('enable')
        if ret is None:
            return False
        else:
            return ret.lower().startswith('true')
37669
def unlock(self, password, auth_no_user_interaction=None):
        """"""
        return self._M.Encrypted.Unlock(
            '(sa{sv})',
            password,
            filter_opt({
                'auth.no_user_interaction': ('b', auth_no_user_interaction),
            })
        )