Python Session.auth方法代码示例

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
    def get_http_request(url, payload, method='POST', headers=None, use_proxy=False, use_proxy_auth=False, trust_env=True):
        try:
            session = Session()
            session.trust_env = trust_env
            session.proxies = Util.get_proxies() if use_proxy else None
            session.auth = Util.get_proxy_auth() if use_proxy_auth else None

            request = Request(
                'POST' if method not in ('GET', 'POST') else method,
                url,
                data=payload if method == 'POST' else None,
                params=payload if method == 'GET' else None,
                headers=headers
            )

            prepped = request.prepare()

            response = session.send(
                prepped,
                timeout=app.config['HTTP_REQUESTS_TIMEOUT']
            )

            session.close()
        except Exception, e:
            response = Response()
            response.raise_for_status()
            return response, 'Error al realizar la consulta - Motivo: {}'.format(e.message)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
 def __init__(self, userid, webhost, password=None):
     if not password:
         password = getpass.getpass()
     session = Session()
     session.auth = HTTPBasicAuth(userid, password)
     self.url = "https://{}/footprints/servicedesk/externalapisoap/ExternalApiServicePort?wsdl".format(webhost)
     self.client = Client(self.url, transport=Transport(session=session))

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
    def __init__(self, env, id_correios, password,
                 cert=False, log_config=None, timeout=None):
        ''' Webservice initialization.

        Depending on the env get a different wsdl definition.
        New Correios SIGEP uses HTTPAuth to do requests.

        Args:
            env (str): Environment used to get the wsdl
            id_correios (str): IdCorreios given by correios website
            password (str): password vinculated to the IdCorreios
            log_config (dict): Dictionary configurations of logging
        '''

        ''' Untrusted ssl certificate for homolog envs see more at:

        https://www.ssllabs.com/ssltest/analyze.html?d=apphom.correios.com.br
        '''
        if cert is False:
            verify = False
        else:
            verify = certifi.where()

        self.timeout = timeout or 300

        if log_config is not None and isinstance(log_config, dict):
            """ Example config from zeep documentation:

            {
                'version': 1,
                'formatters': {
                    'verbose': {
                        'format': '%(name)s: %(message)s'
                    }
                },
                'handlers': {
                    'console': {
                        'level': 'DEBUG',
                        'class': 'logging.StreamHandler',
                        'formatter': 'verbose',
                    },
                },
                'loggers': {
                    'zeep.transports': {
                        'level': 'DEBUG',
                        'propagate': True,
                        'handlers': ['console'],
                    },
                }
            }
            """
            logging.config.dictConfig(log_config)

        session = Session()
        session.timeout = self.timeout
        session.verify = verify
        session.auth=(id_correios, password)

        t = Transport(session=session);
        self.client = Client(wsdl=self.get_env(env), transport=t)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
 def create_session(self, alias, headers=None, auth=None, verify="False", cert=None):
     session = Session()
     if headers:
         session.headers.update(headers)
     if auth:
         session.auth = tuple(auth)
     session.verify = self._builtin.convert_to_boolean(verify)
     session.cert = cert
     self._cache.register(session, alias)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
