PyOTP 2.5.1__tar.gz → 2.7.0__tar.gz

{pyotp-2.5.1 → pyotp-2.7.0}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2011-2017 Mark Percival <m@mdp.im>,
+Copyright (C) 2011-2021 Mark Percival <m@mdp.im>,
 Nathan Reynolds <email@nreynolds.co.uk>, Andrey Kislyuk <kislyuk@gmail.com>,
 and PyOTP contributors
 

{pyotp-2.5.1 → pyotp-2.7.0}/MANIFEST.in

@@ -1,4 +1,3 @@
 include LICENSE
 include README.rst
-include requirements.txt
 include test.py

pyotp-2.7.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.1
+Name: pyotp
+Version: 2.7.0
+Summary: Python One Time Password Library
+Home-page: https://github.com/pyotp/pyotp
+Author: PyOTP contributors
+Author-email: kislyuk@gmail.com
+License: MIT License
+Platform: MacOS X
+Platform: Posix
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.6
+License-File: LICENSE
+
+PyOTP - The Python One-Time Password Library
+============================================
+
+PyOTP is a Python library for generating and verifying one-time passwords. It can be used to implement two-factor (2FA)
+or multi-factor (MFA) authentication methods in web applications and in other systems that require users to log in.
+
+Open MFA standards are defined in `RFC 4226 <https://tools.ietf.org/html/rfc4226>`_ (HOTP: An HMAC-Based One-Time
+Password Algorithm) and in `RFC 6238 <https://tools.ietf.org/html/rfc6238>`_ (TOTP: Time-Based One-Time Password
+Algorithm). PyOTP implements server-side support for both of these standards. Client-side support can be enabled by
+sending authentication codes to users over SMS or email (HOTP) or, for TOTP, by instructing users to use `Google
+Authenticator <https://en.wikipedia.org/wiki/Google_Authenticator>`_, `Authy <https://www.authy.com/>`_, or another
+compatible app. Users can set up auth tokens in their apps easily by using their phone camera to scan `otpauth://
+<https://github.com/google/google-authenticator/wiki/Key-Uri-Format>`_ QR codes provided by PyOTP.
+
+Implementers should read and follow the `HOTP security requirements <https://tools.ietf.org/html/rfc4226#section-7>`_
+and `TOTP security considerations <https://tools.ietf.org/html/rfc6238#section-5>`_ sections of the relevant RFCs. At
+minimum, application implementers should follow this checklist:
+
+- Ensure transport confidentiality by using HTTPS
+- Ensure HOTP/TOTP secret confidentiality by storing secrets in a controlled access database
+- Deny replay attacks by rejecting one-time passwords that have been used by the client (this requires storing the most 
+  recently authenticated timestamp, OTP, or hash of the OTP in your database, and rejecting the OTP when a match is seen)
+- Throttle (rate limit) brute-force attacks against your application's login functionality
+- When implementing a "greenfield" application, consider supporting
+  `FIDO U2F <https://en.wikipedia.org/wiki/Universal_2nd_Factor>`_/`WebAuthn <https://www.w3.org/TR/webauthn/>`_ in
+  addition to HOTP/TOTP. U2F uses asymmetric cryptography to avoid using a shared secret design, which strengthens your
+  MFA solution against server-side attacks. Hardware U2F also sequesters the client secret in a dedicated single-purpose
+  device, which strengthens your clients against client-side attacks. And by automating scoping of credentials to
+  relying party IDs (application origin/domain names), U2F adds protection against phishing attacks. One implementation of
+  FIDO U2F/WebAuthn is PyOTP's sister project, `PyWARP <https://github.com/pyauth/pywarp>`_.
+
+We also recommend that implementers read the
+`OWASP Authentication Cheat Sheet <https://github.com/OWASP/CheatSheetSeries/blob/master/cheatsheets/Authentication_Cheat_Sheet.md>`_ and
+`NIST SP 800-63-3: Digital Authentication Guideline <https://pages.nist.gov/800-63-3/>`_ for a high level overview of
+authentication best practices.
+
+Quick overview of using One Time Passwords on your phone
+--------------------------------------------------------
+
+* OTPs involve a shared secret, stored both on the phone and the server
+* OTPs can be generated on a phone without internet connectivity
+* OTPs should always be used as a second factor of authentication (if your phone is lost, you account is still secured with a password)
+* Google Authenticator and other OTP client apps allow you to store multiple OTP secrets and provision those using a QR Code
+
+Installation
+------------
+::
+
+    pip install pyotp
+
+Usage
+-----
+
+Time-based OTPs
+~~~~~~~~~~~~~~~
+::
+
+    totp = pyotp.TOTP('base32secret3232')
+    totp.now() # => '492039'
+
+    # OTP verified for current time
+    totp.verify('492039') # => True
+    time.sleep(30)
+    totp.verify('492039') # => False
+
+Counter-based OTPs
+~~~~~~~~~~~~~~~~~~
+::
+
+    hotp = pyotp.HOTP('base32secret3232')
+    hotp.at(0) # => '260182'
+    hotp.at(1) # => '055283'
+    hotp.at(1401) # => '316439'
+
+    # OTP verified with a counter
+    hotp.verify('316439', 1401) # => True
+    hotp.verify('316439', 1402) # => False
+
+Generating a Secret Key
+~~~~~~~~~~~~~~~~~~~~~~~
+A helper function is provided to generate a 32-character base32 secret, compatible with Google Authenticator and other OTP apps::
+
+    pyotp.random_base32()
+
+Some applications want the secret key to be formatted as a hex-encoded string::
+
+    pyotp.random_hex()  # returns a 40-character hex-encoded secret
+
+Google Authenticator Compatible
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+PyOTP works with the Google Authenticator iPhone and Android app, as well as other OTP apps like Authy. PyOTP includes the
+ability to generate provisioning URIs for use with the QR Code scanner built into these MFA client apps::
+
+    pyotp.totp.TOTP('JBSWY3DPEHPK3PXP').provisioning_uri(name='alice@google.com', issuer_name='Secure App')
+
+    >>> 'otpauth://totp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App'
+
+    pyotp.hotp.HOTP('JBSWY3DPEHPK3PXP').provisioning_uri(name="alice@google.com", issuer_name="Secure App", initial_count=0)
+
+    >>> 'otpauth://hotp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App&counter=0'
+
+This URL can then be rendered as a QR Code (for example, using https://github.com/soldair/node-qrcode) which can then be scanned
+and added to the users list of OTP credentials.
+
+Parsing these URLs is also supported::
+
+    pyotp.parse_uri('otpauth://totp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App')
+
+    >>> <pyotp.totp.TOTP object at 0xFFFFFFFF>
+
+    pyotp.parse_uri('otpauth://hotp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App&counter=0'
+
+    >>> <pyotp.totp.HOTP object at 0xFFFFFFFF>
+
+Working example
+~~~~~~~~~~~~~~~
+
+Scan the following barcode with your phone's OTP app (e.g. Google Authenticator):
+
+.. image:: https://chart.apis.google.com/chart?cht=qr&chs=250x250&chl=otpauth%3A%2F%2Ftotp%2Falice%40google.com%3Fsecret%3DJBSWY3DPEHPK3PXP
+
+Now run the following and compare the output::
+
+    import pyotp
+    totp = pyotp.TOTP("JBSWY3DPEHPK3PXP")
+    print("Current OTP:", totp.now())
+
+Links
+~~~~~
+
+* `Project home page (GitHub) <https://github.com/pyauth/pyotp>`_
+* `Documentation <https://pyauth.github.io/pyotp/>`_
+* `Package distribution (PyPI) <https://pypi.python.org/pypi/pyotp>`_
+* `Change log <https://github.com/pyauth/pyotp/blob/master/Changes.rst>`_
+* `RFC 4226: HOTP: An HMAC-Based One-Time Password <https://tools.ietf.org/html/rfc4226>`_
+* `RFC 6238: TOTP: Time-Based One-Time Password Algorithm <https://tools.ietf.org/html/rfc6238>`_
+* `ROTP <https://github.com/mdp/rotp>`_ - Original Ruby OTP library by `Mark Percival <https://github.com/mdp>`_
+* `OTPHP <https://github.com/lelag/otphp>`_ - PHP port of ROTP by `Le Lag <https://github.com/lelag>`_
+* `OWASP Authentication Cheat Sheet <https://github.com/OWASP/CheatSheetSeries/blob/master/cheatsheets/Authentication_Cheat_Sheet.md>`_
+* `NIST SP 800-63-3: Digital Authentication Guideline <https://pages.nist.gov/800-63-3/>`_
+
+For new applications:
+
+* `WebAuthn <https://www.w3.org/TR/webauthn/>`_
+* `PyWARP <https://github.com/pyauth/pywarp>`_
+
+.. image:: https://github.com/pyauth/pyotp/workflows/Python%20package/badge.svg
+        :target: https://github.com/pyauth/pyotp/actions
+.. image:: https://img.shields.io/codecov/c/github/pyauth/pyotp/master.svg
+        :target: https://codecov.io/github/pyauth/pyotp?branch=master
+.. image:: https://img.shields.io/pypi/v/pyotp.svg
+        :target: https://pypi.python.org/pypi/pyotp
+.. image:: https://img.shields.io/pypi/l/pyotp.svg
+        :target: https://pypi.python.org/pypi/pyotp
+.. image:: https://readthedocs.org/projects/pyotp/badge/?version=latest
+        :target: https://pyotp.readthedocs.io/

{pyotp-2.5.1 → pyotp-2.7.0}/README.rst

@@ -20,7 +20,7 @@ minimum, application implementers should follow this checklist:
 - Ensure HOTP/TOTP secret confidentiality by storing secrets in a controlled access database
 - Deny replay attacks by rejecting one-time passwords that have been used by the client (this requires storing the most 
   recently authenticated timestamp, OTP, or hash of the OTP in your database, and rejecting the OTP when a match is seen)
-- Throttle brute-force attacks against your application's login functionality
+- Throttle (rate limit) brute-force attacks against your application's login functionality
 - When implementing a "greenfield" application, consider supporting
   `FIDO U2F <https://en.wikipedia.org/wiki/Universal_2nd_Factor>`_/`WebAuthn <https://www.w3.org/TR/webauthn/>`_ in
   addition to HOTP/TOTP. U2F uses asymmetric cryptography to avoid using a shared secret design, which strengthens your
@@ -78,13 +78,13 @@ Counter-based OTPs
 
 Generating a Secret Key
 ~~~~~~~~~~~~~~~~~~~~~~~
-A helper function is provided to generate a 16 character base32 secret, compatible with Google Authenticator and other OTP apps::
+A helper function is provided to generate a 32-character base32 secret, compatible with Google Authenticator and other OTP apps::
 
     pyotp.random_base32()
 
 Some applications want the secret key to be formatted as a hex-encoded string::
 
-    pyotp.random_hex()  # returns a 32-character hex-encoded secret
+    pyotp.random_hex()  # returns a 40-character hex-encoded secret
 
 Google Authenticator Compatible
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -100,7 +100,7 @@ ability to generate provisioning URIs for use with the QR Code scanner built int
 
     >>> 'otpauth://hotp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App&counter=0'
 
-This URL can then be rendered as a QR Code (for example, using https://github.com/neocotic/qrious) which can then be scanned
+This URL can then be rendered as a QR Code (for example, using https://github.com/soldair/node-qrcode) which can then be scanned
 and added to the users list of OTP credentials.
 
 Parsing these URLs is also supported::

pyotp-2.7.0/pyproject.toml

@@ -0,0 +1,5 @@
+[tool.black]
+line-length = 120
+[tool.isort]
+profile = "black"
+line_length = 120

{pyotp-2.5.1 → pyotp-2.7.0}/setup.cfg

@@ -1,9 +1,6 @@
-[bdist_wheel]
-universal = 1
-
 [flake8]
 max-line-length = 120
-ignore = E401, W504
+extend-ignore = E203
 
 [egg_info]
 tag_build = 

{pyotp-2.5.1 → pyotp-2.7.0}/setup.py

@@ -1,21 +1,19 @@
 #!/usr/bin/env python
 
-import os
 from setuptools import setup
 
-install_requires = [line.rstrip() for line in open(os.path.join(os.path.dirname(__file__), "requirements.txt"))]
-
 setup(
     name="pyotp",
-    version="2.5.1",
+    version="2.7.0",
     url="https://github.com/pyotp/pyotp",
     license="MIT License",
     author="PyOTP contributors",
     author_email="kislyuk@gmail.com",
     description="Python One Time Password Library",
     long_description=open("README.rst").read(),
-    install_requires=install_requires,
-    packages=["pyotp"],
+    python_requires=">=3.6",
+    install_requires=[],
+    packages=["pyotp", "pyotp.contrib"],
     package_dir={"": "src"},
     package_data={"pyotp": ["py.typed"]},
     platforms=["MacOS X", "Posix"],
@@ -27,10 +25,12 @@ setup(
         "Operating System :: MacOS :: MacOS X",
         "Operating System :: POSIX",
         "Programming Language :: Python",
-        "Programming Language :: Python :: 3.4",
-        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
-        "Topic :: Software Development :: Libraries :: Python Modules"
-    ]
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
 )

pyotp-2.7.0/src/pyotp/__init__.py

@@ -0,0 +1,98 @@
+import hashlib
+from re import split
+from typing import Any, Dict, Sequence
+from urllib.parse import parse_qsl, unquote, urlparse
+
+from . import contrib  # noqa:F401
+from .compat import random
+from .hotp import HOTP as HOTP
+from .otp import OTP as OTP
+from .totp import TOTP as TOTP
+
+
+def random_base32(length: int = 32, chars: Sequence[str] = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567")) -> str:
+    # Note: the otpauth scheme DOES NOT use base32 padding for secret lengths not divisible by 8.
+    # Some third-party tools have bugs when dealing with such secrets.
+    # We might consider warning the user when generating a secret of length not divisible by 8.
+    if length < 32:
+        raise ValueError("Secrets should be at least 160 bits")
+
+    return "".join(random.choice(chars) for _ in range(length))
+
+
+def random_hex(length: int = 40, chars: Sequence[str] = list("ABCDEF0123456789")) -> str:
+    if length < 40:
+        raise ValueError("Secrets should be at least 160 bits")
+    return random_base32(length=length, chars=chars)
+
+
+def parse_uri(uri: str) -> OTP:
+    """
+    Parses the provisioning URI for the OTP; works for either TOTP or HOTP.
+
+    See also:
+        https://github.com/google/google-authenticator/wiki/Key-Uri-Format
+
+    :param uri: the hotp/totp URI to parse
+    :returns: OTP object
+    """
+
+    # Secret (to be filled in later)
+    secret = None
+
+    # Data we'll parse to the correct constructor
+    otp_data = {}  # type: Dict[str, Any]
+
+    # Parse with URLlib
+    parsed_uri = urlparse(unquote(uri))
+
+    if parsed_uri.scheme != "otpauth":
+        raise ValueError("Not an otpauth URI")
+
+    # Parse issuer/accountname info
+    accountinfo_parts = split(":|%3A", parsed_uri.path[1:], maxsplit=1)
+    if len(accountinfo_parts) == 1:
+        otp_data["name"] = accountinfo_parts[0]
+    else:
+        otp_data["issuer"] = accountinfo_parts[0]
+        otp_data["name"] = accountinfo_parts[1]
+
+    # Parse values
+    for key, value in parse_qsl(parsed_uri.query):
+        if key == "secret":
+            secret = value
+        elif key == "issuer":
+            if "issuer" in otp_data and otp_data["issuer"] is not None and otp_data["issuer"] != value:
+                raise ValueError("If issuer is specified in both label and parameters, it should be equal.")
+            otp_data["issuer"] = value
+        elif key == "algorithm":
+            if value == "SHA1":
+                otp_data["digest"] = hashlib.sha1
+            elif value == "SHA256":
+                otp_data["digest"] = hashlib.sha256
+            elif value == "SHA512":
+                otp_data["digest"] = hashlib.sha512
+            else:
+                raise ValueError("Invalid value for algorithm, must be SHA1, SHA256 or SHA512")
+        elif key == "digits":
+            digits = int(value)
+            if digits not in [6, 7, 8]:
+                raise ValueError("Digits may only be 6, 7, or 8")
+            otp_data["digits"] = digits
+        elif key == "period":
+            otp_data["interval"] = int(value)
+        elif key == "counter":
+            otp_data["initial_count"] = int(value)
+        elif key != "image":
+            raise ValueError("{} is not a valid parameter".format(key))
+
+    if not secret:
+        raise ValueError("No secret found in URI")
+
+    # Create objects
+    if parsed_uri.netloc == "totp":
+        return TOTP(secret, **otp_data)
+    elif parsed_uri.netloc == "hotp":
+        return HOTP(secret, **otp_data)
+
+    raise ValueError("Not a supported OTP type")

pyotp-2.7.0/src/pyotp/contrib/__init__.py

@@ -0,0 +1 @@
+from .steam import Steam  # noqa:F401

pyotp-2.7.0/src/pyotp/contrib/steam.py

@@ -0,0 +1,42 @@
+import hashlib
+from typing import Optional
+
+from ..totp import TOTP
+
+STEAM_CHARS = "23456789BCDFGHJKMNPQRTVWXY"  # steam's custom alphabet
+STEAM_DEFAULT_DIGITS = 5  # Steam TOTP code length
+
+
+class Steam(TOTP):
+    """
+    Steam's custom TOTP. Subclass of `pyotp.totp.TOTP`.
+    """
+
+    def __init__(self, s: str, name: Optional[str] = None, issuer: Optional[str] = None, interval: int = 30) -> None:
+        """
+        :param s: secret in base32 format
+        :param interval: the time interval in seconds for OTP. This defaults to 30.
+        :param name: account name
+        :param issuer: issuer
+        """
+        self.interval = interval
+        super().__init__(s=s, digits=10, digest=hashlib.sha1, name=name, issuer=issuer)
+
+    def generate_otp(self, input: int) -> str:
+        """
+        :param input: the HMAC counter value to use as the OTP input.
+            Usually either the counter, or the computed integer based on the Unix timestamp
+        """
+        str_code = super().generate_otp(input)
+        int_code = int(str_code)
+
+        steam_code = ""
+        total_chars = len(STEAM_CHARS)
+
+        for _ in range(STEAM_DEFAULT_DIGITS):
+            pos = int_code % total_chars
+            char = STEAM_CHARS[int(pos)]
+            steam_code += char
+            int_code //= total_chars
+
+        return steam_code

{pyotp-2.5.1 → pyotp-2.7.0}/src/pyotp/hotp.py

@@ -9,8 +9,16 @@ class HOTP(OTP):
     """
     Handler for HMAC-based OTP counters.
     """
-    def __init__(self, s: str, digits: int = 6, digest: Any = hashlib.sha1, name: Optional[str] = None,
-                 issuer: Optional[str] = None, initial_count: int = 0) -> None:
+
+    def __init__(
+        self,
+        s: str,
+        digits: int = 6,
+        digest: Any = hashlib.sha1,
+        name: Optional[str] = None,
+        issuer: Optional[str] = None,
+        initial_count: int = 0,
+    ) -> None:
         """
         :param s: secret in base32 format
         :param initial_count: starting HMAC counter value, defaults to 0
@@ -41,11 +49,12 @@ class HOTP(OTP):
         return utils.strings_equal(str(otp), str(self.at(counter)))
 
     def provisioning_uri(
-            self,
-            name: Optional[str] = None,
-            initial_count: Optional[int] = None,
-            issuer_name: Optional[str] = None,
-            image: Optional[str] = None) -> str:
+        self,
+        name: Optional[str] = None,
+        initial_count: Optional[int] = None,
+        issuer_name: Optional[str] = None,
+        image: Optional[str] = None,
+    ) -> str:
         """
         Returns the provisioning URI for the OTP.  This can then be
         encoded in a QR Code and used to provision an OTP app like

{pyotp-2.5.1 → pyotp-2.7.0}/src/pyotp/otp.py

@@ -8,12 +8,19 @@ class OTP(object):
     """
     Base class for OTP handlers.
     """
-    def __init__(self, s: str, digits: int = 6, digest: Any = hashlib.sha1, name: Optional[str] = None,
-                 issuer: Optional[str] = None) -> None:
+
+    def __init__(
+        self,
+        s: str,
+        digits: int = 6,
+        digest: Any = hashlib.sha1,
+        name: Optional[str] = None,
+        issuer: Optional[str] = None,
+    ) -> None:
         self.digits = digits
         self.digest = digest
         self.secret = s
-        self.name = name or 'Secret'
+        self.name = name or "Secret"
         self.issuer = issuer
 
     def generate_otp(self, input: int) -> str:
@@ -22,25 +29,28 @@ class OTP(object):
             Usually either the counter, or the computed integer based on the Unix timestamp
         """
         if input < 0:
-            raise ValueError('input must be positive integer')
+            raise ValueError("input must be positive integer")
         hasher = hmac.new(self.byte_secret(), self.int_to_bytestring(input), self.digest)
         hmac_hash = bytearray(hasher.digest())
-        offset = hmac_hash[-1] & 0xf
-        code = ((hmac_hash[offset] & 0x7f) << 24 |
-                (hmac_hash[offset + 1] & 0xff) << 16 |
-                (hmac_hash[offset + 2] & 0xff) << 8 |
-                (hmac_hash[offset + 3] & 0xff))
-        str_code = str(code % 10 ** self.digits)
+        offset = hmac_hash[-1] & 0xF
+        code = (
+            (hmac_hash[offset] & 0x7F) << 24
+            | (hmac_hash[offset + 1] & 0xFF) << 16
+            | (hmac_hash[offset + 2] & 0xFF) << 8
+            | (hmac_hash[offset + 3] & 0xFF)
+        )
+        str_code = str(code % 10**self.digits)
         while len(str_code) < self.digits:
-            str_code = '0' + str_code
+            str_code = "0" + str_code
 
         return str_code
 
     def byte_secret(self) -> bytes:
-        missing_padding = len(self.secret) % 8
+        secret = self.secret
+        missing_padding = len(secret) % 8
         if missing_padding != 0:
-            self.secret += '=' * (8 - missing_padding)
-        return base64.b32decode(self.secret, casefold=True)
+            secret += "=" * (8 - missing_padding)
+        return base64.b32decode(secret, casefold=True)
 
     @staticmethod
     def int_to_bytestring(i: int, padding: int = 8) -> bytes:
@@ -56,4 +66,4 @@ class OTP(object):
         # It's necessary to convert the final result from bytearray to bytes
         # because the hmac functions in python 2.6 and 3.3 don't work with
         # bytearray
-        return bytes(bytearray(reversed(result)).rjust(padding, b'\0'))
+        return bytes(bytearray(reversed(result)).rjust(padding, b"\0"))

{pyotp-2.5.1 → pyotp-2.7.0}/src/pyotp/totp.py

@@ -2,7 +2,7 @@ import calendar
 import datetime
 import hashlib
 import time
-from typing import Any, Union, Optional
+from typing import Any, Optional, Union
 
 from . import utils
 from .otp import OTP
@@ -12,8 +12,16 @@ class TOTP(OTP):
     """
     Handler for time-based OTP counters.
     """
-    def __init__(self, s: str, digits: int = 6, digest: Any = hashlib.sha1, name: Optional[str] = None,
-                 issuer: Optional[str] = None, interval: int = 30) -> None:
+
+    def __init__(
+        self,
+        s: str,
+        digits: int = 6,
+        digest: Any = hashlib.sha1,
+        name: Optional[str] = None,
+        issuer: Optional[str] = None,
+        interval: int = 30,
+    ) -> None:
         """
         :param s: secret in base32 format
         :param interval: the time interval in seconds for OTP. This defaults to 30.
@@ -70,8 +78,9 @@ class TOTP(OTP):
 
         return utils.strings_equal(str(otp), str(self.at(for_time)))
 
-    def provisioning_uri(self, name: Optional[str] = None, issuer_name: Optional[str] = None,
-                         image: Optional[str] = None) -> str:
+    def provisioning_uri(
+        self, name: Optional[str] = None, issuer_name: Optional[str] = None, image: Optional[str] = None
+    ) -> str:
 
         """
         Returns the provisioning URI for the OTP.  This can then be
@@ -82,10 +91,15 @@ class TOTP(OTP):
             https://github.com/google/google-authenticator/wiki/Key-Uri-Format
 
         """
-        return utils.build_uri(self.secret, name if name else self.name,
-                               issuer=issuer_name if issuer_name else self.issuer,
-                               algorithm=self.digest().name,
-                               digits=self.digits, period=self.interval, image=image)
+        return utils.build_uri(
+            self.secret,
+            name if name else self.name,
+            issuer=issuer_name if issuer_name else self.issuer,
+            algorithm=self.digest().name,
+            digits=self.digits,
+            period=self.interval,
+            image=image,
+        )
 
     def timecode(self, for_time: datetime.datetime) -> int:
         """