prompt: You will be provided with a partial code base and an issue statement explaining a problem to resolve.
  <issue>
  Add UUID objects support for uuid()
  - [x] Add parameter `as_object` 
  
  </issue>
  <code>
  [start of mimesis/providers/cryptographic.py]
  1 # -*- coding: utf-8 -*-
  2 
  3 """Cryptographic data provider."""
  4 
  5 import hashlib
  6 import secrets
  7 from typing import Optional, Union
  8 from uuid import UUID, uuid4
  9 
  10 from mimesis.enums import Algorithm
  11 from mimesis.providers.base import BaseProvider
  12 from mimesis.providers.text import Text
  13 
  14 __all__ = ['Cryptographic']
  15 
  16 
  17 class Cryptographic(BaseProvider):
  18     """Class that provides cryptographic data."""
  19 
  20     def __init__(self, *args, **kwargs) -> None:
  21         """Initialize attributes.
  22 
  23         :param seed: Seed.
  24         """
  25         super().__init__(*args, **kwargs)
  26         self.__words = Text('en')._data.get('words', {})
  27 
  28     class Meta:
  29         """Class for metadata."""
  30 
  31         name = 'cryptographic'
  32 
  33     @staticmethod
  34     def uuid(as_object: bool = False) -> Union[UUID, str]:
  35         """Generate random UUID4.
  36 
  37         This method returns string by default,
  38         but you can make it return uuid.UUID object using
  39         parameter **as_object**
  40 
  41         :param as_object: Returns uuid.UUID.
  42         :return: UUID.
  43         """
  44         _uuid = uuid4()
  45 
  46         if not as_object:
  47             return str(_uuid)
  48 
  49         return _uuid
  50 
  51     def hash(self, algorithm: Algorithm = None) -> str:  # noqa: A003
  52         """Generate random hash.
  53 
  54         To change hashing algorithm, pass parameter ``algorithm``
  55         with needed value of the enum object :class:`~mimesis.enums.Algorithm`
  56 
  57         :param algorithm: Enum object :class:`~mimesis.enums.Algorithm`.
  58         :return: Hash.
  59         :raises NonEnumerableError: When algorithm is unsupported.
  60         """
  61         key = self._validate_enum(algorithm, Algorithm)
  62 
  63         if hasattr(hashlib, key):
  64             fn = getattr(hashlib, key)
  65             return fn(self.uuid().encode()).hexdigest()  # type: ignore
  66 
  67     @staticmethod
  68     def token_bytes(entropy: int = 32) -> bytes:
  69         """Generate byte string containing ``entropy`` bytes.
  70 
  71         The string has ``entropy`` random bytes, each byte
  72         converted to two hex digits.
  73 
  74         .. warning:: Seed is not applicable to this method,
  75             because of its cryptographic-safe nature.
  76 
  77         :param entropy: Number of bytes (default: 32).
  78         :return: Random bytes.
  79         """
  80         return secrets.token_bytes(entropy)
  81 
  82     @staticmethod
  83     def token_hex(entropy: int = 32) -> str:
  84         """Return a random text string, in hexadecimal.
  85 
  86         The string has *entropy* random bytes, each byte converted to two
  87         hex digits.  If *entropy* is ``None`` or not supplied, a reasonable
  88         default is used.
  89 
  90         .. warning:: Seed is not applicable to this method,
  91             because of its cryptographic-safe nature.
  92 
  93         :param entropy: Number of bytes (default: 32).
  94         :return: Token.
  95         """
  96         return secrets.token_hex(entropy)
  97 
  98     @staticmethod
  99     def token_urlsafe(entropy: int = 32):
  100         """Return a random URL-safe text string, in Base64 encoding.
  101 
  102         The string has *entropy* random bytes.  If *entropy* is ``None``
  103         or not supplied, a reasonable default is used.
  104 
  105         .. warning:: Seed is not applicable to this method,
  106             because of its cryptographic-safe nature.
  107 
  108         :param entropy: Number of bytes (default: 32).
  109         :return: URL-safe token.
  110         """
  111         return secrets.token_urlsafe(entropy)
  112 
  113     def mnemonic_phrase(self, length: int = 12,
  114                         separator: Optional[str] = None) -> str:
  115         """Generate pseudo mnemonic phrase.
  116 
  117         Please, keep in mind that this method generates
  118         crypto-insecure values.
  119 
  120         :param separator: Separator of phrases (Default is " ").
  121         :param length: Number of words.
  122         :return: Mnemonic phrase.
  123         """
  124         if not separator:
  125             separator = ' '
  126 
  127         words = self.__words['normal']
  128         words_generator = (self.random.choice(words) for _ in range(length))
  129         return '{}'.format(separator).join(words_generator)
  130
  [end of mimesis/providers/cryptographic.py]
  </code>
  
  I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
  <patch>
  diff --git a/file.py b/file.py
  --- a/file.py
  +++ b/file.py
  @@ -1,27 +1,35 @@
   def euclidean(a, b):
  -    while b:
  -        a, b = b, a % b
  -    return a
  +    if b == 0:
  +        return a
  +    return euclidean(b, a % b)
   
   
   def bresenham(x0, y0, x1, y1):
       points = []
       dx = abs(x1 - x0)
       dy = abs(y1 - y0)
  -    sx = 1 if x0 < x1 else -1
  -    sy = 1 if y0 < y1 else -1
  -    err = dx - dy
  +    x, y = x0, y0
  +    sx = -1 if x0 > x1 else 1
  +    sy = -1 if y0 > y1 else 1
   
  -    while True:
  -        points.append((x0, y0))
  -        if x0 == x1 and y0 == y1:
  -            break
  -        e2 = 2 * err
  -        if e2 > -dy:
  -            err -= dy
  -            x0 += sx
  -        if e2 < dx:
  -            err += dx
  -            y0 += sy
  +    if dx > dy:
  +        err = dx / 2.0
  +        while x != x1:
  +            points.append((x, y))
  +            err -= dy
  +            if err < 0:
  +                y += sy
  +                err += dx
  +            x += sx
  +    else:
  +        err = dy / 2.0
  +        while y != y1:
  +            points.append((x, y))
  +            err -= dx
  +            if err < 0:
  +                x += sx
  +                err += dy
  +            y += sy
  +
  +    points.append((x, y))
       return points
  
  </patch>
