Python cookies.cookiejar_from_dict函数代码示例

 def test_param_cookiejar_works(self):
     cj = cookielib.CookieJar()
     cookiejar_from_dict({'foo' : 'bar'}, cj)
     s = requests.session()
     r = s.get(httpbin('cookies'), cookies=cj)
     # Make sure the cookie was sent
     assert r.json()['cookies']['foo'] == 'bar'

 def test_param_cookiejar_works(self):
     cj = cookielib.CookieJar()
     cookiejar_from_dict({"foo": "bar"}, cj)
     s = requests.session()
     r = s.get(httpbin("cookies"), cookies=cj)
     # Make sure the cookie was sent
     assert r.json()["cookies"]["foo"] == "bar"

 def test_generic_cookiejar_works(self):
     cj = cookielib.CookieJar()
     cookiejar_from_dict({'foo': 'bar'}, cj)
     s = requests.session()
     s.cookies = cj
     r = s.get(httpbin('cookies'))
     # Make sure the cookie was sent
     assert r.json()['cookies']['foo'] == 'bar'
     # Make sure the session cj is still the custom one
     assert s.cookies is cj

    def get_response(self, request):
        # if an error was requested then raise that instead of doing response
        if self._exc:
            raise self._exc

        # If a cookie dict is passed convert it into a CookieJar so that the
        # cookies object available in a callback context is always a jar.
        cookies = self._params.get('cookies', CookieJar())
        if isinstance(cookies, dict):
            cookies = cookiejar_from_dict(cookies, CookieJar())

        context = _Context(self._params.get('headers', {}).copy(),
                           self._params.get('status_code', _DEFAULT_STATUS),
                           self._params.get('reason'),
                           cookies)

        # if a body element is a callback then execute it
        def _call(f, *args, **kwargs):
            return f(request, context, *args, **kwargs) if callable(f) else f

        return create_response(request,
                               json=_call(self._params.get('json')),
                               text=_call(self._params.get('text')),
                               content=_call(self._params.get('content')),
                               body=_call(self._params.get('body')),
                               raw=self._params.get('raw'),
                               status_code=context.status_code,
                               reason=context.reason,
                               headers=context.headers,
                               cookies=context.cookies)

    def _initialize(self):
        """
        .. warning: Called automatically by GoLismero. Do not call!
        """

        # Start a new session.
        self.__session = Session()

        # Load the proxy settings.
        proxy_addr = Config.audit_config.proxy_addr
        if proxy_addr:
            proxy_port = Config.audit_config.proxy_port
            if proxy_port:
                proxy_addr = "%s:%s" % (proxy_addr, proxy_port)
            auth_user = Config.audit_config.proxy_user
            auth_pass = Config.audit_config.proxy_pass
            auth, _ = detect_auth_method(proxy_addr)
            self.__session.auth = get_auth_obj(auth, auth_user, auth_pass)
            self.__session.proxies = {
                "http":  proxy_addr,
                "https": proxy_addr,
                "ftp":   proxy_addr,
            }

        # Load the cookies.
        cookie = Config.audit_config.cookie
        if cookie:
            self.__session.cookies = cookiejar_from_dict(cookie)

        # Set User Agent
        self.__user_agent = Config.audit_config.user_agent

 def __init__(self, login, password, cookies=None, db_session=None):
     if cookies is None:
         log.debug('rutracker cookie not found. Requesting new one')
         payload_ = {'login_username': login,
                     'login_password': password, 'login': 'Вход'}
         auth_response = post(
             "http://login.rutracker.org/forum/login.php", data=payload_, follow_redirects=True,
             cookies=cookiejar_from_dict({'spylog_test': '1'}))
         if len(auth_response.cookies) == 0 or auth_response.cookies is None:
             log.fatal('unable to obtain cookies from rutracker')
             raise PluginError('unable to obtain cookies from rutracker')
         self.cookies_ = auth_response.cookies
         if db_session:
             db_session.add(
                 RutrackerAccount(
                     login=login, cookies=dict_from_cookiejar(
                         self.cookies_),
                     expiry_time=datetime.now() + timedelta(days=1)))
             db_session.commit()
         else:
             raise ValueError(
                 'db_session can not be None if cookies is None')
     else:
         log.debug('Using previously saved cookie')
         self.cookies_ = cookies

