def cookie_from_string(text: str, domain: str) -> Cookie: tokens = [t.strip() for t in text.split(";")] name, value = tokens[0].split("=") path = None expires = None for tok in tokens[1:]: k, v = tok.split("=") if k == "path": path = v if k == "expires": expires = parse(v).timestamp() return Cookie( version=0, name=name, value=value, port=None, port_specified=False, domain=domain, domain_specified=True, domain_initial_dot=False, path=path, path_specified=path is not None, secure=False, expires=expires, discard=None, comment=None, comment_url=None, rest=None, rfc2109=False )
def merge_cookies_into_session(cookies_input): jar = _context.session.cookies if isinstance(cookies_input, list): for item in cookies_input: cookie = Cookie( 0, item['name'], item['value'], None, False, item['domain'], True, bool(item['domain'].startswith(".")), item['path'], True, item['secure'], None, False, "", "", [], ) jar.set_cookie(cookie) else: attrs_set = parse_ns_headers(cookies_input.split('; ')) merge_cookies( jar, cookiejar_from_dict({x[0][0]: x[0][1] for x in attrs_set}))
def login(self, mcj): if self.error: return None # if we wanna use https we mast add ssl=enable_ssl to cookie mcj.set_cookie(Cookie(0, "ssl", "enable_ssl", None, False, ".nnmclub.to", True, False, "/", True, False, None, False, None, None, {})) self.session.add_handler(HTTPCookieProcessor(mcj)) response = self._catch_error_request(self.url_login) if not response: return None code = RE_CODE.search(response.decode('cp1251'))[1] form_data = {"username": config['username'], "password": config['password'], "autologin": "******", "code": code, "login": "******"} # so we first encode vals to cp1251 then do default decode whole string data_encoded = urlencode( {k: v.encode('cp1251') for k, v in form_data.items()} ).encode() self._catch_error_request(self.url_login, data_encoded) if self.error: return None logger.debug(f"That we have: {[cookie for cookie in mcj]}") if 'phpbb2mysql_4_sid' in [cookie.name for cookie in mcj]: mcj.save(FILE_C, ignore_discard=True, ignore_expires=True) logger.info('We successfully authorized') else: self.error = "We not authorized, please check your credentials!" logger.warning(self.error)
def authorize(request): phone_number = "" if not os.path.exists('green/config.json'): while(True): phone_number = input("Enter you phone number (+375XXXXXXXXX): ") if re.match(r"^\+375([29|44|25|33]{2})(\d{7})$", phone_number): break else: print("Try again and in correct format") request.post('https://shop.green-market.by/api/v1/auth/request-confirm-code/', json={"phoneNumber" : phone_number}) response = request.post('https://shop.green-market.by/api/v1/auth/verify-confirm-code/', json={"phoneNumber": phone_number, "code" : input("Enter your code: ")}) if response.status_code == STATUS_OK: with open("green/config.json", "w") as write_file: write_file.write(json.dumps(response.cookies._cookies['shop.green-market.by']['/']['Authorization'].__dict__)) else: print("invalid phone number or code") return request else: with open("green/config.json", "r") as read_file: cookie = json.load(read_file) request.cookies.set_cookie(Cookie(*cookie.values())) user_info = request.get('https://shop.green-market.by/api/v1/users/me').json() if user_info.get('pickUpStoreId'): global store_id store_id = user_info.get('pickUpStoreId') return request
def create_cookie(name, value, **kwargs): """Make a cookie from underspecified parameters. By default, the pair of `name` and `value` will be set for the domain '' and sent on every request (this is sometimes called a "supercookie"). """ result = dict( version=0, name=name, value=value, port=None, domain='', path='/', secure=False, expires=None, discard=True, comment=None, comment_url=None, rest={'HttpOnly': None}, rfc2109=False, ) badargs = set(kwargs) - set(result) if badargs: err = 'create_cookie() got unexpected keyword arguments: %s' raise TypeError(err % list(badargs)) result.update(kwargs) result['port_specified'] = bool(result['port']) result['domain_specified'] = bool(result['domain']) result['domain_initial_dot'] = result['domain'].startswith('.') result['path_specified'] = bool(result['path']) return Cookie(**result)
def start(args): """Login and session handler """ # create cookiejar args._cj = LWPCookieJar() # lets urllib handle cookies opener = build_opener(HTTPCookieProcessor(args._cj)) opener.addheaders = [( "User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36" ), ("Accept-Encoding", "identity"), ("Accept-Charset", "utf-8"), ("DNT", "1")] install_opener(opener) # load cookies try: args._cj.load(getCookiePath(args), ignore_discard=True) except IOError: # cookie file does not exist pass args._cj.set_cookie( Cookie(0, "timezoneoffset", str(timezone // 60), None, False, "www.wakanim.tv", False, False, "/", True, False, None, False, None, None, {"HttpOnly": None}, False))
def get_cookie(value='test'): """Helper to create a cookie, which is quite long.""" return Cookie( version=0, name='test-macaroon', value=value, port=None, port_specified=False, domain='snapcraft.io', domain_specified=True, domain_initial_dot=False, path='/', path_specified=True, secure=True, expires=2595425286, discard=False, comment=None, comment_url=None, rest=None, rfc2109=False)
def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None: cookie = Cookie( version=0, name=name, value=value, port=None, port_specified=False, domain=domain, domain_specified=bool(domain), domain_initial_dot=domain.startswith("."), path=path, path_specified=bool(path), secure=False, expires=None, discard=True, comment=None, comment_url=None, rest={}, rfc2109=False, ) self.jar.set_cookie(cookie)
def test_access_invalid_auth_token(service): value = """ .eJwljksOwyAMBe_COpHABgy5TOWv2m3SrKrevUjdzkjz3ic94vTrmY73efuWHi9LR0LjFl5yWAeSPLJ3BcMGLRBnOChDZR_UPKbU6lYWQ_Yw6BrajKP6Eky5OQQTwbKdSV0r0axD2KaKtT6xkYRAWSHMgkKIaUv35ef_DGig9YJ7UOW96uz7pDJ2WXMU4Rm0pO8PiTE6Yg.XcKUnQ.hm2dNwGedmEPV-q8FHuZvgR3Xfg """ cookie = Cookie( version=0, name="session", value=value, port=None, port_specified=False, domain="localhost.local", domain_specified=False, domain_initial_dot=False, path="/", path_specified=True, secure=False, expires=None, discard=True, comment=None, comment_url=None, rest={ "HttpOnly": None }, # type: ignore # TODO: Clean up; this shouldn't require an ignore in theory rfc2109=False, ) service.client.cookie_jar.set_cookie(cookie) response = service.client.get("/api/test/user_protected") assert response.status_code == 401
def test_samesite_invalid(self): cookie = Cookie(name='SESSIONID', comment=None, comment_url=None, discard=False, domain='mozilla.com', domain_initial_dot=False, domain_specified='mozilla.com', expires=None, path='/', path_specified='/', port=443, port_specified=443, rfc2109=False, rest={'HttpOnly': True, 'SameSite': 'Invalid'}, secure=True, version=1, value='bar') self.reqs['session'].cookies.set_cookie(cookie) result = cookies(self.reqs) self.assertEquals('cookies-samesite-flag-invalid', result['result']) self.assertFalse(result['pass']) self.assertIsNone(result['sameSite'])
def mock_cookie(self): """ Makes sure that the cookie is there. """ from http.cookiejar import Cookie self.cookie_storage.write({ 'example.com': { '/': { 'NID': Cookie(version=0, name='NID', value='0000', port=None, port_specified=False, domain='example.com', domain_specified=True, domain_initial_dot=True, path='/', path_specified=True, secure=False, expires=1476201395, discard=False, comment=None, comment_url=None, rest={'HttpOnly': None}, rfc2109=False) } } })
def xuke_login(userName, password): s = requests.session() cookiefile = 'xkcookies.txt' s.cookies = Cookie(cookiefile) s.headers['Referer'] = 'http://cas.hdu.edu.cn/cas/login' try: r = s.get('http://cas.hdu.edu.cn/cas/login', timeout=5) except Exception: print("请求超时") sys.exit(1) data = { 'encodedService': 'http://jxgl.hdu.edu.cn/default.aspx', 'service': 'http://jxgl.hdu.edu.cn/default.aspx', 'serviceName': 'null', 'loginErrCnt': '0', 'username': userName, 'password': hashlib.md5(password.encode()).hexdigest(), 'lt': bs(r.text).select('input[name="lt"]')[0]['value'], } try: r = s.post('http://cas.hdu.edu.cn/cas/login', data=data, timeout=1) s.get(bs(r.text).select('a')[0]['href'], timeout=1) r = s.get('http://jxgl.hdu.edu.cn/xs_main.aspx?xh=%s' % userName) s.cookies.save(ignore_discard=True, ignore_expires=True) except Exception: print("密码错误,请重新登录") sys.exit(1) with open(".username", "w") as f: f.write(userName)
def _init_cookies(cookie_jar: CookieJar, firefox_cookies_path: str): """ Initialize cookies from firefox :param cookie_jar: :param firefox_cookies_path: Firefox Cookies SQLite file For example, in linux, the cookies may at ~/.mozilla/firefox/*/cookies.sqlite :return: """ if firefox_cookies_path is None: firefox_cookies_path = __COOKIES_PATH con = sqlite3.connect(firefox_cookies_path) cur = con.cursor() # noinspection SqlResolve cur.execute("SELECT host, path, isSecure, expiry, name, value FROM moz_cookies") for item in cur.fetchall(): c = Cookie( 0, item[4], item[5], None, False, item[0], item[0].startswith('.'), item[0].startswith('.'), item[1], False, item[2], item[3], item[3] == "", None, None, {} ) cookie_jar.set_cookie(c) return cookie_jar
def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None: """ Set a cookie value by name. May optionally include domain and path. """ kwargs = dict( version=0, name=name, value=value, port=None, port_specified=False, domain=domain, domain_specified=bool(domain), domain_initial_dot=domain.startswith("."), path=path, path_specified=bool(path), secure=False, expires=None, discard=True, comment=None, comment_url=None, rest={"HttpOnly": None}, rfc2109=False, ) cookie = Cookie(**kwargs) # type: ignore self.jar.set_cookie(cookie)
def cookiejar_create(self, cookiejar_file, session): cookie_jar = LWPCookieJar(cookiejar_file.name) cookie_jar.set_cookie( Cookie(0, self.COOKIE_NAME, session, None, False, '', False, True, '/', True, True, None, None, None, None, {})) cookie_jar.save() cookiejar_file.flush()
def test_setting_client_cookies_to_cookiejar() -> None: """ Send a request including a cookie, using a `CookieJar` instance. """ url = "http://example.org/echo_cookies" cookies = CookieJar() cookie = Cookie( version=0, name="example-name", value="example-value", port=None, port_specified=False, domain="", domain_specified=False, domain_initial_dot=False, path="/", path_specified=True, secure=False, expires=None, discard=True, comment=None, comment_url=None, rest={"HttpOnly": ""}, rfc2109=False, ) cookies.set_cookie(cookie) client = httpx.Client(transport=httpx.MockTransport(get_and_set_cookies)) client.cookies = cookies # type: ignore response = client.get(url) assert response.status_code == 200 assert response.json() == {"cookies": "example-name=example-value"}
def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None: """ Set a cookie value by name. May optionally include domain and path. """ kwargs = { "version": 0, "name": name, "value": value, "port": None, "port_specified": False, "domain": domain, "domain_specified": bool(domain), "domain_initial_dot": domain.startswith("."), "path": path, "path_specified": bool(path), "secure": False, "expires": None, "discard": True, "comment": None, "comment_url": None, "rest": { "HttpOnly": None }, "rfc2109": False, } cookie = Cookie(**kwargs) # type: ignore self.jar.set_cookie(cookie)
def test_session_cookie_no_secure_but_hsts(self): cookie = Cookie(name='SESSIONID', comment=None, comment_url=None, discard=False, domain='mozilla.com', domain_initial_dot=False, domain_specified='mozilla.com', expires=None, path='/', path_specified='/', port=443, port_specified=443, rfc2109=False, rest={'HttpOnly': True}, secure=False, version=1, value='bar') self.reqs['session'].cookies.set_cookie(cookie) self.reqs['responses']['https'].headers[ 'Strict-Transport-Security'] = 'max-age=15768000' result = cookies(self.reqs) self.assertEquals( 'cookies-session-without-secure-flag-but-protected-by-hsts', result['result']) self.assertFalse(result['pass'])
def test_session_no_httponly(self): cookie = Cookie(name='SESSIONID', comment=None, comment_url=None, discard=False, domain='mozilla.com', domain_initial_dot=False, domain_specified='mozilla.com', expires=None, path='/', path_specified='/', port=443, port_specified=443, rfc2109=False, rest={}, secure=True, version=1, value='bar') self.reqs['session'].cookies.set_cookie(cookie) result = cookies(self.reqs) self.assertEquals('cookies-session-without-httponly-flag', result['result']) self.assertFalse(result['pass'])
def login(self, mcj): if self.error: return # if we wanna use https we mast add ssl=enable_ssl to cookie mcj.set_cookie(Cookie(0, 'ssl', "enable_ssl", None, False, '.rutracker.org', True, False, '/', True, False, None, 'ParserCookie', None, None, None)) self.session.add_handler(HTTPCookieProcessor(mcj)) form_data = {"login_username": config['username'], "login_password": config['password'], "login": "******"} logger.debug(f"Login. Data before: {form_data}") # so we first encode vals to cp1251 then do default decode whole string data_encoded = urlencode( {k: v.encode('cp1251') for k, v in form_data.items()}).encode() logger.debug(f"Login. Data after: {data_encoded}") self._catch_error_request(self.url + 'login.php', data_encoded) if self.error: return logger.debug(f"That we have: {[cookie for cookie in mcj]}") if 'bb_session' in [cookie.name for cookie in mcj]: mcj.save(FILE_C, ignore_discard=True, ignore_expires=True) logger.info("We successfully authorized") else: self.error = "We not authorized, please check your credentials!" logger.warning(self.error)
def test_anticsrf_without_samesite(self): cookie = Cookie(name='CSRFTOKEN', comment=None, comment_url=None, discard=False, domain='mozilla.com', domain_initial_dot=False, domain_specified='mozilla.com', expires=None, path='/', path_specified='/', port=443, port_specified=443, rfc2109=False, rest={'HttpOnly': True}, secure=True, version=1, value='bar') self.reqs['session'].cookies.set_cookie(cookie) result = cookies(self.reqs) self.assertEquals('cookies-anticsrf-without-samesite-flag', result['result']) self.assertFalse(result['pass']) self.assertFalse(result['sameSite'])
def test_set_cookie_with_cookiejar(): """ Send a request including a cookie, using a `CookieJar` instance. """ url = "http://example.org/echo_cookies" cookies = CookieJar() cookie = Cookie( version=0, name="example-name", value="example-value", port=None, port_specified=False, domain="", domain_specified=False, domain_initial_dot=False, path="/", path_specified=True, secure=False, expires=None, discard=True, comment=None, comment_url=None, rest={"HttpOnly": None}, rfc2109=False, ) cookies.set_cookie(cookie) with Client(dispatch=MockDispatch()) as client: response = client.get(url, cookies=cookies) assert response.status_code == 200 assert response.json() == {"cookies": "example-name=example-value"}
def test_cookie_dict(): c = RetsHttpClient('login_url', 'username', 'password') c._session = mock.MagicMock() jar = RequestsCookieJar() c1 = Cookie( 1, 'name1', 'value1', 80, 80, 'domain', 'domain_specified', 'domain_initial_dot', 'path', 'path_specified', True, True, False, 'comment', 'comment_url', 'rest', ) c2 = Cookie( 1, 'name2', 'value2', 80, 80, 'domain', 'domain_specified', 'domain_initial_dot', 'path', 'path_specified', True, True, False, 'comment', 'comment_url', 'rest', ) jar.set_cookie(c1) jar.set_cookie(c2) c._session.cookies = jar assert c.cookie_dict == {'name1': 'value1', 'name2': 'value2'}
def test_convert_cookie_to_dict(self): cook1 = {'name': 'cook1', 'value': 'value1', 'path': '/', 'secure': False, 'expiry': 1453912471} cookie = Cookie( 0, cook1['name'], cook1['value'], None, False, '.github.com', True, True, cook1['path'], True, cook1['secure'], cook1['expiry'], False, None, None, None, False ) dict1 = convert_cookie_to_dict(cookie) eq_(cook1, dict1)
def create_cookie(self): """ Cookie de autorizacion de logueo """ cookie_jar = CookieJar() cookie = Cookie(0, self.cookie_name, self.cookie_value, self.port, None, self.host, None, None, self.path, None, False, None, None, '', '', None, True) cookie_jar.set_cookie(cookie) return cookie_jar
def test_secure_with_httponly_sessions(self): # Python cookies are the literal worst, seriously, the worst cookie = Cookie(name='SESSIONID', comment=None, comment_url=None, discard=False, domain='mozilla.com', domain_initial_dot=False, domain_specified='mozilla.com', expires=None, path='/', path_specified='/', port=443, port_specified=443, rfc2109=False, rest={'HttpOnly': None}, secure=True, version=1, value='bar') self.reqs['session'].cookies.set_cookie(cookie) cookie = Cookie(name='foo', comment=None, comment_url=None, discard=False, domain='mozilla.com', domain_initial_dot=False, domain_specified='mozilla.com', expires=None, path='/', path_specified='/', port=443, port_specified=443, rfc2109=False, rest={}, secure=True, version=1, value='bar') self.reqs['session'].cookies.set_cookie(cookie) result = cookies(self.reqs) self.assertEquals('cookies-secure-with-httponly-sessions', result['result']) self.assertTrue(result['pass'])
def save_cookie(self, file_name=None, **kwargs): file_name = file_name or self._cookie_file lwp_jar = LWPCookieJar() for item in self._cookie_jar: args = dict(vars(item).items()) args['rest'] = args['_rest'] del (args['_rest']) cookie = Cookie(**args) lwp_jar.set_cookie(cookie) lwp_jar.save(file_name, **kwargs)
def test_foggycam_unpickle_cookies(): foggycam = FoggyCam("joey-tribianni","how-you-doin") cztoken_cookie = Cookie(None, 'cztoken', 'b.000000000', None, None, 'home.nest.com', None, None, '/', None, False, False, 'TestCookie', None, None, None) foggycam.cookie_jar.set_cookie(cztoken_cookie) foggycam.pickle_cookies() foggycam.unpickle_cookies() assert foggycam.nest_access_token
def cookie_from_str(cookie_str): from http.cookiejar import split_header_words, LWPCookieJar, LoadError, Cookie, iso2time import time cookie_str = cookie_str.split('\n') cookie = LWPCookieJar() index = 0 while 1: line = cookie_str[index] index += 1 if line == "": break if not line.startswith(HEADER): continue line = line[len(HEADER):].strip() for data in split_header_words([line]): name, value = data[0] standard = {} rest = {} for k in BOOLEAN_ATTRS: standard[k] = False for k, v in data[1:]: if k is not None: lc = k.lower() else: lc = None if (lc in VALUE_ATTRS) or (lc in BOOLEAN_ATTRS): k = lc if k in BOOLEAN_ATTRS: if v is None: v = True standard[k] = v elif k in VALUE_ATTRS: standard[k] = v else: rest[k] = v h = standard.get expires = h("expires") discard = h("discard") if expires is not None: expires = iso2time(expires) if expires is None: discard = True domain = h("domain") domain_specified = domain.startswith(".") c = Cookie(h("version"), name, value, h("port"), h("port_spec"), domain, domain_specified, h("domain_dot"), h("path"), h("path_spec"), h("secure"), expires, discard, h("comment"), h("commenturl"), rest) cookie.set_cookie(c) return cookie
def __init__(self, pstk='B2F39E7B866A4F13A1207FC98790BD1000000'): print("This is the B365 constructor") super().__init__(self.defaultHeaders) # some 'constants' to use in the creation of the cookies expiry = '1370002304' cookie_host = '.bet365.com' root = '/' port = '80' # Cookie(version, name, value, port, port_specified, domain, # domain_specified, domain_initial_dot, path, path_specified, # secure, expires, discard, comment, comment_url, rest, rfc2109=False) c = Cookie(0, 'session', 'processform=0', port, True, cookie_host, True, False, root, True, False, expiry, False, 'TestCookie', None, None, False) super().addCookie(c) c = Cookie(0, 'pstk', pstk, port, True, cookie_host, True, False, root, True, False, expiry, False, 'TestCookie', None, None, False) super().addCookie(c)
def _really_load(self, f, filename, ignore_discard, ignore_expires): now = time.time() magic = f.readline() if not re.search(self.magic_re, magic): f.close() raise LoadError( "%r does not look like a Netscape format cookies file" % filename) try: while 1: line = f.readline() if line == "": break # last field may be absent, so keep any trailing tab if line.endswith("\n"): line = line[:-1] # skip comments and blank lines XXX what is $ for? if (line.strip().startswith(("#", "$")) or line.strip() == ""): continue domain, domain_specified, path, secure, expires, name, value = \ line.split("\t") secure = (secure == "TRUE") domain_specified = (domain_specified == "TRUE") if name == "": # cookies.txt regards 'Set-Cookie: foo' as a cookie # with no name, whereas cookielib regards it as a # cookie with no value. name = value value = None initial_dot = domain.startswith(".") assert domain_specified == initial_dot discard = False # curl and Wget set expires to 0 for session cookies. if expires == "0" or expires == "": expires = None discard = True # assume path_specified is false c = Cookie(0, name, value, None, False, domain, domain_specified, initial_dot, path, False, secure, expires, discard, None, None, {}) if not ignore_discard and c.discard: continue if not ignore_expires and c.is_expired(now): continue self.set_cookie(c) except IOError: raise except Exception: _warn_unhandled_exception() raise LoadError("invalid Netscape format cookies file %r: %r" % (filename, line))
def _really_load(self, f, filename, ignore_discard, ignore_expires): now = time.time() try: while 1: line = f.readline() if line == "": break # last field may be absent, so keep any trailing tab if line.endswith("\n"): line = line[:-1] sline = line.strip() # support HttpOnly cookies (as stored by curl or old Firefox). if sline.startswith("#HttpOnly_"): line = sline[10:] elif sline.startswith("#") or sline == "": continue domain, domain_specified, path, secure, expires, name, value = line.split( "\t" ) secure = secure == "TRUE" domain_specified = domain_specified == "TRUE" if name == "": # cookies.txt regards 'Set-Cookie: foo' as a cookie # with no name, whereas http.cookiejar regards it as a # cookie with no value. name = value value = None initial_dot = domain.startswith(".") assert domain_specified == initial_dot discard = False if expires == "": expires = None discard = True # assume path_specified is false c = Cookie( 0, name, value, None, False, domain, domain_specified, initial_dot, path, False, secure, expires, discard, None, None, {}, ) if not ignore_discard and c.discard: continue if not ignore_expires and c.is_expired(now): continue self.set_cookie(c) except OSError: raise except Exception: _warn_unhandled_exception() raise OSError( "invalid Netscape format cookies file %r: %r" % (filename, line) )
def load_cookie_data(self, filename, ignore_discard=False, ignore_expires=False): """Load cookies from file containing actual cookie data. Old cookies are kept unless overwritten by newly loaded ones. You should not call this method if the delayload attribute is set. I think each of these files contain all cookies for one user, domain, and path. filename: file containing cookies -- usually found in a file like C:\WINNT\Profiles\joe\Cookies\joe@blah[1].txt """ now = int(time.time()) cookie_data = self._load_cookies_from_file(filename) for cookie in cookie_data: flags = cookie["FLAGS"] secure = ((flags & 0x2000) != 0) filetime = (cookie["HIXP"] << 32) + cookie["LOXP"] expires = epoch_time_offset_from_win32_filetime(filetime) if expires < now: discard = True else: discard = False domain = cookie["DOMAIN"] initial_dot = domain.startswith(".") if initial_dot: domain_specified = True else: # MSIE 5 does not record whether the domain cookie-attribute # was specified. # Assuming it wasn't is conservative, because with strict # domain matching this will match less frequently; with regular # Netscape tail-matching, this will match at exactly the same # times that domain_specified = True would. It also means we # don't have to prepend a dot to achieve consistency with our # own & Mozilla's domain-munging scheme. domain_specified = False # assume path_specified is false # XXX is there other stuff in here? -- e.g. comment, commentURL? c = Cookie(0, cookie["KEY"], cookie["VALUE"], None, False, domain, domain_specified, initial_dot, cookie["PATH"], False, secure, expires, discard, None, None, {"flags": flags}) if not ignore_discard and c.discard: continue if not ignore_expires and c.is_expired(now): continue CookieJar.set_cookie(self, c)