<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: cookies.py.tar</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>opt/hc_python/lib/python3.12/site-packages/requests/cookies.py                                      0000644                 00000044236 15051675120 0020350 0                                                                                                    ustar 00                                                                                                                                                                                                                                                       &quot;&quot;&quot;
requests.cookies
~~~~~~~~~~~~~~~~

Compatibility code to be able to use `http.cookiejar.CookieJar` with requests.

requests.utils imports from here, so be careful with imports.
&quot;&quot;&quot;

import calendar
import copy
import time

from ._internal_utils import to_native_string
from .compat import Morsel, MutableMapping, cookielib, urlparse, urlunparse

try:
    import threading
except ImportError:
    import dummy_threading as threading


class MockRequest:
    &quot;&quot;&quot;Wraps a `requests.Request` to mimic a `urllib2.Request`.

    The code in `http.cookiejar.CookieJar` expects this interface in order to correctly
    manage cookie policies, i.e., determine whether a cookie can be set, given the
    domains of the request and the cookie.

    The original request object is read-only. The client is responsible for collecting
    the new headers via `get_new_headers()` and interpreting them appropriately. You
    probably want `get_cookie_header`, defined below.
    &quot;&quot;&quot;

    def __init__(self, request):
        self._r = request
        self._new_headers = {}
        self.type = urlparse(self._r.url).scheme

    def get_type(self):
        return self.type

    def get_host(self):
        return urlparse(self._r.url).netloc

    def get_origin_req_host(self):
        return self.get_host()

    def get_full_url(self):
        # Only return the response's URL if the user hadn't set the Host
        # header
        if not self._r.headers.get(&quot;Host&quot;):
            return self._r.url
        # If they did set it, retrieve it and reconstruct the expected domain
        host = to_native_string(self._r.headers[&quot;Host&quot;], encoding=&quot;utf-8&quot;)
        parsed = urlparse(self._r.url)
        # Reconstruct the URL as we expect it
        return urlunparse(
            [
                parsed.scheme,
                host,
                parsed.path,
                parsed.params,
                parsed.query,
                parsed.fragment,
            ]
        )

    def is_unverifiable(self):
        return True

    def has_header(self, name):
        return name in self._r.headers or name in self._new_headers

    def get_header(self, name, default=None):
        return self._r.headers.get(name, self._new_headers.get(name, default))

    def add_header(self, key, val):
        &quot;&quot;&quot;cookiejar has no legitimate use for this method; add it back if you find one.&quot;&quot;&quot;
        raise NotImplementedError(
            &quot;Cookie headers should be added with add_unredirected_header()&quot;
        )

    def add_unredirected_header(self, name, value):
        self._new_headers[name] = value

    def get_new_headers(self):
        return self._new_headers

    @property
    def unverifiable(self):
        return self.is_unverifiable()

    @property
    def origin_req_host(self):
        return self.get_origin_req_host()

    @property
    def host(self):
        return self.get_host()


class MockResponse:
    &quot;&quot;&quot;Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.

    ...what? Basically, expose the parsed HTTP headers from the server response
    the way `http.cookiejar` expects to see them.
    &quot;&quot;&quot;

    def __init__(self, headers):
        &quot;&quot;&quot;Make a MockResponse for `cookiejar` to read.

        :param headers: a httplib.HTTPMessage or analogous carrying the headers
        &quot;&quot;&quot;
        self._headers = headers

    def info(self):
        return self._headers

    def getheaders(self, name):
        self._headers.getheaders(name)


def extract_cookies_to_jar(jar, request, response):
    &quot;&quot;&quot;Extract the cookies from the response into a CookieJar.

    :param jar: http.cookiejar.CookieJar (not necessarily a RequestsCookieJar)
    :param request: our own requests.Request object
    :param response: urllib3.HTTPResponse object
    &quot;&quot;&quot;
    if not (hasattr(response, &quot;_original_response&quot;) and response._original_response):
        return
    # the _original_response field is the wrapped httplib.HTTPResponse object,
    req = MockRequest(request)
    # pull out the HTTPMessage with the headers and put it in the mock:
    res = MockResponse(response._original_response.msg)
    jar.extract_cookies(res, req)


def get_cookie_header(jar, request):
    &quot;&quot;&quot;
    Produce an appropriate Cookie header string to be sent with `request`, or None.

    :rtype: str
    &quot;&quot;&quot;
    r = MockRequest(request)
    jar.add_cookie_header(r)
    return r.get_new_headers().get(&quot;Cookie&quot;)


def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
    &quot;&quot;&quot;Unsets a cookie by name, by default over all domains and paths.

    Wraps CookieJar.clear(), is O(n).
    &quot;&quot;&quot;
    clearables = []
    for cookie in cookiejar:
        if cookie.name != name:
            continue
        if domain is not None and domain != cookie.domain:
            continue
        if path is not None and path != cookie.path:
            continue
        clearables.append((cookie.domain, cookie.path, cookie.name))

    for domain, path, name in clearables:
        cookiejar.clear(domain, path, name)


class CookieConflictError(RuntimeError):
    &quot;&quot;&quot;There are two cookies that meet the criteria specified in the cookie jar.
    Use .get and .set and include domain and path args in order to be more specific.
    &quot;&quot;&quot;


