"ipaddress" --- Biblioteca de manipulación IPv4/IPv6
****************************************************

**Código fuente:** Lib/ipaddress.py

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

"ipaddress" proporciona las capacidades para crear, manipular y operar
en direcciones y redes IPv4 e IPv6.

Las funciones y clases de este módulo facilitan el control de varias
tareas relacionadas con las direcciones IP, incluido comprobar si dos
*hosts* están en la misma subred o no, iterar sobre todos los *hosts*
de una subred determinada, comprobar si una cadena de caracteres
representa o no una dirección IP válida o una definición de red, etc.

Esta es la referencia completa de la API del módulo: para obtener
información general y una introducción, véase Introducción al modulo
ipaddress.

Nuevo en la versión 3.3.


Funciones de fábrica de conveniencia
====================================

El módulo "ipaddress" proporciona funciones de fábrica para crear
convenientemente direcciones IP, redes e interfaces:

ipaddress.ip_address(address)

   Return an "IPv4Address" or "IPv6Address" object depending on the IP
   address passed as argument.  Either IPv4 or IPv6 addresses may be
   supplied; integers less than "2**32" will be considered to be IPv4
   by default. A "ValueError" is raised if *address* does not
   represent a valid IPv4 or IPv6 address.

   >>> ipaddress.ip_address('192.168.0.1')
   IPv4Address('192.168.0.1')
   >>> ipaddress.ip_address('2001:db8::')
   IPv6Address('2001:db8::')

ipaddress.ip_network(address, strict=True)

   Return an "IPv4Network" or "IPv6Network" object depending on the IP
   address passed as argument.  *address* is a string or integer
   representing the IP network.  Either IPv4 or IPv6 networks may be
   supplied; integers less than "2**32" will be considered to be IPv4
   by default.  *strict* is passed to "IPv4Network" or "IPv6Network"
   constructor.  A "ValueError" is raised if *address* does not
   represent a valid IPv4 or IPv6 address, or if the network has host
   bits set.

   >>> ipaddress.ip_network('192.168.0.0/28')
   IPv4Network('192.168.0.0/28')

ipaddress.ip_interface(address)

   Return an "IPv4Interface" or "IPv6Interface" object depending on
   the IP address passed as argument.  *address* is a string or
   integer representing the IP address.  Either IPv4 or IPv6 addresses
   may be supplied; integers less than "2**32" will be considered to
   be IPv4 by default.  A "ValueError" is raised if *address* does not
   represent a valid IPv4 or IPv6 address.

Una desventaja de estas funciones de conveniencia es que la necesidad
de manejar ambos formatos IPv4 e IPv6 significa que los mensajes de
error proveen información mínima sobre el error preciso, ya que las
funciones no saben si se pretendía usar el formato IPv4 o IPv6. Un
reporte de error más detallado se puede obtener llamando directamente
a los constructores de clase específicos para la versión apropiada.


Direcciones IP
==============


Objetos de dirección
--------------------

Los objetos "IPv4Address" y "IPv6Address" comparten muchos atributos
comunes.  Algunos atributos que son sólo significativos para
direcciones IPv6 también están implementados para los objetos
"IPv4Address", para que sea más fácil escribir código que maneje ambas
versiones de IP correctamente.  Los objetos de dirección son
*hashable*, por lo que se pueden utilizar como claves en diccionarios.