def github_request(method, endpoint, data=None):
    github_session = Session()
    github_session.auth = (env['GITHUB_API_KEY'], 'x-oauth-basic')
    base_url = 'https://api.github.com'
    method_func = getattr(github_session, method.lower())
    response = method_func(
        base_url + endpoint,
        data=data
    )
    return response

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
def connect(scheme='http', hostname='172.16.1.73', port=80, username='cisco', password='cisco'):
    """ Create new Session in _session_cache """
    session = Session()
    session.auth = (username, password)
    url = device_url(scheme, hostname, port)
    session.cookies['device-url'] = url
    session.cookies['command-url'] = url + '/ins'
    response = session.get(url)
    response.raise_for_status()
    assert _nexus_authentication_cookie_name in response.cookies
    return session

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
    def _setup_session(self):
        s = Session()
        if 'verify' in self.settings:  # default is True
            s.verify = self.settings['verify']
        if 'trust_env' in self.settings:
            s.trust_env = self.settings['trust_env']
        if self._auth is not None:
            s.auth = self._auth

        s.headers = merge_setting(  # add our headers to requests' default set
            self._headers, s.headers, dict_class=CaseInsensitiveDict)

        return s

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
def setup_api():
    session = Session()
    session.headers.update({'Host': PRODUCTION_DOMAIN})
    api_config = {
        'base_url': '%s/api/v1/' % API_HOST,
        'session': session,
    }
    if USER and PASS:
        log.debug("Using slumber with user %s, pointed at %s", USER, API_HOST)
        session.auth = (USER, PASS)
    else:
        log.warning("SLUMBER_USERNAME/PASSWORD settings are not set")
    return API(**api_config)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
 def execute_request(method, endpoint, **kwargs):
     url = "http://%s:%d%s" % (leader, MESOS_MASTER_PORT, endpoint)
     timeout = 15
     s = Session()
     s.auth = (get_principal(), get_secret())
     req = Request(method, url, **kwargs)
     prepared = s.prepare_request(req)
     try:
         resp = s.send(
             prepared,
             timeout=timeout,
         )
         resp.raise_for_status()
         return resp
     except HTTPError:
         raise HTTPError("Error executing API request calling %s." % url)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
 def __init__(self):
     if settings.GP_WS_ENABLED:
         cache = SqliteCache(timeout=30 * 24 * 60 * 60)
         session = Session()
         session.auth = HttpNtlmAuth(
             settings.GP_WS_USERNAME, settings.GP_WS_PASSWORD)
         self.client = Client(
             settings.GP_WS_URL,
             transport=Transport(session=session, cache=cache)
         )
         self.ws_factory1 = self.client.type_factory('ns1')
         self.ws_factory2 = self.client.type_factory('ns2')
         company = self.ws_factory2.CompanyKey(settings.GP_COMPANY_ID)
         self.service_context = self.ws_factory2.Context(
             OrganizationKey=company,
             CurrencyType='Local'
         )

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
 def execute_request(method, endpoint, **kwargs):
     url = "http://%s:%d%s" % (leader, MESOS_MASTER_PORT, endpoint)
     timeout = 15
     s = Session()
     s.auth = load_credentials()
     req = Request(method, url, **kwargs)
     prepared = s.prepare_request(req)
     try:
         resp = s.send(
             prepared,
             timeout=timeout,
         )
         resp.raise_for_status()
         return resp
     except HTTPError as e:
         e.msg = "Error executing API request calling %s. Got error: %s" % (url, e.msg)
         raise

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
def session(requests_session=None, uri=None):
    global gerrit_session
    global api_uri

    if requests_session:
        gerrit_session = requests_session

    if uri:
        api_uri = uri

    if gerrit_session is None:
        gerrit_session = Session()
        # get credentials from .netrc:
        (user, password) = get_netrc_auth(api_uri)
        # Gerrit uses HTTP Digest authentication instead of basic:
        gerrit_session.auth = HTTPDigestAuth(user, password)

    return gerrit_session

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
def setup_api():
    session = Session()
    session.headers.update({'Host': PRODUCTION_DOMAIN})
    api_config = {
        'base_url': '%s/api/v2/' % API_HOST,
        'serializer': serialize.Serializer(
            default='json-drf',
            serializers=[
                serialize.JsonSerializer(),
                DrfJsonSerializer(),
            ]
        ),
        'session': session,
    }
    if USER and PASS:
        log.debug("Using slumber v2 with user %s, pointed at %s", USER, API_HOST)
        session.auth = (USER, PASS)
    else:
        log.warning("SLUMBER_USERNAME/PASSWORD settings are not set")
    return API(**api_config)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
def main(url, files, user='', passwd=''):
    # create session
    if 'www.moodle.tum.de' in url:
        session = establish_moodle_session(user, passwd)
    else:
        session = Session()
        session.auth = (user, passwd)
        session.headers = {
            "Accept-Language": "en-US,en;"
        }

    # get file links
    links = get_file_links(session, url, files)

    # download files
    worker = []
    for l in links:
        while active_count() > NUM_THREADS:
            sleep(0.1)
        worker.append(Thread(target=download_files, args=(session, l)).start())

    [t.join() for t in worker if t]

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import auth [as 别名]
    def create_rest_session(self, alias, headers=None, auth=None, verify=False, cert=None):
        """
        Creates REST session with specified alias.

        Arguments:
        | alias | session alias |
        | headers | custom headers for all requests |
        | auth | basic auth |
        | verify | SSL verification |
        | cert | path to SSL certificate file |

        Example usage:
        | ${headers} | Create Dictionary | Content-Type | application/json |
        | @{service_basic_auth} | Set Variable | username | password |
        | Create Rest Session | session_alias | headers=${headers} | auth=${service_basic_auth} | verify=False |
        """
        session = Session()
        if headers:
            session.headers.update(headers)
        if auth:
            session.auth = tuple(auth)
        session.verify = self._builtin.convert_to_boolean(verify)
        session.cert = cert
        self._cache.register(session, alias)