class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
    &quot;&quot;&quot;Compatibility class; is a http.cookiejar.CookieJar, but exposes a dict
    interface.

    This is the CookieJar we create by default for requests and sessions that
    don't specify one, since some clients may expect response.cookies and
    session.cookies to support dict operations.

    Requests does not use the dict interface internally; it's just for
    compatibility with external client code. All requests code should work
    out of the box with externally provided instances of ``CookieJar``, e.g.
    ``LWPCookieJar`` and ``FileCookieJar``.

    Unlike a regular CookieJar, this class is pickleable.

    .. warning:: dictionary operations that are normally O(1) may be O(n).
    &quot;&quot;&quot;

    def get(self, name, default=None, domain=None, path=None):
        &quot;&quot;&quot;Dict-like get() that also supports optional domain and path args in
        order to resolve naming collisions from using one cookie jar over
        multiple domains.

        .. warning:: operation is O(n), not O(1).
        &quot;&quot;&quot;
        try:
            return self._find_no_duplicates(name, domain, path)
        except KeyError:
            return default

    def set(self, name, value, **kwargs):
        &quot;&quot;&quot;Dict-like set() that also supports optional domain and path args in
        order to resolve naming collisions from using one cookie jar over
        multiple domains.
        &quot;&quot;&quot;
        # support client code that unsets cookies by assignment of a None value:
        if value is None:
            remove_cookie_by_name(
                self, name, domain=kwargs.get(&quot;domain&quot;), path=kwargs.get(&quot;path&quot;)
            )
            return

        if isinstance(value, Morsel):
            c = morsel_to_cookie(value)
        else:
            c = create_cookie(name, value, **kwargs)
        self.set_cookie(c)
        return c

    def iterkeys(self):
        &quot;&quot;&quot;Dict-like iterkeys() that returns an iterator of names of cookies
        from the jar.

        .. seealso:: itervalues() and iteritems().
        &quot;&quot;&quot;
        for cookie in iter(self):
            yield cookie.name

    def keys(self):
        &quot;&quot;&quot;Dict-like keys() that returns a list of names of cookies from the
        jar.

        .. seealso:: values() and items().
        &quot;&quot;&quot;
        return list(self.iterkeys())

    def itervalues(self):
        &quot;&quot;&quot;Dict-like itervalues() that returns an iterator of values of cookies
        from the jar.

        .. seealso:: iterkeys() and iteritems().
        &quot;&quot;&quot;
        for cookie in iter(self):
            yield cookie.value

    def values(self):
        &quot;&quot;&quot;Dict-like values() that returns a list of values of cookies from the
        jar.

        .. seealso:: keys() and items().
        &quot;&quot;&quot;
        return list(self.itervalues())

    def iteritems(self):
        &quot;&quot;&quot;Dict-like iteritems() that returns an iterator of name-value tuples
        from the jar.

        .. seealso:: iterkeys() and itervalues().
        &quot;&quot;&quot;
        for cookie in iter(self):
            yield cookie.name, cookie.value

    def items(self):
        &quot;&quot;&quot;Dict-like items() that returns a list of name-value tuples from the
        jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
        vanilla python dict of key value pairs.

        .. seealso:: keys() and values().
        &quot;&quot;&quot;
        return list(self.iteritems())

    def list_domains(self):
        &quot;&quot;&quot;Utility method to list all the domains in the jar.&quot;&quot;&quot;
        domains = []
        for cookie in iter(self):
            if cookie.domain not in domains:
                domains.append(cookie.domain)
        return domains

    def list_paths(self):
        &quot;&quot;&quot;Utility method to list all the paths in the jar.&quot;&quot;&quot;
        paths = []
        for cookie in iter(self):
            if cookie.path not in paths:
                paths.append(cookie.path)
        return paths

    def multiple_domains(self):
        &quot;&quot;&quot;Returns True if there are multiple domains in the jar.
        Returns False otherwise.

        :rtype: bool
        &quot;&quot;&quot;
        domains = []
        for cookie in iter(self):
            if cookie.domain is not None and cookie.domain in domains:
                return True
            domains.append(cookie.domain)
        return False  # there is only one domain in jar

    def get_dict(self, domain=None, path=None):
        &quot;&quot;&quot;Takes as an argument an optional domain and path and returns a plain
        old Python dict of name-value pairs of cookies that meet the
        requirements.

        :rtype: dict
        &quot;&quot;&quot;
        dictionary = {}
        for cookie in iter(self):
            if (domain is None or cookie.domain == domain) and (
                path is None or cookie.path == path
            ):
                dictionary[cookie.name] = cookie.value
        return dictionary

    def __contains__(self, name):
        try:
            return super().__contains__(name)
        except CookieConflictError:
            return True

    def __getitem__(self, name):
        &quot;&quot;&quot;Dict-like __getitem__() for compatibility with client code. Throws
        exception if there are more than one cookie with name. In that case,
        use the more explicit get() method instead.

        .. warning:: operation is O(n), not O(1).
        &quot;&quot;&quot;
        return self._find_no_duplicates(name)

    def __setitem__(self, name, value):
        &quot;&quot;&quot;Dict-like __setitem__ for compatibility with client code. Throws
        exception if there is already a cookie of that name in the jar. In that
        case, use the more explicit set() method instead.
        &quot;&quot;&quot;
        self.set(name, value)

    def __delitem__(self, name):
        &quot;&quot;&quot;Deletes a cookie given a name. Wraps ``http.cookiejar.CookieJar``'s
        ``remove_cookie_by_name()``.
        &quot;&quot;&quot;
        remove_cookie_by_name(self, name)

    def set_cookie(self, cookie, *args, **kwargs):
        if (
            hasattr(cookie.value, &quot;startswith&quot;)
            and cookie.value.startswith('&quot;')
            and cookie.value.endswith('&quot;')
        ):
            cookie.value = cookie.value.replace('\\&quot;', &quot;&quot;)
        return super().set_cookie(cookie, *args, **kwargs)

    def update(self, other):
        &quot;&quot;&quot;Updates this jar with cookies from another CookieJar or dict-like&quot;&quot;&quot;
        if isinstance(other, cookielib.CookieJar):
            for cookie in other:
                self.set_cookie(copy.copy(cookie))
        else:
            super().update(other)

    def _find(self, name, domain=None, path=None):
        &quot;&quot;&quot;Requests uses this method internally to get cookie values.

        If there are conflicting cookies, _find arbitrarily chooses one.
        See _find_no_duplicates if you want an exception thrown if there are
        conflicting cookies.

        :param name: a string containing name of cookie
        :param domain: (optional) string containing domain of cookie
        :param path: (optional) string containing path of cookie
        :return: cookie.value
        &quot;&quot;&quot;
        for cookie in iter(self):
            if cookie.name == name:
                if domain is None or cookie.domain == domain:
                    if path is None or cookie.path == path:
                        return cookie.value

        raise KeyError(f&quot;name={name!r}, domain={domain!r}, path={path!r}&quot;)

    def _find_no_duplicates(self, name, domain=None, path=None):
        &quot;&quot;&quot;Both ``__get_item__`` and ``get`` call this function: it's never
        used elsewhere in Requests.

        :param name: a string containing name of cookie
        :param domain: (optional) string containing domain of cookie
        :param path: (optional) string containing path of cookie
        :raises KeyError: if cookie is not found
        :raises CookieConflictError: if there are multiple cookies
            that match name and optionally domain and path
        :return: cookie.value
        &quot;&quot;&quot;
        toReturn = None
        for cookie in iter(self):
            if cookie.name == name:
                if domain is None or cookie.domain == domain:
                    if path is None or cookie.path == path:
                        if toReturn is not None:
                            # if there are multiple cookies that meet passed in criteria
                            raise CookieConflictError(
                                f&quot;There are multiple cookies with name, {name!r}&quot;
                            )
                        # we will eventually return this as long as no cookie conflict
                        toReturn = cookie.value

        if toReturn:
            return toReturn
        raise KeyError(f&quot;name={name!r}, domain={domain!r}, path={path!r}&quot;)

    def __getstate__(self):
        &quot;&quot;&quot;Unlike a normal CookieJar, this class is pickleable.&quot;&quot;&quot;
        state = self.__dict__.copy()
        # remove the unpickleable RLock object
        state.pop(&quot;_cookies_lock&quot;)
        return state

    def __setstate__(self, state):
        &quot;&quot;&quot;Unlike a normal CookieJar, this class is pickleable.&quot;&quot;&quot;
        self.__dict__.update(state)
        if &quot;_cookies_lock&quot; not in self.__dict__:
            self._cookies_lock = threading.RLock()

    def copy(self):
        &quot;&quot;&quot;Return a copy of this RequestsCookieJar.&quot;&quot;&quot;
        new_cj = RequestsCookieJar()
        new_cj.set_policy(self.get_policy())
        new_cj.update(self)
        return new_cj

    def get_policy(self):
        &quot;&quot;&quot;Return the CookiePolicy instance used.&quot;&quot;&quot;
        return self._policy


def _copy_cookie_jar(jar):
    if jar is None:
        return None

    if hasattr(jar, &quot;copy&quot;):
        # We're dealing with an instance of RequestsCookieJar
        return jar.copy()
    # We're dealing with a generic CookieJar instance
    new_jar = copy.copy(jar)
    new_jar.clear()
    for cookie in jar:
        new_jar.set_cookie(copy.copy(cookie))
    return new_jar


