"http.cookiejar" --- Cookie handling for HTTP clients
*****************************************************

**Código fuente:** Lib/http/cookiejar.py

======================================================================

The "http.cookiejar" module defines classes for automatic handling of
HTTP cookies.  It is useful for accessing websites that require small
pieces of data -- *cookies* -- to be set on the client machine by an
HTTP response from a web server, and then returned to the server in
later HTTP requests.

Se manejan tanto el protocolo de cookies normal de Netscape como el
protocolo definido por **RFC 2965**. El manejo de RFC 2965 está
desactivado de forma predeterminada. Las cookies **RFC 2109** se
analizan como cookies de Netscape y, posteriormente, se tratan como
cookies de Netscape o RFC 2965 de acuerdo con la "política" en vigor.
Tenga en cuenta que la gran mayoría de las cookies en Internet son
cookies de Netscape. "http.cookiejar" intenta seguir el protocolo de
cookies de Netscape de facto (que difiere sustancialmente del
establecido en la especificación original de Netscape), incluida la
toma de nota de los atributos de cookies "max-age" y "port"
introducidos con RFC 2965.

Nota:

  Diversos parámetros nombrados que se encuentran en *Set-Cookie* y
  *Set-Cookie2* (ejem. "domain" y "expires") son convencionalmente
  referidos como *attributes*. Para distinguirlos de los atributos de
  Python, la documentación de este módulo utiliza el término *cookie-
  attribute*.

El módulo define la siguiente excepción:

exception http.cookiejar.LoadError

   Las instancias de "FileCookieJar" provocan esta excepción al no
   cargar las cookies desde un archivo. "LoadError" es una subclase de
   "OSError".

   Distinto en la versión 3.3: "LoadError" used to be a subtype of
   "IOError", which is now an alias of "OSError".

Se proporcionan las siguientes clases:

class http.cookiejar.CookieJar(policy=None)

   *policy* es un objeto implementando la interfaz "CookiePolicy".

   La clase "CookieJar" almacena HTTP cookies. Ésta extrae cookies de
   los request de HTTP, y las retorna en forma de responses de HTTP.
   Las instancias de "CookieJar" automáticamente expiran las cookies
   contenidas cuando es necesario. Las subclases también son
   responsables de almacenar y recuperar cookies de un archivo o base
   de datos.

class http.cookiejar.FileCookieJar(filename=None, delayload=None, policy=None)

   *policy* es un objeto implementando la interfaz "CookiePolicy".
   Para los otros argumentos, te recomendamos visitar la documentación
   correspondiente a los atributos.

   Una "CookieJar" puede cargar cookies de, y posiblemente almacenar,
   un archivo en el disco. Las cookies **NO** son cargadas desde un
   archivo nombrado hasta que alguno de los métodos "load()" o
   "revert()" es llamado. Subclases de esta clase son documentadas en
   la sección Subclases FileCookieJar y co-operación con navegadores
   web.

   Esto no debe inicializarse directamente; en su lugar, use sus
   subclases a continuación.

   Distinto en la versión 3.8: El parámetro filename soporta un *path-
   like object*.

class http.cookiejar.CookiePolicy

   Esta clase es responsable de decidir si cada cookie debe ser
   aceptada del servidor, o retornada al mismo.

class http.cookiejar.DefaultCookiePolicy(blocked_domains=None, allowed_domains=None, netscape=True, rfc2965=False, rfc2109_as_netscape=None, hide_cookie2=False, strict_domain=False, strict_rfc2965_unverifiable=True, strict_ns_unverifiable=False, strict_ns_domain=DefaultCookiePolicy.DomainLiberal, strict_ns_set_initial_dollar=False, strict_ns_set_path=False, secure_protocols=('https', 'wss'))

   Los argumentos del constructor sólo deben ser dados como argumentos
   clave. *blocked_domains* es una secuencia de nombres de dominio
   cuyas cookies nunca deben de ser aceptadas o retornadas.
   *allowed_domains* y no "None", es una secuencia de sólo dominios
   que podemos aceptar y retornar cookies. *secure_protocols* es una
   secuencia de protocolos para los que se pueden agregar cookies
   seguras. De manera predeterminada *https* y *wss* (websocket
   seguro) son considerados protocolos seguros. Para todos los demás
   argumentos, te recomendamos visitar la documentación para los
   objetos "CookiePolicy" y "DefaultCookiePolicy".

   "DefaultCookiePolicy" implementa el estándar de reglas
   aceptar/rechazar para cookies Netscape y **RFC 2965**. De manera
   predeterminada, las cookies **RFC 2109** (es decir, las cookies que
   reciben una cabecera *Set-Cookie* con una versión cookie-attribute
   de 1) son tratadas de acuerdo con las reglas del RFC 2965. Sin
   embargo, si el manejo del RFC2965 se encuentra apagado o
   "rfc2109_as_netscape" es "True", las cookies RFC 2109 son
   'degradadas' por la instancia "CookieJar" a las cookies Netscape,
   configurando la "version" del atributo de la instancia "Cookie"
   como 0. "DefaultCookiePolicy" también provee algunos parámetros que
   permiten fine-tunning en el policy.