class ipaddress.IPv4Address(address)

   Construye una dirección IPv4.  Se genera un "AddressValueError" si
   *address* no es una dirección IPv4 válida.

   Lo siguiente constituye una dirección IPv4 válida:

   1. A string in decimal-dot notation, consisting of four decimal
      integers in the inclusive range 0--255, separated by dots (e.g.
      "192.168.0.1"). Each integer represents an octet (byte) in the
      address. Leading zeroes are not tolerated to prevent confusion
      with octal notation.

   2. Un entero que cabe en 32 bits.

   3. Un entero empaquetado en un objeto "bytes" de longitud 4 (el
      octeto más significativo primero).

   >>> ipaddress.IPv4Address('192.168.0.1')
   IPv4Address('192.168.0.1')
   >>> ipaddress.IPv4Address(3232235521)
   IPv4Address('192.168.0.1')
   >>> ipaddress.IPv4Address(b'\xC0\xA8\x00\x01')
   IPv4Address('192.168.0.1')

   Distinto en la versión 3.8: Leading zeros are tolerated, even in
   ambiguous cases that look like octal notation.

   Distinto en la versión 3.10: Leading zeros are no longer tolerated
   and are treated as an error. IPv4 address strings are now parsed as
   strict as glibc "inet_pton()".

   Distinto en la versión 3.9.5: The above change was also included in
   Python 3.9 starting with version 3.9.5.

   Distinto en la versión 3.8.12: The above change was also included
   in Python 3.8 starting with version 3.8.12.

   version

      El número de versión apropiado: "4" para IPv4, "6" para IPv6.

   max_prefixlen

      El número total de bits en la representación de la dirección
      para esta versión: "32" para IPv4, "128" para IPv6.

      El prefijo define el número de bits iniciales en una  dirección
      que son comparados para determinar si una dirección es o no
      parte de una red.

   compressed

   exploded

      La representación de cadena de caracteres en notación decimal
      con puntos. Los ceros a la izquierda nunca se incluyen en la
      representación.

      Como IPv4 no define una notación abreviada para direcciones con
      octetos establecidos en cero, estos dos atributos son siempre
      los mismos que "str(addr)" para direcciones IPv4. Exponer estos
      atributos hace que sea más fácil escribir código de
      visualización que pueda manejar direcciones IPv4 e IPv46.

   packed

      La representación binaria de esta dirección - un objeto "bytes"
      de la longitud apropiada (octeto más significativo primero).
      Esta es 4 bytes para IPv4 y 16 bytes para IPv6.

   reverse_pointer

      El nombre del registro PTR DNS inverso para la dirección IP, por
      ejemplo:

         >>> ipaddress.ip_address("127.0.0.1").reverse_pointer
         '1.0.0.127.in-addr.arpa'
         >>> ipaddress.ip_address("2001:db8::1").reverse_pointer
         '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa'

      Este es el nombre que podría usarse para realizar una búsqueda
      PTR, no el nombre de *host* resuelto en sí.

      Nuevo en la versión 3.5.

   is_multicast

      "True" si la dirección está reservada para uso de multidifusión.
      Véase **RFC 3171** (para IPv4) o **RFC 2373** (para IPv6).

   is_private

      "True" if the address is defined as not globally reachable by
      iana-ipv4-special-registry (for IPv4) or iana-ipv6-special-
      registry (for IPv6) with the following exceptions:

      * "is_private" is "False" for the shared address space
        ("100.64.0.0/10")

      * For IPv4-mapped IPv6-addresses the "is_private" value is
        determined by the semantics of the underlying IPv4 addresses
        and the following condition holds (see
        "IPv6Address.ipv4_mapped"):

           address.is_private == address.ipv4_mapped.is_private

      "is_private" has value opposite to "is_global", except for the
      shared address space ("100.64.0.0/10" range) where they are both
      "False".

      Distinto en la versión 3.9.20: Fixed some false positives and
      false negatives.

      * "192.0.0.0/24" is considered private with the exception of
        "192.0.0.9/32" and "192.0.0.10/32" (previously: only the
        "192.0.0.0/29" sub-range was considered private).

      * "64:ff9b:1::/48" is considered private.

      * "2002::/16" is considered private.

      * There are exceptions within "2001::/23" (otherwise considered
        private): "2001:1::1/128", "2001:1::2/128", "2001:3::/32",
        "2001:4:112::/48", "2001:20::/28", "2001:30::/28". The
        exceptions are not considered private.

   is_global

      "True" if the address is defined as globally reachable by iana-
      ipv4-special-registry (for IPv4) or iana-ipv6-special-registry
      (for IPv6) with the following exception:

      For IPv4-mapped IPv6-addresses the "is_private" value is
      determined by the semantics of the underlying IPv4 addresses and
      the following condition holds (see "IPv6Address.ipv4_mapped"):

         address.is_global == address.ipv4_mapped.is_global

      "is_global" has value opposite to "is_private", except for the
      shared address space ("100.64.0.0/10" range) where they are both
      "False".

      Nuevo en la versión 3.4.

      Distinto en la versión 3.9.20: Fixed some false positives and
      false negatives, see "is_private" for details.

   is_unspecified

      "True" si la dirección no está especificada.  Véase **RFC 5735**
      (para IPv4) o **RFC 2373** (para IPv6).

   is_reserved

      "True" si la dirección está reservada por la IETF.

   is_loopback

      "True" si esta es una dirección de *loopback*.  Véase **RFC
      3330** (para IPv4) o **RFC 2373** (para IPv6).

   is_link_local

      "True" si la dirección está reservada para uso de enlace-local.
      Véase **RFC 3927**.