def create_cookie(name, value, **kwargs):
    &quot;&quot;&quot;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 &quot;supercookie&quot;).
    &quot;&quot;&quot;
    result = {
        &quot;version&quot;: 0,
        &quot;name&quot;: name,
        &quot;value&quot;: value,
        &quot;port&quot;: None,
        &quot;domain&quot;: &quot;&quot;,
        &quot;path&quot;: &quot;/&quot;,
        &quot;secure&quot;: False,
        &quot;expires&quot;: None,
        &quot;discard&quot;: True,
        &quot;comment&quot;: None,
        &quot;comment_url&quot;: None,
        &quot;rest&quot;: {&quot;HttpOnly&quot;: None},
        &quot;rfc2109&quot;: False,
    }

    badargs = set(kwargs) - set(result)
    if badargs:
        raise TypeError(
            f&quot;create_cookie() got unexpected keyword arguments: {list(badargs)}&quot;
        )

    result.update(kwargs)
    result[&quot;port_specified&quot;] = bool(result[&quot;port&quot;])
    result[&quot;domain_specified&quot;] = bool(result[&quot;domain&quot;])
    result[&quot;domain_initial_dot&quot;] = result[&quot;domain&quot;].startswith(&quot;.&quot;)
    result[&quot;path_specified&quot;] = bool(result[&quot;path&quot;])

    return cookielib.Cookie(**result)


def morsel_to_cookie(morsel):
    &quot;&quot;&quot;Convert a Morsel object into a Cookie containing the one k/v pair.&quot;&quot;&quot;

    expires = None
    if morsel[&quot;max-age&quot;]:
        try:
            expires = int(time.time() + int(morsel[&quot;max-age&quot;]))
        except ValueError:
            raise TypeError(f&quot;max-age: {morsel['max-age']} must be integer&quot;)
    elif morsel[&quot;expires&quot;]:
        time_template = &quot;%a, %d-%b-%Y %H:%M:%S GMT&quot;
        expires = calendar.timegm(time.strptime(morsel[&quot;expires&quot;], time_template))
    return create_cookie(
        comment=morsel[&quot;comment&quot;],
        comment_url=bool(morsel[&quot;comment&quot;]),
        discard=False,
        domain=morsel[&quot;domain&quot;],
        expires=expires,
        name=morsel.key,
        path=morsel[&quot;path&quot;],
        port=None,
        rest={&quot;HttpOnly&quot;: morsel[&quot;httponly&quot;]},
        rfc2109=False,
        secure=bool(morsel[&quot;secure&quot;]),
        value=morsel.value,
        version=morsel[&quot;version&quot;] or 0,
    )


def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
    &quot;&quot;&quot;Returns a CookieJar from a key/value dictionary.

    :param cookie_dict: Dict of key/values to insert into CookieJar.
    :param cookiejar: (optional) A cookiejar to add the cookies to.
    :param overwrite: (optional) If False, will not replace cookies
        already in the jar with new ones.
    :rtype: CookieJar
    &quot;&quot;&quot;
    if cookiejar is None:
        cookiejar = RequestsCookieJar()

    if cookie_dict is not None:
        names_from_jar = [cookie.name for cookie in cookiejar]
        for name in cookie_dict:
            if overwrite or (name not in names_from_jar):
                cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))

    return cookiejar


def merge_cookies(cookiejar, cookies):
    &quot;&quot;&quot;Add cookies to cookiejar and returns a merged CookieJar.

    :param cookiejar: CookieJar object to add the cookies to.
    :param cookies: Dictionary or CookieJar object to be added.
    :rtype: CookieJar
    &quot;&quot;&quot;
    if not isinstance(cookiejar, cookielib.CookieJar):
        raise ValueError(&quot;You can only merge into CookieJar&quot;)

    if isinstance(cookies, dict):
        cookiejar = cookiejar_from_dict(cookies, cookiejar=cookiejar, overwrite=False)
    elif isinstance(cookies, cookielib.CookieJar):
        try:
            cookiejar.update(cookies)
        except AttributeError:
            for cookie_in_jar in cookies:
                cookiejar.set_cookie(cookie_in_jar)

    return cookiejar
                                                                                                                                                                                                                                                                                                                                                                  opt/alt/python-internal/lib64/python3.11/http/cookies.py                                            0000644                 00000046600 15052000170 0017006 0                                                                                                    ustar 00                                                                                                                                                                                                                                                       ####
# Copyright 2000 by Timothy O'Malley &lt;timo@alum.mit.edu&gt;
#
#                All Rights Reserved
#
# Permission to use, copy, modify, and distribute this software
# and its documentation for any purpose and without fee is hereby
# granted, provided that the above copyright notice appear in all
# copies and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Timothy O'Malley  not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
# ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
####
#
# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
#   by Timothy O'Malley &lt;timo@alum.mit.edu&gt;
#
#  Cookie.py is a Python module for the handling of HTTP
#  cookies as a Python dictionary.  See RFC 2109 for more
#  information on cookies.
#
#  The original idea to treat Cookies as a dictionary came from
#  Dave Mitchell (davem@magnet.com) in 1995, when he released the
#  first version of nscookie.py.
#
####

r&quot;&quot;&quot;
Here's a sample session to show how to use this module.
At the moment, this is the only documentation.

The Basics
----------

Importing is easy...

   &gt;&gt;&gt; from http import cookies

Most of the time you start by creating a cookie.

   &gt;&gt;&gt; C = cookies.SimpleCookie()

Once you've created your Cookie, you can add values just as if it were
a dictionary.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;fig&quot;] = &quot;newton&quot;
   &gt;&gt;&gt; C[&quot;sugar&quot;] = &quot;wafer&quot;
   &gt;&gt;&gt; C.output()
   'Set-Cookie: fig=newton\r\nSet-Cookie: sugar=wafer'

Notice that the printable representation of a Cookie is the
appropriate format for a Set-Cookie: header.  This is the
default behavior.  You can change the header and printed
attributes by using the .output() function

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;rocky&quot;] = &quot;road&quot;
   &gt;&gt;&gt; C[&quot;rocky&quot;][&quot;path&quot;] = &quot;/cookie&quot;
   &gt;&gt;&gt; print(C.output(header=&quot;Cookie:&quot;))
   Cookie: rocky=road; Path=/cookie
   &gt;&gt;&gt; print(C.output(attrs=[], header=&quot;Cookie:&quot;))
   Cookie: rocky=road

The load() method of a Cookie extracts cookies from a string.  In a
CGI script, you would use this method to extract the cookies from the
HTTP_COOKIE environment variable.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C.load(&quot;chips=ahoy; vienna=finger&quot;)
   &gt;&gt;&gt; C.output()
   'Set-Cookie: chips=ahoy\r\nSet-Cookie: vienna=finger'

The load() method is darn-tootin smart about identifying cookies
within a string.  Escaped quotation marks, nested semicolons, and other
such trickeries do not confuse it.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C.load('keebler=&quot;E=everybody; L=\\&quot;Loves\\&quot;; fudge=\\012;&quot;;')
   &gt;&gt;&gt; print(C)
   Set-Cookie: keebler=&quot;E=everybody; L=\&quot;Loves\&quot;; fudge=\012;&quot;