class http.cookiejar.Cookie

   Esta clase representa Netscape, las cookies **RFC 2109** y **RFC
   2965**. No se espera que los usuarios de "http.cookiejar"
   construyan sus propias instancias de "Cookie". En vez de ello, si
   es necesario, llama al método "make_cookies()" de la instancia
   "CookieJar".

Ver también:

  Módulo "urllib.request"
     Apertura de URL con manejo automático de cookies.

  Módulo "http.cookies"
     Clases de cookies HTTP, principalmente útiles para código server-
     side. Los módulos "http.cookiejar" y "http.cookies" no dependen
     uno del otro.

  https://curl.se/rfc/cookie_spec.html
     La especificación original del protocolo de cookies Netscape.
     Aunque éste sigue siendo el protocolo dominante, el 'protocolo de
     cookies Netscape' implementado por la mayoría de los navegadores
     (y el protocolo "http.cookiejar") sólo tienen in parecido
     pasajero con el bosquejado en "cookie_spec.html".

  **RFC 2109** - Mecanismo de Gestión de Estados HTTP
     Obsoleto por **RFC 2965**. Usa *Set-Cookie* con versión=1.

  **RFC 2965** - Mecanismo de Gestión de Estados HTTP
     El protocolo Netscape con los errores solucionados. Usa *Set-
     Cookie2* en lugar de *Set-Cookie*. No es ampliamente usado.

  https://kristol.org/cookie/errata.html
     Fe de erratas sin finalizar hasta el **RFC 2965**.

  **RFC 2964** - Mecanismo de Gestión de Estados HTTP


Objetos CookieJar y FileCookieJar
=================================

Los objetos "CookieJar" soportan el protocolo *iterator* para iterar
sobre los objetos "Cookie" contenidos.

"CookieJar" tiene los siguientes métodos:

CookieJar.add_cookie_header(request)

   Añade la cookie correcta a la cabecera del request.

   Si el *policy* admite (ie. los atributos "rfc2965" y "hide_cookie2"
   de la instancia "CookieJar" del "CookiePolicy" son de manera
   respectiva verdadero y falso), la cabecera *Cookie2* es igualmente
   añadido cuando es apropiado.

   El objeto *request* (usualmente una instancia de
   "urllib.request.Request") debe soportar los métodos
   "get_full_url()", "has_header()", "get_header()", "header_items()",
   "add_unredirected_header()" y los atributos "host", "type",
   "unverifiable" y "origin_req_host" según lo documentado por
   "urllib.request".

   Distinto en la versión 3.3: el objeto *request* necesita del
   atributo  "origin_req_host". La dependencia en el método deprecado
   "get_origin_req_host()" ha sido removida.

CookieJar.extract_cookies(response, request)

   Extrae las cookies del *response* HTTP y las almacena en el
   "CookieJar", donde está permitido por la policy.

   El "CookieJar" buscará por cabeceras *Set-Cookie* y *Set-Cookie2*
   permitidos en el argumento *response*, y almacena las cookies
   cuando es apropiado (sujeto a la aprobación del método
   "CookiePolicy.set_ok()").

   El objeto *response* (usualmente el resultado de llamar
   "urllib.request.urlopen()", o similares) debe de soportar un método
   "info()" , el cual retorna una instancia "email.message.Message".

   El objeto *request* (usualmente una instancia de
   "urllib.request.Request") debe soportar los métodos
   "get_full_url()" y los atributos "host", "unverifiable" y
   "origin_req_host" según lo documentado por "urllib.request". La
   solicitud se utiliza para establecer valores predeterminados para
   los atributos de las cookies, así como para verificar si la cookie
   puede establecerse.

   Distinto en la versión 3.3: el objeto *request* necesita del
   atributo  "origin_req_host". La dependencia en el método deprecado
   "get_origin_req_host()" ha sido removida.

