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

    def __init__(self):

        #: A case-insensitive dictionary of headers to be sent on each
        #: :class:`Request <Request>` sent from this
        #: :class:`Session <Session>`.
        self.headers = default_headers()

        #: Default Authentication tuple or object to attach to
        #: :class:`Request <Request>`.
        self.auth = None

        #: Dictionary mapping protocol to the URL of the proxy (e.g.
        #: {'http': 'foo.bar:3128'}) to be used on each
        #: :class:`Request <Request>`.
        self.proxies = {}

        #: Event-handling hooks.
        self.hooks = default_hooks()

        #: Dictionary of querystring data to attach to each
        #: :class:`Request <Request>`. The dictionary values may be lists for
        #: representing multivalued query parameters.
        self.params = {}

        #: Stream response content default.
        self.stream = False

        #: SSL Verification default.
        self.verify = True

        #: SSL certificate default.
        self.cert = None

        #: Maximum number of redirects allowed. If the request exceeds this
        #: limit, a :class:`TooManyRedirects` exception is raised.
        self.max_redirects = DEFAULT_REDIRECT_LIMIT

        #: Should we trust the environment?
        self.trust_env = True

        #: A CookieJar containing all currently outstanding cookies set on this
        #: session. By default it is a
        #: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but
        #: may be any other ``cookielib.CookieJar`` compatible object.
        self.cookies = cookiejar_from_dict({})



        # Only store 1000 redirects to prevent using infinite memory
        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE)

def addLinkSpider(add_link_dictionary):
    # get user's download information from add_link_dictionary
    for i in ['link', 'header', 'out', 'user-agent', 'load-cookies', 'referer']:
        if not (i in add_link_dictionary):
            add_link_dictionary[i] = None

    link = add_link_dictionary['link']
    header = add_link_dictionary['header']
    user_agent = add_link_dictionary['user-agent']
    raw_cookies = add_link_dictionary['load-cookies']
    referer = add_link_dictionary['referer']

    requests_session = requests.Session()  # defining a requests Session

    if raw_cookies:  # set cookies
        cookie = SimpleCookie()
        cookie.load(raw_cookies)

        cookies = {key: morsel.value for key, morsel in cookie.items()}
        requests_session.cookies = cookiejar_from_dict(cookies)

    if referer:
        # set referer to the session
        requests_session.headers.update({'referer': referer})

    if user_agent:
        # set user_agent to the session
        requests_session.headers.update({'user-agent': user_agent})

    # find headers
    response = requests_session.head(link)
    header = response.headers

    file_size = None 
    if 'Content-Length' in header.keys():  # checking if file_size is available
        file_size = int(header['Content-Length'])
        if int(file_size/1073741824) != 0:  # converting file_size to KB or MB or GB
            file_size = file_size/1073741824
            size_str = str(round(file_size, 2)) + " GB"
        elif int(file_size/1048576) != 0:
            size_str = str(int(file_size/1048576)) + " MB"
        elif int(file_size/1024) != 0:
            size_str = str(int(file_size/1024)) + " KB"
        else:
            size_str = str(file_size)
        filesize = size_str



    return filesize

    def build_response(self, req, resp):
        response = Response()

        response.status_code = resp.status_code
        response.headers = CaseInsensitiveDict((k, v) for k, v in resp.items())

        response.encoding = get_encoding_from_headers(response.headers)
        response.raw = StringIO(resp.content)
        response.reason = None

        if isinstance(req.url, bytes):
            response.url = req.url.decode('utf-8')
        else:
            response.url = req.url

        # Convert from django's SimpleCookie to request's CookieJar
        cookiejar_from_dict(resp.cookies, response.cookies)

        # context
        response.request = req
        response.connection = self

        response = dispatch_hook('response', req.hooks, response)
        return response

def queueSpider(add_link_dictionary):
    # get download information from add_link_dictionary
    for i in ['link', 'header', 'out', 'user_agent', 'load_cookies', 'referer']:
        if not (i in add_link_dictionary):
            add_link_dictionary[i] = None

    link = add_link_dictionary['link']
    header = add_link_dictionary['header']
    user_agent = add_link_dictionary['user_agent']
    raw_cookies = add_link_dictionary['load_cookies']
    referer = add_link_dictionary['referer']

    requests_session = requests.Session()  # defining a requests Session

    if raw_cookies:  # set cookies
        cookie = SimpleCookie()
        cookie.load(raw_cookies)

        cookies = {key: morsel.value for key, morsel in cookie.items()}
        requests_session.cookies = cookiejar_from_dict(cookies)

    if referer:
        # set referer to the session
        requests_session.headers.update({'referer': referer})

    if user_agent:
        # set user_agent to the session
        requests_session.headers.update({'user-agent': user_agent})

    # find headers
    try:
        response = requests_session.head(link)
        header = response.headers
    except:
        header = {}
    filename = None
    if 'Content-Disposition' in header.keys():  # checking if filename is available
        content_disposition = header['Content-Disposition']
        if content_disposition.find('filename') != -1:
            filename_splited = content_disposition.split('filename=')
            filename_splited = filename_splited[-1]
            # getting file name in desired format
            filename = filename_splited[1:-1]

    if not(filename):
        filename = link.split('/')[-1]

    return filename

def create_request(session, method, url, params=None, data=None, headers=None, cookies=None, files=None, auth=None):
	cookies = cookies or {}

	if not isinstance(cookies, cookielib.CookieJar):
		cookies = cookiejar_from_dict(cookies)

	merged_cookies = RequestsCookieJar()
	merged_cookies.update(session.cookies)
	merged_cookies.update(cookies)
	cookies = merged_cookies

	params = merge_setting_safe(params, session.params)
	headers = merge_setting_safe(headers, session.headers, dict_class=CaseInsensitiveDict)
	auth = merge_setting_safe(auth, session.auth)

	return Request(method=method.upper(), url=url, headers=headers, files=files, data=data, params=params, auth=auth, cookies=cookies)