Each element of the Cookie also supports all of the RFC 2109
Cookie attributes.  Here's an example which sets the Path
attribute.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;oreo&quot;] = &quot;doublestuff&quot;
   &gt;&gt;&gt; C[&quot;oreo&quot;][&quot;path&quot;] = &quot;/&quot;
   &gt;&gt;&gt; print(C)
   Set-Cookie: oreo=doublestuff; Path=/

Each dictionary element has a 'value' attribute, which gives you
back the value associated with the key.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;twix&quot;] = &quot;none for you&quot;
   &gt;&gt;&gt; C[&quot;twix&quot;].value
   'none for you'

The SimpleCookie expects that all values should be standard strings.
Just to be sure, SimpleCookie invokes the str() builtin to convert
the value to a string, when the values are set dictionary-style.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;number&quot;] = 7
   &gt;&gt;&gt; C[&quot;string&quot;] = &quot;seven&quot;
   &gt;&gt;&gt; C[&quot;number&quot;].value
   '7'
   &gt;&gt;&gt; C[&quot;string&quot;].value
   'seven'
   &gt;&gt;&gt; C.output()
   'Set-Cookie: number=7\r\nSet-Cookie: string=seven'

Finis.
&quot;&quot;&quot;

#
# Import our required modules
#
import re
import string
import types

__all__ = [&quot;CookieError&quot;, &quot;BaseCookie&quot;, &quot;SimpleCookie&quot;]

_nulljoin = ''.join
_semispacejoin = '; '.join
_spacejoin = ' '.join

#
# Define an exception visible to External modules
#
class CookieError(Exception):
    pass


# These quoting routines conform to the RFC2109 specification, which in
# turn references the character definitions from RFC2068.  They provide
# a two-way quoting algorithm.  Any non-text character is translated
# into a 4 character sequence: a forward-slash followed by the
# three-digit octal equivalent of the character.  Any '\' or '&quot;' is
# quoted with a preceding '\' slash.
# Because of the way browsers really handle cookies (as opposed to what
# the RFC says) we also encode &quot;,&quot; and &quot;;&quot;.
#
# These are taken from RFC2068 and RFC2109.
#       _LegalChars       is the list of chars which don't require &quot;'s
#       _Translator       hash-table for fast quoting
#
_LegalChars = string.ascii_letters + string.digits + &quot;!#$%&amp;'*+-.^_`|~:&quot;
_UnescapedChars = _LegalChars + ' ()/&lt;=&gt;?@[]{}'

_Translator = {n: '\\%03o' % n
               for n in set(range(256)) - set(map(ord, _UnescapedChars))}
_Translator.update({
    ord('&quot;'): '\\&quot;',
    ord('\\'): '\\\\',
})

_is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch

def _quote(str):
    r&quot;&quot;&quot;Quote a string for use in a cookie header.

    If the string does not need to be double-quoted, then just return the
    string.  Otherwise, surround the string in doublequotes and quote
    (with a \) special characters.
    &quot;&quot;&quot;
    if str is None or _is_legal_key(str):
        return str
    else:
        return '&quot;' + str.translate(_Translator) + '&quot;'


_unquote_sub = re.compile(r'\\(?:([0-3][0-7][0-7])|(.))').sub

def _unquote_replace(m):
    if m[1]:
        return chr(int(m[1], 8))
    else:
        return m[2]

def _unquote(str):
    # If there aren't any doublequotes,
    # then there can't be any special characters.  See RFC 2109.
    if str is None or len(str) &lt; 2:
        return str
    if str[0] != '&quot;' or str[-1] != '&quot;':
        return str

    # We have to assume that we must decode this string.
    # Down to work.

    # Remove the &quot;s
    str = str[1:-1]

    # Check for special sequences.  Examples:
    #    \012 --&gt; \n
    #    \&quot;   --&gt; &quot;
    #
    return _unquote_sub(_unquote_replace, str)

# The _getdate() routine is used to set the expiration time in the cookie's HTTP
# header.  By default, _getdate() returns the current time in the appropriate
# &quot;expires&quot; format for a Set-Cookie header.  The one optional argument is an
# offset from now, in seconds.  For example, an offset of -3600 means &quot;one hour
# ago&quot;.  The offset may be a floating point number.
#

_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