def get_cookiejar():
    logged_in_user = os.environ.get('IA_LOGGED_IN_USER')
    logged_in_sig = os.environ.get('IA_LOGGED_IN_SIG')
    if not logged_in_user or not logged_in_sig:
        config = _get_config()
        cookie_config = config.get('cookies', {})
    return cookiejar_from_dict(cookie_config)

    def _initialize(self):
        """
        .. warning: Called automatically by GoLismero. Do not call!
        """

        # Initialize the CA bundle.
        if not environ.get("CURL_CA_BUNDLE"):
            environ["CURL_CA_BUNDLE"] = join(get_data_folder(), "cacert.pem")

        # Start a new session.
        self.__session = Session()

        # Load the proxy settings.
        proxy_addr = Config.audit_config.proxy_addr
        if proxy_addr:
            proxy_port = Config.audit_config.proxy_port
            if proxy_port:
                proxy_addr = "%s:%s" % (proxy_addr, proxy_port)
            auth_user = Config.audit_config.proxy_user
            auth_pass = Config.audit_config.proxy_pass
            auth, _ = detect_auth_method(proxy_addr)
            self.__session.auth = get_auth_obj(auth, auth_user, auth_pass)
            self.__session.proxies = {
                "http":  proxy_addr,
                "https": proxy_addr,
                "ftp":   proxy_addr,
            }

        # Load the cookies.
        cookie = Config.audit_config.cookie
        if cookie:
            self.__session.cookies = cookiejar_from_dict(cookie)

        # Set User Agent
        self.__user_agent = Config.audit_config.user_agent

    def _hello(self):
        log.debug('_hello ...')

        # a new session is required for the app_token
        self.session.http.cookies = cookiejar_from_dict({})
        res = self.session.http.get(self.base_url)
        match = self._app_token_re.search(res.text)

        app_token = match.group(1)
        hello_url = self.API_HELLO.format(self.base_url)

        if self._uuid:
            __uuid = self._uuid
        else:
            __uuid = str(uuid.uuid4())
            self._session_attributes.set(
                'uuid', __uuid, expires=self.TIME_SESSION)

        params = {
            'client_app_token': app_token,
            'uuid': __uuid,
            'lang': 'en',
            'format': 'json'
        }
        res = self.session.http.post(hello_url, headers=self.headers, data=params)

 def start_session(self):
     if self.session is None:
         self.session = Session()
     try:
         with open(COOKIE_JAR_DUMP_FILE, 'rb') as f:
             self.session.cookies = cookiejar_from_dict(pickle.load(f))
     except IOError:
         pass

 def get_session(self):
     session = ProxmoxHttpSession()
     session.verify = self.verify_ssl
     session.auth = self.auth
     session.cookies = cookiejar_from_dict({"PVEAuthCookie": self.auth.pve_auth_cookie})
     session.headers['Connection'] = 'keep-alive'
     session.headers["accept"] = self.get_serializer().get_accept_types()
     return session

    def cookies(self):
        jar = cookiejar_from_dict({})

        if self._cookiejar is not None:
            for cookie in self._cookiejar:
                jar.set_cookie(cookie)

        return jar

 def try_authenticate(self, payload):
     for _ in itertools.repeat(None, 5):
         auth_response = post("http://login.rutracker.org/forum/login.php", data=payload,
                              cookies=cookiejar_from_dict({'spylog_test': '1'}))
         if auth_response.cookies and len(auth_response.cookies) > 0:
             return auth_response
         else:
             sleep(3)
     raise PluginError('unable to obtain cookies from rutracker')

def cookiejar_from_str(cookie_string):
    """
    Returns a CookieJar from a Cookie header string.
    :param cookie_string: Cookie header string
    :return: RequestJar
    """
    tokens = cookie_string.split('; ')
    pairs = [t.split('=', 1) for t in tokens]
    return cookiejar_from_dict(dict(pairs))

    def cookies(self):
        """
        Get a copy of this response's cookies.

        :rtype: :class:`requests.cookies.RequestsCookieJar`
        """
        jar = cookiejar_from_dict({})

        if self._cookiejar is not None:
            for cookie in self._cookiejar:
                jar.set_cookie(cookie)

        return jar