IPv4Address.__format__(fmt)

   Retorna una representación en cadena de caracteres de la dirección
   IP, controlada por una cadena de formato explícito. *fmt* puede ser
   uno de los siguientes: "'s'", la opción predeterminada, equivalente
   a "str()", "'b'" para una cadena binaria con relleno de ceros,
   "'X'" o "'x'" para una representación hexadecimal en mayúsculas o
   minúsculas, o "'n'", que es equivalente a "'b'" para direcciones
   IPv4 y "'x'" para IPv6. Para representaciones binarias y
   hexadecimales, el especificador de formulario "'#'" y la opción de
   agrupación "'_'" están disponibles. "__format__" es utilizado por
   "format", "str.format" y f-strings.

   >>> format(ipaddress.IPv4Address('192.168.0.1'))
   '192.168.0.1'
   >>> '{:#b}'.format(ipaddress.IPv4Address('192.168.0.1'))
   '0b11000000101010000000000000000001'
   >>> f'{ipaddress.IPv6Address("2001:db8::1000"):s}'
   '2001:db8::1000'
   >>> format(ipaddress.IPv6Address('2001:db8::1000'), '_X')
   '2001_0DB8_0000_0000_0000_0000_0000_1000'
   >>> '{:#_n}'.format(ipaddress.IPv6Address('2001:db8::1000'))
   '0x2001_0db8_0000_0000_0000_0000_0000_1000'

   Nuevo en la versión 3.9.

class ipaddress.IPv6Address(address)

   Construye una dirección IPv6.  Se genera un "AddressValueError" si
   *address* no es una dirección IPv6 válida.

   Lo siguiente constituye una dirección IPv6 válida:

   1. Una cadena de caracteres que consta de 8 grupos de cuatro
      dígitos hexadecimales, cada grupo representa 16 bits.  Los
      grupos son separados por dos puntos. Esto describe una notación
      completa (larga).  La cadena también puede ser comprimida
      (notación corta) de varias maneras.  Véase **RFC 4291** para más
      detalles.  Por ejemplo,
      ""0000:0000:0000:0000:0000:0abc:0007:0def"" puede ser comprimida
      a ""::abc:7:def"".

      Opcionalmente, la cadena de caracteres también puede tener un ID
      alcance, expresado con un sufijo "%scope_id". Si está presente,
      el ID de alcance no debe estar vacío y no puede contener "%".
      Consulte **RFC 4007** para obtener más detalles. Por ejemplo,
      "fe80::1234% 1" podría identificar la dirección "fe80::1234" en
      el primer enlace del nodo.

   2. Un entero que cabe en 128 bits.

   3. Un entero empaquetado en un objeto "bytes" de longitud 16, *big-
      endian*.

   >>> ipaddress.IPv6Address('2001:db8::1000')
   IPv6Address('2001:db8::1000')
   >>> ipaddress.IPv6Address('ff02::5678%1')
   IPv6Address('ff02::5678%1')

   compressed

   La forma abreviada de la representación de la dirección, omitiendo
   los ceros a la izquierda en los grupos y la secuencia más larga de
   grupos que consisten completamente de ceros colapsada en un sólo
   grupo vacío.

   Este es también el valor retornado por "str(addr)" para direcciones
   IPv6.

   exploded

   La forma larga de la representación de la dirección, incluidos
   todos los ceros iniciales y los grupos que consisten completamente
   de ceros.

   Para los siguientes atributos, véase la documentación
   correspondiente de la clase "IPv4Address":

   packed

   reverse_pointer

   version

   max_prefixlen

   is_multicast

   is_private

   is_global

   is_unspecified

   is_reserved

   is_loopback

   is_link_local

      Nuevo en la versión 3.4: is_global

   is_site_local

      "True" si la dirección está reservada para el uso local del
      sitio.  Tenga en cuenta que el espacio de direcciones locales
      del sitio ha quedado en desuso por **RFC 3879**. Utilice
      "is_private" para probar si esta dirección está en el espacio de
      direcciones locales únicas según lo definido por **RFC 4193**.

   ipv4_mapped

      Para las direcciones que parecen ser direcciones IPv4 mapeadas
      (comenzando con "::FFFF/96"), esta propiedad informará la
      dirección IPv4 incrustada. Para cualquier otra dirección, esta
      propiedad será "None".

   scope_id

      Para las direcciones con alcance como es definido por **RFC
      4007**, esta propiedad identifica la zona particular del alcance
      de la dirección a la que pertenece dicha dirección, como una
      cadena de caracteres. Cuando no se especifica ninguna zona de
      alcance, esta propiedad será "None".

   sixtofour

      Para las direcciones que parecen ser direcciones 6to4
      (comenzando con "2002::/16") según lo definido por **RFC 3056**,
      esta propiedad reportará la dirección IPv4 incrustada. Para
      cualquier otra dirección, esta propiedad será "None".

   teredo

      Para las direcciones que parecen ser direcciones *Teredo*
      (comenzando con "2001::/32") según lo definido en **RFC 4380**,
      esta propiedad reportará el par de direcciones IP "(servidor,
      cliente)" incrustadas.  Para cualquier otra dirección, esta
      propiedad será "None".

IPv6Address.__format__(fmt)

   Consulta en "IPv4Address" la documentación de atributos
   correspondiente.

   Nuevo en la versión 3.9.


Conversión a cadenas de caracteres y enteros
--------------------------------------------