_monthname = [None,
              'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
    from time import gmtime, time
    now = time()
    year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
    return &quot;%s, %02d %3s %4d %02d:%02d:%02d GMT&quot; % \
           (weekdayname[wd], day, monthname[month], year, hh, mm, ss)


class Morsel(dict):
    &quot;&quot;&quot;A class to hold ONE (key, value) pair.

    In a cookie, each such pair may have several attributes, so this class is
    used to keep the attributes associated with the appropriate key,value pair.
    This class also includes a coded_value attribute, which is used to hold
    the network representation of the value.
    &quot;&quot;&quot;
    # RFC 2109 lists these attributes as reserved:
    #   path       comment         domain
    #   max-age    secure      version
    #
    # For historical reasons, these attributes are also reserved:
    #   expires
    #
    # This is an extension from Microsoft:
    #   httponly
    #
    # This dictionary provides a mapping from the lowercase
    # variant on the left to the appropriate traditional
    # formatting on the right.
    _reserved = {
        &quot;expires&quot;  : &quot;expires&quot;,
        &quot;path&quot;     : &quot;Path&quot;,
        &quot;comment&quot;  : &quot;Comment&quot;,
        &quot;domain&quot;   : &quot;Domain&quot;,
        &quot;max-age&quot;  : &quot;Max-Age&quot;,
        &quot;secure&quot;   : &quot;Secure&quot;,
        &quot;httponly&quot; : &quot;HttpOnly&quot;,
        &quot;version&quot;  : &quot;Version&quot;,
        &quot;samesite&quot; : &quot;SameSite&quot;,
    }

    _flags = {'secure', 'httponly'}

    def __init__(self):
        # Set defaults
        self._key = self._value = self._coded_value = None

        # Set default attributes
        for key in self._reserved:
            dict.__setitem__(self, key, &quot;&quot;)

    @property
    def key(self):
        return self._key

    @property
    def value(self):
        return self._value

    @property
    def coded_value(self):
        return self._coded_value

    def __setitem__(self, K, V):
        K = K.lower()
        if not K in self._reserved:
            raise CookieError(&quot;Invalid attribute %r&quot; % (K,))
        dict.__setitem__(self, K, V)

    def setdefault(self, key, val=None):
        key = key.lower()
        if key not in self._reserved:
            raise CookieError(&quot;Invalid attribute %r&quot; % (key,))
        return dict.setdefault(self, key, val)

    def __eq__(self, morsel):
        if not isinstance(morsel, Morsel):
            return NotImplemented
        return (dict.__eq__(self, morsel) and
                self._value == morsel._value and
                self._key == morsel._key and
                self._coded_value == morsel._coded_value)

    __ne__ = object.__ne__

    def copy(self):
        morsel = Morsel()
        dict.update(morsel, self)
        morsel.__dict__.update(self.__dict__)
        return morsel

    def update(self, values):
        data = {}
        for key, val in dict(values).items():
            key = key.lower()
            if key not in self._reserved:
                raise CookieError(&quot;Invalid attribute %r&quot; % (key,))
            data[key] = val
        dict.update(self, data)

    def isReservedKey(self, K):
        return K.lower() in self._reserved

    def set(self, key, val, coded_val):
        if key.lower() in self._reserved:
            raise CookieError('Attempt to set a reserved key %r' % (key,))
        if not _is_legal_key(key):
            raise CookieError('Illegal key %r' % (key,))

        # It's a good key, so save it.
        self._key = key
        self._value = val
        self._coded_value = coded_val

    def __getstate__(self):
        return {
            'key': self._key,
            'value': self._value,
            'coded_value': self._coded_value,
        }

    def __setstate__(self, state):
        self._key = state['key']
        self._value = state['value']
        self._coded_value = state['coded_value']

    def output(self, attrs=None, header=&quot;Set-Cookie:&quot;):
        return &quot;%s %s&quot; % (header, self.OutputString(attrs))

    __str__ = output

    def __repr__(self):
        return '&lt;%s: %s&gt;' % (self.__class__.__name__, self.OutputString())

    def js_output(self, attrs=None):
        # Print javascript
        return &quot;&quot;&quot;
        &lt;script type=&quot;text/javascript&quot;&gt;
        &lt;!-- begin hiding
        document.cookie = \&quot;%s\&quot;;
        // end hiding --&gt;
        &lt;/script&gt;
        &quot;&quot;&quot; % (self.OutputString(attrs).replace('&quot;', r'\&quot;'))

    def OutputString(self, attrs=None):
        # Build up our result
        #
        result = []
        append = result.append

        # First, the key=value pair
        append(&quot;%s=%s&quot; % (self.key, self.coded_value))

        # Now add any defined attributes
        if attrs is None:
            attrs = self._reserved
        items = sorted(self.items())
        for key, value in items:
            if value == &quot;&quot;:
                continue
            if key not in attrs:
                continue
            if key == &quot;expires&quot; and isinstance(value, int):
                append(&quot;%s=%s&quot; % (self._reserved[key], _getdate(value)))
            elif key == &quot;max-age&quot; and isinstance(value, int):
                append(&quot;%s=%d&quot; % (self._reserved[key], value))
            elif key == &quot;comment&quot; and isinstance(value, str):
                append(&quot;%s=%s&quot; % (self._reserved[key], _quote(value)))
            elif key in self._flags:
                if value:
                    append(str(self._reserved[key]))
            else:
                append(&quot;%s=%s&quot; % (self._reserved[key], value))

        # Return the result
        return _semispacejoin(result)

    __class_getitem__ = classmethod(types.GenericAlias)


#
# Pattern for finding cookie
#
# This used to be strict parsing based on the RFC2109 and RFC2068
# specifications.  I have since discovered that MSIE 3.0x doesn't
# follow the character rules outlined in those specs.  As a
# result, the parsing rules here are less strict.
#

_LegalKeyChars  = r&quot;\w\d!#%&amp;'~_`&gt;&lt;@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=&quot;
_LegalValueChars = _LegalKeyChars + r'\[\]'
_CookiePattern = re.compile(r&quot;&quot;&quot;
    \s*                            # Optional whitespace at start of cookie
    (?P&lt;key&gt;                       # Start of group 'key'
    [&quot;&quot;&quot; + _LegalKeyChars + r&quot;&quot;&quot;]+?   # Any word of at least one letter
    )                              # End of group 'key'
    (                              # Optional group: there may not be a value.
    \s*=\s*                          # Equal Sign
    (?P&lt;val&gt;                         # Start of group 'val'
    &quot;(?:[^\\&quot;]|\\.)*&quot;                  # Any doublequoted string
    |                                  # or
    \w{3},\s[\w\d\s-]{9,11}\s[\d:]{8}\sGMT  # Special case for &quot;expires&quot; attr
    |                                  # or
    [&quot;&quot;&quot; + _LegalValueChars + r&quot;&quot;&quot;]*      # Any word or empty string
    )                                # End of group 'val'
    )?                             # End of optional value group
    \s*                            # Any number of spaces.
    (\s+|;|$)                      # Ending either at space, semicolon, or EOS.
    &quot;&quot;&quot;, re.ASCII | re.VERBOSE)    # re.ASCII may be removed if safe.


# At long last, here is the cookie class.  Using this class is almost just like
# using a dictionary.  See this module's docstring for example usage.
#
class BaseCookie(dict):
    &quot;&quot;&quot;A container class for a set of Morsels.&quot;&quot;&quot;

    def value_decode(self, val):
        &quot;&quot;&quot;real_value, coded_value = value_decode(STRING)
        Called prior to setting a cookie's value from the network
        representation.  The VALUE is the value read from HTTP
        header.
        Override this function to modify the behavior of cookies.
        &quot;&quot;&quot;
        return val, val

    def value_encode(self, val):
        &quot;&quot;&quot;real_value, coded_value = value_encode(VALUE)
        Called prior to setting a cookie's value from the dictionary
        representation.  The VALUE is the value being assigned.
        Override this function to modify the behavior of cookies.
        &quot;&quot;&quot;
        strval = str(val)
        return strval, strval

    def __init__(self, input=None):
        if input:
            self.load(input)

    def __set(self, key, real_value, coded_value):
        &quot;&quot;&quot;Private method for setting a cookie's value&quot;&quot;&quot;
        M = self.get(key, Morsel())
        M.set(key, real_value, coded_value)
        dict.__setitem__(self, key, M)

    def __setitem__(self, key, value):
        &quot;&quot;&quot;Dictionary style assignment.&quot;&quot;&quot;
        if isinstance(value, Morsel):
            # allow assignment of constructed Morsels (e.g. for pickling)
            dict.__setitem__(self, key, value)
        else:
            rval, cval = self.value_encode(value)
            self.__set(key, rval, cval)

    def output(self, attrs=None, header=&quot;Set-Cookie:&quot;, sep=&quot;\015\012&quot;):
        &quot;&quot;&quot;Return a string suitable for HTTP.&quot;&quot;&quot;
        result = []
        items = sorted(self.items())
        for key, value in items:
            result.append(value.output(attrs, header))
        return sep.join(result)

    __str__ = output

    def __repr__(self):
        l = []
        items = sorted(self.items())
        for key, value in items:
            l.append('%s=%s' % (key, repr(value.value)))
        return '&lt;%s: %s&gt;' % (self.__class__.__name__, _spacejoin(l))

    def js_output(self, attrs=None):
        &quot;&quot;&quot;Return a string suitable for JavaScript.&quot;&quot;&quot;
        result = []
        items = sorted(self.items())
        for key, value in items:
            result.append(value.js_output(attrs))
        return _nulljoin(result)

    def load(self, rawdata):
        &quot;&quot;&quot;Load cookies from a string (presumably HTTP_COOKIE) or
        from a dictionary.  Loading cookies from a dictionary 'd'
        is equivalent to calling:
            map(Cookie.__setitem__, d.keys(), d.values())
        &quot;&quot;&quot;
        if isinstance(rawdata, str):
            self.__parse_string(rawdata)
        else:
            # self.update() wouldn't call our custom __setitem__
            for key, value in rawdata.items():
                self[key] = value
        return

    def __parse_string(self, str, patt=_CookiePattern):
        i = 0                 # Our starting point
        n = len(str)          # Length of string
        parsed_items = []     # Parsed (type, key, value) triples
        morsel_seen = False   # A key=value pair was previously encountered

        TYPE_ATTRIBUTE = 1
        TYPE_KEYVALUE = 2

        # We first parse the whole cookie string and reject it if it's
        # syntactically invalid (this helps avoid some classes of injection
        # attacks).
        while 0 &lt;= i &lt; n:
            # Start looking for a cookie
            match = patt.match(str, i)
            if not match:
                # No more cookies
                break

            key, value = match.group(&quot;key&quot;), match.group(&quot;val&quot;)
            i = match.end(0)

            if key[0] == &quot;$&quot;:
                if not morsel_seen:
                    # We ignore attributes which pertain to the cookie
                    # mechanism as a whole, such as &quot;$Version&quot;.
                    # See RFC 2965. (Does anyone care?)
                    continue
                parsed_items.append((TYPE_ATTRIBUTE, key[1:], value))
            elif key.lower() in Morsel._reserved:
                if not morsel_seen:
                    # Invalid cookie string
                    return
                if value is None:
                    if key.lower() in Morsel._flags:
                        parsed_items.append((TYPE_ATTRIBUTE, key, True))
                    else:
                        # Invalid cookie string
                        return
                else:
                    parsed_items.append((TYPE_ATTRIBUTE, key, _unquote(value)))
            elif value is not None:
                parsed_items.append((TYPE_KEYVALUE, key, self.value_decode(value)))
                morsel_seen = True
            else:
                # Invalid cookie string
                return

        # The cookie string is valid, apply it.
        M = None         # current morsel
        for tp, key, value in parsed_items:
            if tp == TYPE_ATTRIBUTE:
                assert M is not None
                M[key] = value
            else:
                assert tp == TYPE_KEYVALUE
                rval, cval = value
                self.__set(key, rval, cval)
                M = self[key]


class SimpleCookie(BaseCookie):
    &quot;&quot;&quot;
    SimpleCookie supports strings as cookie values.  When setting
    the value using the dictionary assignment notation, SimpleCookie
    calls the builtin str() to convert the value to a string.  Values
    received from HTTP are kept as strings.
    &quot;&quot;&quot;
    def value_decode(self, val):
        return _unquote(val), val

    def value_encode(self, val):
        strval = str(val)
        return strval, _quote(strval)
                                                                                                                                opt/alt/python312/lib64/python3.12/http/cookies.py                                                  0000644                 00000046757 15052113066 0015451 0                                                                                                    ustar 00                                                                                                                                                                                                                                                       ####
# Copyright 2000 by Timothy O'Malley &lt;timo@alum.mit.edu&gt;
#
#                All Rights Reserved
#
# Permission to use, copy, modify, and distribute this software
# and its documentation for any purpose and without fee is hereby
# granted, provided that the above copyright notice appear in all
# copies and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Timothy O'Malley  not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
# ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
####
#
# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
#   by Timothy O'Malley &lt;timo@alum.mit.edu&gt;
#
#  Cookie.py is a Python module for the handling of HTTP
#  cookies as a Python dictionary.  See RFC 2109 for more
#  information on cookies.
#
#  The original idea to treat Cookies as a dictionary came from
#  Dave Mitchell (davem@magnet.com) in 1995, when he released the
#  first version of nscookie.py.
#
####

r&quot;&quot;&quot;
Here's a sample session to show how to use this module.
At the moment, this is the only documentation.

The Basics
----------

Importing is easy...

   &gt;&gt;&gt; from http import cookies

Most of the time you start by creating a cookie.

   &gt;&gt;&gt; C = cookies.SimpleCookie()

Once you've created your Cookie, you can add values just as if it were
a dictionary.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;fig&quot;] = &quot;newton&quot;
   &gt;&gt;&gt; C[&quot;sugar&quot;] = &quot;wafer&quot;
   &gt;&gt;&gt; C.output()
   'Set-Cookie: fig=newton\r\nSet-Cookie: sugar=wafer'