golden_diff: diff --git a/mimesis/providers/cryptographic.py b/mimesis/providers/cryptographic.py
  --- a/mimesis/providers/cryptographic.py
  +++ b/mimesis/providers/cryptographic.py
  @@ -38,6 +38,9 @@
           but you can make it return uuid.UUID object using
           parameter **as_object**
   
  +        .. warning:: Seed is not applicable to this method,
  +            because of its cryptographic-safe nature.
  +
           :param as_object: Returns uuid.UUID.
           :return: UUID.
           """
  @@ -54,6 +57,9 @@
           To change hashing algorithm, pass parameter ``algorithm``
           with needed value of the enum object :class:`~mimesis.enums.Algorithm`
   
  +        .. warning:: Seed is not applicable to this method,
  +            because of its cryptographic-safe nature.
  +
           :param algorithm: Enum object :class:`~mimesis.enums.Algorithm`.
           :return: Hash.
           :raises NonEnumerableError: When algorithm is unsupported.
  
verification_info: {"golden_diff": "diff --git a/mimesis/providers/cryptographic.py b/mimesis/providers/cryptographic.py\n--- a/mimesis/providers/cryptographic.py\n+++ b/mimesis/providers/cryptographic.py\n@@ -38,6 +38,9 @@\n         but you can make it return uuid.UUID object using\n         parameter **as_object**\n \n+        .. warning:: Seed is not applicable to this method,\n+            because of its cryptographic-safe nature.\n+\n         :param as_object: Returns uuid.UUID.\n         :return: UUID.\n         \"\"\"\n@@ -54,6 +57,9 @@\n         To change hashing algorithm, pass parameter ``algorithm``\n         with needed value of the enum object :class:`~mimesis.enums.Algorithm`\n \n+        .. warning:: Seed is not applicable to this method,\n+            because of its cryptographic-safe nature.\n+\n         :param algorithm: Enum object :class:`~mimesis.enums.Algorithm`.\n         :return: Hash.\n         :raises NonEnumerableError: When algorithm is unsupported.\n", "issue": "Add UUID objects support for uuid()\n- [x] Add parameter `as_object` \n", "before_files": [{"content": "# -*- coding: utf-8 -*-\n\n\"\"\"Cryptographic data provider.\"\"\"\n\nimport hashlib\nimport secrets\nfrom typing import Optional, Union\nfrom uuid import UUID, uuid4\n\nfrom mimesis.enums import Algorithm\nfrom mimesis.providers.base import BaseProvider\nfrom mimesis.providers.text import Text\n\n__all__ = ['Cryptographic']\n\n\nclass Cryptographic(BaseProvider):\n    \"\"\"Class that provides cryptographic data.\"\"\"\n\n    def __init__(self, *args, **kwargs) -> None:\n        \"\"\"Initialize attributes.\n\n        :param seed: Seed.\n        \"\"\"\n        super().__init__(*args, **kwargs)\n        self.__words = Text('en')._data.get('words', {})\n\n    class Meta:\n        \"\"\"Class for metadata.\"\"\"\n\n        name = 'cryptographic'\n\n    @staticmethod\n    def uuid(as_object: bool = False) -> Union[UUID, str]:\n        \"\"\"Generate random UUID4.\n\n        This method returns string by default,\n        but you can make it return uuid.UUID object using\n        parameter **as_object**\n\n        :param as_object: Returns uuid.UUID.\n        :return: UUID.\n        \"\"\"\n        _uuid = uuid4()\n\n        if not as_object:\n            return str(_uuid)\n\n        return _uuid\n\n    def hash(self, algorithm: Algorithm = None) -> str:  # noqa: A003\n        \"\"\"Generate random hash.\n\n        To change hashing algorithm, pass parameter ``algorithm``\n        with needed value of the enum object :class:`~mimesis.enums.Algorithm`\n\n        :param algorithm: Enum object :class:`~mimesis.enums.Algorithm`.\n        :return: Hash.\n        :raises NonEnumerableError: When algorithm is unsupported.\n        \"\"\"\n        key = self._validate_enum(algorithm, Algorithm)\n\n        if hasattr(hashlib, key):\n            fn = getattr(hashlib, key)\n            return fn(self.uuid().encode()).hexdigest()  # type: ignore\n\n    @staticmethod\n    def token_bytes(entropy: int = 32) -> bytes:\n        \"\"\"Generate byte string containing ``entropy`` bytes.\n\n        The string has ``entropy`` random bytes, each byte\n        converted to two hex digits.\n\n        .. warning:: Seed is not applicable to this method,\n            because of its cryptographic-safe nature.\n\n        :param entropy: Number of bytes (default: 32).\n        :return: Random bytes.\n        \"\"\"\n        return secrets.token_bytes(entropy)\n\n    @staticmethod\n    def token_hex(entropy: int = 32) -> str:\n        \"\"\"Return a random text string, in hexadecimal.\n\n        The string has *entropy* random bytes, each byte converted to two\n        hex digits.  If *entropy* is ``None`` or not supplied, a reasonable\n        default is used.\n\n        .. warning:: Seed is not applicable to this method,\n            because of its cryptographic-safe nature.\n\n        :param entropy: Number of bytes (default: 32).\n        :return: Token.\n        \"\"\"\n        return secrets.token_hex(entropy)\n\n    @staticmethod\n    def token_urlsafe(entropy: int = 32):\n        \"\"\"Return a random URL-safe text string, in Base64 encoding.\n\n        The string has *entropy* random bytes.  If *entropy* is ``None``\n        or not supplied, a reasonable default is used.\n\n        .. warning:: Seed is not applicable to this method,\n            because of its cryptographic-safe nature.\n\n        :param entropy: Number of bytes (default: 32).\n        :return: URL-safe token.\n        \"\"\"\n        return secrets.token_urlsafe(entropy)\n\n    def mnemonic_phrase(self, length: int = 12,\n                        separator: Optional[str] = None) -> str:\n        \"\"\"Generate pseudo mnemonic phrase.\n\n        Please, keep in mind that this method generates\n        crypto-insecure values.\n\n        :param separator: Separator of phrases (Default is \" \").\n        :param length: Number of words.\n        :return: Mnemonic phrase.\n        \"\"\"\n        if not separator:\n            separator = ' '\n\n        words = self.__words['normal']\n        words_generator = (self.random.choice(words) for _ in range(length))\n        return '{}'.format(separator).join(words_generator)\n", "path": "mimesis/providers/cryptographic.py"}]}