# `http.cookiejar` — Manejo de cookies para clientes HTTP

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

El módulo `http.cookiejar` define clases para el manejo automático de cookies HTTP. Es útil para acceder a sitios web que requieren pequeñas piezas de datos – cookies – para establecerse en el equipo del cliente a través de una respuesta HTTP de un servidor web, y que además retornan al servidor más tarde en forma de requests de HTTP.

Se manejan tanto el protocolo de cookies Netscape regular y el protocolo definido por RFC 2965. El manejo del RFC 2695 se encuentra desactivado de forma predeterminada. Las cookies RFC 2109 se analizan como cookies Netscape, y subsecuentemente se tratan como cookies Netscape o RFC 2695 de acuerdo con el «policy» actual. Tenga en cuenta que la gran mayoría de las cookies en el Internet son Netscape cookies. `http.cookiejar` intenta seguir de-facto el protocolo de cookies Netscape (el cual difiere substancialmente de las especificaciones originales de Netscape), incluyendo los importantes cookie-attribute `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 fue transformado a una subclase de `OSError` en vez de `IOError`.

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, 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.

  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.

http://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 `urllib.request.Request`) debe de soportar los métodos `get_full_url()`, `get_host()`, `get_type()`, `unverifiable()`, `has_header()`, `get_header()`, `header_items()`, `add_unredirected_header()` y el atributo `origin_req_host` como es documentado en `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 `urllib.request.Request`) debe soportar los métodos `get_full_url()`, `get_host()`, `unverifiable()`, y el atributo `origin_req_host`, como es documentado en `urllib.request`. La request es utilizada para establecer valores predeterminados en los atributos-cookie así como de comprobar si tiene permitido hacerlo.

  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 generará 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, delayload=None, policy=None)

  Un `FileCookieJar` que puede cargar y guardar cookies al disco en el formato de archivo Mozilla `cookies.txt` (el cual es también utilizado por 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, 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 negra y una lista blanca (ambas desactivas de manera predeterminada). Sólo los dominios que no se encuentran en la lista negra y que están presentes en la lista blanca (si la lista blanca se encuentra activada) participan en el establecimiento y regreso de cookies. Usa los argumentos constructor de blocked_domains, y los métodos `blocked_domains()` y `set_blocked_domains()` (además de los argumentos y métodos correspondientes para allowed_domains). Si estableces una lista blanca, puedes apagarla de nuevo estableciéndola en `None`.

Los dominios en las listas de bloqueo o permiso que no pueden empezar con un punto deben de ser iguales al dominio de la cookie para que coincidan. Por ejemplo `"example.com"` coincide con una entrada de la lista negra de `"example.com"`, pero `"www.example.com"` no lo hace. Los dominios que empiezan con un punto son también emparejados con dominios más específicos. Por ejemplo, ambas `"www.example.com"` y `"www.coyote.example.com"` coinciden con `".example.com"` (pero `"example.com"` en sí misma no). Las direcciones IP son la excepción, y deben coincidir exactamente. Por ejemplo, si bolcked_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 si domain se encuentra en la lista negra o no 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 si domain no se encuentra o si en la lista blanca para establecer y 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` es una colección de indicadores. Su valor está construido o siendo construido en conjunto (por ejemplo, `DomainStrictNoDots|DomainStrictNonDomain` significa que ambos indicadores se encuentran establecidos).

`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.``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/")