Return either: * The token as passed in by --token * The token for the selected email * 'more'
972619
function(input) {
          if (input) {
            var more = (input && input === 'more');
            var token = options.token || input;
            return (more) ? 'more' : token;
          }
        }
490820
def parse_email(self, email):
        
        splitted = safe_unicode(email).rsplit(",", 1)
        if len(splitted) == 1:
            return (False, splitted[0])
        elif len(splitted) == 2:
            return (splitted[0], splitted[1])
        else:
            raise ValueError("Could not parse email '{}'".format(email))
589484
def email_verification_email(token, root_url)
    @token = token
    @protocol, @host = *root_url.split('://', 2)
    @host.slice!(-1) if @host[-1] == ?/
    hostname = @host.split(':', 2).first  # Strip out any port.

    mail to: @token.email,
         subject: email_verification_subject(token, hostname, @protocol),
         from: email_verification_from(token, hostname, @protocol)
  end
21289
def get_upload_token(mail, pwd):
    '''
    
    '''
    try:
        params = urllib.urlencode({"email": mail, "password": pwd})
        response = urllib.urlopen(LOGIN_URL, params)
    except:
        return None
    resp = json.loads(response.read())
    if not resp or 'token' not in resp:
        return None
    return resp['token']
808797
public String generateEmailConfirmationToken() {
		if (StringUtils.isBlank(identifier)) {
			return "";
		}
		Sysprop s = CoreUtils.getInstance().getDao().read(getAppid(), identifier);
		if (s != null) {
			String token = Utils.base64encURL(Utils.generateSecurityToken().getBytes());
			s.addProperty(Config._EMAIL_TOKEN, token);
			CoreUtils.getInstance().getDao().update(getAppid(), s);
			return token;
		}
		return "";
	}
388827
def url(self, key, includeToken=None):
        
        if self._token and (includeToken or self._showSecrets):
            delim = '&' if '?' in key else '?'
            return '%s%s%sX-Plex-Token=%s' % (self._baseurl, key, delim, self._token)
        return '%s%s' % (self._baseurl, key)
345859
def expect_optional_keyword(lexer: Lexer, value: str) -> Optional[Token]:
    
    token = lexer.token
    if token.kind == TokenKind.NAME and token.value == value:
        lexer.advance()
        return token

    return None
930570
function _parseLeafToken(token) {
  const [, name, remainder] = token.match(LEAF_REGEX);

  return {
    name: name.toLowerCase(),
    params: _parseParams(remainder),
  };
}
4134
def expect_optional_token(lexer: Lexer, kind: TokenKind) -> Optional[Token]:
    
    token = lexer.token
    if token.kind == kind:
        lexer.advance()
        return token

    return None
246204
def t_ID(self, token):
        '
        if token.value in self.KEYWORDS:
            token.type = self.KEYWORDS[token.value]
            return token
        else:
            return token
622886
function overrideEmail(email: string): string {
  if (!_.includes(cfg.email.guardedEnvironments, process.env.NODE_ENV)) {
    return email;
  }
  if (!cfg.email.devEmail) {
    throw new Error("Email failed to send: cfg.email.devEmail is not set");
  }
  return getOverriddenEmail(email);
}
1256907
function processToken(token, done) {
    var user = _.find(users, function (item) {
        return item.username === token[claims.username];
    });
    if (!user) {
        user = {
            id          : token[claims.id] || currId++,
            username    : token[claims.username],
            email       : token[claims.email],
            firstName   : token[claims.firstName],
            lastName    : token[claims.lastName]
        };
        var roles = token[claims.role];
        if (!roles) {
            roles = ["guest"];
        } else if (!(roles instanceof Array)) {
            roles = [roles];
        }
        user.roles = roles;
        users.push(user);
    }
    done(null, user);
}
191654
def same_as?(other_email)
      if other_email.is_a?(String)
        other_email = EmailAddress::Address.new(other_email)
      end

      self.canonical   == other_email.canonical ||
        self.redact    == other_email.canonical ||
        self.canonical == other_email.redact
    end
21398
def token(cls: Type[SIGType], pubkey: str) -> SIGType:
        
        sig = cls()
        sig.pubkey = pubkey
        return sig
10379
def get_request_token(self):
        
        
        if self._request_token is None:
            self._request_token = self._get_request_token()
        return self._request_token
700312
def equivalent_to(self, token):
        
        return self.filter(character_id=token.character_id).require_scopes_exact(token.scopes.all()).filter(
            models.Q(user=token.user) | models.Q(user__isnull=True)).exclude(pk=token.pk)
890028
def as_dict(self, **extra):
        
        return [self._construct_email(email, **extra) for email in self.emails]