"uuid" --- objetos UUID según **RFC 4122**
******************************************

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

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

Este módulo proporciona objetos "UUID" inmutables (la clase "UUID") y
las funciones "uuid1()", "uuid3()", "uuid4()", "uuid5()" para generar
los UUID de las versiones 1, 3, 4 y 5 como se especifica en **RFC
4122**.

Si todo lo que quieres es una identificación única, probablemente
deberías llamar a "uuuid1()" o "uuid4()".  Ten en cuenta que "uuid1()"
puede comprometer la privacidad ya que crea un UUID que contiene la
dirección de red del ordenador. "uuid4()" crea un UUID aleatorio.

Depending on support from the underlying platform, "uuid1()" may or
may not return a "safe" UUID.  A safe UUID is one which is generated
using synchronization methods that ensure no two processes can obtain
the same UUID.  All instances of "UUID" have an "is_safe" attribute
which relays any information about the UUID's safety, using this
enumeration:

class uuid.SafeUUID

   Nuevo en la versión 3.7.

   safe

      El UUID fue generado por la plataforma de una manera segura para
      multiprocesamiento.

   unsafe

      El UUID no fue generado por la plataforma de una manera segura
      de multiprocesamiento.

   unknown

      La plataforma no proporciona información sobre si el UUID se
      generó de forma segura o no.

class uuid.UUID(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=SafeUUID.unknown)

   Crea un UUID a partir de una cadena de 32 dígitos hexadecimales,
   una cadena de 16 bytes en orden *big-endian* como el argumento
   *bytes*, una cadena de 16 bytes en orden *little-endian* como el
   argumento *bytes_le*, una tupla de seis enteros (32-bit *time_low*,
   16-bit *time_mid*, 16-bit *time_hi_version*, 8-bit
   *clock_seq_hi_variant*, 8-bit *clock_seq_low*, 48-bit *node*) como
   el argumento *fields*, o un solo entero de 128-bit como el
   argumento *int*. Cuando se da una cadena de dígitos hexadecimales,
   los corchetes, los guiones y el prefijo URN son todos opcionales.
   Por ejemplo, todas estas expresiones producen el mismo UUID:

      UUID('{12345678-1234-5678-1234-567812345678}')
      UUID('12345678123456781234567812345678')
      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
      UUID(bytes=b'\x12\x34\x56\x78'*4)
      UUID(bytes_le=b'\x78\x56\x34\x12\x34\x12\x78\x56' +
                    b'\x12\x34\x56\x78\x12\x34\x56\x78')
      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
      UUID(int=0x12345678123456781234567812345678)

   Exactamente uno de *hex*, *bytes*, *bytes_le*, *fields*, o *int*
   debe ser dado. El argumento *version* es opcional; si se da, el
   UUID resultante tendrá su variante y número de versión establecidos
   de acuerdo con **RFC 4122**, anulando los bits en la *hex*,
   *bytes*, *bytes_le*, *fields*, o *int* dados.

   La comparación de los objetos UUID se hace mediante la comparación
   de sus atributos "UID.int".  La comparación con un objeto no UUID
   produce un "TypeError".

   "str(uuid)" retorna una cadena en la forma
   "12345678-1234-5678-1234-567812345678" donde los 32 dígitos
   hexadecimales representan el UUID.

Las instancias de "UUID" tienen estos atributos de sólo lectura:

UUID.bytes

   El UUID como una cadena de 16 bytes (que contiene los seis campos
   enteros en orden de bytes *big-endian*).

UUID.bytes_le

   El UUID como una cadena de 16 bytes (con *time_low*, *time_mid*, y
   *time_hi_version* en el orden de bytes *little-endian*).

UUID.fields

   Una tupla de los seis campos enteros de la UUID, que también están
   disponibles como seis atributos individuales y dos atributos
   derivados:

+----------------------------------------------------+----------------------------------------------------+
| Campo                                              | Significado                                        |
+----------------------------------------------------+----------------------------------------------------+
| UUID.time_low                                      | The first 32 bits of the UUID.                     |
+----------------------------------------------------+----------------------------------------------------+
| UUID.time_mid                                      | The next 16 bits of the UUID.                      |
+----------------------------------------------------+----------------------------------------------------+
| UUID.time_hi_version                               | The next 16 bits of the UUID.                      |
+----------------------------------------------------+----------------------------------------------------+
| UUID.clock_seq_hi_variant                          | The next 8 bits of the UUID.                       |
+----------------------------------------------------+----------------------------------------------------+
| UUID.clock_seq_low                                 | The next 8 bits of the UUID.                       |
+----------------------------------------------------+----------------------------------------------------+
| UUID.node                                          | The last 48 bits of the UUID.                      |
+----------------------------------------------------+----------------------------------------------------+
| UUID.time                                          | The 60-bit timestamp.                              |
+----------------------------------------------------+----------------------------------------------------+
| UUID.clock_seq                                     | The 14-bit sequence number.                        |
+----------------------------------------------------+----------------------------------------------------+

UUID.hex

   The UUID as a 32-character lowercase hexadecimal string.