Para interoperar con interfaces de red como el módulo *socket*, las
direcciones se deben convertir en cadenas de caracteres o enteros.
Esto se gestiona usando las funciones "str()" e "int()" incorporadas:

   >>> str(ipaddress.IPv4Address('192.168.0.1'))
   '192.168.0.1'
   >>> int(ipaddress.IPv4Address('192.168.0.1'))
   3232235521
   >>> str(ipaddress.IPv6Address('::1'))
   '::1'
   >>> int(ipaddress.IPv6Address('::1'))
   1

Tenga en cuenta que las direcciones IPv6 con alcance se convierten en
números enteros sin ID de zona de alcance.


Operadores
----------

Los objetos de dirección admiten algunos operadores.  A menos que se
indique lo contrario, los operadores solo se pueden aplicar entre
objetos compatibles (es decir, IPv4 con IPv4, IPv6 con IPv6).


Operadores de comparación
~~~~~~~~~~~~~~~~~~~~~~~~~

Los objetos de dirección pueden compararse con el conjunto usual de
operadores de comparación. Las mismas direcciones IPv6 con diferentes
ID de zona de alcance no son iguales. Algunos ejemplos:

   >>> IPv4Address('127.0.0.2') > IPv4Address('127.0.0.1')
   True
   >>> IPv4Address('127.0.0.2') == IPv4Address('127.0.0.1')
   False
   >>> IPv4Address('127.0.0.2') != IPv4Address('127.0.0.1')
   True
   >>> IPv6Address('fe80::1234') == IPv6Address('fe80::1234%1')
   False
   >>> IPv6Address('fe80::1234%1') != IPv6Address('fe80::1234%2')
   True


Operadores aritméticos
~~~~~~~~~~~~~~~~~~~~~~

Los enteros pueden ser sumados o restados de objetos de dirección.
Algunos ejemplos:

   >>> IPv4Address('127.0.0.2') + 3
   IPv4Address('127.0.0.5')
   >>> IPv4Address('127.0.0.2') - 3
   IPv4Address('126.255.255.255')
   >>> IPv4Address('255.255.255.255') + 1
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ipaddress.AddressValueError: 4294967296 (>= 2**32) is not permitted as an IPv4 address


Definiciones de red IP
======================

Los objetos "IPv4Network" y "IPv6Network" proveen un mecanismo para
definir e inspeccionar definiciones de redes IP.  Una definición de
red consiste en una máscara y una dirección de red, y como tal define
un rango de direcciones IP que son iguales a la dirección de red
cuando se enmascaran (*AND* binario) con la máscara.  Por ejemplo, una
definición de red con la máscara "255.255.255.0" y la dirección de red
"192.168.1.0" consiste de las direcciones IP en el rango inclusivo
"192.168.1.0" a "192.168.1.255".


Prefijo, máscara de red y máscara de *host*
-------------------------------------------

Hay varias maneras equivalentes de especificar máscaras de red IP.  Un
*prefijo* es una notación que denota cuántos bits de orden superior se
establecen en la máscara de red.  Una *máscara de red* es una
dirección IP con cierto número de bits de orden superior establecidos.
Por lo tanto, el prefijo "/24" es equivalente a la máscara de red
"255.255.255.0" en IPv4, o "ffff:ff00::" en IPv6.  Además, una
*máscara del host* es la inversa lógica de una *máscara de red*, y se
utiliza a veces (por ejemplo en las listas de control de acceso de
Cisco) para denotar una máscara de red.  La máscara de host
equivalente a "/24" en IPv4 es "0.0.0.255".


Objetos de red
--------------

Todos los atributos implementados por los objetos de dirección también
se implementan mediante objetos de red.  Además, los objetos de red
implementan atributos adicionales. Todos estos son comunes entre
"IPv4Network" y "IPv6Network", por lo que para evitar la duplicación
solo están documentados para "IPv4Network". Los objetos de red son
*hashable*, por lo que se pueden utilizar como claves en diccionarios.