Notice that the printable representation of a Cookie is the
appropriate format for a Set-Cookie: header.  This is the
default behavior.  You can change the header and printed
attributes by using the .output() function

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;rocky&quot;] = &quot;road&quot;
   &gt;&gt;&gt; C[&quot;rocky&quot;][&quot;path&quot;] = &quot;/cookie&quot;
   &gt;&gt;&gt; print(C.output(header=&quot;Cookie:&quot;))
   Cookie: rocky=road; Path=/cookie
   &gt;&gt;&gt; print(C.output(attrs=[], header=&quot;Cookie:&quot;))
   Cookie: rocky=road

The load() method of a Cookie extracts cookies from a string.  In a
CGI script, you would use this method to extract the cookies from the
HTTP_COOKIE environment variable.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C.load(&quot;chips=ahoy; vienna=finger&quot;)
   &gt;&gt;&gt; C.output()
   'Set-Cookie: chips=ahoy\r\nSet-Cookie: vienna=finger'

The load() method is darn-tootin smart about identifying cookies
within a string.  Escaped quotation marks, nested semicolons, and other
such trickeries do not confuse it.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C.load('keebler=&quot;E=everybody; L=\\&quot;Loves\\&quot;; fudge=\\012;&quot;;')
   &gt;&gt;&gt; print(C)
   Set-Cookie: keebler=&quot;E=everybody; L=\&quot;Loves\&quot;; fudge=\012;&quot;

Each element of the Cookie also supports all of the RFC 2109
Cookie attributes.  Here's an example which sets the Path
attribute.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;oreo&quot;] = &quot;doublestuff&quot;
   &gt;&gt;&gt; C[&quot;oreo&quot;][&quot;path&quot;] = &quot;/&quot;
   &gt;&gt;&gt; print(C)
   Set-Cookie: oreo=doublestuff; Path=/

Each dictionary element has a 'value' attribute, which gives you
back the value associated with the key.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;twix&quot;] = &quot;none for you&quot;
   &gt;&gt;&gt; C[&quot;twix&quot;].value
   'none for you'

The SimpleCookie expects that all values should be standard strings.
Just to be sure, SimpleCookie invokes the str() builtin to convert
the value to a string, when the values are set dictionary-style.

   &gt;&gt;&gt; C = cookies.SimpleCookie()
   &gt;&gt;&gt; C[&quot;number&quot;] = 7
   &gt;&gt;&gt; C[&quot;string&quot;] = &quot;seven&quot;
   &gt;&gt;&gt; C[&quot;number&quot;].value
   '7'
   &gt;&gt;&gt; C[&quot;string&quot;].value
   'seven'
   &gt;&gt;&gt; C.output()
   'Set-Cookie: number=7\r\nSet-Cookie: string=seven'

Finis.
&quot;&quot;&quot;

#
# Import our required modules
#
import re
import string
import types

__all__ = [&quot;CookieError&quot;, &quot;BaseCookie&quot;, &quot;SimpleCookie&quot;]

_nulljoin = ''.join
_semispacejoin = '; '.join
_spacejoin = ' '.join

#
# Define an exception visible to External modules
#
class CookieError(Exception):
    pass


# These quoting routines conform to the RFC2109 specification, which in
# turn references the character definitions from RFC2068.  They provide
# a two-way quoting algorithm.  Any non-text character is translated
# into a 4 character sequence: a forward-slash followed by the
# three-digit octal equivalent of the character.  Any '\' or '&quot;' is
# quoted with a preceding '\' slash.
# Because of the way browsers really handle cookies (as opposed to what
# the RFC says) we also encode &quot;,&quot; and &quot;;&quot;.
#
# These are taken from RFC2068 and RFC2109.
#       _LegalChars       is the list of chars which don't require &quot;'s
#       _Translator       hash-table for fast quoting
#
_LegalChars = string.ascii_letters + string.digits + &quot;!#$%&amp;'*+-.^_`|~:&quot;
_UnescapedChars = _LegalChars + ' ()/&lt;=&gt;?@[]{}'

