Python Session.post方法代码示例

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def vote_login(username, passwd):
    """login in the univs
	Args:
		username: the account name
		passwd: the passwd

	Returns:
		the session

	"""
    try:
        s = Session()
        sso_url = "http://uzone.univs.cn/sso.action"
        sso_data = {}
        sso_data["gUser.loginName"] = username
        sso_data["gUser.password"] = passwd
        r = s.post(sso_url, data=sso_data)
        if not r.content.find("<code>0</code>") > 0:
            return None
        res1 = s.get("http://mzml.univs.cn:8081/common/checkcode")
        code = json.loads(res1.content)
        check_sso_url = "http://uzone.univs.cn/checkSSOLogin.action?token=%s&subSiteId=%s&checkCode=%s&returnUrl=http://mzml.univs.cn:8081/land.html"
        res2 = s.get(check_sso_url % (code["data"]["date"], code["data"]["subSiteId"], code["data"]["checkout"]))
        codes = res2.url
        sign_in = "http://mzml.univs.cn:8081/user/sigin"
        sign_data = {}
        sign_data["uid"] = codes.split("?")[1].split("&")[1].split("=")[1]
        sign_data["token"] = code["data"]["date"]
        sign_data["checkcode"] = codes.split("?")[1].split("&")[0].split("=")[1]
        s.post(sign_in, data=sign_data)
        return s
    except ConnectionError, Timeout:
        logging.exception("Timeout" + username)
        return 1

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
class AppStatsClient(object):
    limit = 100 # records
    interval = 60 # seconds
    timeout = 1 # timeout in seconds to submit data

    def __init__(self, url, app_id):
        self.url = url
        self.app_id = app_id
        self._acc = defaultdict(Counter)
        self._last_sent = time()
        self._session = Session(
            headers = {'Content-Type': 'application/json'},
            timeout = self.timeout,
        )
        self._req_count = 0

    def add(self, name, counts):
        with lock:
            self._acc[name]['NUMBER'] += 1
            for counter in counts:
                self._acc[name][counter] += counts[counter]
            self._req_count += 1

            elapsed = time() - self._last_sent
            if elapsed >= self.interval or self._req_count >= self.limit:
                self.submit()

    def submit(self):
        data = json.dumps({self.app_id: self._acc})
        try:
            self._session.post(self.url, data=data)
        except RequestException, e:
            log.debug('Error during data submission: %s' % e)
        else:

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def login(username, passwd, url=None):
	"""Login 

	>>> login('6102114000', '000000')  # doctest: +ELLIPSIS
	<requests.sessions.Session object at 0x...>


	"""
	sesion = Session()
	data = {}
	data['USERNAME'] = username
	data['PASSWORD'] = passwd
	data['useDogCode'] = ''
	data['x'] = 37
	data['y'] = 8
	ip = LOGIN_HOST [int(username)%3]
	try:
		res = sesion.post(ip % ('Logon.do?method=logon'), data=data, timeout=TIME_OUT)
		res = sesion.post(ip % ('Logon.do?method=logonBySSO'), timeout=TIME_OUT)
		if res.ok:
			return sesion
		else:
			return WRONG_USENAME
	except RequestException as error:
		return CONECTION_ERROR

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
    def login(self, username, password):
        s = Session()
        # login over bogi.ru
        params = {"login": username, "password": password}
        r1 = s.post(self.login_url, params, verify=False)
        # in case of failed login, bogi redirects to:
        # http://www.lostfilm.tv/blg.php?code=6&text=incorrect%20login/password
        if r1.request.url != self.login_url:
            url = urlparse(r1.url)
            if url.netloc == self.netloc:
                query = parse_qs(url.query)
                code = int(query.get('code', ['-1'])[0])
                text = query.get('text', "-")
                r1.encoding = 'windows-1251'
                message = r1.text
                raise LostFilmTVLoginFailedException(code, text, message)
            else:
                raise LostFilmTVLoginFailedException(-1, None, None)

        # callback to lostfilm.tv
        soup = BeautifulSoup(r1.text)
        inputs = soup.findAll("input")
        action = soup.find("form")['action']
        cparams = dict([(i['name'], i['value']) for i in inputs if 'value' in i.attrs])
        s.post(action, cparams, verify=False)

        # call to profile page
        r3 = s.get(self.profile_url)

        # read required params
        self.c_uid = s.cookies['uid']
        self.c_pass = s.cookies['pass']
        self.c_usess = self.search_usess_re.findall(r3.text)[0]

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
    def login(cls, username, password):
        login_url = "https://login1.bogi.ru/login.php?referer=https%3A%2F%2Fwww.lostfilm.tv%2F"
        profile_url = 'http://www.lostfilm.tv/my.php'
        search_usess_re = re.compile(u'\(usess=([a-f0-9]{32})\)', re.IGNORECASE)

        cls_params = {'login': username, 'password': password}

        s = Session()
        # login over bogi.ru
        params = {"login": username, "password": password}
        r1 = s.post(login_url, params, verify=False)
        # in case of failed login, bogi redirects to:
        # http://www.lostfilm.tv/blg.php?code=6&text=incorrect%20login/password
        if r1.request.url != login_url:
            raise Exception('Can\'t login into lostfilm.tv')

        soup = get_soup(r1.text)
        inputs = soup.findAll("input")
        action = soup.find("form")['action']
        cparams = dict([(i['name'], i['value']) for i in inputs if 'value' in i.attrs])
        cls_params['bogi_uid'] = cparams['uid']
        cls_params['email'] = cparams['email']
        s.post(action, cparams, verify=False, allow_redirects=False)
        r3 = s.get(profile_url)
        cls_params['uid'] = s.cookies['uid']
        cls_params['_pass'] = s.cookies['pass']
        cls_params['usess'] = search_usess_re.findall(r3.text)[0]

        return cls(**cls_params)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def main():
    for user in create_login_payload():
        logging.info('Opening a Grafana session...')
        session = Session()
        login(session, user)

        if check_initialized(session):
            logging.info('Grafana has already been initialized, skipping!')
            return

        logging.info('Attempting to add configured datasource...')
        r = session.post('{url}/api/datasources'.format(url=GRAFANA_URL),
                         json=create_datasource_payload())
        logging.debug('Response: %r', r.json())
        r.raise_for_status()

        for path in sorted(glob.glob('{dir}/*.json'.format(dir=DASHBOARDS_DIR))):
            logging.info('Creating dashboard from file: {path}'.format(path=path))
            r = session.post('{url}/api/dashboards/db'.format(url=GRAFANA_URL),
                             json=create_dashboard_payload(path))
            logging.debug('Response: %r', r.json())
            r.raise_for_status()

        logging.info('Ending %r session...', user.get('user'))
        session.get('{url}/logout'.format(url=GRAFANA_URL))

    logging.info('Finished successfully.')

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
class Requester(object):
    def __init__(self):
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:41.0) Gecko/20100101 Firefox/41.0'
        }
        self.session = Session()
        self.session.headers.update(self.headers)

        max_retries_adapter = adapters.HTTPAdapter(max_retries=5)
        self.session.mount('http://', max_retries_adapter)
        self.session.mount('https://', max_retries_adapter)

    def get(self, url):
        return self.session.get(url)

    def post(self, url, data):
        return self.session.post(url, data)

    def post_json(self, url, data):
        return self.session.post(url, json=data)

    def post_file(self, url, file_name):
        files = {
            'file': open(file_name, 'rb'),
        }
        return self.session.post(url, files=files)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def getJefferson(num, predir, name, suffix, postdir):
    url = 'http://www.jeffersoncountyclerk.org/WhereDoIVote/Default.aspx'
    addrStr = '{0} {1} {2} {3} {4}'.format(num, predir, name, suffix, postdir)
    addrStr = addrStr.strip().replace('   ', ' ').replace('  ', ' ')
    session = Session()
    data = {'count': 20, 'prefixText': addrStr}
    header = {'Content-Type': 'application/json; charset=UTF-8'}
    response = session.post(url + '/GetAddress', data=json.dumps(data),
                            headers=header)
    data = json.loads(response.text)
    addresses = data['d']
    address = matchString(addrStr, addresses)
    html = session.get(url).text
    fields = getHiddenValues(BeautifulSoup(html).find('form'))
    fields['txtStreet'] = address
    fields['cmdDisplay'] = 'Search'
    response = session.post(url, data=fields)
    soup = BeautifulSoup(response.text)
    name = ''
    address = ''
    ppid = ''
    nameLabel = soup.find('span', {'id': 'lblLocation'})
    addressLabel = soup.find('span', {'id': 'lblAddress'})
    if nameLabel is not None:
        name = nameLabel.string.strip()
    if addressLabel is not None:
        address = addressLabel.string.strip()
        address += ' LOUISVILLE, KY'
    return ppid, name, address

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def log_in(username: str, password: str) -> Optional[Tuple[Session, str]]:
    s = Session()
    response = s.get(BB_HOST + '/wps/portal/ibank/')
    if response.status_code >= 400:
        logger.debug(response.status_code)
        return None
    doc = html.fromstring(response.text.encode('utf-8'))

    action = doc.cssselect('form.loginForm')[0].get('action')
    login_step_one_response = s.post(BB_HOST + action, data={
        'bbIbUseridField': username,
        'bbIbPasswordField': password,
        'bbIbLoginAction': 'in-action',
    })
    logger.debug(login_step_one_response)
    if login_step_one_response.status_code >= 400:
        return None
    doc = html.fromstring(login_step_one_response.text.encode('utf-8'))
    action = doc.cssselect('form[name=LoginForm1]')[0].get('action')
    key_number = re.compile('.*?(\d+)').match(doc.cssselect('input[name=bbIbCodevalueField]')[0].get('placeholder')).group(1)
    logger.debug(key_number)
    login_step_two_request = {
        'cancelindicator': 'false',
        'bbIbLoginAction': 'in-action',
        'bbIbCodevalueField': get_key(key_number),
    }
    for field in ('field_1', 'field_2', 'field_3', 'field_4', 'field_5'):
        login_step_two_request[field] = doc.cssselect('form input[name={}]'.format(field))[0].get('value')
    login_step_two_response = s.post(BB_HOST + action, data=login_step_two_request)
    logger.debug('Login, step 2 response code is {}'.format(login_step_two_response.status_code))
    if login_step_two_response.status_code >= 400:
        return None

    return s, login_step_two_response.text.encode('utf-8')

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def auth_asi():
    s = Session()
    s.post(auth_url, data=auth)
    r = s.get(link_url)
    doc = pq(r.text)
    asi, = parse_qs(doc('a[href*="&asi="]').attr('href'))['asi']
    return {'session': s, 'asi': asi}

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def restartRouter():

    MUTEX.acquire()

    try:
        global lastRestart

        if datetime.now() - lastRestart < TIEMPO_ENTRE_RESTARTS:
            print "Reinicio de router no aceptado, no paso suficiente tiempo"
            return

        s = Session()
        data = {
            'action': 'login',
            'frashnum':'',
            'Frm_Logintoken':'0',
            'Username': 'instalador',
            'Password': 'wwzz2233',

            }
        #Inicio sesion y obtengo cookie
        try:
            print "Reiniciando router"
            print "Iniciando sesion en router..."
            r = s.get('http://192.168.1.1/')

            try:    
                data['Frm_Logintoken'] = routerParseRegex.search(r.text).group(1)
            except:
                print "Error obteniendo login token... intentando de todas formas"

            r = s.post('http://192.168.1.1/', data=data)
            
            print "Cookie de session obtenida: " + s.cookies.get('SID','NINGUNA')
            
                        
            print "Reiniciando router..."
            data = {
                'IF_ACTION':'devrestart',
                'IF_ERRORSTR':'SUCC',
                'IF_ERRORPARAM':'SUCC',
                'IF_ERRORTYPE':'-1',
                'flag':'1'
            }
            r = s.post('http://192.168.1.1/getpage.gch?pid=1002&nextpage=manager_dev_conf_t.gch', data=data)

            print "Router reiniciado"

            lastRestart = datetime.now()

        except Exception as e:
            raise Exception("Error en login: "+str(e))


    except Exception as e:
        print "Error al reiniciar router: "+str(e)
    finally:
        MUTEX.release()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