CookieJar.set_policy(policy)

   Establece la instancia "CookiePolicy" para ser usada.

CookieJar.make_cookies(response, request)

   Retorna una secuencia de objetos "Cookie" extraída del objeto
   *response*.

   Revisa la documentación "extract_cookies()" para conocer las
   interfaces necesarias de los argumentos *response* y *request*.

CookieJar.set_cookie_if_ok(cookie, request)

   Establece una "Cookie" si la política (*policy*) dice OK para
   hacerlo.

CookieJar.set_cookie(cookie)

   Establece una "Cookie", sin consultar con la política (*policy*)
   para ver si se debe de establecer o no.

CookieJar.clear([domain[, path[, name]]])

   Borra algunas cookies.

   Si se invoca sin argumentos, borra todas las cookies. Si se le da
   un solo argumento. sólo las cookies que pertenecen a tal *domain*
   serán removidas. Si se le da dos argumentos, las cookies
   pertenecientes al especificado *domain* y *path* URL serán
   removidas. Si se le da tres argumentos, entonces la cookie con el
   especificado *domain*, *path* y *name* será removida.

   Lanza "KeyError" si no existe ninguna cookie que coincida.

CookieJar.clear_session_cookies()

   Descarta todas las cookies de la sesión.

   Descarta todas las cookies que tengan un atributo "discard" true
   (usualmente porque no tienen "max-age" o "expires"
   atributos'cookie, o un explícito atributo-cookie "discard"). Para
   los navegadores interactivos, el fin de la sesión usualmente
   corresponde con el cierre de la ventana del navegador.

   Nota que el método "save()" no guardará las cookies de la sesión de
   todas maneras, a menos que de otra manera preguntes para pasar un
   argumento *ignore_discard* como true.

"FileCookieJar" implementa los siguientes métodos adicionales:

FileCookieJar.save(filename=None, ignore_discard=False, ignore_expires=False)

   Guarda las cookies en un archivo.

   Esta clase base genera "NotImplementedError". Las subclases podrían
   dejar este método sin implementar.

   *filename* es el nombre del archivo en el que se guardarán las
   cookies. Si *filename* no es especificado, "self.filename" es
   utilizado (cuyo valor predeterminado es el valor que será pasado al
   constructor, si hay alguno); si "self.filename" es "None", se
   genera un "ValueError".

   *ignore_discard*: almacena incluso las cookies configuradas para
   ser descartadas. *ignore_expires*: almacena las cookies que han
   caducado

   El archivo se sobrescribe si ya existe, borrando así todas las
   cookies que contiene. Las cookies guardadas se pueden restaurar
   después utilizando los métodos "load()" o "revert()".

FileCookieJar.load(filename=None, ignore_discard=False, ignore_expires=False)

   Carga las cookies desde un archivo.

   Las viejas cookies son guardadas a menos que sean sobre escritas
   por nuevas recién cargadas.

   Los argumentos son en cuanto a "save()".

   El archivo nombrado debe estar en un formato entendible para la
   clase, o se lanzará un "LoadError". Además, puede generarse un
   "OSError", por ejemplo, si el archivo no existe.

   Distinto en la versión 3.3: Solía levantarse un "IOError", pero
   ahora es un alias de "OSError".

FileCookieJar.revert(filename=None, ignore_discard=False, ignore_expires=False)

   Limpia todas las cookies y recarga las cookies de un archivo
   guardado.

   "revert()" puede levantar las mismas excepciones que "load()". Si
   hay un fallo. el estado del objeto no se alterará.

Instancias "FileCookieJar" tienen los siguientes atributos públicos:

FileCookieJar.filename

   Nombre del archivo predeterminado para el archivo en donde se
   almacenan las cookies. Este atributo podría ser asignado.

FileCookieJar.delayload

   Si es true, carga perezosamente las cookies desde el disco. Este
   atributo no se debería de asignar. Esta es solo una pista, debido a
   que solo el rendimiento, y no al comportamiento (a menos que las
   cookies en el disco sean cambiadas). Un objeto "CookieJar" puede
   ignorarlo. Ninguna de las clases de "FileCookieJar" incluidas en la
   librería estándar carga las cookies de manera perezosa.


Subclases FileCookieJar y co-operación con navegadores web
==========================================================

Las siguientes subclases "CookieJar" son proveídas para lectura y
escritura.

class http.cookiejar.MozillaCookieJar(filename=None, delayload=None, policy=None)

   Un "FileCookieJar" que puede cargar y guardar cookies al disco en
   el formato de archivo "cookies.txt" de Mozilla (que también es
   utilizado por curl y los navegadores Lynx y Netscape).

   Nota:

     Esto puede perder información acerca de cookies **RFC 2965**, y
     también sobre atributos nuevos o no estándar como "port".

   Advertencia:

     Realiza una copia de seguridad de tus cookies antes de
     guardarlas, especialmente si tienes cookies cuya perdida /
     corrupción puede ser inconveniente (hay algunas sutilezas que
     pueden conducir a ligeros cambios en el archivo sobre una carga /
     guardado round-trip).

   También toma en cuenta que las cookies guardadas mientras Mozilla
   se está ejecutando se volverán torpes debido a Mozilla.

class http.cookiejar.LWPCookieJar(filename=None, delayload=None, policy=None)

   Un "FileCookieJar" que puede cargar y guardar en disco en formato
   compatible con el formato de archivo "Set-Cookie3" de la librería
   libwww-perl. Estos es conveniente si tu quieres guardar cookies en
   un archivo legible para los humanos.

   Distinto en la versión 3.8: El parámetro filename soporta un *path-
   like object*.


Objetos CookiePolicy
====================

Objetos implementando la interfaz "CookiePolicy" tienen los siguientes
métodos:

CookiePolicy.set_ok(cookie, request)

   Retorna un valor booleano indicando si la cookie debe ser aceptada
   o no desde el servidor.

   *cookie* es una instancia de "Cookie". *request* es un objeto
   implementando la interfaz definida por la documentación de
   "CookieJar.extract_cookies()".

CookiePolicy.return_ok(cookie, request)

   Retorna un valor booleano indicando si la cookie debe ser retornada
   o no al servidor.

   *cookie* es una instancia de "Cookie". *request* es un objeto
   implementando la interfaz definida por la documentación de
   "CookieJar.add_cookie_header()".

CookiePolicy.domain_return_ok(domain, request)

   Retorna "False" si las cookies no deben de ser retornadas, a partir
   del dominio cookie dado.

   Este método es una optimización. Elimina la necesidad de verificar
   cada cookie con un domino en particular (lo cual puede involucrar
   la lectura de muchos archivos). Retornando true de
   "domain_return_ok()" y "path_return_ok()" deja todo el trabajo a
   "return_ok()".

   Si "domain_return_ok()" retorna true para el dominio de cookies,
   "path_return_ok()" es llamado para el path de cookies. De otra
   manera, "path_return_ok()" y "return_ok()" no son nunca llamados
   para ese dominio de cookies. Si "path_return_ok()" retorna true,
   "return_ok()" es llamado con el objeto "Cookie" en sí para una
   revisión completa. De otra manera, "return_ok()" es nunca llamado
   para ese path de cookies.

   Ten en cuenta que "domain_return_ok()" es llamado para cada dominio
   *cookie*, no solamente para el dominio *request*. Por ejemplo, la
   función podría ser llamada con ambos "".example.com"" y
   ""www.example.com"" si el dominio request es ""www.example.com"".
   Lo mismo se aplica para "path_return_ok()".

   El argumento *request* es tal y como es documentado para
   "return_ok()".

CookiePolicy.path_return_ok(path, request)

   Retorna "False" si las cookies no deben de ser retornadas, dado el
   path de las cookies.

   Revisa la documentación para "domain_return_ok()".

Adicionalmente a los métodos implementados anteriormente, las
implementaciones de la interfaz "CookiePolicy" también deben de
proporcionar los siguientes atributos, indicando cuales protocolos
deben de ser utilizados, y como. Todos estos atributos se pueden
asignar.

CookiePolicy.netscape

   Implementa el protocolo Netscape.

CookiePolicy.rfc2965

   Implementa el protocolo **RFC 2965**.

CookiePolicy.hide_cookie2

   No añadas la cabecera *Cookie2* a las requests (la presencia de
   esta cabecera indica al servidor que nosotros entendemos las
   cookies **RFC 2965**).

El camino más útil para definir una clase "CookiePolicy" es haciendo
una subclase de "DefaultCookiePolicy" y sobre escribir algunos o todos
los métodos anteriores. "CookiePolicy" en sí misma puede ser utilizada
como una 'null policy' para permitir establecer y recibir algunas o
todas las cookies (esto raramente puede ser útil).


Objetos DefaultCookiePolicy
===========================

Implementa las reglas estándar para aceptar y retornar cookies.

Ambas cookies, **RFC 2965** y Netscape son cubiertas. El manejo del
RFC 2965 está desactivado de forma predeterminada.

La forma más sencilla de proporcionar tu propia política (*policy*) es
sobre escribir esta clase y llamar sus métodos en tus implementaciones
modificadas antes de añadir tu propias comprobaciones adicionales:

   import http.cookiejar
   class MyCookiePolicy(http.cookiejar.DefaultCookiePolicy):
       def set_ok(self, cookie, request):
           if not http.cookiejar.DefaultCookiePolicy.set_ok(self, cookie, request):
               return False
           if i_dont_want_to_store_this_cookie(cookie):
               return False
           return True

En adición a las características requeridas para implementar la
interfaz "CookiePolicy", esta clase te permite que bloquees o permitas
dominios de establecer y recibir cookies. También hay algunos
interruptores estrictos que te permiten ajustar un poco las reglas
flojas del protocolo Netscape (a costa de bloquear algunas cookies
benignas).

Se proporciona una lista de bloqueo y una lista de permitidos del
dominio (ambos desactivados de forma predeterminada). Solo los
dominios que no están en la lista de bloqueo y que están presentes en
la lista de permisos (si la lista de permisos está activa) participan
en la configuración y devolución de cookies. Utilice el argumento del
constructor *blocked_domains* y los métodos "blocked_domains()" y
"set_blocked_domains()" (y el argumento y los métodos correspondientes
para *allowed_domains*). Si configura una lista de permitidos, puede
desactivarla nuevamente configurándola en "None".

Los dominios en listas de bloqueos o permitidos que no comienzan con
un punto deben ser iguales al dominio de la cookie para que coincidan.
Por ejemplo, ""example.com"" coincide con una entrada de lista de
bloqueo de ""example.com"", pero ""www.example.com"" no. Los dominios
que comienzan con un punto también se corresponden con dominios más
específicos. Por ejemplo, tanto ""www.example.com"" como
""www.coyote.example.com"" coinciden con "".example.com"" (pero el
propio ""example.com"" no lo hace). Las direcciones IP son una
excepción y deben coincidir exactamente. Por ejemplo, si block_domains
contiene ""192.168.1.2"" y "".168.1.2"", 192.168.1.2 está bloqueado,
pero 193.168.1.2 no.

"DefaultCookiePolicy" implementa los siguientes métodos adicionales:

DefaultCookiePolicy.blocked_domains()

   Retorna una secuencia de dominios bloqueados (en forma de tupla).

DefaultCookiePolicy.set_blocked_domains(blocked_domains)

   Establece la secuencia de dominios bloqueados.

DefaultCookiePolicy.is_blocked(domain)

   Retorna "True" si *domain* está en la lista de bloqueo para
   establecer o recibir cookies.

DefaultCookiePolicy.allowed_domains()

   Retorna "None", o la secuencia de los dominios permitidos (en forma
   de tupla).

DefaultCookiePolicy.set_allowed_domains(allowed_domains)

   Establece la secuencia de los dominios permitidos, o "None".

DefaultCookiePolicy.is_not_allowed(domain)

   Retorna "True" si *domain* no está en la lista de permitidos para
   establecer o recibir cookies.

Las instancias "DefaultCookiePolicy" tienen los siguientes atributos,
que son todos inicializados desde los argumentos del constructor del
mismo nombre, y el cual todos pueden ser asignados a.

DefaultCookiePolicy.rfc2109_as_netscape

   Si es true, solicita que la instancia "CookieJar" degrade las
   cookies **RFC 2109** (es decir, las cookies recibidas en una
   cabecera *Set-Cookie* con un cookie-attribute versión de 1) a
   cookies Netscape al establecer la versión del atributo de la
   instancia "Cookie" a 0. El valor predeterminado es "None", en cuyo
   caso las cookies RFC 2109 son degradadas si y sólo si el control de
   **RFC 2965** se encuentra apagado. Por lo tanto, las cookies RFC
   2109 son degradadas de forma predeterminada.

Interruptores generales de rigurosidad:

DefaultCookiePolicy.strict_domain

   No permite que los sitios establezcan dominios de dos componentes
   con dominios country-code top-level como ".co.uk", ".gov.uk",
   ".co.nz".etc. ¡Esto está lejos de ser perfecto y no está
   garantizado a que vaya a funcionar!

Interruptores de rigurosidad del protocolo **RFC 2965**:

DefaultCookiePolicy.strict_rfc2965_unverifiable

   Siga las reglas **RFC 2965** sobre transacciones no verificables
   (normalmente, una transacción no verificable es una del resultado
   de una redirección o una solicitud de una imagen alojada en otro
   sitio). Si esto es falso, las cookies *nunca* se bloquean en base a
   la verificabilidad

Interruptores de rigurosidad del protocolo Netscape:

DefaultCookiePolicy.strict_ns_unverifiable

   Aplica las reglas del **RFC 2965** a transacciones no verificables
   incluso a cookies Netscape.

DefaultCookiePolicy.strict_ns_domain

   Indicadores que señalan que tan estricto deben ser con las reglas
   de domain-matching para cookies Netscape. Consulte a continuación
   los valores aceptables.

DefaultCookiePolicy.strict_ns_set_initial_dollar

   Ignora las cookies en las cabeceras Set-Cookie: que tengan nombres
   que comienzan con "'$'".

DefaultCookiePolicy.strict_ns_set_path

   No permite establecer cookies cuyo path no concuerde con el request
   URI.

"strict_ns_domain" is a collection of flags.  Its value is constructed
by or-ing together (for example,
"DomainStrictNoDots|DomainStrictNonDomain" means both flags are set).

DefaultCookiePolicy.DomainStrictNoDots

   Cuando configuras las cookies, el 'host prefix' no debe de contener
   un punto (ejem. "www.foo.bar.com" no puede establecer una cookie
   para ".bar.com", porque "www.foo" tiene un punto).

DefaultCookiePolicy.DomainStrictNonDomain

   Las cookies que no especifican explícitamente un cookie-attribute
   "domain" sólo se pueden retornar a un dominio igual al que
   estableció la cookie (ejem. "spam.example.com" no retornará las
   cookies de "example.com" que no tuvieran un cookie-attribute
   "domain")

DefaultCookiePolicy.DomainRFC2965Match

   Cuando se establecen las cookies, requiere de un completo
   emparejamiento de dominio **RFC 2965**.

Los siguientes atributos son proveídos por conveniencia, y son las
combinaciones más útiles de los indicadores anteriores:

DefaultCookiePolicy.DomainLiberal

   Equivalente a 0 (es decir, todos los anteriores indicadores de
   rigurosidad de los dominios Netscape están apagados).

DefaultCookiePolicy.DomainStrict

   Equivalente a "DomainStrictNoDots|DomainStrictNonDomain".


Objetos Cookie
==============

Las instancias "Cookie" tienen atributos Python mas o menos
correspondientes a los estándar cookie-attribute especificados en los
diferentes estándares cookie. La correspondencia no es uno a uno,
porque existen complicadas reglas para asignar valores
predeterminados, debido a que los cookie-attribute "max-age" y
"expires" contienen información equivalente, además que las cookies
**RFC 2109** pueden estar 'downgraded' por "http.cookiejar" desde la
versión 1 a la 0 (Netscape) cookies.

La asignación a estos atributos no debe de ser necesario excepto en
raras circunstancias en un método "CookiePolicy". La clase no aplica
consistencia interna, por lo que tienes que saber lo que estás
haciendo si lo estas aplicando.

Cookie.version

   Entero o "None". Las cookies Netscape tienen "version" 0. **RFC
   2965** y las cookies **RFC 2109** tienen una "version" del cookie-
   attribute de 1. Sin embargo, ten en cuenta que "http.cookiejar"
   puede 'downgrade' las cookies RFC 2109 a Netscape cookies, en cuyo
   caso "version" es 0.

Cookie.name

   Nombre de la cookie (un string).

Cookie.value

   El valor de la cookie (una string), o "None".

Cookie.port

   String que representa un puerto o un conjunto de puertos (ejem.
   '80', o '80,8080') o incluso "None".

Cookie.domain

   Cookie domain (a string).

Cookie.path

   Ruta de la cookie (un string, ejem. "'/acme/rocket_launchers'").

Cookie.secure

   "True" si cookie sólo debe de ser retornada sobre una conexión
   segura.

Cookie.expires

   Fecha de caducidad entera en segundos desde la parte temporal, o
   "None". Véase también el método "is_expired()".

Cookie.discard

   "True" si esta es una sesión de cookies.

Cookie.comment

   Comentario string del servidor explicando la función de esta
   cookie, o "None".

Cookie.comment_url

   URL que enlaza a un comentario desde un servidor explicando la
   función de esta cookie, o "None".

Cookie.rfc2109

   "True" si esta cookie fue recibida como una cookie **RFC 2109** (es
   decir, la cookie fue recibida en una cabecera *Set-Cookie*, y el
   valor del cookie-attribute Versión en la cabecera fue de 1). Este
   atributo es proveído porque "http.cookiejar" puede 'degradar'
   cookies RFC 2109 a cookies Netscape, en cuyo caso "version" es 0.

Cookie.port_specified

   "True" si un puerto o un conjunto de puertos fue explícitamente
   especificado por el servidor (en la cabecera *Set-Cookie* / *Set-
   Cookie2*).

Cookie.domain_specified

   "True" si un domino fue explícitamente especificado por el
   servidor.

Cookie.domain_initial_dot

   "True" si el dominio explícitamente especificado por el servidor
   empieza con un punto ("'.'").

Las cookies pueden tener cookie-attribute no estándar adicionales. Se
pueden acceder a estos usando los siguientes métodos:

Cookie.has_nonstandard_attr(name)

   Retorna "True" si cookie tiene nombrado el cookie-attribute.

Cookie.get_nonstandard_attr(name, default=None)

   Si la cookie tiene nombrado el cookie-attribute, retorna su valor.
   De otra manera, retorna *default*.

Cookie.set_nonstandard_attr(name, value)

   Retorna el valor del nombrado cookie-attribute.

La clase "Cookie" también define el siguiente método:

Cookie.is_expired(now=None)

   "True" si la cookie ha excedido el tiempo que el servidor solicitó
   para que expirara. Si *now* es dado (en segundos desde la parte
   temporal), retorna si la cookie ha expirado en el momento
   especificado.


Ejemplos
========

El primer ejemplo muestra el uso más común de "http.cookiejar":

   import http.cookiejar, urllib.request
   cj = http.cookiejar.CookieJar()
   opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
   r = opener.open("http://example.com/")

Este ejemplo ilustra como abrir una URL usando tus cookies Netscape,
Mozilla, o Lynx (asume la convención Unix/Netscape para la ubicación
del archivo de cookies):

   import os, http.cookiejar, urllib.request
   cj = http.cookiejar.MozillaCookieJar()
   cj.load(os.path.join(os.path.expanduser("~"), ".netscape", "cookies.txt"))
   opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
   r = opener.open("http://example.com/")

El siguiente ejemplo ilustra el uso de "DefaultCookiePolicy". Activa
las cookies **RFC 2965**, es más estricto con respecto a los dominios
cuando se establecen o se retornan cookies Netscape, y bloquea algunos
dominios para establecer o retornar cookies:

   import urllib.request
   from http.cookiejar import CookieJar, DefaultCookiePolicy
   policy = DefaultCookiePolicy(
       rfc2965=True, strict_ns_domain=Policy.DomainStrict,
       blocked_domains=["ads.net", ".ads.net"])
   cj = CookieJar(policy)
   opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
   r = opener.open("http://example.com/")