_Translator = {n: '\\%03o' % n
               for n in set(range(256)) - set(map(ord, _UnescapedChars))}
_Translator.update({
    ord('&quot;'): '\\&quot;',
    ord('\\'): '\\\\',
})

_is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch

def _quote(str):
    r&quot;&quot;&quot;Quote a string for use in a cookie header.

    If the string does not need to be double-quoted, then just return the
    string.  Otherwise, surround the string in doublequotes and quote
    (with a \) special characters.
    &quot;&quot;&quot;
    if str is None or _is_legal_key(str):
        return str
    else:
        return '&quot;' + str.translate(_Translator) + '&quot;'


_unquote_sub = re.compile(r'\\(?:([0-3][0-7][0-7])|(.))').sub

def _unquote_replace(m):
    if m[1]:
        return chr(int(m[1], 8))
    else:
        return m[2]

def _unquote(str):
    # If there aren't any doublequotes,
    # then there can't be any special characters.  See RFC 2109.
    if str is None or len(str) &lt; 2:
        return str
    if str[0] != '&quot;' or str[-1] != '&quot;':
        return str

    # We have to assume that we must decode this string.
    # Down to work.

    # Remove the &quot;s
    str = str[1:-1]

    # Check for special sequences.  Examples:
    #    \012 --&gt; \n
    #    \&quot;   --&gt; &quot;
    #
    return _unquote_sub(_unquote_replace, str)

# The _getdate() routine is used to set the expiration time in the cookie's HTTP
# header.  By default, _getdate() returns the current time in the appropriate
# &quot;expires&quot; format for a Set-Cookie header.  The one optional argument is an
# offset from now, in seconds.  For example, an offset of -3600 means &quot;one hour
# ago&quot;.  The offset may be a floating-point number.
#

_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

