Parameters:
     - login
     - property
979564
def removeProperty(self, login, property):
    
    self.send_removeProperty(login, property)
    self.recv_removeProperty()
1351262
def login(self):
        
        response = self._request('Login')
        parser = OneXLogin()
        parser.parse(response)

        self.session_id = response.cookies.get(self.session_id_cookie_name, '')

        if parser.headers.get('RETS-Version') is not None:
            self.version = str(parser.headers.get('RETS-Version'))
            self.client.headers['RETS-Version'] = self.version

        for k, v in parser.capabilities.items():
            self.add_capability(k, v)

        if self.capabilities.get('Action'):
            self._request('Action')
        return True
1051222
def logon(self, password='admin'):
        
        r = self._basic_post(url='logon', data=password)
        return r.json()
1347932
public FessMessages addErrorsSsoLoginError(String property) {
        assertPropertyNotNull(property);
        add(property, new UserMessage(ERRORS_sso_login_error));
        return this;
    }
36766
def init_login(self, from_local=False):
        """"""
        if self.toolbar:
            self.removeToolBar(self.toolbar)
        widget_login = login.Loading(self.statusBar(), self.theory_main)
        self.centralWidget().addWidget(widget_login)
        widget_login.loaded.connect(self.init_tabs)
        widget_login.canceled.connect(self._quit)
        widget_login.updated.connect(self.on_update_at_launch)
        if from_local:
            widget_login.propose_load_local()
        else:
            self.statusBar().showMessage("Données chargées depuis le serveur.", 5000)
253850
function logIn(config, location, options) {
    return Q.Promise(function (resolve, reject) {
      if (isLoggedIn) {
        setLocation(location, options).then(resolve);
        return;
      }
      api.init(config.username, config.password, locWrap(location), config.provider, function (err) {
        if (err) {
          return reject(err);
        }
        isLoggedIn = true;
        resolve();
      });
    });
  }
761697
async def login(
        host: str,
        password: str,
        websession: ClientSession,
        *,
        port: int = 8080,
        ssl: bool = True,
        request_timeout: int = DEFAULT_TIMEOUT) -> Controller:
    """"""
    print('regenmaschine.client.login() is deprecated; see documentation!')
    client = Client(websession, request_timeout)
    await client.load_local(host, password, port, ssl)
    return next(iter(client.controllers.values()))
206767
def login(self, username, password):
        
        r0 = self.req(API_HOME)
        time.sleep(1)
        cookies = dict(r0.cookies)
        data = {
            'source': 'index_nav',
            'form_email': username,
            'form_password': password,
            'remember': 'on',
        }
        r1 = self.req(API_ACCOUNT_LOGIN, method='post', data=data)
        cookies.update(dict(r1.cookies))
        [cookies.update(dict(r.cookies)) for r in r1.history]
        if 'dbcl2' not in cookies:
            raise Exception('Authorization failed for <%s>: %s' % (username, r1.url))
        cookies.update(dict(r1.cookies))
        self.logger.info('login with username <%s>' % username)
        self.use(cookies)
        return self
693895
function (login, pass) {
    try {
        document.getElementsByName("email")[0].value = login;
        document.getElementsByName("pass")[0].value = pass;
        document.getElementById("login_submit").submit();
    } catch (e) {
    }
}
581449
def login_handler(self, config=None, prefix=None, **args):
        
        headers = {}
        headers['Access-control-allow-origin'] = '*'
        headers['Content-type'] = 'text/html'
        auth = request.authorization
        if (auth and auth.username == auth.password):
            return self.set_cookie_close_window_response(
                "valid-http-basic-login")
        else:
            headers['WWW-Authenticate'] = (
                'Basic realm="HTTP-Basic-Auth at %s (u=p to login)"' %
                (self.name))
            return make_response("", 401, headers)
147157
def set_property(self, prop, value):
        """"""
        cmd_url = 'ctrl-int/1/setproperty?{}={}&[AUTH]'.format(
            prop, value)
        return self.daap.post(cmd_url)
351028
def login(self) -> bool:
        
        response = self.get(self.LOGIN_URL)
        login_url = get_base_url(response.text)
        login_data = {'email': self._login, 'pass': self._password}
        login_response = self.post(login_url, login_data)
        url_params = get_url_params(login_response.url)
        self.check_for_additional_actions(url_params,
                                          login_response.text,
                                          login_data)
        if 'remixsid' in self.cookies or 'remixsid6' in self.cookies:
            return True
640153
def login(self):
        """"""
        response = self.session.get(self.signin_url, verify=False)
        user_param, password_param = self._get_hashed_params(response.text)
        login_data = {
            user_param: self.config['username'],
            password_param: self.config['password'],
            'once': self._get_once(response.text),
            'next': '/'
        }
        headers = {'Referer': 'https://www.v2ex.com/signin'}
        self.session.post(self.signin_url, headers=headers, data=login_data)
672537
def _login(self, user, provider=None, remember=False, force=False, **attrs):
        
        user.last_login_at = datetime.datetime.now()
        user.last_login_provider = provider or self.options["default_auth_provider_name"]
        user.last_login_from = request.remote_addr
        populate_obj(user, attrs)
        save_model(user)
        flask_login.login_user(user, remember=remember, force=force)
1337028
def get_user(self, login):
        
        return youtrack.User(self._get("/admin/user/" + urlquote(login.encode('utf8'))), self)
699531
def login(self, schema, username, password):
        
        self.schema = schema
        self.username = username
        self.password = password
        self.connection = schema
987097
def login_not_required(func):
    

    @functools.wraps(func)
    def decorated_view(*args, **kwargs):
        return func(*args, **kwargs)

    return decorated_view