class PWSAdmin(object):
    def __init__(self, endpoint, username, password):
        self.endpoint = endpoint
        self.credentials = {'ID': username, 'password': password}
        self.session = None

    def _page(self, page):
        return self.endpoint + page

    def dbinfo(self):
        soup = self.fetch_soup('dbmaint.asp')
        tables = self.table(soup, 'table', simple=True)
        return map(dbinfo_transform, tables)

    def fetch_soup(self, page):
        r = self.session.get(self._page(page))
        if r.status_code == 302:
            raise Exception('Redirected while fetching ' + page)
        return BeautifulSoup(r.content, 'lxml')

    def post_soup(self, page, data=None):
        r = self.session.post(self._page(page), data=data)
        if r.status_code == 302:
            raise Exception('Redirected while fetching ' + page)
        return BeautifulSoup(r.content, 'lxml')

    def login(self):
        self.session = Session()
        self.session.post(self._page('layout_menu.asp'), data=self.credentials)

    def rooms(self):
        table = self.table(self.fetch_soup('mproom.asp'), 'table.tablesorter')
        return map(room_transform, table)

    def table(self, soup, selector, simple=False):
        tables = soup.select(selector)[0]

        if simple:
            rows = tables.select('tr')
            headers = clean_els(rows[0].select('td'))
            rows = rows[1:]
        else:
            rows = tables.select('tbody tr')
            headers = clean_els(tables.select('thead tr th'))

        return map(lambda r: dict(zip(headers, clean_els(r.select('td')))), rows)

    def user_transactions(self, userid, start, end):
        params = dict(expand_date(start, 'start').items() + expand_date(end, 'end').items())
        params = (params.items() + {
            'id': userid,
            'action': 'SEARCH',
            'Submit': 'Submit',
            'username': ''
        }.items())

        soup = self.post_soup('listtransactions.asp', params)
        return map(txn_transform, self.table(soup, 'table.tablesorter'))

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
 def try_authenticate(self, payload):
     for _ in range(5):
         s = RSession()
         s.post("http://login.rutracker.org/forum/login.php", data=payload)
         if s.cookies and len(s.cookies) > 0:
             return s.cookies
         else:
             sleep(3)
     raise PluginError('unable to obtain cookies from rutracker')

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
 def try_authenticate(self, payload):
     for _ in range(5):
         s = RSession()
         s.post('{}/forum/login.php'.format(self.base_url), data=payload)
         if s.cookies and len(s.cookies) > 0:
             return s.cookies
         else:
             sleep(3)
     raise PluginError('unable to obtain cookies from rutracker')

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import post [as 别名]
def establish_moodle_session(user, passwd):
    session = Session()

    response = session.get('https://www.moodle.tum.de')
    response = session.get('https://www.moodle.tum.de/Shibboleth.sso/Login?providerId=https://tumidp.lrz.de/idp/shibboleth&target=https://www.moodle.tum.de/auth/shibboleth/index.php')
    response = session.post('https://tumidp.lrz.de/idp/profile/SAML2/Redirect/SSO?execution=e1s1', data={'j_username': user, 'j_password': passwd, '_eventId_proceed':''})

    parsed = html.fromstring(response.text)

    session.post('https://www.moodle.tum.de/Shibboleth.sso/SAML2/POST',
                 data={'RelayState': parsed.forms[0].fields['RelayState'],
                       'SAMLResponse': parsed.forms[0].fields['SAMLResponse']})

    return session