_monthname = [None,
              'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
    from time import gmtime, time
    now = time()
    year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
    return &quot;%s, %02d %3s %4d %02d:%02d:%02d GMT&quot; % \
           (weekdayname[wd], day, monthname[month], year, hh, mm, ss)


class Morsel(dict):
    &quot;&quot;&quot;A class to hold ONE (key, value) pair.

    In a cookie, each such pair may have several attributes, so this class is
    used to keep the attributes associated with the appropriate key,value pair.
    This class also includes a coded_value attribute, which is used to hold
    the network representation of the value.
    &quot;&quot;&quot;
    # RFC 2109 lists these attributes as reserved:
    #   path       comment         domain
    #   max-age    secure      version
    #
    # For historical reasons, these attributes are also reserved:
    #   expires
    #
    # This is an extension from Microsoft:
    #   httponly
    #
    # This dictionary provides a mapping from the lowercase
    # variant on the left to the appropriate traditional
    # formatting on the right.
    _reserved = {
        &quot;expires&quot;  : &quot;expires&quot;,
        &quot;path&quot;     : &quot;Path&quot;,
        &quot;comment&quot;  : &quot;Comment&quot;,
        &quot;domain&quot;   : &quot;Domain&quot;,
        &quot;max-age&quot;  : &quot;Max-Age&quot;,
        &quot;secure&quot;   : &quot;Secure&quot;,
        &quot;httponly&quot; : &quot;HttpOnly&quot;,
        &quot;version&quot;  : &quot;Version&quot;,
        &quot;samesite&quot; : &quot;SameSite&quot;,
    }

    _flags = {'secure', 'httponly'}

    def __init__(self):
        # Set defaults
        self._key = self._value = self._coded_value = None

        # Set default attributes
        for key in self._reserved:
            dict.__setitem__(self, key, &quot;&quot;)

    @property
    def key(self):
        return self._key

    @property
    def value(self):
        return self._value

    @property
    def coded_value(self):
        return self._coded_value

    def __setitem__(self, K, V):
        K = K.lower()
        if not K in self._reserved:
            raise CookieError(&quot;Invalid attribute %r&quot; % (K,))
        dict.__setitem__(self, K, V)

    def setdefault(self, key, val=None):
        key = key.lower()
        if key not in self._reserved:
            raise CookieError(&quot;Invalid attribute %r&quot; % (key,))
        return dict.setdefault(self, key, val)

    def __eq__(self, morsel):
        if not isinstance(morsel, Morsel):
            return NotImplemented
        return (dict.__eq__(self, morsel) and
                self._value == morsel._value and
                self._key == morsel._key and
                self._coded_value == morsel._coded_value)

    __ne__ = object.__ne__

    def copy(self):
        morsel = Morsel()
        dict.update(morsel, self)
        morsel.__dict__.update(self.__dict__)
        return morsel

    def update(self, values):
        data = {}
        for key, val in dict(values).items():
            key = key.lower()
            if key not in self._reserved:
                raise CookieError(&quot;Invalid attribute %r&quot; % (key,))
            data[key] = val
        dict.update(self, data)

    def isReservedKey(self, K):
        return K.lower() in self._reserved

    def set(self, key, val, coded_val):
        if key.lower() in self._reserved:
            raise CookieError('Attempt to set a reserved key %r' % (key,))
        if not _is_legal_key(key):
            raise CookieError('Illegal key %r' % (key,))

        # It's a good key, so save it.
        self._key = key
        self._value = val
        self._coded_value = coded_val

    def __getstate__(self):
        return {
            'key': self._key,
            'value': self._value,
            'coded_value': self._coded_value,
        }

    def __setstate__(self, state):
        self._key = state['key']
        self._value = state['value']
        self._coded_value = state['coded_value']

    def output(self, attrs=None, header=&quot;Set-Cookie:&quot;):
        return &quot;%s %s&quot; % (header, self.OutputString(attrs))

    __str__ = output

    def __repr__(self):
        return '&lt;%s: %s&gt;' % (self.__class__.__name__, self.OutputString())

    def js_output(self, attrs=None):
        # Print javascript
        return &quot;&quot;&quot;
        &lt;script type=&quot;text/javascript&quot;&gt;
        &lt;!-- begin hiding
        document.cookie = \&quot;%s\&quot;;
        // end hiding --&gt;
        &lt;/script&gt;
        &quot;&quot;&quot; % (self.OutputString(attrs).replace('&quot;', r'\&quot;'))

    def OutputString(self, attrs=None):
        # Build up our result
        #
        result = []
        append = result.append

        # First, the key=value pair
        append(&quot;%s=%s&quot; % (self.key, self.coded_value))

        # Now add any defined attributes
        if attrs is None:
            attrs = self._reserved
        items = sorted(self.items())
        for key, value in items:
            if value == &quot;&quot;:
                continue
            if key not in attrs:
                continue
            if key == &quot;expires&quot; and isinstance(value, int):
                append(&quot;%s=%s&quot; % (self._reserved[key], _getdate(value)))
            elif key == &quot;max-age&quot; and isinstance(value, int):
                append(&quot;%s=%d&quot; % (self._reserved[key], value))
            elif key == &quot;comment&quot; and isinstance(value, str):
                append(&quot;%s=%s&quot; % (self._reserved[key], _quote(value)))
            elif key in self._flags:
                if value:
                    append(str(self._reserved[key]))
            else:
                append(&quot;%s=%s&quot; % (self._reserved[key], value))

        # Return the result
        return _semispacejoin(result)

    __class_getitem__ = classmethod(types.GenericAlias)


#
# Pattern for finding cookie
#
# This used to be strict parsing based on the RFC2109 and RFC2068
# specifications.  I have since discovered that MSIE 3.0x doesn't
# follow the character rules outlined in those specs.  As a
# result, the parsing rules here are less strict.
#

_LegalKeyChars  = r&quot;\w\d!#%&amp;'~_`&gt;&lt;@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=&quot;
_LegalValueChars = _LegalKeyChars + r'\[\]'
_CookiePattern = re.compile(r&quot;&quot;&quot;
    \s*                            # Optional whitespace at start of cookie
    (?P&lt;key&gt;                       # Start of group 'key'
    [&quot;&quot;&quot; + _LegalKeyChars + r&quot;&quot;&quot;]+?   # Any word of at least one letter
    )                              # End of group 'key'
    (                              # Optional group: there may not be a value.
    \s*=\s*                          # Equal Sign
    (?P&lt;val&gt;                         # Start of group 'val'
    &quot;(?:[^\\&quot;]|\\.)*&quot;                  # Any double-quoted string
    |                                  # or
    # Special case for &quot;expires&quot; attr
    (\w{3,6}day|\w{3}),\s              # Day of the week or abbreviated day
    [\w\d\s-]{9,11}\s[\d:]{8}\sGMT     # Date and time in specific format
    |                                  # or
    [&quot;&quot;&quot; + _LegalValueChars + r&quot;&quot;&quot;]*      # Any word or empty string
    )                                # End of group 'val'
    )?                             # End of optional value group
    \s*                            # Any number of spaces.
    (\s+|;|$)                      # Ending either at space, semicolon, or EOS.
    &quot;&quot;&quot;, re.ASCII | re.VERBOSE)    # re.ASCII may be removed if safe.


# At long last, here is the cookie class.  Using this class is almost just like
# using a dictionary.  See this module's docstring for example usage.
#
class BaseCookie(dict):
    &quot;&quot;&quot;A container class for a set of Morsels.&quot;&quot;&quot;

    def value_decode(self, val):
        &quot;&quot;&quot;real_value, coded_value = value_decode(STRING)
        Called prior to setting a cookie's value from the network
        representation.  The VALUE is the value read from HTTP
        header.
        Override this function to modify the behavior of cookies.
        &quot;&quot;&quot;
        return val, val

    def value_encode(self, val):
        &quot;&quot;&quot;real_value, coded_value = value_encode(VALUE)
        Called prior to setting a cookie's value from the dictionary
        representation.  The VALUE is the value being assigned.
        Override this function to modify the behavior of cookies.
        &quot;&quot;&quot;
        strval = str(val)
        return strval, strval

    def __init__(self, input=None):
        if input:
            self.load(input)

    def __set(self, key, real_value, coded_value):
        &quot;&quot;&quot;Private method for setting a cookie's value&quot;&quot;&quot;
        M = self.get(key, Morsel())
        M.set(key, real_value, coded_value)
        dict.__setitem__(self, key, M)

    def __setitem__(self, key, value):
        &quot;&quot;&quot;Dictionary style assignment.&quot;&quot;&quot;
        if isinstance(value, Morsel):
            # allow assignment of constructed Morsels (e.g. for pickling)
            dict.__setitem__(self, key, value)
        else:
            rval, cval = self.value_encode(value)
            self.__set(key, rval, cval)

    def output(self, attrs=None, header=&quot;Set-Cookie:&quot;, sep=&quot;\015\012&quot;):
        &quot;&quot;&quot;Return a string suitable for HTTP.&quot;&quot;&quot;
        result = []
        items = sorted(self.items())
        for key, value in items:
            result.append(value.output(attrs, header))
        return sep.join(result)

    __str__ = output

    def __repr__(self):
        l = []
        items = sorted(self.items())
        for key, value in items:
            l.append('%s=%s' % (key, repr(value.value)))
        return '&lt;%s: %s&gt;' % (self.__class__.__name__, _spacejoin(l))

    def js_output(self, attrs=None):
        &quot;&quot;&quot;Return a string suitable for JavaScript.&quot;&quot;&quot;
        result = []
        items = sorted(self.items())
        for key, value in items:
            result.append(value.js_output(attrs))
        return _nulljoin(result)

    def load(self, rawdata):
        &quot;&quot;&quot;Load cookies from a string (presumably HTTP_COOKIE) or
        from a dictionary.  Loading cookies from a dictionary 'd'
        is equivalent to calling:
            map(Cookie.__setitem__, d.keys(), d.values())
        &quot;&quot;&quot;
        if isinstance(rawdata, str):
            self.__parse_string(rawdata)
        else:
            # self.update() wouldn't call our custom __setitem__
            for key, value in rawdata.items():
                self[key] = value
        return

    def __parse_string(self, str, patt=_CookiePattern):
        i = 0                 # Our starting point
        n = len(str)          # Length of string
        parsed_items = []     # Parsed (type, key, value) triples
        morsel_seen = False   # A key=value pair was previously encountered

        TYPE_ATTRIBUTE = 1
        TYPE_KEYVALUE = 2

        # We first parse the whole cookie string and reject it if it's
        # syntactically invalid (this helps avoid some classes of injection
        # attacks).
        while 0 &lt;= i &lt; n:
            # Start looking for a cookie
            match = patt.match(str, i)
            if not match:
                # No more cookies
                break

            key, value = match.group(&quot;key&quot;), match.group(&quot;val&quot;)
            i = match.end(0)

            if key[0] == &quot;$&quot;:
                if not morsel_seen:
                    # We ignore attributes which pertain to the cookie
                    # mechanism as a whole, such as &quot;$Version&quot;.
                    # See RFC 2965. (Does anyone care?)
                    continue
                parsed_items.append((TYPE_ATTRIBUTE, key[1:], value))
            elif key.lower() in Morsel._reserved:
                if not morsel_seen:
                    # Invalid cookie string
                    return
                if value is None:
                    if key.lower() in Morsel._flags:
                        parsed_items.append((TYPE_ATTRIBUTE, key, True))
                    else:
                        # Invalid cookie string
                        return
                else:
                    parsed_items.append((TYPE_ATTRIBUTE, key, _unquote(value)))
            elif value is not None:
                parsed_items.append((TYPE_KEYVALUE, key, self.value_decode(value)))
                morsel_seen = True
            else:
                # Invalid cookie string
                return

        # The cookie string is valid, apply it.
        M = None         # current morsel
        for tp, key, value in parsed_items:
            if tp == TYPE_ATTRIBUTE:
                assert M is not None
                M[key] = value
            else:
                assert tp == TYPE_KEYVALUE
                rval, cval = value
                self.__set(key, rval, cval)
                M = self[key]


class SimpleCookie(BaseCookie):
    &quot;&quot;&quot;
    SimpleCookie supports strings as cookie values.  When setting
    the value using the dictionary assignment notation, SimpleCookie
    calls the builtin str() to convert the value to a string.  Values
    received from HTTP are kept as strings.
    &quot;&quot;&quot;
    def value_decode(self, val):
        return _unquote(val), val

    def value_encode(self, val):
        strval = str(val)
        return strval, _quote(strval)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 </textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2F-20250808174531'>🔙 Back</a>