BXQc@sdZddlZddlZddlZddlZddlZddlZddlZyddlZeZ [Wn&e k rddl Z e Z [ nXdZ dZ ddlmZmZddlmZddlZejdjZfdZejd Zd Zd Zd Zd ZejdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&ejdZ'dZ(dZ)dZ*dZ+ye,Wne-k rdZ,nXdfdYZ.d fd!YZ/d"e/fd#YZ0d$Z1d%fd&YZ2d'fd(YZ3d)fd*YZ4d+e5fd,YZ6d-e4fd.YZ7dS(/swHTTP cookie handling for web clients. This module originally developed from my port of Gisle Aas' Perl module HTTP::Cookies, from the libwww-perl library. Docstrings, comments and debug strings in this code refer to the attributes of the HTTP cookie system as cookie-attributes, to distinguish them clearly from Python attributes. CookieJar____ / \ FileCookieJar \ / | \ \ MozillaCookieJar | LWPCookieJar \ | | | ---MSIEBase | | / | | | / MSIEDBCookieJar BSDDBCookieJar |/ MSIECookieJar Comments to John J Lee . Copyright 2002-2006 John J Lee Copyright 1997-1999 Gisle Aas (original libwww-perl code) Copyright 2002-2003 Johnny Lee (original MSIE Perl code) This code is free software; you can redistribute it and/or modify it under the terms of the BSD or ZPL 2.1 licenses (see the file COPYING.txt included with the distribution). iNsQa filename was not supplied (nor was the CookieJar instance initialised with one)t80(tsplit_header_wordstparse_ns_headers(t isstringlikesmechanize.cookiescCsddl}ddl}|js'n|tttf}tjd}t||r_nddl }ddl }|j }|j d||j }|jd|dddS(Niismechanize bug! %st stackleveli(t mechanizetwarningstUSE_BARE_EXCEPTtKeyboardInterruptt SystemExitt MemoryErrortsystexc_infot issubclasst tracebacktStringIOt print_exctNonetgetvaluetwarn(tunmaskedRRtetypeRRtftmsg((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreraise_unmasked_exceptions6s   s\.\d+$cCs:tj|p8|dkp8|ddkp8|ddk S(s*Return True if text is a host domain name.tit.i(tIPV4_REtsearch(ttext((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytis_HDNJs cCs|j}|j}||kr(tSt|s8tS|j|}|dkp\|dk }|o|jdot|dS(sReturn True if domain A domain-matches domain B, according to RFC 2965. A and B may be host domain names or IP addresses. RFC 2965, section 1: Host names can be specified either as an IP address or a HDN string. Sometimes we compare one host name with another. (Such comparisons SHALL be case-insensitive.) Host A's name domain-matches host B's if * their host name strings string-compare equal; or * A is a HDN string and has the form NB, where N is a non-empty name string, B has the form .B', and B' is a HDN string. (So, x.y.com domain-matches .Y.com but not Y.com.) Note that domain-match is not a commutative operation: a.b.c.com domain-matches .c.com, but not the reverse. iiRi(tlowertTrueRtFalsetrfindt startswith(tAtBtit has_form_nb((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt domain_matchUs    cCstj| S(sdReturn True if text is a sort-of-like a host domain name. For accepting/blocking domains. (RR(R((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytliberal_is_HDNzscCs|j}|j}t|o-t|sD||kr@tStS|jd}|rl|j|rltS| r||krtStS(s\For blocking/accepting domains. A and B may be host domain names or IP addresses. R(RR)R R!R#tendswith(R$R%t initial_dot((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytuser_domain_matchs   s:\d+$cCsS|j}tj|d}|dkr@|jdd}ntjd|dS(sReturn request-host, as defined by RFC 2965. Variation from RFC: returned value is lowercased, for convenient comparison. itHostRN(t get_full_urlt_rfc3986turlsplitRt get_headert cut_port_retsub(trequestturlthost((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt request_hosts   cCst|jS(N(R7R(R4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytrequest_host_lcscCsLt|}}|jddkrBtj| rB|d}n||fS(s;Return a tuple (request-host, effective request-host name).Ris.local(R7tfindRR(R4terhntreq_host((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyteff_request_hosts% cCs(t|\}}|j|jfS(N(R<R(R4R;R:((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyteff_request_host_lcscCst|dS(s:Return the effective request-host, as defined by RFC 2965.i(R<(R4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyteffective_request_hostscCsE|j}ttj|d}|jdsAd|}n|S(s=Return path component of request-URI, as defined by RFC 2965.it/(R.t escape_pathR/R0R#(R4R5tpath((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt request_paths   cCsr|j}|jd}|dkrh||d}yt|Wqntk rdtd|dSXnt}|S(Nt:iisnonnumeric port: '%s'(tget_hostR9tintt ValueErrortdebugRtDEFAULT_HTTP_PORT(R4R6R&tport((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt request_ports    cCs?y|jSWn*tk r:t|dr4|jSnXdS(Nt unverifiable(tis_unverifiabletAttributeErrorthasattrRK(R4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytrequest_is_unverifiables  s%/;:@&=+$,!~*'()s%([0-9a-fA-F][0-9a-fA-F])cCsd|jdjS(Ns%%%si(tgrouptupper(tmatch((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytuppercase_escaped_charscCsLt|tjr$|jd}ntj|t}tjt |}|S(sEEscape any invalid characters in HTTP URL, and uppercase all escapes.sutf-8( t isinstancettypest UnicodeTypetencodeturllibtquotetHTTP_PATH_SAFEtESCAPED_CHAR_RER3RS(RA((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyR@s cCsk|jd}|dkrg||d}|jd}t|rg|dks\|dkrgd|Sn|S(sBReturn reach of host h, as defined by RFC 2965, section 1. The reach R of a host name H is defined as follows: * If - H is the host domain name of a host; and, - H has the form A.B; and - A has no embedded (that is, interior) dots; and - B has at least one embedded dot, or B is the string "local". then the reach of H is .B. * Otherwise, the reach of H is H. >>> reach("www.acme.com") '.acme.com' >>> reach("acme.com") 'acme.com' >>> reach("acme.local") '.local' Riitlocal(R9R(thR&tb((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreachs $ cCs#t|}t|t|j S(s RFC 2965, section 3.3.6: An unverifiable transaction is to a third-party host if its request- host U does not domain-match the reach R of the request-host O in the origin transaction. (R8R(R_torigin_req_host(R4R;((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytis_third_partys cCsx|D]}|stSqWtS(N(R!R (titerabletx((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytall#s tCookiecBsweZdZdZedZdZddZdZ dZ ddZ dZ dZ dZdZRS(snHTTP Cookie. This class represents both Netscape and RFC 2965 cookies. This is deliberately a very simple class. It just holds attributes. It's possible to construct Cookie instances that don't comply with the cookie standards. CookieJar.make_cookies is the factory function for Cookie objects -- it deals with cookie parsing, supplying defaults, and normalising to the representation used in this class. CookiePolicy is responsible for checking them to see whether they should be accepted from and returned to the server. version: integer; name: string; value: string (may be None); port: string; None indicates no attribute was supplied (e.g. "Port", rather than eg. "Port=80"); otherwise, a port string (eg. "80") or a port list string (e.g. "80,8080") port_specified: boolean; true if a value was supplied with the Port cookie-attribute domain: string; domain_specified: boolean; true if Domain was explicitly set domain_initial_dot: boolean; true if Domain as set in HTTP header by server started with a dot (yes, this really is necessary!) path: string; path_specified: boolean; true if Path was explicitly set secure: boolean; true if should only be returned over secure connection expires: integer; seconds since epoch (RFC 2965 cookies should calculate this value from the Max-Age attribute) discard: boolean, true if this is a session cookie; (if no expires value, this should be true) comment: string; comment_url: string; rfc2109: boolean; true if cookie arrived in a Set-Cookie: (not Set-Cookie2:) header, but had a version cookie-attribute of 1 rest: mapping of other cookie-attributes Note that the port may be present in the headers, but unspecified ("Port" rather than"Port=80", for example); if this is the case, port is None. tversiontnametvalueRItport_specifiedtdomaintdomain_specifiedtdomain_initial_dotRAtpath_specifiedtsecuretexpirestdiscardtcommentt comment_urltrfc2109t_restcCs |dk rt|}n| dk r6t| } n|dkr]|tkr]tdn||_||_||_||_||_|j |_ ||_ ||_ | |_ | |_| |_| |_| |_||_||_||_tj||_dS(Ns-if port is None, port_specified must be false(RRER RFRfRgRhRIRiRRjRkRlRARmRnRoRpRqRrRstcopyRt(tselfRfRgRhRIRiRjRkRlRARmRnRoRpRqRrtrestRs((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__init__]s.                 cCs|jj|S(N(Rtthas_key(RvRg((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pythas_nonstandard_attrscCs|jj||S(N(Rttget(RvRgtdefault((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytget_nonstandard_attrscCs||j|s(Rdt_attrs(RvR((RvRs</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__eq__scCs ||k S(N((RvR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__ne__scCsx|jdkrd}n d|j}|j||j}|jdk rad|j|jf}n |j}d||fS(NRRCs%s=%ss(RIRRjRARhRg(Rvtptlimitt namevalue((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__str__s   cCsg}xgddddddddd d d d d ddgD]2}t||}|jd|t|fq:W|jdt|j|jdt|jddj|S(NRfRgRhRIRiRjRkRlRARmRnRoRpRqRrs%s=%ssrest=%ss rfc2109=%ss Cookie(%s)s, (RtappendtreprRtRstjoin(RvtargsRgtattr((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__repr__s  !(sversionsnamesvaluesportsport_specifiedsdomainsdomain_specifiedsdomain_initial_dotspathspath_specifiedssecuresexpiressdiscardscomments comment_urlsrfc2109s_restN(t__name__t __module__t__doc__RR!RxRzRR}R~RRRRRR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRe*s")        t CookiePolicycBs2eZdZdZdZdZdZRS(sDefines which cookies get accepted from and returned to server. May also modify cookies. The subclass DefaultCookiePolicy defines the standard rules for Netscape and RFC 2965 cookies -- override that if you want a customised policy. As well as implementing set_ok and return_ok, implementations of this interface must also supply the following attributes, indicating which protocols should be used, and how. These can be read and set at any time, though whether that makes complete sense from the protocol point of view is doubtful. Public attributes: netscape: implement netscape protocol rfc2965: implement RFC 2965 protocol rfc2109_as_netscape: WARNING: This argument will change or go away if is not accepted into the Python standard library in this form! If true, treat RFC 2109 cookies as though they were Netscape cookies. The default is for this attribute to be None, which means treat 2109 cookies as RFC 2965 cookies unless RFC 2965 handling is switched off (which it is, by default), and as Netscape cookies otherwise. hide_cookie2: don't add Cookie2 header to requests (the presence of this header indicates to the server that we understand RFC 2965 cookies) cCs tdS(sVReturn true if (and only if) cookie should be accepted from server. Currently, pre-expired cookies never get this far -- the CookieJar class deletes such cookies itself. cookie: mechanize.Cookie object request: object implementing the interface defined by CookieJar.extract_cookies.__doc__ N(tNotImplementedError(RvtcookieR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytset_oks cCs tdS(sReturn true if (and only if) cookie should be returned to server. cookie: mechanize.Cookie object request: object implementing the interface defined by CookieJar.add_cookie_header.__doc__ N(R(RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt return_okscCstS(s\Return false if cookies should not be returned, given cookie domain. This is here as an optimization, to remove the need for checking every cookie with a particular domain (which may involve reading many files). The default implementations of domain_return_ok and path_return_ok (return True) leave all the work to return_ok. If domain_return_ok returns true for the cookie domain, path_return_ok is called for the cookie path. Otherwise, path_return_ok and return_ok are never called for that cookie domain. If path_return_ok returns true, return_ok is called with the Cookie object itself for a full check. Otherwise, return_ok is never called for that cookie path. Note that domain_return_ok is called for every *cookie* domain, not just for the *request* domain. For example, the function might be called with both ".acme.com" and "www.acme.com" if the request domain is "www.acme.com". The same goes for path_return_ok. For argument documentation, see the docstring for return_ok. (R (RvRjR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytdomain_return_okscCstS(s}Return false if cookies should not be returned, given cookie path. See the docstring for domain_return_ok. (R (RvRAR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytpath_return_oks(RRRRRRR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs  tDefaultCookiePolicyc Bs,eZdZdZdZdZdZeeBZdde e de e e e ee e d Z dZ dZ dZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"RS(s-Implements the standard rules for accepting and returning cookies. Both RFC 2965 and Netscape cookies are covered. RFC 2965 handling is switched off by default. The easiest way to provide your own policy is to override this class and call its methods in your overriden implementations before adding your own additional checks. import mechanize class MyCookiePolicy(mechanize.DefaultCookiePolicy): def set_ok(self, cookie, request): if not mechanize.DefaultCookiePolicy.set_ok( self, cookie, request): return False if i_dont_want_to_store_this_cookie(): return False return True In addition to the features required to implement the CookiePolicy interface, this class allows you to block and allow domains from setting and receiving cookies. There are also some strictness switches that allow you to tighten up the rather loose Netscape protocol rules a little bit (at the cost of blocking some benign cookies). A domain blacklist and whitelist is provided (both off by default). Only domains not in the blacklist and present in the whitelist (if the whitelist is active) participate in cookie setting and returning. Use the blocked_domains constructor argument, and blocked_domains and set_blocked_domains methods (and the corresponding argument and methods for allowed_domains). If you set a whitelist, you can turn it off again by setting it to None. Domains in block or allow lists that do not start with a dot must string-compare equal. For example, "acme.com" matches a blacklist entry of "acme.com", but "www.acme.com" does not. Domains that do start with a dot are matched by more specific domains too. For example, both "www.acme.com" and "www.munitions.acme.com" match ".acme.com" (but "acme.com" itself does not). IP addresses are an exception, and must match exactly. For example, if blocked_domains contains "192.168.1.2" and ".168.1.2" 192.168.1.2 is blocked, but 193.168.1.2 is not. Additional Public Attributes: General strictness switches strict_domain: don't allow sites to set two-component domains with country-code top-level domains like .co.uk, .gov.uk, .co.nz. etc. This is far from perfect and isn't guaranteed to work! RFC 2965 protocol strictness switches strict_rfc2965_unverifiable: follow RFC 2965 rules on unverifiable transactions (usually, an unverifiable transaction is one resulting from a redirect or an image hosted on another site); if this is false, cookies are NEVER blocked on the basis of verifiability Netscape protocol strictness switches strict_ns_unverifiable: apply RFC 2965 rules on unverifiable transactions even to Netscape cookies strict_ns_domain: flags indicating how strict to be with domain-matching rules for Netscape cookies: DomainStrictNoDots: when setting cookies, host prefix must not contain a dot (e.g. www.foo.bar.com can't set a cookie for .bar.com, because www.foo contains a dot) DomainStrictNonDomain: cookies that did not explicitly specify a Domain cookie-attribute can only be returned to a domain that string-compares equal to the domain that set the cookie (e.g. rockets.acme.com won't be returned cookies from acme.com that had no Domain cookie-attribute) DomainRFC2965Match: when setting cookies, require a full RFC 2965 domain-match DomainLiberal and DomainStrict are the most useful combinations of the above flags, for convenience strict_ns_set_initial_dollar: ignore cookies in Set-Cookie: headers that have names starting with '$' strict_ns_set_path: don't allow setting cookies whose path doesn't path-match request URI iiiic Cs||_||_||_||_||_||_| |_| |_| |_| |_ |dk rxt ||_ n d|_ |dk rt |}n||_ dS(s Constructor arguments should be used as keyword arguments only. blocked_domains: sequence of domain names that we never accept cookies from, nor return cookies to allowed_domains: if not None, this is a sequence of the only domains for which we accept and return cookies For other arguments, see CookiePolicy.__doc__ and DefaultCookiePolicy.__doc__.. N((tnetscapetrfc2965trfc2109_as_netscapet hide_cookie2t strict_domaintstrict_rfc2965_unverifiabletstrict_ns_unverifiabletstrict_ns_domaintstrict_ns_set_initial_dollartstrict_ns_set_pathRttuplet_blocked_domainst_allowed_domains( Rvtblocked_domainstallowed_domainsRRRRRRRRRR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRxbs              cCs|jS(s4Return the sequence of blocked domains (as a tuple).(R(Rv((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRscCst||_dS(s$Set the sequence of blocked domains.N(RR(RvR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytset_blocked_domainsscCs+x$|jD]}t||r tSq WtS(N(RR,R R!(RvRjtblocked_domain((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt is_blockedscCs|jS(s=Return None, or the sequence of allowed domains (as a tuple).(R(Rv((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRscCs(|dk rt|}n||_dS(s-Set the sequence of allowed domains, or None.N(RRR(RvR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytset_allowed_domainss cCs>|jdkrtSx$|jD]}t||rtSqWtS(N(RRR!R,R (RvRjtallowed_domain((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytis_not_alloweds cCsctd||jd k s"tx:d D]2}d|}t||}|||s)tSq)WtS( s If you override set_ok, be sure to call this method. If it returns false, so should your subclass (assuming your subclass wants to be more strict about which cookies to accept). s - checking cookie %sRft verifiabilityRgRARjRItset_ok_N(sversionRsnamespathsdomainsport(RGRgRtAssertionErrorRR!R (RvRR4tntfn_nametfn((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs   cCsr|jdkr td|tS|jdkrG|j rGtdtS|jdkrn|j rntdtStS(Ns- Set-Cookie2 without version attribute (%s)is$ RFC 2965 cookies are switched offs$ Netscape cookies are switched off(RfRRGR!RRR (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytset_ok_versions   cCskt|rgt|rg|jdkr>|jr>tdtS|jdkrg|jrgtdtSntS(Nis> third-party RFC 2965 cookie during unverifiable transactions> third-party Netscape cookie during unverifiable transaction(RORaRfRRGR!RR (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytset_ok_verifiabilitys  cCsB|jdkr>|jr>|jjdr>td|jtStS(Nit$s' illegal name (starts with '$'): '%s'(RfRRgR#RGR!R (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt set_ok_names cCsm|jrit|}|jdks<|jdkri|jri|j|j ritd|j|tSntS(Nis7 path attribute %s is not a prefix of request path %s( RmRBRfRR#RARGR!R (RvRR4treq_path((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt set_ok_paths   cCs|jr|jr|j}|jds0t|jddkr|jd}||d}|d|!}|jdkrt|dkrt Sqnt S(sReturn False if explicit cookie domain is not acceptable. Called by set_ok_domain, for convenience of overriding by subclasses. RiitcotactcomtedutorgtnettgovtmilREtaerotbiztcattcooptinfotjobstmobitmuseumRgtprottravel(scoRRRRRRRsintRRscatRsinfoRRRsnameRR( RkRRjR#RtcountR"RtlenR!R (RvRR4RjR&ttldtsld((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytset_ok_countrycode_domains     c Cs|j|jr&td|jtS|j|jrLtd|jtS|j||srtd|jtS|jrt|\}}|j}|jdr|d}n|}|j ddk}| r|dkrtd|tS|j dkrK|j | rK|jd rKd|j | rKtd ||tSn|j dksj|j |j @rt||std ||tSn|j dks|j |j@r|t| }|j ddkrtj| rtd ||tSqntS( Ns" domain %s is in user block-lists& domain %s is not in user allow-lists& country-code second level domain %sRiis.locals/ non-local domain %s contains no embedded dotsS effective request-host %s (even with added initial dot) does not end end with %ss5 effective request-host %s does not domain-match %ss. host prefix %s for domain %s contains a dot(RRjRGR!RRRkR=R#R9RfR*RtDomainRFC2965MatchR(tDomainStrictNoDotsRRRR ( RvRR4R;R:Rjtundotted_domaint embedded_dotst host_prefix((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt set_ok_domain sT       cCs|jrt|}|dkr*d}n t|}xt|jjdD]F}yt|Wntk r~td|t SX||krIPqIqIWtd||jt Snt S(NRt,s bad port %s (not numeric)s$ request port (%s) not found in %s( RiRJRtstrRItsplitRERFRGR!R (RvRR4treq_portR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt set_ok_port9s"         cCsNtd|x:d D]2}d|}t||}|||stSqWtS( s If you override return_ok, be sure to call this method. If it returns false, so should your subclass (assuming your subclass wants to be more strict about which cookies to return). s - checking cookie %sRfRRnRoRIRjt return_ok_(sversions verifiabilityssecuresexpiressportsdomain(RGRR!R (RvRR4RRR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRNs   cCsR|jdkr'|j r'tdtS|jdkrN|j rNtdtStS(Nis$ RFC 2965 cookies are switched offs$ Netscape cookies are switched off(RfRRGR!RR (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreturn_ok_versionas  cCskt|rgt|rg|jdkr>|jr>tdtS|jdkrg|jrgtdtSntS(Nis> third-party RFC 2965 cookie during unverifiable transactions> third-party Netscape cookie during unverifiable transaction(RORaRfRRGR!RR (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreturn_ok_verifiabilityjs  cCs-|jr)|jdkr)tdtStS(Nthttpss( secure cookie with non-secure request(Rntget_typeRGR!R (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreturn_ok_securevs cCs$|j|jr tdtStS(Ns cookie expired(Rt_nowRGR!R (RvRR4((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreturn_ok_expires|s cCsu|jrqt|}|dkr*d}nxD|jjdD]}||kr=Pq=q=Wtd||jtSntS(NRRs0 request port %s does not match cookie port %s(RIRJRRRGR!R (RvRR4RR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreturn_ok_ports      c Cst|\}}|j}|jdkr^|j|j@r^|j r^||kr^tdtS|jdkrt|| rtd||tS|jdkrd|j | rtd||tSt S(NisQ cookie with unspecified domain does not string-compare equal to request domainsQ effective request-host name %s does not domain-match RFC 2965 cookie domain %sRs; request-host %s does not match Netscape cookie domain %s( R=RjRfRtDomainStrictNonDomainRkRGR!R(R*R (RvRR4R;R:Rj((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreturn_ok_domains    # cCst|\}}|jds.d|}n|jdsJd|}n|j|pe|j|sltS|j|rtd|tS|j|rtd|tStS(NRs" domain %s is in user block-lists& domain %s is not in user allow-list(R=R#R*R!RRGRR (RvRjR4tdotted_req_hostt dotted_erhn((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs    cCs@td|t|}|j|s<td||tStS(Ns- checking cookie path=%ss %s does not path-match %s(RGRBR#R!R (RvRAR4R((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs   N(#RRRRRRt DomainLiberalt DomainStrictRR R!RxRRRRRRRRRRRRRRRRRRRRRRR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyR sNP  "          .       cCs&|j}|jt|j|S(N(RtsorttmapR{(tadictR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytvals_sorted_by_keys  tMappingIteratorcBs)eZdZdZdZdZRS(sBIterates over nested mapping, depth-first, in sorted order by key.cCst|ddfg|_dS(Ni(RRt_s(Rvtmapping((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRxscCs|S(N((Rv((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__iter__scCsxy|jj\}}}Wntk r;tnX|t|kr||}|d}|jj|||fy |jWntk rPqX|jjt|d|fqqq|S(Nii( Rtpopt IndexErrort StopIterationRRtitemsRMR(RvtvalsR&t prev_itemtitem((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytnexts        (RRRRxRR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs  tAbsentcBseZRS((RR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRst CookieJarcBsFeZdZejdZejdZejdZejdZejdZ ddZ dZ dZ d Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZddddZdZdZdZdZ dZ!dZ"dZ#RS( sCollection of HTTP cookies. You may not need to know about this class: try mechanize.urlopen(). The major methods are extract_cookies and add_cookie_header; these are all you are likely to need. CookieJar supports the iterator protocol: for cookie in cookiejar: # do something with cookie Methods: add_cookie_header(request) extract_cookies(response, request) get_policy() set_policy(policy) cookies_for_request(request) make_cookies(response, request) set_cookie_if_ok(cookie, request) set_cookie(cookie) clear_session_cookies() clear_expired_cookies() clear(domain=None, path=None, name=None) Public attributes policy: CookiePolicy object s\Ws([\"\\])s\.?[^.]*s[^.]*s^\.+cCs7|dkrt}n||_i|_d|_dS(sD See CookieJar.__doc__ for argument documentation. iN(RRt_policyt_cookiest_prev_getitem_index(Rvtpolicy((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRxs     cCs|jS(N(R(Rv((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt get_policy%scCs ||_dS(N(R(RvR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt set_policy(scCsg}|jj||sgStd||j|}x|jD]~}|jj||sgqFn||}xP|jD]B}|jj||stdq~ntd|j|q~WqFW|S(Ns!Checking %s for cookies to returns not returning cookies it's a match( RRRGRRRtvaluesRR(RvRjR4tcookiestcookies_by_pathRAtcookies_by_nameR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt_cookies_for_domain+s      cCsHttj|j_|_|j|}d}|j||S(sOReturn a list of cookies to be returned to server. The returned list of cookie instances is sorted in the order they should appear in the Cookie: header for return to the server. See add_cookie_header.__doc__ for the interface required of the request argument. New in version 0.1.10 cSstt|jt|jS(N(tcmpRRA(RR^((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytdecreasing_sizeLs(RERRRt_cookies_for_requestR(RvR4R R((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytcookies_for_request=s   cCs=g}x0|jjD]}|j|j||qW|S(s2Return a list of cookies to be returned to server.(RRtextendR(RvR4R Rj((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRPsc Cst}g}x|D]}|j}|sQt}|dkrQ|jd|qQn|jd k r|jj|jr|dkr|jj d|j}n |j}|jd kr|j|j n|jd|j |f|dkr|j r |jd|j n|j jdrb|j }|j rN|jdrN|d}n|jd|n|jd k rd }|jr|d |j}n|j|qqqW|S( sZReturn a list of cookie-attributes to be returned to server. The $Version attribute is also added when appropriate (currently only once per request). >>> jar = CookieJar() >>> ns_cookie = Cookie(0, "foo", '"bar"', None, False, ... "example.com", False, False, ... "/", False, False, None, True, ... None, None, {}) >>> jar._cookie_attrs([ns_cookie]) ['foo="bar"'] >>> rfc2965_cookie = Cookie(1, "foo", "bar", None, False, ... ".example.com", True, False, ... "/", False, False, None, True, ... None, None, {}) >>> jar._cookie_attrs([rfc2965_cookie]) ['$Version=1', 'foo=bar', '$Domain="example.com"'] is $Version=%ss\\\1s%s=%ss $Path="%s"Ris $Domain="%s"s$Ports="%s"N(R!RfR RRhRt non_word_reRtquote_reR3RgRmRARjR#RlRIRi( RvR t version_settattrsRRfRhRjR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt _cookie_attrs[s<   !       cCstd|j|}|j|}|r\|jds\|jddj|q\n|jjr|jj rxD|D]9}|j dkr||jd r||jddPq|q|Wn|j dS(sAdd correct Cookie: header to request (mechanize.Request object). The Cookie2 header is also added unless policy.hide_cookie2 is true. The request object (usually a mechanize.Request instance) must support the methods get_full_url, get_host, is_unverifiable, get_type, has_header, get_header, header_items and add_unredirected_header, as documented by urllib2. tadd_cookie_headerRes; itCookie2s $Version="1"N( RGRRt has_headertadd_unredirected_headerRRRRRftclear_expired_cookies(RvR4R RR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs   c Cs@g}d}d}x'|D]}|d \}}t}t} i} i} x|d D]\} } | j}||ks||kr|} n| |kr| dkrt} n| j| rqRn| dkr| dkrtd t} Pn| j} n| dkr3|rqRn| dkr3tdqRq3n| dkrt}| dkretdt} Pnyt| } Wn"tk rtdt} PnXd} |j| } n| |ks| |kr| dkr| dkrtd| t} Pn| | | s   cCstd|jttj|j_|_x|j||D]}|jdk r|j|jkry |j |j |j |j Wnt k rnXtd|j |j |j qE|jj||rEtd||j|qEqEWdS(sExtract cookies from response, where allowable given the request. Look for allowable Set-Cookie: and Set-Cookie2: headers in the response object passed as argument. Any of these headers that are found are used to update the state of the object (subject to the policy.set_ok method's approval). The response object (usually be the result of a call to mechanize.urlopen, or similar) should support an info method, which returns a mimetools.Message object (in fact, the 'mimetools.Message object' may be any object that provides a getheaders method). The request object (usually a mechanize.Request instance) must support the methods get_full_url, get_type, get_host, and is_unverifiable, as documented by mechanize, and the port attribute (the port number). The request is used to set default values for cookie-attributes as well as for checking that the cookie is OK to be set. sextract_cookies: %ss2Expiring cookie, domain='%s', path='%s', name='%s's setting cookie: %sN(RGRRERRRR<RoRtclearRjRARgtKeyErrorRR>(RvR7R4R((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytextract_cookiess!   cCs|dk rH|dks$|dkr3tdn|j|||=nZ|dk r|dkrotdn|j||=n"|dk r|j|=n i|_dS(sClear some cookies. Invoking this method without arguments will clear all cookies. If given a single argument, only cookies belonging to that domain will be removed. If given two arguments, cookies belonging to the specified path within that domain are removed. If given three arguments, then the cookie with the specified name, path and domain is removed. Raises KeyError if no matching cookie exists. s8domain and path must be given to remove a cookie by names.domain must be given to remove cookies by pathN(RRFR(RvRjRARg((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRCs       cCs=x6|D].}|jr|j|j|j|jqqWdS(s Discard all session cookies. Discards all cookies held by object which had either no Max-Age or Expires cookie-attribute or an explicit Discard cookie-attribute, or which otherwise have ended up with a true discard attribute. For interactive browsers, the end of a session usually corresponds to closing the browser window. Note that the save method won't save session cookies anyway, unless you ask otherwise by passing a true ignore_discard argument. N(RpRCRjRARg(RvR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytclear_session_cookiess  cCsOtj}x<|D]4}|j|r|j|j|j|jqqWdS(sDiscard all expired cookies. You probably don't need to call this method: expired cookies are never sent back to the server (provided you're using DefaultCookiePolicy), this method is called by CookieJar itself every so often, and the save method won't save expired cookies anyway (unless you ask otherwise by passing a true ignore_expires argument). N(RRRCRjRARg(RvRR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyR0s  cCs{|dkr|j|_n"|j|dkr@tdn||_y|jjSWntk rvtnXdS(Niis8CookieJar.__getitem__ only supports sequential iteration(Rt_getitem_iteratorRRRR(RvR&((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt __getitem__?s    cCs t|jS(N(RR(Rv((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRJscCs%d}x|D]}|d}q W|S(s#Return number of contained cookies.ii((RvR&R((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt__len__Ms cCsDg}x!|D]}|jt|q Wd|jdj|fS(Ns<%s[%s]>s, (RRt __class__R(RvtrR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRSs cCsDg}x!|D]}|jt|q Wd|jdj|fS(Ns<%s[%s]>s, (RRRJR(RvRKR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRXs N($RRRR,tcompileRRtstrict_domain_ret domain_retdots_reRRxRR RRRRRR*R.R/R0R<R=R?R>RERCRFRRHRRIRR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRs>      D  e R 5 %     t LoadErrorcBseZRS((RR(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRP^st FileCookieJarcBsVeZdZdeddZdeedZdeedZdeedZRS(sCookieJar that can be loaded from and saved to a file. Additional methods save(filename=None, ignore_discard=False, ignore_expires=False) load(filename=None, ignore_discard=False, ignore_expires=False) revert(filename=None, ignore_discard=False, ignore_expires=False) Additional public attributes filename: filename for loading and saving cookies Additional public readable attributes delayload: request that cookies are lazily loaded from disk; this is only a hint since this only affects performance, not behaviour (unless the cookies on disk are changing); a CookieJar object may ignore it (in fact, only MSIECookieJar lazily loads cookies at the moment) cCsTtj|||dk r8t| r8tdn||_t||_dS(s See FileCookieJar.__doc__ for argument documentation. Cookies are NOT loaded from the named file until either the load or revert method is called. sfilename must be string-likeN(RRxRRRFtfilenameR+t delayload(RvRRRSR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRxvs  cCs tdS(sSave cookies to a file. filename: name of file in which to save cookies ignore_discard: save even cookies set to be discarded ignore_expires: save even cookies that have expired The file is overwritten if it already exists, thus wiping all its cookies. Saved cookies can be restored later using the load or revert methods. If filename is not specified, self.filename is used; if self.filename is None, ValueError is raised. N(R(RvRRtignore_discardtignore_expires((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytsaves cCsn|dkr6|jdk r'|j}q6ttnt|}z|j||||Wd|jXdS(sLoad cookies from a file. Old cookies are kept unless overwritten by newly loaded ones. Arguments are as for .save(). If filename is not specified, self.filename is used; if self.filename is None, ValueError is raised. The named file must be in the format understood by the class, or LoadError will be raised. This format will be identical to that written by the save method, unless the load format is not sufficiently well understood (as is the case for MSIECookieJar). N(RRRRFtMISSING_FILENAME_TEXTtopent _really_loadtclose(RvRRRTRUR((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytloads   cCs|dkr6|jdk r'|j}q6ttntj|j}i|_y|j|||Wn#tt fk r||_nXdS(sClear all cookies and reload cookies from a saved file. Raises LoadError (or IOError) if reversion is not successful; the object's state will not be altered if this happens. N( RRRRFRWRutdeepcopyRR[RPtIOError(RvRRRTRUt old_state((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pytreverts    N( RRRRR!RxRVR[R_(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyRQ`s (8RR R,RuRRXRUtloggingt threadingt _threadingt ImportErrortdummy_threadingRWRHt _headersutilRRt_utilRR/t getLoggerRGRRLRRR(R)R,R2R7R8R<R=R>RBRJRORZR[RSR@R_RaRdt NameErrorReRRRRRRt ExceptionRPRQ(((s</scratch/rashmi/Condor_Script/src/mechanize/_clientcookie.pyt!shT      %             #   V  p