UUID.int

   El UUID como un entero de 128 bits.

UUID.urn

   El UUID como URN como se especifica en **RFC 4122**.

UUID.variant

   La variante UUID, que determina la disposición interna del UUID.
   Esta será una de las constantes "RESERVED_NCS", "RFC_4122",
   "RESERVED_MICROSOFT", o "RESERVED_FUTURE".

UUID.version

   El número de versión UUID (del 1 al 5, significativo sólo cuando la
   variante es "RFC_4122").

UUID.is_safe

   Una enumeración de "SafeUUID" que indica si la plataforma generó el
   UUID de forma segura para el multiprocesamiento.

   Nuevo en la versión 3.7.

El módulo "uuid" define las siguientes funciones:

uuid.getnode()

   Obtiene la dirección del hardware como un entero positivo de 48
   bits.  La primera vez que esto se ejecute, puede lanzar un programa
   separado, que podría ser bastante lento.  Si todos los intentos de
   obtener la dirección de hardware fallan, elegimos un número
   aleatorio de 48 bits con el bit multicast (el bit menos
   significativo del primer octeto) puesto a 1 como se recomienda en
   **RFC 4122**.  "Dirección de hardware" significa la dirección MAC
   de una interfaz de red.  En una máquina con múltiples interfaces de
   red, las direcciones MAC administradas universalmente (es decir,
   donde el segundo bit menos significativo del primer octeto es
   *unset*) se preferirán a las direcciones MAC administradas
   localmente, pero sin otras garantías de orden.

   Distinto en la versión 3.7: Se prefieren las direcciones MAC
   administradas universalmente a las administradas localmente, ya que
   se garantiza que las primeras son únicas a nivel mundial, mientras
   que las segundas no lo son.

uuid.uuid1(node=None, clock_seq=None)

   Genera un UUID a partir de un ID de host, número de secuencia y la
   hora actual. Si no se da *node*, se usa "getnode()" para obtener la
   dirección del hardware. Si se da *clock_seq*, se utiliza como
   número de secuencia; de lo contrario se elige un número de
   secuencia aleatorio de 14 bits.

uuid.uuid3(namespace, name)

   Genera un UUID basado en el hash MD5 de un identificador de espacio
   de nombres (que es un UUID) y un nombre (que es una cadena).

uuid.uuid4()

   Genera un UUID aleatorio.

uuid.uuid5(namespace, name)

   Genera un UUID basado en el hash SHA-1 de un identificador de
   espacio de nombres (que es un UUID) y un nombre (que es una
   cadena).Generar un UUID basado en el hash SHA-1 de un identificador
   de espacio de nombres (que es un UUID) y un nombre (que es una
   cadena).

El módulo "uuuid" define los siguientes identificadores de espacios de
nombres para su uso con "uuid3()" o "uuuid5()".

uuid.NAMESPACE_DNS

   When this namespace is specified, the *name* string is a fully
   qualified domain name.

uuid.NAMESPACE_URL

   Cuando se especifica este espacio de nombres, la cadena *name* es
   una URL.

uuid.NAMESPACE_OID

   Cuando se especifica este espacio de nombres, la cadena *name* es
   un OID ISO.

uuid.NAMESPACE_X500

   Cuando se especifica este espacio de nombres, la cadena *name* es
   un X.500 DN en DER o un formato de salida de texto.

The "uuid" module defines the following constants for the possible
values of the "variant" attribute:

uuid.RESERVED_NCS

   Reservado para la compatibilidad con NCS.

uuid.RFC_4122

   Especifica el diseño del UUID dado en **RFC 4122**.

uuid.RESERVED_MICROSOFT

   Reservado para la compatibilidad con Microsoft.

uuid.RESERVED_FUTURE

   Reservado para una futura definición.

Ver también:

  **RFC 4122** - Un espacio de nombres URN de identificador único
  universal (UUID)
     Esta especificación define un espacio de nombres de recursos
     uniforme para los UUID, el formato interno de los UUID y los
     métodos de generación de los UUID.


Ejemplo
=======

Aquí hay algunos ejemplos del uso típico del modulo "uuid":

   >>> import uuid

   >>> # make a UUID based on the host ID and current time
   >>> uuid.uuid1()
   UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')

   >>> # make a UUID using an MD5 hash of a namespace UUID and a name
   >>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
   UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')

   >>> # make a random UUID
   >>> uuid.uuid4()
   UUID('16fd2706-8baf-433b-82eb-8c7fada847da')

   >>> # make a UUID using a SHA-1 hash of a namespace UUID and a name
   >>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
   UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')

   >>> # make a UUID from a string of hex digits (braces and hyphens ignored)
   >>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')

   >>> # convert a UUID to a string of hex digits in standard form
   >>> str(x)
   '00010203-0405-0607-0809-0a0b0c0d0e0f'

   >>> # get the raw 16 bytes of the UUID
   >>> x.bytes
   b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'

   >>> # make a UUID from a 16-byte string
   >>> uuid.UUID(bytes=x.bytes)
   UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')