class ipaddress.IPv4Network(address, strict=True)

   Construye una definición de red IPv4.  *address* puede ser uno de
   los siguientes:

   1. Una cadena de caracteres de una dirección IP y una máscara
      opcional, separadas por una barra diagonal ("/").  La dirección
      IP es la dirección de red, y la máscara puede ser un número
      único, lo que significa que es un prefijo, o una representación
      de una dirección IPv4. Si es la última, la máscara se interpreta
      como una máscara de red si comienza con un campo distinto de
      cero, o como una máscara de *host* si comienza con un campo
      igual a cero, con la única excepción de una máscara con todos
      ceros que es tratada como una máscara de red.  Si no se
      proporciona una máscara, se considera "\32".

      Por ejemplo, las siguientes especificaciones de *address* son
      equivalentes: "192.168.1.0/24", "192.168.1.0/255.255.255.0" y
      "192.168.1.0/0.0.0.255".

   2. Un entero que cabe en 32 bits.  Este es equivalente a una red de
      una sola dirección, siendo *address* la dirección de red y "/32"
      la máscara.

   3. Un entero empaquetado en un objeto "bytes" de longitud 4, *big-
      endian*. La interpretación es similar a un entero *address*.

   4. Una tupla con dos elementos con una descripción de dirección y
      una máscara de red, donde la descripción de dirección es una
      cadena de caracteres, un entero de 32 bits, un entero
      empaquetado de 4 bytes, o un objeto IPv4Address existente; y una
      máscara de red es un entero que representa la longitud del
      prefijo (por ejemplo "24") o una cadena de caracteres que
      representa la máscara de prefijo (por ejemplo "255.255.255.0").

   Se genera un "AddressValueError" si *address* no es una dirección
   IPv4 válida.  Se genera un "NetmaskValueError" si la máscara no es
   válida para un dirección IPv4.

   Si *strict* es "True" y los bits de *host* están establecidos en la
   dirección proporcionada, se genera "ValueError".  De lo contrario,
   los bits de *host* se enmascaran para determinar la dirección de
   red adecuada.

   A menos que se indique lo contrario, todos los métodos de red que
   acepten otros objetos de red/dirección generarán "TypeError" si la
   versión IP del argumento es incompatible con "self".

   Distinto en la versión 3.5: Se agregó la forma de tupla con dos
   elementos para el parámetro *address* del constructor.

   version

   max_prefixlen

      Consulta en "IPv4Address" la documentación de atributos
      correspondiente.

   is_multicast

   is_private

   is_unspecified

   is_reserved

   is_loopback

   is_link_local

      Estos atributos son verdaderos para la red en su conjunto si son
      verdaderos tanto para la dirección de red como para la dirección
      de difusión.

   network_address

      La dirección de red para la red. La dirección de red y la
      longitud del prefijo juntas definen de forma única una red.

   broadcast_address

      La dirección de difusión para la red. Los paquetes enviados a la
      dirección de difusión deberían ser recibidos por cada *host* en
      la red.

   hostmask

      La máscara de *host*, como un objeto "IPv4Address".

   netmask

      La máscara de red, como un objeto "IPv4Address".

   with_prefixlen

   compressed

   exploded

      Una representación en cadena de caracteres de la red, con la
      máscara en notación de prefijo.

      "with_prefixlen" y "compressed" son siempre lo mismo que
      "str(network)". "exploded" usa la forma completa de la dirección
      de red.

   with_netmask

      Una representación en cadena de caracteres de la red, con la
      máscara en notación de máscara de red.

   with_hostmask

      Una representación de cadena de caracteres de la red, con la
      máscara en notación de máscara de *host*.

   num_addresses

      El número total de direcciones en la red.

   prefixlen

      Longitud del prefijo de red, en bits.

   hosts()

      Retorna un iterador a través de los *hosts* utilizables de la
      red. Los *hosts* utilizables son todas las direcciones IP que
      pertenecen a la red, excepto la propia dirección de red y la
      dirección de difusión de red. Para las redes con una longitud de
      máscara de 31, la dirección de red y la dirección de difusión de
      red también se incluyen en el resultado. Las redes con una
      máscara de 32 retornarán una lista que contiene la única
      dirección de host.

      >>> list(ip_network('192.0.2.0/29').hosts())  
      [IPv4Address('192.0.2.1'), IPv4Address('192.0.2.2'),
       IPv4Address('192.0.2.3'), IPv4Address('192.0.2.4'),
       IPv4Address('192.0.2.5'), IPv4Address('192.0.2.6')]
      >>> list(ip_network('192.0.2.0/31').hosts())
      [IPv4Address('192.0.2.0'), IPv4Address('192.0.2.1')]
      >>> list(ip_network('192.0.2.1/32').hosts())
      [IPv4Address('192.0.2.1')]

   overlaps(other)

      "True" si esta red está parcial o totalmente contenida en
      *other* u *other* está totalmente contenida en esta red.

   address_exclude(network)

      Calcula las definiciones de red que resultan de eliminar
      *network* de esta red.  Retorna un iterador de objetos de red.
      Se genera "ValueError" si *network* no está completamente
      contenida en esta red.

      >>> n1 = ip_network('192.0.2.0/28')
      >>> n2 = ip_network('192.0.2.1/32')
      >>> list(n1.address_exclude(n2))  
      [IPv4Network('192.0.2.8/29'), IPv4Network('192.0.2.4/30'),
       IPv4Network('192.0.2.2/31'), IPv4Network('192.0.2.0/32')]

   subnets(prefixlen_diff=1, new_prefix=None)

      Las subredes que se unen para crear la definición de red actual,
      en función de los valores de argumento.  *prefixlen_diff* es la
      cantidad en la que debería aumentarse nuestra longitud de
      prefijo.  *new_prefix* es el nuevo prefijo deseado de las
      subredes; debe ser más grande que nuestro prefijo.  Se debe
      establecer uno y solo uno de *prefixlen_diff* y *new_prefix*.
      Retorna un iterador de objetos de red.

      >>> list(ip_network('192.0.2.0/24').subnets())
      [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/25')]
      >>> list(ip_network('192.0.2.0/24').subnets(prefixlen_diff=2))  
      [IPv4Network('192.0.2.0/26'), IPv4Network('192.0.2.64/26'),
       IPv4Network('192.0.2.128/26'), IPv4Network('192.0.2.192/26')]
      >>> list(ip_network('192.0.2.0/24').subnets(new_prefix=26))  
      [IPv4Network('192.0.2.0/26'), IPv4Network('192.0.2.64/26'),
       IPv4Network('192.0.2.128/26'), IPv4Network('192.0.2.192/26')]
      >>> list(ip_network('192.0.2.0/24').subnets(new_prefix=23))
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
          raise ValueError('new prefix must be longer')
      ValueError: new prefix must be longer
      >>> list(ip_network('192.0.2.0/24').subnets(new_prefix=25))
      [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/25')]

   supernet(prefixlen_diff=1, new_prefix=None)

      La superred que contiene esta definición de red, dependiendo de
      los valores de los argumentos.  *prefixlen_diff* es la cantidad
      en la que debería reducirse la longitud de nuestro prefijo.
      *new_prefix* es el nuevo prefijo deseado de la superred; debe
      ser más pequeño que nuestro prefijo.  Se debe establecer uno y
      solo uno de *prefixlen_diff* y *new_prefix*.  Retorna un único
      objeto de red.

      >>> ip_network('192.0.2.0/24').supernet()
      IPv4Network('192.0.2.0/23')
      >>> ip_network('192.0.2.0/24').supernet(prefixlen_diff=2)
      IPv4Network('192.0.0.0/22')
      >>> ip_network('192.0.2.0/24').supernet(new_prefix=20)
      IPv4Network('192.0.0.0/20')

   subnet_of(other)

      Retorna "True" si esta red es una subred de *other*.

      >>> a = ip_network('192.168.1.0/24')
      >>> b = ip_network('192.168.1.128/30')
      >>> b.subnet_of(a)
      True

      Nuevo en la versión 3.7.

   supernet_of(other)

      Retorna "True" si esta red es una superred de *other*.

      >>> a = ip_network('192.168.1.0/24')
      >>> b = ip_network('192.168.1.128/30')
      >>> a.supernet_of(b)
      True

      Nuevo en la versión 3.7.

   compare_networks(other)

      Compara esta red con *other*.  En esta comparación solo se
      consideran las direcciones de red; los bits de *host* no.
      Retorna "-1", "0" o "1".

      >>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.2/32'))
      -1
      >>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.0/32'))
      1
      >>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.1/32'))
      0

      Obsoleto desde la versión 3.7: Utiliza el mismo algoritmo de
      ordenación y comparación que "<", "==", y ">"

class ipaddress.IPv6Network(address, strict=True)

   Construye una definición de red IPv6.  *address* puede ser uno de
   los siguientes:

   1. Una cadena de caracteres que consta de una dirección IP y una
      longitud de prefijo opcional, separadas por una barra diagonal
      ("/").  La dirección IP es la dirección de red y la longitud del
      prefijo debe ser un solo número, el *prefijo*.  Si no se
      proporciona ninguna longitud de prefijo, se considera que es
      "/128".

      Note that currently expanded netmasks are not supported.  That
      means "2001:db00::0/24" is a valid argument while
      "2001:db00::0/ffff:ff00::" is not.

   2. Un entero que cabe en 128 bits.  Este es equivalente a una red
      de una sola dirección, siendo *address* la dirección de red y
      "/128" la máscara.

   3. Un entero empaquetado en un objeto "bytes" de longitud 16, *big-
      endian*. La interpretación es similar a un entero *address*.

   4. Una tupla con dos elementos con una descripción de dirección y
      una máscara de red, donde la descripción de dirección es una
      cadena de caracteres, un entero de 128 bits, un entero
      empaquetado de 16 bytes, o un objeto IPv6Address existente; y
      una máscara de red es un entero que representa la longitud del
      prefijo.

   Se genera un "AddressValueError" si *address* no es una dirección
   IPv6 válida.  Se genera un "NetmaskValueError" si la máscara no es
   válida para una dirección IPv6.

   Si *strict* es "True" y los bits de *host* están establecidos en la
   dirección proporcionada, se genera "ValueError".  De lo contrario,
   los bits de *host* se enmascaran para determinar la dirección de
   red adecuada.

   Distinto en la versión 3.5: Se agregó la forma de tupla con dos
   elementos para el parámetro *address* del constructor.

   version

   max_prefixlen

   is_multicast

   is_private

   is_unspecified

   is_reserved

   is_loopback

   is_link_local

   network_address

   broadcast_address

   hostmask

   netmask

   with_prefixlen

   compressed

   exploded

   with_netmask

   with_hostmask

   num_addresses

   prefixlen

   hosts()

      Retorna un iterador sobre los *hosts* utilizables de la red. Los
      *hosts* utilizables son todas las direcciones IP que pertenecen
      a la red, excepto la dirección *anycast Subnet-Router*. Para las
      redes con una longitud de máscara de 127, la dirección *anycast
      Subnet-Router* también se incluye en el resultado. Las redes con
      una máscara de 128 retornarán una lista que contiene la única
      dirección de host.

   overlaps(other)

   address_exclude(network)

   subnets(prefixlen_diff=1, new_prefix=None)

   supernet(prefixlen_diff=1, new_prefix=None)

   subnet_of(other)

   supernet_of(other)

   compare_networks(other)

      Consulta en "IPv4Network" la documentación de atributos
      correspondiente.

   is_site_local

      Este atributo es verdadero para la red en su conjunto si es
      verdadero tanto para la dirección de red como para la dirección
      de difusión.


Operadores
----------

Los objetos de red admiten algunos operadores.  A menos que se indique
lo contrario, los operadores solo se pueden aplicar entre objetos
compatibles (es decir, IPv4 con IPv4, IPv6 con IPv6).


Operadores lógicos
~~~~~~~~~~~~~~~~~~

Los objetos de red pueden compararse con el conjunto usual de
operadores lógicos. Los objetos de red son ordenados primero por
dirección de red, y después por máscara de red.


Iteración
~~~~~~~~~

Los objetos de red se pueden iterar para listar todas las direcciones
que pertenecen a la red.  Para la iteración, se retornan todos los
*hosts*, incluyendo *hosts* inutilizables (para *hosts* utilizables,
se usa el método "hosts()").  Un ejemplo:

   >>> for addr in IPv4Network('192.0.2.0/28'):
   ...     addr
   ...
   IPv4Address('192.0.2.0')
   IPv4Address('192.0.2.1')
   IPv4Address('192.0.2.2')
   IPv4Address('192.0.2.3')
   IPv4Address('192.0.2.4')
   IPv4Address('192.0.2.5')
   IPv4Address('192.0.2.6')
   IPv4Address('192.0.2.7')
   IPv4Address('192.0.2.8')
   IPv4Address('192.0.2.9')
   IPv4Address('192.0.2.10')
   IPv4Address('192.0.2.11')
   IPv4Address('192.0.2.12')
   IPv4Address('192.0.2.13')
   IPv4Address('192.0.2.14')
   IPv4Address('192.0.2.15')


Redes como contenedores de direcciones
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Los objetos de red pueden actuar como contenedores de direcciones.
Algunos ejemplos:

   >>> IPv4Network('192.0.2.0/28')[0]
   IPv4Address('192.0.2.0')
   >>> IPv4Network('192.0.2.0/28')[15]
   IPv4Address('192.0.2.15')
   >>> IPv4Address('192.0.2.6') in IPv4Network('192.0.2.0/28')
   True
   >>> IPv4Address('192.0.3.6') in IPv4Network('192.0.2.0/28')
   False


Objetos de interfaz
===================

Los objetos de interfaz son *hashable*, por lo que se pueden utilizar
como claves en diccionarios.

class ipaddress.IPv4Interface(address)

   Construye una interfaz IPv4.  El significado de *address* es el
   mismo que en el constructor de "IPv4Network", excepto que las
   direcciones de *host* arbitrarias son siempre aceptadas.

   "IPv4Interface" es una subclase de "IPv4Address", así que hereda
   todos los atributos de esa clase.  Adicionalmente, los siguientes
   atributos están disponibles:

   ip

      La dirección ("IPv4Address") sin información de red.

      >>> interface = IPv4Interface('192.0.2.5/24')
      >>> interface.ip
      IPv4Address('192.0.2.5')

   network

      La red ("IPv4Network") a la que pertenece esta interfaz.

      >>> interface = IPv4Interface('192.0.2.5/24')
      >>> interface.network
      IPv4Network('192.0.2.0/24')

   with_prefixlen

      Una representación en cadena de caracteres de la interfaz con la
      máscara en notación de prefijo.

      >>> interface = IPv4Interface('192.0.2.5/24')
      >>> interface.with_prefixlen
      '192.0.2.5/24'

   with_netmask

      Una representación en cadena de caracteres de la interfaz con la
      red como una máscara de red.

      >>> interface = IPv4Interface('192.0.2.5/24')
      >>> interface.with_netmask
      '192.0.2.5/255.255.255.0'

   with_hostmask

      Una representación de la interfaz con la red como una máscara de
      *host*.

      >>> interface = IPv4Interface('192.0.2.5/24')
      >>> interface.with_hostmask
      '192.0.2.5/0.0.0.255'

class ipaddress.IPv6Interface(address)

   Construye una interfaz IPv6.  El significado de *address* es el
   mismo que en el constructor de "IPv6Network", excepto que las
   direcciones de *host* arbitrarias son siempre aceptadas.

   "IPv6Interface" es una subclase de "IPv6Address", así que hereda
   todos los atributos de esa clase.  Adicionalmente, los siguientes
   atributos están disponibles:

   ip

   network

   with_prefixlen

   with_netmask

   with_hostmask

      Consulta en "IPv4Interface" la documentación de atributos
      correspondiente.


Operadores
----------

Los objetos de interfaz admiten algunos operadores.  A menos que se
indique lo contrario, los operadores solo se pueden aplicar entre
objetos compatibles (es decir, IPv4 con IPv4, IPv6 con IPv6).


Operadores lógicos
~~~~~~~~~~~~~~~~~~

Los objetos de interfaz pueden compararse con el conjunto usual de
operadores lógicos.

Para la comparación de igualdad ("==" and "!="), tanto la dirección IP
como la red deben ser iguales para que los objetos sean iguales.  Una
interfaz no será igual a ningún objeto de dirección o de red.

Para el ordenamiento ("<", ">", etc.) las reglas son diferentes.  Los
objetos de interfaz y de dirección con la misma versión de IP se
pueden comparar, y los objetos de dirección siempre se ordenarán antes
que los objetos de interfaz.  Dos objetos de interfaz se comparan
primero por sus redes y, si son iguales, luego por sus direcciones IP.


Otras funciones a nivel de módulo
=================================

El módulo también provee las siguientes funciones a nivel de módulo:

ipaddress.v4_int_to_packed(address)

   Representa una dirección como 4 bytes empaquetados en orden de red
   (*big-endian*). *address* es una representación en entero de una
   dirección IPv4.  Se genera un "ValueError" si el entero es negativo
   o demasiado grande para ser una dirección IPv4.

   >>> ipaddress.ip_address(3221225985)
   IPv4Address('192.0.2.1')
   >>> ipaddress.v4_int_to_packed(3221225985)
   b'\xc0\x00\x02\x01'

ipaddress.v6_int_to_packed(address)

   Representa una dirección como 16 bytes empaquetados en orden de red
   (*big-endian*). *address* es una representación en entero de una
   dirección IPv6.  Se genera un "ValueError" si el entero es negativo
   o demasiado grande para ser una dirección IPv6.

ipaddress.summarize_address_range(first, last)

   Retorna un iterador del rango de red resumido dadas la primera y la
   última dirección IP.  *first* es la primera "IPv4Address" o
   "IPv6Address" en el rango y *last* es la última "IPv4Address" o
   "IPv6Address" en el rango.  Se genera un "TypeError" si *first* o
   *last* no son direcciones IP o no son de la misma versión.  Se
   genera un "ValueError" si *last* no es mayor que *first* o si la
   versión de *first* no es 4 o 6.

   >>> [ipaddr for ipaddr in ipaddress.summarize_address_range(
   ...    ipaddress.IPv4Address('192.0.2.0'),
   ...    ipaddress.IPv4Address('192.0.2.130'))]
   [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'), IPv4Network('192.0.2.130/32')]

ipaddress.collapse_addresses(addresses)

   Retorna un iterador de los objetos colapsados "IPv4Network" o
   "IPv6Network".  *addresses* es un iterador de objetos "IPv4Network"
   o "IPv6Network".  Se genera un "TypeError" si *addresses* contiene
   objetos de versiones distintas.

   >>> [ipaddr for ipaddr in
   ... ipaddress.collapse_addresses([ipaddress.IPv4Network('192.0.2.0/25'),
   ... ipaddress.IPv4Network('192.0.2.128/25')])]
   [IPv4Network('192.0.2.0/24')]

ipaddress.get_mixed_type_key(obj)

   Retorna una clave adecuada para ordenar entre redes y direcciones.
   Los objetos de dirección y red no son ordenables por defecto; son
   fundamentalmente diferentes, así que la expresión:

      IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')

   no tiene sentido.  Sin embargo, hay veces donde se desearía hacer
   que "ipaddress" las ordene de cualquier forma.  Si se necesita
   hacer esto, se puede usar esta función como el argumento *key* de
   "sorted()".

   *obj* es un objeto de red o de dirección.


Excepciones personalizadas
==========================

Para soportar un reporte de errores más específico desde los
constructores de clase, el módulo define las siguientes excepciones:

exception ipaddress.AddressValueError(ValueError)

   Cualquier valor de error relacionado a la dirección.

exception ipaddress.NetmaskValueError(ValueError)

   Cualquier valor de error relacionado a la máscara de red.
