diff --git a/.travis.yml b/.travis.yml
index 948b7ae..6fbac08 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +1,10 @@
+dist: xenial
+
 language: python
 python:
-  - 2.7
-  - 3.4
-  - 3.5
   - 3.6
+  - 3.7
+  - 3.8
 
 cache:
   pip: true
@@ -14,8 +15,7 @@ env:
   global:
     - RANDOM_SEED=0
   matrix:
-    - FLASK_VERSION=0.12.4
-    - FLASK_VERSION=1.0.2
+    - FLASK_VERSION=2.3.2
 
 before_install:
   - pip install pipenv
diff --git a/Makefile b/Makefile
index 121c48f..d89b3e6 100644
--- a/Makefile
+++ b/Makefile
@@ -70,7 +70,7 @@ endif
 .PHONY: test
 test: install ## Run unit and integration tests
 	$(NOSE) $(PACKAGE) $(NOSE_OPTIONS)
-	$(COVERAGESPACE) $(REPOSITORY) overall
+	$(COVERAGESPACE) update overall
 
 .PHONY: read-coverage
 read-coverage:
diff --git a/Pipfile b/Pipfile
index 44c7127..69c54e4 100644
--- a/Pipfile
+++ b/Pipfile
@@ -12,16 +12,16 @@ Markdown = "<3"
 [dev-packages]
 
 # Linters
-flake8 = "~=2.1"
+flake8 = "~=3.7.9"
 
 # Testing
 nose = "*"
 
 # Reports
-coveragespace = "*"
+coveragespace = "~=4.1"
 
 # Documentation
-mkdocs = "~=0.17.2"
+mkdocs = "~=1.2.3"
 docutils = "*"
 
 # Release
diff --git a/Pipfile.lock b/Pipfile.lock
index 95649e3..3db0df7 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "594412d0816530df7cf2020970de492e606ceb3d28c3c1172b312917c11f9ce6"
+            "sha256": "662759c6b1e37a84f88b13fc4053a0d627d21897ff7f89cae656649393e94549"
         },
         "pipfile-spec": 6,
         "requires": {},
@@ -14,34 +14,45 @@
         ]
     },
     "default": {
+        "blinker": {
+            "hashes": [
+                "sha256:4afd3de66ef3a9f8067559fb7a1cbe555c17dcbe15971b05d1b625c3e7abe213",
+                "sha256:c3d739772abb7bc2860abf5f2ec284223d9ad5c76da018234f6f50d6f31ab1f0"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==1.6.2"
+        },
         "click": {
             "hashes": [
-                "sha256:2335065e6395b9e67ca716de5f7526736bfa6ceead690adf616d925bdc622b13",
-                "sha256:5b94b49521f6456670fdb30cd82a4eca9412788a93fa6dd6df72c94d5a8ff2d7"
+                "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e",
+                "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"
             ],
-            "version": "==7.0"
+            "markers": "python_version >= '3.7'",
+            "version": "==8.1.3"
         },
         "flask": {
             "hashes": [
-                "sha256:2271c0070dbcb5275fad4a82e29f23ab92682dc45f9dfbc22c02ba9b9322ce48",
-                "sha256:a080b744b7e345ccfcbc77954861cb05b3c63786e93f2b3875e0913d44b43f05"
+                "sha256:77fd4e1249d8c9923de34907236b747ced06e5467ecac1a7bb7115ae0e9670b0",
+                "sha256:8c2f9abd47a9e8df7f0c3f091ce9497d011dc3b31effcf4c85a6e2b50f4114ef"
             ],
             "index": "pypi",
-            "version": "==1.0.2"
+            "version": "==2.3.2"
         },
         "itsdangerous": {
             "hashes": [
-                "sha256:321b033d07f2a4136d3ec762eac9f16a10ccd60f53c0c91af90217ace7ba1f19",
-                "sha256:b12271b2047cb23eeb98c8b5622e2e5c5e9abd9784a153e9d8ef9cb4dd09d749"
+                "sha256:2c2349112351b88699d8d4b6b075022c0808887cb7ad10069318a8b0bc88db44",
+                "sha256:5dbbc68b317e5e42f327f9021763545dc3fc3bfe22e6deb96aaf1fc38874156a"
             ],
-            "version": "==1.1.0"
+            "markers": "python_version >= '3.7'",
+            "version": "==2.1.2"
         },
         "jinja2": {
             "hashes": [
-                "sha256:74c935a1b8bb9a3947c50a54766a969d4846290e1e788ea44c1392163723c3bd",
-                "sha256:f84be1bb0040caca4cea721fcbbbbd61f9be9464ca236387158b0feea01914a4"
+                "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852",
+                "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"
             ],
-            "version": "==2.10"
+            "markers": "python_version >= '3.7'",
+            "version": "==3.1.2"
         },
         "markdown": {
             "hashes": [
@@ -53,131 +64,350 @@
         },
         "markupsafe": {
             "hashes": [
-                "sha256:048ef924c1623740e70204aa7143ec592504045ae4429b59c30054cb31e3c432",
-                "sha256:130f844e7f5bdd8e9f3f42e7102ef1d49b2e6fdf0d7526df3f87281a532d8c8b",
-                "sha256:19f637c2ac5ae9da8bfd98cef74d64b7e1bb8a63038a3505cd182c3fac5eb4d9",
-                "sha256:1b8a7a87ad1b92bd887568ce54b23565f3fd7018c4180136e1cf412b405a47af",
-                "sha256:1c25694ca680b6919de53a4bb3bdd0602beafc63ff001fea2f2fc16ec3a11834",
-                "sha256:1f19ef5d3908110e1e891deefb5586aae1b49a7440db952454b4e281b41620cd",
-                "sha256:1fa6058938190ebe8290e5cae6c351e14e7bb44505c4a7624555ce57fbbeba0d",
-                "sha256:31cbb1359e8c25f9f48e156e59e2eaad51cd5242c05ed18a8de6dbe85184e4b7",
-                "sha256:3e835d8841ae7863f64e40e19477f7eb398674da6a47f09871673742531e6f4b",
-                "sha256:4e97332c9ce444b0c2c38dd22ddc61c743eb208d916e4265a2a3b575bdccb1d3",
-                "sha256:525396ee324ee2da82919f2ee9c9e73b012f23e7640131dd1b53a90206a0f09c",
-                "sha256:52b07fbc32032c21ad4ab060fec137b76eb804c4b9a1c7c7dc562549306afad2",
-                "sha256:52ccb45e77a1085ec5461cde794e1aa037df79f473cbc69b974e73940655c8d7",
-                "sha256:5c3fbebd7de20ce93103cb3183b47671f2885307df4a17a0ad56a1dd51273d36",
-                "sha256:5e5851969aea17660e55f6a3be00037a25b96a9b44d2083651812c99d53b14d1",
-                "sha256:5edfa27b2d3eefa2210fb2f5d539fbed81722b49f083b2c6566455eb7422fd7e",
-                "sha256:7d263e5770efddf465a9e31b78362d84d015cc894ca2c131901a4445eaa61ee1",
-                "sha256:83381342bfc22b3c8c06f2dd93a505413888694302de25add756254beee8449c",
-                "sha256:857eebb2c1dc60e4219ec8e98dfa19553dae33608237e107db9c6078b1167856",
-                "sha256:98e439297f78fca3a6169fd330fbe88d78b3bb72f967ad9961bcac0d7fdd1550",
-                "sha256:bf54103892a83c64db58125b3f2a43df6d2cb2d28889f14c78519394feb41492",
-                "sha256:d9ac82be533394d341b41d78aca7ed0e0f4ba5a2231602e2f05aa87f25c51672",
-                "sha256:e982fe07ede9fada6ff6705af70514a52beb1b2c3d25d4e873e82114cf3c5401",
-                "sha256:edce2ea7f3dfc981c4ddc97add8a61381d9642dc3273737e756517cc03e84dd6",
-                "sha256:efdc45ef1afc238db84cb4963aa689c0408912a0239b0721cb172b4016eb31d6",
-                "sha256:f137c02498f8b935892d5c0172560d7ab54bc45039de8805075e19079c639a9c",
-                "sha256:f82e347a72f955b7017a39708a3667f106e6ad4d10b25f237396a7115d8ed5fd",
-                "sha256:fb7c206e01ad85ce57feeaaa0bf784b97fa3cad0d4a5737bc5295785f5c613a1"
-            ],
-            "version": "==1.1.0"
+                "sha256:0576fe974b40a400449768941d5d0858cc624e3249dfd1e0c33674e5c7ca7aed",
+                "sha256:085fd3201e7b12809f9e6e9bc1e5c96a368c8523fad5afb02afe3c051ae4afcc",
+                "sha256:090376d812fb6ac5f171e5938e82e7f2d7adc2b629101cec0db8b267815c85e2",
+                "sha256:0b462104ba25f1ac006fdab8b6a01ebbfbce9ed37fd37fd4acd70c67c973e460",
+                "sha256:137678c63c977754abe9086a3ec011e8fd985ab90631145dfb9294ad09c102a7",
+                "sha256:1bea30e9bf331f3fef67e0a3877b2288593c98a21ccb2cf29b74c581a4eb3af0",
+                "sha256:22152d00bf4a9c7c83960521fc558f55a1adbc0631fbb00a9471e097b19d72e1",
+                "sha256:22731d79ed2eb25059ae3df1dfc9cb1546691cc41f4e3130fe6bfbc3ecbbecfa",
+                "sha256:2298c859cfc5463f1b64bd55cb3e602528db6fa0f3cfd568d3605c50678f8f03",
+                "sha256:28057e985dace2f478e042eaa15606c7efccb700797660629da387eb289b9323",
+                "sha256:2e7821bffe00aa6bd07a23913b7f4e01328c3d5cc0b40b36c0bd81d362faeb65",
+                "sha256:2ec4f2d48ae59bbb9d1f9d7efb9236ab81429a764dedca114f5fdabbc3788013",
+                "sha256:340bea174e9761308703ae988e982005aedf427de816d1afe98147668cc03036",
+                "sha256:40627dcf047dadb22cd25ea7ecfe9cbf3bbbad0482ee5920b582f3809c97654f",
+                "sha256:40dfd3fefbef579ee058f139733ac336312663c6706d1163b82b3003fb1925c4",
+                "sha256:4cf06cdc1dda95223e9d2d3c58d3b178aa5dacb35ee7e3bbac10e4e1faacb419",
+                "sha256:50c42830a633fa0cf9e7d27664637532791bfc31c731a87b202d2d8ac40c3ea2",
+                "sha256:55f44b440d491028addb3b88f72207d71eeebfb7b5dbf0643f7c023ae1fba619",
+                "sha256:608e7073dfa9e38a85d38474c082d4281f4ce276ac0010224eaba11e929dd53a",
+                "sha256:63ba06c9941e46fa389d389644e2d8225e0e3e5ebcc4ff1ea8506dce646f8c8a",
+                "sha256:65608c35bfb8a76763f37036547f7adfd09270fbdbf96608be2bead319728fcd",
+                "sha256:665a36ae6f8f20a4676b53224e33d456a6f5a72657d9c83c2aa00765072f31f7",
+                "sha256:6d6607f98fcf17e534162f0709aaad3ab7a96032723d8ac8750ffe17ae5a0666",
+                "sha256:7313ce6a199651c4ed9d7e4cfb4aa56fe923b1adf9af3b420ee14e6d9a73df65",
+                "sha256:7668b52e102d0ed87cb082380a7e2e1e78737ddecdde129acadb0eccc5423859",
+                "sha256:7df70907e00c970c60b9ef2938d894a9381f38e6b9db73c5be35e59d92e06625",
+                "sha256:7e007132af78ea9df29495dbf7b5824cb71648d7133cf7848a2a5dd00d36f9ff",
+                "sha256:835fb5e38fd89328e9c81067fd642b3593c33e1e17e2fdbf77f5676abb14a156",
+                "sha256:8bca7e26c1dd751236cfb0c6c72d4ad61d986e9a41bbf76cb445f69488b2a2bd",
+                "sha256:8db032bf0ce9022a8e41a22598eefc802314e81b879ae093f36ce9ddf39ab1ba",
+                "sha256:99625a92da8229df6d44335e6fcc558a5037dd0a760e11d84be2260e6f37002f",
+                "sha256:9cad97ab29dfc3f0249b483412c85c8ef4766d96cdf9dcf5a1e3caa3f3661cf1",
+                "sha256:a4abaec6ca3ad8660690236d11bfe28dfd707778e2442b45addd2f086d6ef094",
+                "sha256:a6e40afa7f45939ca356f348c8e23048e02cb109ced1eb8420961b2f40fb373a",
+                "sha256:a6f2fcca746e8d5910e18782f976489939d54a91f9411c32051b4aab2bd7c513",
+                "sha256:a806db027852538d2ad7555b203300173dd1b77ba116de92da9afbc3a3be3eed",
+                "sha256:abcabc8c2b26036d62d4c746381a6f7cf60aafcc653198ad678306986b09450d",
+                "sha256:b8526c6d437855442cdd3d87eede9c425c4445ea011ca38d937db299382e6fa3",
+                "sha256:bb06feb762bade6bf3c8b844462274db0c76acc95c52abe8dbed28ae3d44a147",
+                "sha256:c0a33bc9f02c2b17c3ea382f91b4db0e6cde90b63b296422a939886a7a80de1c",
+                "sha256:c4a549890a45f57f1ebf99c067a4ad0cb423a05544accaf2b065246827ed9603",
+                "sha256:ca244fa73f50a800cf8c3ebf7fd93149ec37f5cb9596aa8873ae2c1d23498601",
+                "sha256:cf877ab4ed6e302ec1d04952ca358b381a882fbd9d1b07cccbfd61783561f98a",
+                "sha256:d9d971ec1e79906046aa3ca266de79eac42f1dbf3612a05dc9368125952bd1a1",
+                "sha256:da25303d91526aac3672ee6d49a2f3db2d9502a4a60b55519feb1a4c7714e07d",
+                "sha256:e55e40ff0cc8cc5c07996915ad367fa47da6b3fc091fdadca7f5403239c5fec3",
+                "sha256:f03a532d7dee1bed20bc4884194a16160a2de9ffc6354b3878ec9682bb623c54",
+                "sha256:f1cd098434e83e656abf198f103a8207a8187c0fc110306691a2e94a78d0abb2",
+                "sha256:f2bfb563d0211ce16b63c7cb9395d2c682a23187f54c3d79bfec33e6705473c6",
+                "sha256:f8ffb705ffcf5ddd0e80b65ddf7bed7ee4f5a441ea7d3419e861a12eaf41af58"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==2.1.2"
         },
         "werkzeug": {
             "hashes": [
-                "sha256:c3fd7a7d41976d9f44db327260e263132466836cef6f91512889ed60ad26557c",
-                "sha256:d5da73735293558eb1651ee2fddc4d0dedcfa06538b8813a2e20011583c9e49b"
+                "sha256:1d5a58e0377d1fe39d061a5de4469e414e78ccb1e1e59c0f5ad6fa1c36c52b76",
+                "sha256:48e5e61472fee0ddee27ebad085614ebedb7af41e88f687aaf881afb723a162f"
             ],
-            "version": "==0.14.1"
+            "markers": "python_version >= '3.8'",
+            "version": "==2.3.4"
         }
     },
     "develop": {
-        "backports.shutil-get-terminal-size": {
-            "hashes": [
-                "sha256:0975ba55054c15e346944b38956a4c9cbee9009391e41b86c68990effb8c1f64",
-                "sha256:713e7a8228ae80341c70586d1cc0a8caa5207346927e23d09dcbcaf18eadec80"
-            ],
-            "version": "==1.0.0"
-        },
         "bleach": {
             "hashes": [
-                "sha256:48d39675b80a75f6d1c3bdbffec791cf0bbbab665cf01e20da701c77de278718",
-                "sha256:73d26f018af5d5adcdabf5c1c974add4361a9c76af215fe32fdec8a6fc5fb9b9"
+                "sha256:1a1a85c1595e07d8db14c5f09f09e6433502c51c595970edc090551f0db99414",
+                "sha256:33c16e3353dbd13028ab4799a0f89a83f113405c766e9c122df8a06f5b85b3f4"
             ],
-            "version": "==3.0.2"
+            "markers": "python_version >= '3.7'",
+            "version": "==6.0.0"
         },
         "certifi": {
             "hashes": [
-                "sha256:339dc09518b07e2fa7eda5450740925974815557727d6bd35d319c1524a04a4c",
-                "sha256:6d58c986d22b038c8c0df30d639f23a3e6d172a05c3583e766f4c0b785c0986a"
-            ],
-            "version": "==2018.10.15"
-        },
-        "chardet": {
-            "hashes": [
-                "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae",
-                "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"
-            ],
-            "version": "==3.0.4"
+                "sha256:0f0d56dc5a6ad56fd4ba36484d6cc34451e1c6548c61daad8c320169f91eddc7",
+                "sha256:c6c2e98f5c7869efca1f8916fed228dd91539f9f1b444c314c06eef02980c716"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==2023.5.7"
+        },
+        "cffi": {
+            "hashes": [
+                "sha256:00a9ed42e88df81ffae7a8ab6d9356b371399b91dbdf0c3cb1e84c03a13aceb5",
+                "sha256:03425bdae262c76aad70202debd780501fabeaca237cdfddc008987c0e0f59ef",
+                "sha256:04ed324bda3cda42b9b695d51bb7d54b680b9719cfab04227cdd1e04e5de3104",
+                "sha256:0e2642fe3142e4cc4af0799748233ad6da94c62a8bec3a6648bf8ee68b1c7426",
+                "sha256:173379135477dc8cac4bc58f45db08ab45d228b3363adb7af79436135d028405",
+                "sha256:198caafb44239b60e252492445da556afafc7d1e3ab7a1fb3f0584ef6d742375",
+                "sha256:1e74c6b51a9ed6589199c787bf5f9875612ca4a8a0785fb2d4a84429badaf22a",
+                "sha256:2012c72d854c2d03e45d06ae57f40d78e5770d252f195b93f581acf3ba44496e",
+                "sha256:21157295583fe8943475029ed5abdcf71eb3911894724e360acff1d61c1d54bc",
+                "sha256:2470043b93ff09bf8fb1d46d1cb756ce6132c54826661a32d4e4d132e1977adf",
+                "sha256:285d29981935eb726a4399badae8f0ffdff4f5050eaa6d0cfc3f64b857b77185",
+                "sha256:30d78fbc8ebf9c92c9b7823ee18eb92f2e6ef79b45ac84db507f52fbe3ec4497",
+                "sha256:320dab6e7cb2eacdf0e658569d2575c4dad258c0fcc794f46215e1e39f90f2c3",
+                "sha256:33ab79603146aace82c2427da5ca6e58f2b3f2fb5da893ceac0c42218a40be35",
+                "sha256:3548db281cd7d2561c9ad9984681c95f7b0e38881201e157833a2342c30d5e8c",
+                "sha256:3799aecf2e17cf585d977b780ce79ff0dc9b78d799fc694221ce814c2c19db83",
+                "sha256:39d39875251ca8f612b6f33e6b1195af86d1b3e60086068be9cc053aa4376e21",
+                "sha256:3b926aa83d1edb5aa5b427b4053dc420ec295a08e40911296b9eb1b6170f6cca",
+                "sha256:3bcde07039e586f91b45c88f8583ea7cf7a0770df3a1649627bf598332cb6984",
+                "sha256:3d08afd128ddaa624a48cf2b859afef385b720bb4b43df214f85616922e6a5ac",
+                "sha256:3eb6971dcff08619f8d91607cfc726518b6fa2a9eba42856be181c6d0d9515fd",
+                "sha256:40f4774f5a9d4f5e344f31a32b5096977b5d48560c5592e2f3d2c4374bd543ee",
+                "sha256:4289fc34b2f5316fbb762d75362931e351941fa95fa18789191b33fc4cf9504a",
+                "sha256:470c103ae716238bbe698d67ad020e1db9d9dba34fa5a899b5e21577e6d52ed2",
+                "sha256:4f2c9f67e9821cad2e5f480bc8d83b8742896f1242dba247911072d4fa94c192",
+                "sha256:50a74364d85fd319352182ef59c5c790484a336f6db772c1a9231f1c3ed0cbd7",
+                "sha256:54a2db7b78338edd780e7ef7f9f6c442500fb0d41a5a4ea24fff1c929d5af585",
+                "sha256:5635bd9cb9731e6d4a1132a498dd34f764034a8ce60cef4f5319c0541159392f",
+                "sha256:59c0b02d0a6c384d453fece7566d1c7e6b7bae4fc5874ef2ef46d56776d61c9e",
+                "sha256:5d598b938678ebf3c67377cdd45e09d431369c3b1a5b331058c338e201f12b27",
+                "sha256:5df2768244d19ab7f60546d0c7c63ce1581f7af8b5de3eb3004b9b6fc8a9f84b",
+                "sha256:5ef34d190326c3b1f822a5b7a45f6c4535e2f47ed06fec77d3d799c450b2651e",
+                "sha256:6975a3fac6bc83c4a65c9f9fcab9e47019a11d3d2cf7f3c0d03431bf145a941e",
+                "sha256:6c9a799e985904922a4d207a94eae35c78ebae90e128f0c4e521ce339396be9d",
+                "sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c",
+                "sha256:7473e861101c9e72452f9bf8acb984947aa1661a7704553a9f6e4baa5ba64415",
+                "sha256:8102eaf27e1e448db915d08afa8b41d6c7ca7a04b7d73af6514df10a3e74bd82",
+                "sha256:87c450779d0914f2861b8526e035c5e6da0a3199d8f1add1a665e1cbc6fc6d02",
+                "sha256:8b7ee99e510d7b66cdb6c593f21c043c248537a32e0bedf02e01e9553a172314",
+                "sha256:91fc98adde3d7881af9b59ed0294046f3806221863722ba7d8d120c575314325",
+                "sha256:94411f22c3985acaec6f83c6df553f2dbe17b698cc7f8ae751ff2237d96b9e3c",
+                "sha256:98d85c6a2bef81588d9227dde12db8a7f47f639f4a17c9ae08e773aa9c697bf3",
+                "sha256:9ad5db27f9cabae298d151c85cf2bad1d359a1b9c686a275df03385758e2f914",
+                "sha256:a0b71b1b8fbf2b96e41c4d990244165e2c9be83d54962a9a1d118fd8657d2045",
+                "sha256:a0f100c8912c114ff53e1202d0078b425bee3649ae34d7b070e9697f93c5d52d",
+                "sha256:a591fe9e525846e4d154205572a029f653ada1a78b93697f3b5a8f1f2bc055b9",
+                "sha256:a5c84c68147988265e60416b57fc83425a78058853509c1b0629c180094904a5",
+                "sha256:a66d3508133af6e8548451b25058d5812812ec3798c886bf38ed24a98216fab2",
+                "sha256:a8c4917bd7ad33e8eb21e9a5bbba979b49d9a97acb3a803092cbc1133e20343c",
+                "sha256:b3bbeb01c2b273cca1e1e0c5df57f12dce9a4dd331b4fa1635b8bec26350bde3",
+                "sha256:cba9d6b9a7d64d4bd46167096fc9d2f835e25d7e4c121fb2ddfc6528fb0413b2",
+                "sha256:cc4d65aeeaa04136a12677d3dd0b1c0c94dc43abac5860ab33cceb42b801c1e8",
+                "sha256:ce4bcc037df4fc5e3d184794f27bdaab018943698f4ca31630bc7f84a7b69c6d",
+                "sha256:cec7d9412a9102bdc577382c3929b337320c4c4c4849f2c5cdd14d7368c5562d",
+                "sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9",
+                "sha256:d61f4695e6c866a23a21acab0509af1cdfd2c013cf256bbf5b6b5e2695827162",
+                "sha256:db0fbb9c62743ce59a9ff687eb5f4afbe77e5e8403d6697f7446e5f609976f76",
+                "sha256:dd86c085fae2efd48ac91dd7ccffcfc0571387fe1193d33b6394db7ef31fe2a4",
+                "sha256:e00b098126fd45523dd056d2efba6c5a63b71ffe9f2bbe1a4fe1716e1d0c331e",
+                "sha256:e229a521186c75c8ad9490854fd8bbdd9a0c9aa3a524326b55be83b54d4e0ad9",
+                "sha256:e263d77ee3dd201c3a142934a086a4450861778baaeeb45db4591ef65550b0a6",
+                "sha256:ed9cb427ba5504c1dc15ede7d516b84757c3e3d7868ccc85121d9310d27eed0b",
+                "sha256:fa6693661a4c91757f4412306191b6dc88c1703f780c8234035eac011922bc01",
+                "sha256:fcd131dd944808b5bdb38e6f5b53013c5aa4f334c5cad0c72742f6eba4b73db0"
+            ],
+            "version": "==1.15.1"
+        },
+        "charset-normalizer": {
+            "hashes": [
+                "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6",
+                "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1",
+                "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e",
+                "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373",
+                "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62",
+                "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230",
+                "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be",
+                "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c",
+                "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0",
+                "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448",
+                "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f",
+                "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649",
+                "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d",
+                "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0",
+                "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706",
+                "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a",
+                "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59",
+                "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23",
+                "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5",
+                "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb",
+                "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e",
+                "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e",
+                "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c",
+                "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28",
+                "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d",
+                "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41",
+                "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974",
+                "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce",
+                "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f",
+                "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1",
+                "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d",
+                "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8",
+                "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017",
+                "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31",
+                "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7",
+                "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8",
+                "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e",
+                "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14",
+                "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd",
+                "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d",
+                "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795",
+                "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b",
+                "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b",
+                "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b",
+                "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203",
+                "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f",
+                "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19",
+                "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1",
+                "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a",
+                "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac",
+                "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9",
+                "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0",
+                "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137",
+                "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f",
+                "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6",
+                "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5",
+                "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909",
+                "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f",
+                "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0",
+                "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324",
+                "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755",
+                "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb",
+                "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854",
+                "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c",
+                "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60",
+                "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84",
+                "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0",
+                "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b",
+                "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1",
+                "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531",
+                "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1",
+                "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11",
+                "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326",
+                "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df",
+                "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==3.1.0"
         },
         "click": {
             "hashes": [
-                "sha256:2335065e6395b9e67ca716de5f7526736bfa6ceead690adf616d925bdc622b13",
-                "sha256:5b94b49521f6456670fdb30cd82a4eca9412788a93fa6dd6df72c94d5a8ff2d7"
+                "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e",
+                "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"
             ],
-            "version": "==7.0"
+            "markers": "python_version >= '3.7'",
+            "version": "==8.1.3"
         },
         "colorama": {
             "hashes": [
-                "sha256:463f8483208e921368c9f306094eb6f725c6ca42b0f97e313cb5d5512459feda",
-                "sha256:48eb22f4f8461b1df5734a074b57042430fb06e1d61bd1e11b078c0fe6d7a1f1"
+                "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44",
+                "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"
             ],
-            "version": "==0.3.9"
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6'",
+            "version": "==0.4.6"
         },
         "coverage": {
             "hashes": [
-                "sha256:09e47c529ff77bf042ecfe858fb55c3e3eb97aac2c87f0349ab5a7efd6b3939f",
-                "sha256:0a1f9b0eb3aa15c990c328535655847b3420231af299386cfe5efc98f9c250fe",
-                "sha256:0cc941b37b8c2ececfed341444a456912e740ecf515d560de58b9a76562d966d",
-                "sha256:10e8af18d1315de936d67775d3a814cc81d0747a1a0312d84e27ae5610e313b0",
-                "sha256:1b4276550b86caa60606bd3572b52769860a81a70754a54acc8ba789ce74d607",
-                "sha256:1e8a2627c48266c7b813975335cfdea58c706fe36f607c97d9392e61502dc79d",
-                "sha256:2b224052bfd801beb7478b03e8a66f3f25ea56ea488922e98903914ac9ac930b",
-                "sha256:447c450a093766744ab53bf1e7063ec82866f27bcb4f4c907da25ad293bba7e3",
-                "sha256:46101fc20c6f6568561cdd15a54018bb42980954b79aa46da8ae6f008066a30e",
-                "sha256:4710dc676bb4b779c4361b54eb308bc84d64a2fa3d78e5f7228921eccce5d815",
-                "sha256:510986f9a280cd05189b42eee2b69fecdf5bf9651d4cd315ea21d24a964a3c36",
-                "sha256:5535dda5739257effef56e49a1c51c71f1d37a6e5607bb25a5eee507c59580d1",
-                "sha256:5a7524042014642b39b1fcae85fb37556c200e64ec90824ae9ecf7b667ccfc14",
-                "sha256:5f55028169ef85e1fa8e4b8b1b91c0b3b0fa3297c4fb22990d46ff01d22c2d6c",
-                "sha256:6694d5573e7790a0e8d3d177d7a416ca5f5c150742ee703f3c18df76260de794",
-                "sha256:6831e1ac20ac52634da606b658b0b2712d26984999c9d93f0c6e59fe62ca741b",
-                "sha256:77f0d9fa5e10d03aa4528436e33423bfa3718b86c646615f04616294c935f840",
-                "sha256:828ad813c7cdc2e71dcf141912c685bfe4b548c0e6d9540db6418b807c345ddd",
-                "sha256:85a06c61598b14b015d4df233d249cd5abfa61084ef5b9f64a48e997fd829a82",
-                "sha256:8cb4febad0f0b26c6f62e1628f2053954ad2c555d67660f28dfb1b0496711952",
-                "sha256:a5c58664b23b248b16b96253880b2868fb34358911400a7ba39d7f6399935389",
-                "sha256:aaa0f296e503cda4bc07566f592cd7a28779d433f3a23c48082af425d6d5a78f",
-                "sha256:ab235d9fe64833f12d1334d29b558aacedfbca2356dfb9691f2d0d38a8a7bfb4",
-                "sha256:b3b0c8f660fae65eac74fbf003f3103769b90012ae7a460863010539bb7a80da",
-                "sha256:bab8e6d510d2ea0f1d14f12642e3f35cefa47a9b2e4c7cea1852b52bc9c49647",
-                "sha256:c45297bbdbc8bb79b02cf41417d63352b70bcb76f1bbb1ee7d47b3e89e42f95d",
-                "sha256:d19bca47c8a01b92640c614a9147b081a1974f69168ecd494687c827109e8f42",
-                "sha256:d64b4340a0c488a9e79b66ec9f9d77d02b99b772c8b8afd46c1294c1d39ca478",
-                "sha256:da969da069a82bbb5300b59161d8d7c8d423bc4ccd3b410a9b4d8932aeefc14b",
-                "sha256:ed02c7539705696ecb7dc9d476d861f3904a8d2b7e894bd418994920935d36bb",
-                "sha256:ee5b8abc35b549012e03a7b1e86c09491457dba6c94112a2482b18589cc2bdb9"
-            ],
-            "version": "==4.5.2"
+                "sha256:06a9a2be0b5b576c3f18f1a241f0473575c4a26021b52b2a85263a00f034d51f",
+                "sha256:06fb182e69f33f6cd1d39a6c597294cff3143554b64b9825d1dc69d18cc2fff2",
+                "sha256:0a5f9e1dbd7fbe30196578ca36f3fba75376fb99888c395c5880b355e2875f8a",
+                "sha256:0e1f928eaf5469c11e886fe0885ad2bf1ec606434e79842a879277895a50942a",
+                "sha256:171717c7cb6b453aebac9a2ef603699da237f341b38eebfee9be75d27dc38e01",
+                "sha256:1e9d683426464e4a252bf70c3498756055016f99ddaec3774bf368e76bbe02b6",
+                "sha256:201e7389591af40950a6480bd9edfa8ed04346ff80002cec1a66cac4549c1ad7",
+                "sha256:245167dd26180ab4c91d5e1496a30be4cd721a5cf2abf52974f965f10f11419f",
+                "sha256:2aee274c46590717f38ae5e4650988d1af340fe06167546cc32fe2f58ed05b02",
+                "sha256:2e07b54284e381531c87f785f613b833569c14ecacdcb85d56b25c4622c16c3c",
+                "sha256:31563e97dae5598556600466ad9beea39fb04e0229e61c12eaa206e0aa202063",
+                "sha256:33d6d3ea29d5b3a1a632b3c4e4f4ecae24ef170b0b9ee493883f2df10039959a",
+                "sha256:3d376df58cc111dc8e21e3b6e24606b5bb5dee6024f46a5abca99124b2229ef5",
+                "sha256:419bfd2caae268623dd469eff96d510a920c90928b60f2073d79f8fe2bbc5959",
+                "sha256:48c19d2159d433ccc99e729ceae7d5293fbffa0bdb94952d3579983d1c8c9d97",
+                "sha256:49969a9f7ffa086d973d91cec8d2e31080436ef0fb4a359cae927e742abfaaa6",
+                "sha256:52edc1a60c0d34afa421c9c37078817b2e67a392cab17d97283b64c5833f427f",
+                "sha256:537891ae8ce59ef63d0123f7ac9e2ae0fc8b72c7ccbe5296fec45fd68967b6c9",
+                "sha256:54b896376ab563bd38453cecb813c295cf347cf5906e8b41d340b0321a5433e5",
+                "sha256:58c2ccc2f00ecb51253cbe5d8d7122a34590fac9646a960d1430d5b15321d95f",
+                "sha256:5b7540161790b2f28143191f5f8ec02fb132660ff175b7747b95dcb77ac26562",
+                "sha256:5baa06420f837184130752b7c5ea0808762083bf3487b5038d68b012e5937dbe",
+                "sha256:5e330fc79bd7207e46c7d7fd2bb4af2963f5f635703925543a70b99574b0fea9",
+                "sha256:61b9a528fb348373c433e8966535074b802c7a5d7f23c4f421e6c6e2f1697a6f",
+                "sha256:63426706118b7f5cf6bb6c895dc215d8a418d5952544042c8a2d9fe87fcf09cb",
+                "sha256:6d040ef7c9859bb11dfeb056ff5b3872436e3b5e401817d87a31e1750b9ae2fb",
+                "sha256:6f48351d66575f535669306aa7d6d6f71bc43372473b54a832222803eb956fd1",
+                "sha256:7ee7d9d4822c8acc74a5e26c50604dff824710bc8de424904c0982e25c39c6cb",
+                "sha256:81c13a1fc7468c40f13420732805a4c38a105d89848b7c10af65a90beff25250",
+                "sha256:8d13c64ee2d33eccf7437961b6ea7ad8673e2be040b4f7fd4fd4d4d28d9ccb1e",
+                "sha256:8de8bb0e5ad103888d65abef8bca41ab93721647590a3f740100cd65c3b00511",
+                "sha256:8fa03bce9bfbeeef9f3b160a8bed39a221d82308b4152b27d82d8daa7041fee5",
+                "sha256:924d94291ca674905fe9481f12294eb11f2d3d3fd1adb20314ba89e94f44ed59",
+                "sha256:975d70ab7e3c80a3fe86001d8751f6778905ec723f5b110aed1e450da9d4b7f2",
+                "sha256:976b9c42fb2a43ebf304fa7d4a310e5f16cc99992f33eced91ef6f908bd8f33d",
+                "sha256:9e31cb64d7de6b6f09702bb27c02d1904b3aebfca610c12772452c4e6c21a0d3",
+                "sha256:a342242fe22407f3c17f4b499276a02b01e80f861f1682ad1d95b04018e0c0d4",
+                "sha256:a3d33a6b3eae87ceaefa91ffdc130b5e8536182cd6dfdbfc1aa56b46ff8c86de",
+                "sha256:a895fcc7b15c3fc72beb43cdcbdf0ddb7d2ebc959edac9cef390b0d14f39f8a9",
+                "sha256:afb17f84d56068a7c29f5fa37bfd38d5aba69e3304af08ee94da8ed5b0865833",
+                "sha256:b1c546aca0ca4d028901d825015dc8e4d56aac4b541877690eb76490f1dc8ed0",
+                "sha256:b29019c76039dc3c0fd815c41392a044ce555d9bcdd38b0fb60fb4cd8e475ba9",
+                "sha256:b46517c02ccd08092f4fa99f24c3b83d8f92f739b4657b0f146246a0ca6a831d",
+                "sha256:b7aa5f8a41217360e600da646004f878250a0d6738bcdc11a0a39928d7dc2050",
+                "sha256:b7b4c971f05e6ae490fef852c218b0e79d4e52f79ef0c8475566584a8fb3e01d",
+                "sha256:ba90a9563ba44a72fda2e85302c3abc71c5589cea608ca16c22b9804262aaeb6",
+                "sha256:cb017fd1b2603ef59e374ba2063f593abe0fc45f2ad9abdde5b4d83bd922a353",
+                "sha256:d22656368f0e6189e24722214ed8d66b8022db19d182927b9a248a2a8a2f67eb",
+                "sha256:d2c2db7fd82e9b72937969bceac4d6ca89660db0a0967614ce2481e81a0b771e",
+                "sha256:d39b5b4f2a66ccae8b7263ac3c8170994b65266797fb96cbbfd3fb5b23921db8",
+                "sha256:d62a5c7dad11015c66fbb9d881bc4caa5b12f16292f857842d9d1871595f4495",
+                "sha256:e7d9405291c6928619403db1d10bd07888888ec1abcbd9748fdaa971d7d661b2",
+                "sha256:e84606b74eb7de6ff581a7915e2dab7a28a0517fbe1c9239eb227e1354064dcd",
+                "sha256:eb393e5ebc85245347950143969b241d08b52b88a3dc39479822e073a1a8eb27",
+                "sha256:ebba1cd308ef115925421d3e6a586e655ca5a77b5bf41e02eb0e4562a111f2d1",
+                "sha256:ee57190f24fba796e36bb6d3aa8a8783c643d8fa9760c89f7a98ab5455fbf818",
+                "sha256:f2f67fe12b22cd130d34d0ef79206061bfb5eda52feb6ce0dba0644e20a03cf4",
+                "sha256:f6951407391b639504e3b3be51b7ba5f3528adbf1a8ac3302b687ecababf929e",
+                "sha256:f75f7168ab25dd93110c8a8117a22450c19976afbc44234cbf71481094c1b850",
+                "sha256:fdec9e8cbf13a5bf63290fc6013d216a4c7232efb51548594ca3631a7f13c3a3"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==7.2.7"
         },
         "coveragespace": {
             "hashes": [
-                "sha256:498b54ec158a19e1f5647da681dc77fd9d17df11ecff1253d60ac7970209f6e5",
-                "sha256:7c5ce4641e0f995b9be0e8b53401fd7b6d17db1b8c23bfd06f0c845ad0de5b5f"
+                "sha256:6dcdee802be5cdaa9820538203ad0e182a1ea56c679cdf65b36d4b85937d2e38",
+                "sha256:a59fa4227166406f74c0fd89ad871b6d699d35de5468eeca96bf556838af0f0c"
             ],
             "index": "pypi",
-            "version": "==2.1"
+            "version": "==4.1"
+        },
+        "cryptography": {
+            "hashes": [
+                "sha256:0ddaee209d1cf1f180f1efa338a68c4621154de0afaef92b89486f5f96047c55",
+                "sha256:14754bcdae909d66ff24b7b5f166d69340ccc6cb15731670435efd5719294895",
+                "sha256:344c6de9f8bda3c425b3a41b319522ba3208551b70c2ae00099c205f0d9fd3be",
+                "sha256:34d405ea69a8b34566ba3dfb0521379b210ea5d560fafedf9f800a9a94a41928",
+                "sha256:3680248309d340fda9611498a5319b0193a8dbdb73586a1acf8109d06f25b92d",
+                "sha256:3c5ef25d060c80d6d9f7f9892e1d41bb1c79b78ce74805b8cb4aa373cb7d5ec8",
+                "sha256:4ab14d567f7bbe7f1cdff1c53d5324ed4d3fc8bd17c481b395db224fb405c237",
+                "sha256:5c1f7293c31ebc72163a9a0df246f890d65f66b4a40d9ec80081969ba8c78cc9",
+                "sha256:6b71f64beeea341c9b4f963b48ee3b62d62d57ba93eb120e1196b31dc1025e78",
+                "sha256:7d92f0248d38faa411d17f4107fc0bce0c42cae0b0ba5415505df72d751bf62d",
+                "sha256:8362565b3835ceacf4dc8f3b56471a2289cf51ac80946f9087e66dc283a810e0",
+                "sha256:84a165379cb9d411d58ed739e4af3396e544eac190805a54ba2e0322feb55c46",
+                "sha256:88ff107f211ea696455ea8d911389f6d2b276aabf3231bf72c8853d22db755c5",
+                "sha256:9f65e842cb02550fac96536edb1d17f24c0a338fd84eaf582be25926e993dde4",
+                "sha256:a4fc68d1c5b951cfb72dfd54702afdbbf0fb7acdc9b7dc4301bbf2225a27714d",
+                "sha256:b7f2f5c525a642cecad24ee8670443ba27ac1fab81bba4cc24c7b6b41f2d0c75",
+                "sha256:b846d59a8d5a9ba87e2c3d757ca019fa576793e8758174d3868aecb88d6fc8eb",
+                "sha256:bf8fc66012ca857d62f6a347007e166ed59c0bc150cefa49f28376ebe7d992a2",
+                "sha256:f5d0bf9b252f30a31664b6f64432b4730bb7038339bd18b1fafe129cfc2be9be"
+            ],
+            "index": "pypi",
+            "version": "==41.0.0"
         },
         "docopt": {
             "hashes": [
@@ -187,47 +417,87 @@
         },
         "docutils": {
             "hashes": [
-                "sha256:02aec4bd92ab067f6ff27a38a38a41173bf01bed8f89157768c1573f53e474a6",
-                "sha256:51e64ef2ebfb29cae1faa133b3710143496eca21c530f3f71424d77687764274",
-                "sha256:7a4bd47eaf6596e1295ecb11361139febe29b084a87bf005bf899f9a42edc3c6"
+                "sha256:686577d2e4c32380bb50cbb22f575ed742d58168cee37e99117a854bcd88f125",
+                "sha256:cf316c8370a737a022b72b56874f6602acf974a37a9fba42ec2876387549fc61"
             ],
             "index": "pypi",
-            "version": "==0.14"
+            "version": "==0.17.1"
+        },
+        "entrypoints": {
+            "hashes": [
+                "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19",
+                "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451"
+            ],
+            "markers": "python_version >= '2.7'",
+            "version": "==0.3"
         },
         "flake8": {
             "hashes": [
-                "sha256:231cd86194aaec4bdfaa553ae1a1cd9b7b4558332fbc10136c044940d587a778",
-                "sha256:7ac3bbaac27174d95bc4734ed23a07de567ffbcf4fc7e316854b4f3015d4fd15"
+                "sha256:45681a117ecc81e870cbf1262835ae4af5e7a8b08e40b944a8a6e6b895914cfb",
+                "sha256:49356e766643ad15072a789a20915d3c91dc89fd313ccd71802303fd67e4deca"
             ],
             "index": "pypi",
-            "version": "==2.6.2"
+            "version": "==3.7.9"
+        },
+        "ghp-import": {
+            "hashes": [
+                "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619",
+                "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"
+            ],
+            "version": "==2.1.0"
         },
         "idna": {
             "hashes": [
-                "sha256:156a6814fb5ac1fc6850fb002e0852d56c0c8d2531923a51032d1b70760e186e",
-                "sha256:684a38a6f903c1d71d6d5fac066b58d7768af4de2b832e426ec79c30daa94a16"
+                "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4",
+                "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==3.4"
+        },
+        "importlib-metadata": {
+            "hashes": [
+                "sha256:43dd286a2cd8995d5eaef7fee2066340423b818ed3fd70adf0bad5f1fac53fed",
+                "sha256:92501cdf9cc66ebd3e612f1b4f0c0765dfa42f0fa38ffb319b6bd84dd675d705"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==6.6.0"
+        },
+        "jaraco.classes": {
+            "hashes": [
+                "sha256:2353de3288bc6b82120752201c6b1c1a14b058267fa424ed5ce5984e3b922158",
+                "sha256:89559fa5c1d3c34eff6f631ad80bb21f378dbcbb35dd161fd2c6b93f5be2f98a"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==3.2.3"
+        },
+        "jeepney": {
+            "hashes": [
+                "sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806",
+                "sha256:c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755"
             ],
-            "version": "==2.7"
+            "markers": "sys_platform == 'linux'",
+            "version": "==0.8.0"
         },
         "jinja2": {
             "hashes": [
-                "sha256:74c935a1b8bb9a3947c50a54766a969d4846290e1e788ea44c1392163723c3bd",
-                "sha256:f84be1bb0040caca4cea721fcbbbbd61f9be9464ca236387158b0feea01914a4"
+                "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852",
+                "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"
             ],
-            "version": "==2.10"
+            "markers": "python_version >= '3.7'",
+            "version": "==3.1.2"
         },
-        "livereload": {
+        "keyring": {
             "hashes": [
-                "sha256:583179dc8d49b040a9da79bd33de59e160d2a8802b939e304eb359a4419f6498",
-                "sha256:dd4469a8f5a6833576e9f5433f1439c306de15dbbfeceabd32479b1123380fa5"
+                "sha256:771ed2a91909389ed6148631de678f82ddc73737d85a927f382a8a1b157898cd",
+                "sha256:ba2e15a9b35e21908d0aaf4e0a47acc52d6ae33444df0da2b49d41a46ef6d678"
             ],
-            "version": "==2.5.2"
+            "markers": "python_version >= '3.7'",
+            "version": "==23.13.1"
         },
         "macfsevents": {
             "hashes": [
                 "sha256:1324b66b356051de662ba87d84f73ada062acd42b047ed1246e60a449f833e10"
             ],
-            "index": "pypi",
             "markers": "sys_platform == 'darwin'",
             "version": "==0.8.1"
         },
@@ -241,51 +511,98 @@
         },
         "markupsafe": {
             "hashes": [
-                "sha256:048ef924c1623740e70204aa7143ec592504045ae4429b59c30054cb31e3c432",
-                "sha256:130f844e7f5bdd8e9f3f42e7102ef1d49b2e6fdf0d7526df3f87281a532d8c8b",
-                "sha256:19f637c2ac5ae9da8bfd98cef74d64b7e1bb8a63038a3505cd182c3fac5eb4d9",
-                "sha256:1b8a7a87ad1b92bd887568ce54b23565f3fd7018c4180136e1cf412b405a47af",
-                "sha256:1c25694ca680b6919de53a4bb3bdd0602beafc63ff001fea2f2fc16ec3a11834",
-                "sha256:1f19ef5d3908110e1e891deefb5586aae1b49a7440db952454b4e281b41620cd",
-                "sha256:1fa6058938190ebe8290e5cae6c351e14e7bb44505c4a7624555ce57fbbeba0d",
-                "sha256:31cbb1359e8c25f9f48e156e59e2eaad51cd5242c05ed18a8de6dbe85184e4b7",
-                "sha256:3e835d8841ae7863f64e40e19477f7eb398674da6a47f09871673742531e6f4b",
-                "sha256:4e97332c9ce444b0c2c38dd22ddc61c743eb208d916e4265a2a3b575bdccb1d3",
-                "sha256:525396ee324ee2da82919f2ee9c9e73b012f23e7640131dd1b53a90206a0f09c",
-                "sha256:52b07fbc32032c21ad4ab060fec137b76eb804c4b9a1c7c7dc562549306afad2",
-                "sha256:52ccb45e77a1085ec5461cde794e1aa037df79f473cbc69b974e73940655c8d7",
-                "sha256:5c3fbebd7de20ce93103cb3183b47671f2885307df4a17a0ad56a1dd51273d36",
-                "sha256:5e5851969aea17660e55f6a3be00037a25b96a9b44d2083651812c99d53b14d1",
-                "sha256:5edfa27b2d3eefa2210fb2f5d539fbed81722b49f083b2c6566455eb7422fd7e",
-                "sha256:7d263e5770efddf465a9e31b78362d84d015cc894ca2c131901a4445eaa61ee1",
-                "sha256:83381342bfc22b3c8c06f2dd93a505413888694302de25add756254beee8449c",
-                "sha256:857eebb2c1dc60e4219ec8e98dfa19553dae33608237e107db9c6078b1167856",
-                "sha256:98e439297f78fca3a6169fd330fbe88d78b3bb72f967ad9961bcac0d7fdd1550",
-                "sha256:bf54103892a83c64db58125b3f2a43df6d2cb2d28889f14c78519394feb41492",
-                "sha256:d9ac82be533394d341b41d78aca7ed0e0f4ba5a2231602e2f05aa87f25c51672",
-                "sha256:e982fe07ede9fada6ff6705af70514a52beb1b2c3d25d4e873e82114cf3c5401",
-                "sha256:edce2ea7f3dfc981c4ddc97add8a61381d9642dc3273737e756517cc03e84dd6",
-                "sha256:efdc45ef1afc238db84cb4963aa689c0408912a0239b0721cb172b4016eb31d6",
-                "sha256:f137c02498f8b935892d5c0172560d7ab54bc45039de8805075e19079c639a9c",
-                "sha256:f82e347a72f955b7017a39708a3667f106e6ad4d10b25f237396a7115d8ed5fd",
-                "sha256:fb7c206e01ad85ce57feeaaa0bf784b97fa3cad0d4a5737bc5295785f5c613a1"
-            ],
-            "version": "==1.1.0"
+                "sha256:0576fe974b40a400449768941d5d0858cc624e3249dfd1e0c33674e5c7ca7aed",
+                "sha256:085fd3201e7b12809f9e6e9bc1e5c96a368c8523fad5afb02afe3c051ae4afcc",
+                "sha256:090376d812fb6ac5f171e5938e82e7f2d7adc2b629101cec0db8b267815c85e2",
+                "sha256:0b462104ba25f1ac006fdab8b6a01ebbfbce9ed37fd37fd4acd70c67c973e460",
+                "sha256:137678c63c977754abe9086a3ec011e8fd985ab90631145dfb9294ad09c102a7",
+                "sha256:1bea30e9bf331f3fef67e0a3877b2288593c98a21ccb2cf29b74c581a4eb3af0",
+                "sha256:22152d00bf4a9c7c83960521fc558f55a1adbc0631fbb00a9471e097b19d72e1",
+                "sha256:22731d79ed2eb25059ae3df1dfc9cb1546691cc41f4e3130fe6bfbc3ecbbecfa",
+                "sha256:2298c859cfc5463f1b64bd55cb3e602528db6fa0f3cfd568d3605c50678f8f03",
+                "sha256:28057e985dace2f478e042eaa15606c7efccb700797660629da387eb289b9323",
+                "sha256:2e7821bffe00aa6bd07a23913b7f4e01328c3d5cc0b40b36c0bd81d362faeb65",
+                "sha256:2ec4f2d48ae59bbb9d1f9d7efb9236ab81429a764dedca114f5fdabbc3788013",
+                "sha256:340bea174e9761308703ae988e982005aedf427de816d1afe98147668cc03036",
+                "sha256:40627dcf047dadb22cd25ea7ecfe9cbf3bbbad0482ee5920b582f3809c97654f",
+                "sha256:40dfd3fefbef579ee058f139733ac336312663c6706d1163b82b3003fb1925c4",
+                "sha256:4cf06cdc1dda95223e9d2d3c58d3b178aa5dacb35ee7e3bbac10e4e1faacb419",
+                "sha256:50c42830a633fa0cf9e7d27664637532791bfc31c731a87b202d2d8ac40c3ea2",
+                "sha256:55f44b440d491028addb3b88f72207d71eeebfb7b5dbf0643f7c023ae1fba619",
+                "sha256:608e7073dfa9e38a85d38474c082d4281f4ce276ac0010224eaba11e929dd53a",
+                "sha256:63ba06c9941e46fa389d389644e2d8225e0e3e5ebcc4ff1ea8506dce646f8c8a",
+                "sha256:65608c35bfb8a76763f37036547f7adfd09270fbdbf96608be2bead319728fcd",
+                "sha256:665a36ae6f8f20a4676b53224e33d456a6f5a72657d9c83c2aa00765072f31f7",
+                "sha256:6d6607f98fcf17e534162f0709aaad3ab7a96032723d8ac8750ffe17ae5a0666",
+                "sha256:7313ce6a199651c4ed9d7e4cfb4aa56fe923b1adf9af3b420ee14e6d9a73df65",
+                "sha256:7668b52e102d0ed87cb082380a7e2e1e78737ddecdde129acadb0eccc5423859",
+                "sha256:7df70907e00c970c60b9ef2938d894a9381f38e6b9db73c5be35e59d92e06625",
+                "sha256:7e007132af78ea9df29495dbf7b5824cb71648d7133cf7848a2a5dd00d36f9ff",
+                "sha256:835fb5e38fd89328e9c81067fd642b3593c33e1e17e2fdbf77f5676abb14a156",
+                "sha256:8bca7e26c1dd751236cfb0c6c72d4ad61d986e9a41bbf76cb445f69488b2a2bd",
+                "sha256:8db032bf0ce9022a8e41a22598eefc802314e81b879ae093f36ce9ddf39ab1ba",
+                "sha256:99625a92da8229df6d44335e6fcc558a5037dd0a760e11d84be2260e6f37002f",
+                "sha256:9cad97ab29dfc3f0249b483412c85c8ef4766d96cdf9dcf5a1e3caa3f3661cf1",
+                "sha256:a4abaec6ca3ad8660690236d11bfe28dfd707778e2442b45addd2f086d6ef094",
+                "sha256:a6e40afa7f45939ca356f348c8e23048e02cb109ced1eb8420961b2f40fb373a",
+                "sha256:a6f2fcca746e8d5910e18782f976489939d54a91f9411c32051b4aab2bd7c513",
+                "sha256:a806db027852538d2ad7555b203300173dd1b77ba116de92da9afbc3a3be3eed",
+                "sha256:abcabc8c2b26036d62d4c746381a6f7cf60aafcc653198ad678306986b09450d",
+                "sha256:b8526c6d437855442cdd3d87eede9c425c4445ea011ca38d937db299382e6fa3",
+                "sha256:bb06feb762bade6bf3c8b844462274db0c76acc95c52abe8dbed28ae3d44a147",
+                "sha256:c0a33bc9f02c2b17c3ea382f91b4db0e6cde90b63b296422a939886a7a80de1c",
+                "sha256:c4a549890a45f57f1ebf99c067a4ad0cb423a05544accaf2b065246827ed9603",
+                "sha256:ca244fa73f50a800cf8c3ebf7fd93149ec37f5cb9596aa8873ae2c1d23498601",
+                "sha256:cf877ab4ed6e302ec1d04952ca358b381a882fbd9d1b07cccbfd61783561f98a",
+                "sha256:d9d971ec1e79906046aa3ca266de79eac42f1dbf3612a05dc9368125952bd1a1",
+                "sha256:da25303d91526aac3672ee6d49a2f3db2d9502a4a60b55519feb1a4c7714e07d",
+                "sha256:e55e40ff0cc8cc5c07996915ad367fa47da6b3fc091fdadca7f5403239c5fec3",
+                "sha256:f03a532d7dee1bed20bc4884194a16160a2de9ffc6354b3878ec9682bb623c54",
+                "sha256:f1cd098434e83e656abf198f103a8207a8187c0fc110306691a2e94a78d0abb2",
+                "sha256:f2bfb563d0211ce16b63c7cb9395d2c682a23187f54c3d79bfec33e6705473c6",
+                "sha256:f8ffb705ffcf5ddd0e80b65ddf7bed7ee4f5a441ea7d3419e861a12eaf41af58"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==2.1.2"
         },
         "mccabe": {
             "hashes": [
-                "sha256:16293af41e7242031afd73896fef6458f4cad38201d21e28f344fff50ae1c25e",
-                "sha256:f9b58bf366c1506dcd6117b33e5c4874746f0de859c9c7cab8b516cb6be1d22e"
+                "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
+                "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"
             ],
-            "version": "==0.5.3"
+            "version": "==0.6.1"
+        },
+        "mergedeep": {
+            "hashes": [
+                "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8",
+                "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==1.3.4"
+        },
+        "minilog": {
+            "hashes": [
+                "sha256:0c48879cc9e72f0127aa2c36b522dc6fa10fa8532956197436b491d31617d5d5",
+                "sha256:2048a8d381b36ef5f146fb9a657e627729411f8e2ed0047e2c1286cf8e3e58d7"
+            ],
+            "markers": "python_version >= '3.7' and python_version < '4.0'",
+            "version": "==2.1"
         },
         "mkdocs": {
             "hashes": [
-                "sha256:1b4d46cd1cb517cd743358da96a3efc588fd86f81512fb9c28214597b6dc731f",
-                "sha256:cd7264ea42d76f5bc1a0bd8b0a2c6c6e6be3a8742f5e78f47104a452dbe93600"
+                "sha256:89f5a094764381cda656af4298727c9f53dc3e602983087e1fe96ea1df24f4c1",
+                "sha256:a1fa8c2d0c1305d7fc2b9d9f607c71778572a8b110fb26642aa00296c9e6d072"
             ],
             "index": "pypi",
-            "version": "==0.17.5"
+            "version": "==1.2.3"
+        },
+        "more-itertools": {
+            "hashes": [
+                "sha256:cabaa341ad0389ea83c17a94566a53ae4c9d07349861ecb14dc6d0345cf9ac5d",
+                "sha256:d2bc7f02446e86a68911e58ded76d6561eea00cddfb2a91e7019bbb586c799f3"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==9.1.0"
         },
         "nose": {
             "hashes": [
@@ -296,48 +613,67 @@
             "index": "pypi",
             "version": "==1.3.7"
         },
+        "packaging": {
+            "hashes": [
+                "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61",
+                "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==23.1"
+        },
         "pkginfo": {
             "hashes": [
-                "sha256:5878d542a4b3f237e359926384f1dde4e099c9f5525d236b1840cf704fa8d474",
-                "sha256:a39076cb3eb34c333a0dd390b568e9e1e881c7bf2cc0aee12120636816f55aee"
+                "sha256:4b7a555a6d5a22169fcc9cf7bfd78d296b0361adad412a346c1226849af5e546",
+                "sha256:8fd5896e8718a4372f0ea9cc9d96f6417c9b986e23a4d116dda26b62cc29d046"
             ],
-            "version": "==1.4.2"
+            "markers": "python_version >= '3.6'",
+            "version": "==1.9.6"
         },
         "pycodestyle": {
             "hashes": [
-                "sha256:2ce83f2046f5ab85c652ceceddfbde7a64a909900989b4b43e92b10b743d0ce5",
-                "sha256:37f0420b14630b0eaaf452978f3a6ea4816d787c3e6dcbba6fb255030adae2e7"
+                "sha256:95a2219d12372f05704562a14ec30bc76b05a5b297b21a5dfe3f6fac3491ae56",
+                "sha256:e40a936c9a450ad81df37f549d676d127b1b66000a6c500caa2b085bc0ca976c"
             ],
-            "version": "==2.0.0"
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==2.5.0"
+        },
+        "pycparser": {
+            "hashes": [
+                "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9",
+                "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"
+            ],
+            "version": "==2.21"
         },
         "pyflakes": {
             "hashes": [
-                "sha256:2e4a1b636d8809d8f0a69f341acf15b2e401a3221ede11be439911d23ce2139e",
-                "sha256:e87bac26c62ea5b45067cc89e4a12f56e1483f1f2cda17e7c9b375b9fd2f40da"
+                "sha256:17dbeb2e3f4d772725c777fabc446d5634d1038f234e77343108ce445ea69ce0",
+                "sha256:d976835886f8c5b31d47970ed689944a0262b5f3afa00a5a7b4dc81e5449f8a2"
             ],
-            "version": "==1.2.3"
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==2.1.1"
         },
         "pygments": {
             "hashes": [
-                "sha256:78f3f434bcc5d6ee09020f92ba487f95ba50f1e3ef83ae96b9d5ffa1bab25c5d",
-                "sha256:dbae1046def0efb574852fab9e90209b23f556367b5a320c0bcb871c77c3e8cc"
+                "sha256:8ace4d3c1dd481894b2005f560ead0f9f19ee64fe983366be1a21e171d12775c",
+                "sha256:db2db3deb4b4179f399a09054b023b6a586b76499d36965813c71aa8ed7b5fd1"
             ],
-            "version": "==2.2.0"
+            "markers": "python_version >= '3.7'",
+            "version": "==2.15.1"
         },
         "pync": {
             "hashes": [
                 "sha256:85737aab9fc69cf59dc9fe831adbe94ac224944c05e297c98de3c2413f253530"
             ],
-            "index": "pypi",
             "markers": "sys_platform == 'darwin'",
             "version": "==1.6.1"
         },
         "python-dateutil": {
             "hashes": [
-                "sha256:063df5763652e21de43de7d9e00ccf239f953a832941e37be541614732cdfc93",
-                "sha256:88f9287c0174266bb0d8cedd395cfba9c58e87e5ad86b2ce58859bc11be3cf02"
+                "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86",
+                "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"
             ],
-            "version": "==2.7.5"
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==2.8.2"
         },
         "python-termstyle": {
             "hashes": [
@@ -348,87 +684,178 @@
         },
         "pyyaml": {
             "hashes": [
-                "sha256:3d7da3009c0f3e783b2c873687652d83b1bbfd5c88e9813fb7e5b03c0dd3108b",
-                "sha256:3ef3092145e9b70e3ddd2c7ad59bdd0252a94dfe3949721633e41344de00a6bf",
-                "sha256:40c71b8e076d0550b2e6380bada1f1cd1017b882f7e16f09a65be98e017f211a",
-                "sha256:558dd60b890ba8fd982e05941927a3911dc409a63dcb8b634feaa0cda69330d3",
-                "sha256:a7c28b45d9f99102fa092bb213aa12e0aaf9a6a1f5e395d36166639c1f96c3a1",
-                "sha256:aa7dd4a6a427aed7df6fb7f08a580d68d9b118d90310374716ae90b710280af1",
-                "sha256:bc558586e6045763782014934bfaf39d48b8ae85a2713117d16c39864085c613",
-                "sha256:d46d7982b62e0729ad0175a9bc7e10a566fc07b224d2c79fafb5e032727eaa04",
-                "sha256:d5eef459e30b09f5a098b9cea68bebfeb268697f78d647bd255a085371ac7f3f",
-                "sha256:e01d3203230e1786cd91ccfdc8f8454c8069c91bee3962ad93b87a4b2860f537",
-                "sha256:e170a9e6fcfd19021dd29845af83bb79236068bf5fd4df3327c1be18182b2531"
-            ],
-            "version": "==3.13"
+                "sha256:01b45c0191e6d66c470b6cf1b9531a771a83c1c4208272ead47a3ae4f2f603bf",
+                "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293",
+                "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b",
+                "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57",
+                "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b",
+                "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4",
+                "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07",
+                "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba",
+                "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9",
+                "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287",
+                "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513",
+                "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0",
+                "sha256:432557aa2c09802be39460360ddffd48156e30721f5e8d917f01d31694216782",
+                "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0",
+                "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92",
+                "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f",
+                "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2",
+                "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc",
+                "sha256:81957921f441d50af23654aa6c5e5eaf9b06aba7f0a19c18a538dc7ef291c5a1",
+                "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c",
+                "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86",
+                "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4",
+                "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c",
+                "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34",
+                "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b",
+                "sha256:afa17f5bc4d1b10afd4466fd3a44dc0e245382deca5b3c353d8b757f9e3ecb8d",
+                "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c",
+                "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb",
+                "sha256:bfaef573a63ba8923503d27530362590ff4f576c626d86a9fed95822a8255fd7",
+                "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737",
+                "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3",
+                "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d",
+                "sha256:d4b0ba9512519522b118090257be113b9468d804b19d63c71dbcf4a48fa32358",
+                "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53",
+                "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78",
+                "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803",
+                "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a",
+                "sha256:dbad0e9d368bb989f4515da330b88a057617d16b6a8245084f1b05400f24609f",
+                "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174",
+                "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==6.0"
+        },
+        "pyyaml-env-tag": {
+            "hashes": [
+                "sha256:70092675bda14fdec33b31ba77e7543de9ddc88f2e5b99160396572d11525bdb",
+                "sha256:af31106dec8a4d68c60207c1886031cbf839b68aa7abccdb19868200532c2069"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==0.1"
         },
         "readme-renderer": {
             "hashes": [
-                "sha256:bb16f55b259f27f75f640acf5e00cf897845a8b3e4731b5c1a436e4b8529202f",
-                "sha256:c8532b79afc0375a85f10433eca157d6b50f7d6990f337fa498c96cd4bfc203d"
+                "sha256:cd653186dfc73055656f090f227f5cb22a046d7f71a841dfa305f55c9a513273",
+                "sha256:f67a16caedfa71eef48a31b39708637a6f4664c4394801a7b0d6432d13907343"
             ],
-            "version": "==24.0"
+            "markers": "python_version >= '3.7'",
+            "version": "==37.3"
         },
         "requests": {
             "hashes": [
-                "sha256:65b3a120e4329e33c9889db89c80976c5272f56ea92d3e74da8a463992e3ff54",
-                "sha256:ea881206e59f41dbd0bd445437d792e43906703fff75ca8ff43ccdb11f33f263"
+                "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f",
+                "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"
             ],
-            "version": "==2.20.1"
+            "markers": "python_version >= '3.7'",
+            "version": "==2.31.0"
         },
         "requests-toolbelt": {
             "hashes": [
-                "sha256:42c9c170abc2cacb78b8ab23ac957945c7716249206f90874651971a4acff237",
-                "sha256:f6a531936c6fa4c6cfce1b9c10d5c4f498d16528d2a54a22ca00011205a187b5"
+                "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6",
+                "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"
             ],
-            "version": "==0.8.0"
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==1.0.0"
         },
-        "six": {
+        "rfc3986": {
             "hashes": [
-                "sha256:70e8a77beed4562e7f14fe23a786b54f6296e34344c23bc42f07b15018ff98e9",
-                "sha256:832dc0e10feb1aa2c68dcc57dbb658f1c7e65b9b61af69048abc87a2db00a0eb"
+                "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd",
+                "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c"
             ],
-            "version": "==1.11.0"
+            "markers": "python_version >= '3.7'",
+            "version": "==2.0.0"
         },
-        "sniffer": {
+        "secretstorage": {
             "hashes": [
-                "sha256:e8a0daa4c51dff3d00482b45dc9b978159100a8d5a7df327c28ed96586559970",
-                "sha256:e90c1ad4bd3c31a5fad8e03d45dfc83377b31420aa0779f17280c817ce0c9dd8"
+                "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77",
+                "sha256:f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99"
             ],
-            "index": "pypi",
-            "version": "==0.4.0"
+            "markers": "sys_platform == 'linux'",
+            "version": "==3.3.3"
         },
-        "tornado": {
+        "setuptools": {
             "hashes": [
-                "sha256:5ef073ac6180038ccf99411fe05ae9aafb675952a2c8db60592d5daf8401f803",
-                "sha256:6d14e47eab0e15799cf3cdcc86b0b98279da68522caace2bd7ce644287685f0a",
-                "sha256:92b7ca81e18ba9ec3031a7ee73d4577ac21d41a0c9b775a9182f43301c3b5f8e",
-                "sha256:ab587996fe6fb9ce65abfda440f9b61e4f9f2cf921967723540679176915e4c3",
-                "sha256:b36298e9f63f18cad97378db2222c0e0ca6a55f6304e605515e05a25483ed51a"
+                "sha256:5df61bf30bb10c6f756eb19e7c9f3b473051f48db77fddbe06ff2ca307df9a6f",
+                "sha256:62642358adc77ffa87233bc4d2354c4b2682d214048f500964dbe760ccedf102"
             ],
-            "version": "==4.5.3"
+            "markers": "python_version >= '3.7'",
+            "version": "==67.8.0"
+        },
+        "six": {
+            "hashes": [
+                "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926",
+                "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==1.16.0"
+        },
+        "sniffer": {
+            "hashes": [
+                "sha256:b37665053fb83d7790bf9e51d616c11970863d14b5ea5a51155a4e95759d1529",
+                "sha256:f120843fe152d0e380402fc11313b151e2044c47fdd36895de2efedc8624dbb8"
+            ],
+            "index": "pypi",
+            "version": "==0.4.1"
         },
         "tqdm": {
             "hashes": [
-                "sha256:3c4d4a5a41ef162dd61f1edb86b0e1c7859054ab656b2e7c7b77e7fbf6d9f392",
-                "sha256:5b4d5549984503050883bc126280b386f5f4ca87e6c023c5d015655ad75bdebb"
+                "sha256:1871fb68a86b8fb3b59ca4cdd3dcccbc7e6d613eeed31f4c332531977b89beb5",
+                "sha256:c4f53a17fe37e132815abceec022631be8ffe1b9381c2e6e30aa70edc99e9671"
             ],
-            "version": "==4.28.1"
+            "markers": "python_version >= '3.7'",
+            "version": "==4.65.0"
         },
         "twine": {
             "hashes": [
-                "sha256:7d89bc6acafb31d124e6e5b295ef26ac77030bf098960c2a4c4e058335827c5c",
-                "sha256:fad6f1251195f7ddd1460cb76d6ea106c93adb4e56c41e0da79658e56e547d2c"
+                "sha256:16f706f2f1687d7ce30e7effceee40ed0a09b7c33b9abb5ef6434e5551565d83",
+                "sha256:a56c985264b991dc8a8f4234eb80c5af87fa8080d0c224ad8f2cd05a2c22e83b"
             ],
             "index": "pypi",
-            "version": "==1.12.1"
+            "version": "==3.4.1"
         },
         "urllib3": {
             "hashes": [
-                "sha256:61bf29cada3fc2fbefad4fdf059ea4bd1b4a86d2b6d15e1c7c0b582b9752fe39",
-                "sha256:de9529817c93f27c8ccbfead6985011db27bd0ddfcdb2d86f3f663385c6a9c22"
-            ],
-            "version": "==1.24.1"
+                "sha256:61717a1095d7e155cdb737ac7bb2f4324a858a1e2e6466f6d03ff630ca68d3cc",
+                "sha256:d055c2f9d38dc53c808f6fdc8eab7360b6fdbbde02340ed25cfbcd817c62469e"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==2.0.2"
+        },
+        "watchdog": {
+            "hashes": [
+                "sha256:0e06ab8858a76e1219e68c7573dfeba9dd1c0219476c5a44d5333b01d7e1743a",
+                "sha256:13bbbb462ee42ec3c5723e1205be8ced776f05b100e4737518c67c8325cf6100",
+                "sha256:233b5817932685d39a7896b1090353fc8efc1ef99c9c054e46c8002561252fb8",
+                "sha256:25f70b4aa53bd743729c7475d7ec41093a580528b100e9a8c5b5efe8899592fc",
+                "sha256:2b57a1e730af3156d13b7fdddfc23dea6487fceca29fc75c5a868beed29177ae",
+                "sha256:336adfc6f5cc4e037d52db31194f7581ff744b67382eb6021c868322e32eef41",
+                "sha256:3aa7f6a12e831ddfe78cdd4f8996af9cf334fd6346531b16cec61c3b3c0d8da0",
+                "sha256:3ed7c71a9dccfe838c2f0b6314ed0d9b22e77d268c67e015450a29036a81f60f",
+                "sha256:4c9956d27be0bb08fc5f30d9d0179a855436e655f046d288e2bcc11adfae893c",
+                "sha256:4d98a320595da7a7c5a18fc48cb633c2e73cda78f93cac2ef42d42bf609a33f9",
+                "sha256:4f94069eb16657d2c6faada4624c39464f65c05606af50bb7902e036e3219be3",
+                "sha256:5113334cf8cf0ac8cd45e1f8309a603291b614191c9add34d33075727a967709",
+                "sha256:51f90f73b4697bac9c9a78394c3acbbd331ccd3655c11be1a15ae6fe289a8c83",
+                "sha256:5d9f3a10e02d7371cd929b5d8f11e87d4bad890212ed3901f9b4d68767bee759",
+                "sha256:7ade88d0d778b1b222adebcc0927428f883db07017618a5e684fd03b83342bd9",
+                "sha256:7c5f84b5194c24dd573fa6472685b2a27cc5a17fe5f7b6fd40345378ca6812e3",
+                "sha256:7e447d172af52ad204d19982739aa2346245cc5ba6f579d16dac4bfec226d2e7",
+                "sha256:8ae9cda41fa114e28faf86cb137d751a17ffd0316d1c34ccf2235e8a84365c7f",
+                "sha256:8f3ceecd20d71067c7fd4c9e832d4e22584318983cabc013dbf3f70ea95de346",
+                "sha256:9fac43a7466eb73e64a9940ac9ed6369baa39b3bf221ae23493a9ec4d0022674",
+                "sha256:a70a8dcde91be523c35b2bf96196edc5730edb347e374c7de7cd20c43ed95397",
+                "sha256:adfdeab2da79ea2f76f87eb42a3ab1966a5313e5a69a0213a3cc06ef692b0e96",
+                "sha256:ba07e92756c97e3aca0912b5cbc4e5ad802f4557212788e72a72a47ff376950d",
+                "sha256:c07253088265c363d1ddf4b3cdb808d59a0468ecd017770ed716991620b8f77a",
+                "sha256:c9d8c8ec7efb887333cf71e328e39cffbf771d8f8f95d308ea4125bf5f90ba64",
+                "sha256:d00e6be486affb5781468457b21a6cbe848c33ef43f9ea4a73b4882e5f188a44",
+                "sha256:d429c2430c93b7903914e4db9a966c7f2b068dd2ebdd2fa9b9ce094c7d459f33"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==3.0.0"
         },
         "webencodings": {
             "hashes": [
@@ -436,6 +863,14 @@
                 "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"
             ],
             "version": "==0.5.1"
+        },
+        "zipp": {
+            "hashes": [
+                "sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b",
+                "sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==3.15.0"
         }
     }
 }
diff --git a/README.md b/README.md
index cf188b0..29166a3 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 Browsable web APIs for Flask.
 
-[![Unix Build Status](https://img.shields.io/travis/flask-api/flask-api.svg)](https://travis-ci.org/flask-api/flask-api) 
+[![Unix Build Status](https://img.shields.io/travis/com/flask-api/flask-api.svg)](https://travis-ci.com/flask-api/flask-api)
 [![Coverage Status](https://img.shields.io/coveralls/flask-api/flask-api.svg)](https://coveralls.io/r/flask-api/flask-api)
 [![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/flask-api/flask-api.svg)](https://scrutinizer-ci.com/g/flask-api/flask-api/)
 [![PyPI Version](https://img.shields.io/pypi/v/Flask-API.svg)](https://pypi.org/project/Flask-API/)
@@ -19,8 +19,8 @@ Flask API is a drop-in replacement for Flask that provides an implementation of
 
 Requirements:
 
-* Python 2.7+ or 3.4+
-* Flask 0.12.3+
+* Python 3.6+
+* Flask 1.1.+
 
 Install using `pip`:
 
@@ -46,7 +46,7 @@ def example():
     return {'hello': 'world'}
 ```
 
-A renderer for the response data will be selected using content negotiation based on the client 'Accept' header. If you're making the API request from a regular client, this will default to a JSON response. If you're viewing the API in a browser, it'll default to the browsable API HTML. 
+A renderer for the response data will be selected using content negotiation based on the client 'Accept' header. If you're making the API request from a regular client, this will default to a JSON response. If you're viewing the API in a browser, it'll default to the browsable API HTML.
 
 ## Requests
 
@@ -133,8 +133,8 @@ You can now open a new tab and interact with the API from the command line:
 
 ```shell
 $ curl -X GET http://127.0.0.1:5000/
-[{"url": "http://127.0.0.1:5000/0/", "text": "do the shopping"}, 
- {"url": "http://127.0.0.1:5000/1/", "text": "build the codez"}, 
+[{"url": "http://127.0.0.1:5000/0/", "text": "do the shopping"},
+ {"url": "http://127.0.0.1:5000/1/", "text": "build the codez"},
  {"url": "http://127.0.0.1:5000/2/", "text": "paint the door"}]
 
 $ curl -X GET http://127.0.0.1:5000/1/
diff --git a/docs/CNAME b/docs/CNAME
deleted file mode 100644
index 08b39d2..0000000
--- a/docs/CNAME
+++ /dev/null
@@ -1 +0,0 @@
-www.flaskapi.org
diff --git a/docs/about/release-notes.md b/docs/about/release-notes.md
index f31fa3b..084d595 100644
--- a/docs/about/release-notes.md
+++ b/docs/about/release-notes.md
@@ -1,5 +1,18 @@
 # Release Notes
 
+## Version 3.1
+
+- Fixed support for Flask `2.3`.
+
+## Version 3.0
+
+* Dropped support for Flask `<2.0`.
+
+## Version 2.0
+
+* Dropped support for Python `<3.6`.
+* Dropped support for Flask `<1.1`.
+
 ## Version 1.1
 
 * Added support for custom JSON encoders.
diff --git a/docs/index.md b/docs/index.md
index 87835a7..43831b7 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -14,8 +14,8 @@ Flask API is a drop-in replacement for Flask that provides an implementation of
 
 Requirements:
 
-* Python 2.7+ or 3.4+
-* Flask 0.12.3+
+* Python 3.6+
+* Flask 1.1+
 
 The following packages are optional:
 
@@ -39,7 +39,7 @@ Return any valid response object as normal, or return a `list` or `dict`.
     def example():
         return {'hello': 'world'}
 
-A renderer for the response data will be selected using content negotiation based on the client 'Accept' header. If you're making the API request from a regular client, this will default to a JSON response. If you're viewing the API in a browser it'll default to the browsable API HTML. 
+A renderer for the response data will be selected using content negotiation based on the client 'Accept' header. If you're making the API request from a regular client, this will default to a JSON response. If you're viewing the API in a browser it'll default to the browsable API HTML.
 
 ## Requests
 
@@ -55,23 +55,23 @@ The following example demonstrates a simple API for creating, listing, updating
 
     from flask import request, url_for
     from flask_api import FlaskAPI, status, exceptions
-    
+
     app = FlaskAPI(__name__)
-    
-    
+
+
     notes = {
         0: 'do the shopping',
         1: 'build the codez',
         2: 'paint the door',
     }
-    
+
     def note_repr(key):
         return {
             'url': request.host_url.rstrip('/') + url_for('notes_detail', key=key),
             'text': notes[key]
         }
-    
-    
+
+
     @app.route("/", methods=['GET', 'POST'])
     def notes_list():
         """
@@ -82,11 +82,11 @@ The following example demonstrates a simple API for creating, listing, updating
             idx = max(notes.keys()) + 1
             notes[idx] = note
             return note_repr(idx), status.HTTP_201_CREATED
-    
+
         # request.method == 'GET'
         return [note_repr(idx) for idx in sorted(notes.keys())]
-    
-    
+
+
     @app.route("/<int:key>/", methods=['GET', 'PUT', 'DELETE'])
     def notes_detail(key):
         """
@@ -96,17 +96,17 @@ The following example demonstrates a simple API for creating, listing, updating
             note = str(request.data.get('text', ''))
             notes[key] = note
             return note_repr(key)
-    
+
         elif request.method == 'DELETE':
             notes.pop(key, None)
             return '', status.HTTP_204_NO_CONTENT
-    
+
         # request.method == 'GET'
         if key not in notes:
             raise exceptions.NotFound()
         return note_repr(key)
-    
-    
+
+
     if __name__ == "__main__":
         app.run(debug=True)
 
diff --git a/docs/screenshot.png b/docs/screenshot.png
index 9dba138..5d01222 100644
Binary files a/docs/screenshot.png and b/docs/screenshot.png differ
diff --git a/example.py b/example.py
index 0680147..4b5511c 100644
--- a/example.py
+++ b/example.py
@@ -1,29 +1,30 @@
 from flask import request, url_for
-from flask.ext.api import FlaskAPI, status, exceptions
+from flask.ext.api import FlaskAPI, exceptions, status
 
 app = FlaskAPI(__name__)
 
 
 notes = {
-    0: 'do the shopping',
-    1: 'build the codez',
-    2: 'paint the door',
+    0: "do the shopping",
+    1: "build the codez",
+    2: "paint the door",
 }
 
+
 def note_repr(key):
     return {
-        'url': request.host_url.rstrip('/') + url_for('notes_detail', key=key),
-        'text': notes[key]
+        "url": request.host_url.rstrip("/") + url_for("notes_detail", key=key),
+        "text": notes[key],
     }
 
 
-@app.route("/", methods=['GET', 'POST'])
+@app.route("/", methods=["GET", "POST"])
 def notes_list():
     """
     List or create notes.
     """
-    if request.method == 'POST':
-        note = str(request.data.get('text', ''))
+    if request.method == "POST":
+        note = str(request.data.get("text", ""))
         idx = max(notes.keys()) + 1
         notes[idx] = note
         return note_repr(idx), status.HTTP_201_CREATED
@@ -32,19 +33,19 @@ def notes_list():
     return [note_repr(idx) for idx in sorted(notes.keys())]
 
 
-@app.route("/<int:key>/", methods=['GET', 'PUT', 'DELETE'])
+@app.route("/<int:key>/", methods=["GET", "PUT", "DELETE"])
 def notes_detail(key):
     """
     Retrieve, update or delete note instances.
     """
-    if request.method == 'PUT':
-        note = str(request.data.get('text', ''))
+    if request.method == "PUT":
+        note = str(request.data.get("text", ""))
         notes[key] = note
         return note_repr(key)
 
-    elif request.method == 'DELETE':
+    elif request.method == "DELETE":
         notes.pop(key, None)
-        return '', status.HTTP_204_NO_CONTENT
+        return "", status.HTTP_204_NO_CONTENT
 
     # request.method == 'GET'
     if key not in notes:
diff --git a/flask_api/__init__.py b/flask_api/__init__.py
index 519fd4d..7d4d782 100644
--- a/flask_api/__init__.py
+++ b/flask_api/__init__.py
@@ -1,3 +1,3 @@
 from flask_api.app import FlaskAPI
 
-__version__ = '1.1'
+__version__ = "3.1"
diff --git a/flask_api/app.py b/flask_api/app.py
index 6036c4c..5556445 100644
--- a/flask_api/app.py
+++ b/flask_api/app.py
@@ -1,23 +1,23 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask import request, Flask, Blueprint
-from flask._compat import reraise, string_types, text_type
+import re
+import sys
+from itertools import chain
+
+from flask import Blueprint, Flask, request
+from werkzeug.exceptions import HTTPException
+
+from flask_api.compat import is_flask_legacy
 from flask_api.exceptions import APIException
 from flask_api.request import APIRequest
 from flask_api.response import APIResponse
 from flask_api.settings import APISettings
 from flask_api.status import HTTP_204_NO_CONTENT
-from itertools import chain
-from werkzeug.exceptions import HTTPException
-import re
-import sys
-from flask_api.compat import is_flask_legacy
-
 
 api_resources = Blueprint(
-    'flask-api', __name__,
-    url_prefix='/flask-api',
-    template_folder='templates', static_folder='static'
+    "flask-api",
+    __name__,
+    url_prefix="/flask-api",
+    template_folder="templates",
+    static_folder="static",
 )
 
 
@@ -30,15 +30,15 @@ class FlaskAPI(Flask):
     response_class = APIResponse
 
     def __init__(self, *args, **kwargs):
-        super(FlaskAPI, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.api_settings = APISettings(self.config)
         self.register_blueprint(api_resources)
-        self.jinja_env.filters['urlize_quoted_links'] = urlize_quoted_links
+        self.jinja_env.filters["urlize_quoted_links"] = urlize_quoted_links
 
     def preprocess_request(self):
         request.parser_classes = self.api_settings.DEFAULT_PARSERS
         request.renderer_classes = self.api_settings.DEFAULT_RENDERERS
-        return super(FlaskAPI, self).preprocess_request()
+        return super().preprocess_request()
 
     def make_response(self, rv):
         """
@@ -50,16 +50,16 @@ def make_response(self, rv):
             rv, status_or_headers, headers = rv + (None,) * (3 - len(rv))
 
         if rv is None and status_or_headers == HTTP_204_NO_CONTENT:
-            rv = ''
+            rv = ""
 
         if rv is None and status_or_headers:
-            raise ValueError('View function did not return a response')
+            raise ValueError("View function did not return a response")
 
         if isinstance(status_or_headers, (dict, list)):
             headers, status_or_headers = status_or_headers, None
 
         if not isinstance(rv, self.response_class):
-            if isinstance(rv, (text_type, bytes, bytearray, list, dict)):
+            if isinstance(rv, (str, bytes, bytearray, list, dict)):
                 status = status_or_headers
                 rv = self.response_class(rv, headers=headers, status=status)
                 headers = status_or_headers = None
@@ -67,7 +67,7 @@ def make_response(self, rv):
                 rv = self.response_class.force_type(rv, request.environ)
 
         if status_or_headers is not None:
-            if isinstance(status_or_headers, string_types):
+            if isinstance(status_or_headers, str):
                 rv.status = status_or_headers
             else:
                 rv.status_code = status_or_headers
@@ -99,15 +99,16 @@ def handle_user_exception(self, e):
                 if isinstance(e, typecheck):
                     return handler(e)
         else:
-            for typecheck, handler in chain(dict(blueprint_handlers).items(),
-                    dict(app_handlers).items()):
+            for typecheck, handler in chain(
+                dict(blueprint_handlers).items(), dict(app_handlers).items()
+            ):
                 if isinstance(e, typecheck):
                     return handler(e)
 
-        reraise(exc_type, exc_value, tb)
+        raise e
 
     def handle_api_exception(self, exc):
-        content = {'message': exc.detail}
+        content = {"message": exc.detail}
         status = exc.status_code
         return self.response_class(content, status=status)
 
@@ -120,13 +121,15 @@ def create_url_adapter(self, request):
         """
         if request is not None:
             environ = request.environ.copy()
-            environ['REQUEST_METHOD'] = request.method
-            return self.url_map.bind_to_environ(environ,
-                server_name=self.config['SERVER_NAME'])
+            environ["REQUEST_METHOD"] = request.method
+            return self.url_map.bind_to_environ(
+                environ, server_name=self.config["SERVER_NAME"]
+            )
         # We need at the very least the server name to be set for this
         # to work.
-        if self.config['SERVER_NAME'] is not None:
+        if self.config["SERVER_NAME"] is not None:
             return self.url_map.bind(
-                self.config['SERVER_NAME'],
-                script_name=self.config['APPLICATION_ROOT'] or '/',
-                url_scheme=self.config['PREFERRED_URL_SCHEME'])
+                self.config["SERVER_NAME"],
+                script_name=self.config["APPLICATION_ROOT"] or "/",
+                url_scheme=self.config["PREFERRED_URL_SCHEME"],
+            )
diff --git a/flask_api/compat.py b/flask_api/compat.py
index c59b984..8760df5 100644
--- a/flask_api/compat.py
+++ b/flask_api/compat.py
@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals, absolute_import
 from flask import __version__ as flask_version
 
 # Markdown is optional
@@ -17,7 +15,6 @@ def apply_markdown(text):
         md = markdown.Markdown(extensions=extensions)
         return md.convert(text)
 
-
 except ImportError:  # pragma: no cover - markdown installed for tests
     apply_markdown = None
 
diff --git a/flask_api/decorators.py b/flask_api/decorators.py
index d3a09b2..6b9f5b8 100644
--- a/flask_api/decorators.py
+++ b/flask_api/decorators.py
@@ -1,4 +1,5 @@
 from functools import wraps
+
 from flask import request
 
 
@@ -11,7 +12,9 @@ def decorated_function(*args, **kwargs):
             else:
                 request.parser_classes = parsers
             return func(*args, **kwargs)
+
         return decorated_function
+
     return decorator
 
 
@@ -24,5 +27,7 @@ def decorated_function(*args, **kwargs):
             else:
                 request.renderer_classes = renderers
             return func(*args, **kwargs)
+
         return decorated_function
+
     return decorator
diff --git a/flask_api/exceptions.py b/flask_api/exceptions.py
index 27b261d..0ac0df1 100644
--- a/flask_api/exceptions.py
+++ b/flask_api/exceptions.py
@@ -1,10 +1,9 @@
-from __future__ import unicode_literals
 from flask_api import status
 
 
 class APIException(Exception):
     status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
-    detail = ''
+    detail = ""
 
     def __init__(self, detail=None):
         if detail is not None:
@@ -16,27 +15,28 @@ def __str__(self):
 
 class ParseError(APIException):
     status_code = status.HTTP_400_BAD_REQUEST
-    detail = 'Malformed request.'
+    detail = "Malformed request."
 
 
 class AuthenticationFailed(APIException):
     status_code = status.HTTP_401_UNAUTHORIZED
-    detail = 'Incorrect authentication credentials.'
+    detail = "Incorrect authentication credentials."
 
 
 class NotAuthenticated(APIException):
     status_code = status.HTTP_401_UNAUTHORIZED
-    detail = 'Authentication credentials were not provided.'
+    detail = "Authentication credentials were not provided."
 
 
 class PermissionDenied(APIException):
     status_code = status.HTTP_403_FORBIDDEN
-    detail = 'You do not have permission to perform this action.'
+    detail = "You do not have permission to perform this action."
 
 
 class NotFound(APIException):
     status_code = status.HTTP_404_NOT_FOUND
-    detail = 'This resource does not exist.'
+    detail = "This resource does not exist."
+
 
 # class MethodNotAllowed(APIException):
 #     status_code = status.HTTP_405_METHOD_NOT_ALLOWED
@@ -48,17 +48,18 @@ class NotFound(APIException):
 
 class NotAcceptable(APIException):
     status_code = status.HTTP_406_NOT_ACCEPTABLE
-    detail = 'Could not satisfy the request Accept header.'
+    detail = "Could not satisfy the request Accept header."
 
 
 class UnsupportedMediaType(APIException):
     status_code = status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
-    detail = 'Unsupported media type in the request Content-Type header.'
+    detail = "Unsupported media type in the request Content-Type header."
 
 
 class Throttled(APIException):
     status_code = status.HTTP_429_TOO_MANY_REQUESTS
-    detail = 'Request was throttled.'
+    detail = "Request was throttled."
+
 
 #     def __init__(self, wait=None, detail=None):
 #         if wait is None:
diff --git a/flask_api/mediatypes.py b/flask_api/mediatypes.py
index eac96e8..e159b37 100644
--- a/flask_api/mediatypes.py
+++ b/flask_api/mediatypes.py
@@ -1,14 +1,10 @@
-# coding: utf8
-from __future__ import unicode_literals
-
-
-class MediaType(object):
+class MediaType:
     def __init__(self, media_type):
         self.main_type, self.sub_type, self.params = self._parse(media_type)
 
     @property
     def full_type(self):
-        return self.main_type + '/' + self.sub_type
+        return self.main_type + "/" + self.sub_type
 
     @property
     def precedence(self):
@@ -20,11 +16,11 @@ def precedence(self):
         1. 'type/*'
         0. '*/*'
         """
-        if self.main_type == '*':
+        if self.main_type == "*":
             return 0
-        elif self.sub_type == '*':
+        elif self.sub_type == "*":
             return 1
-        elif not self.params or list(self.params.keys()) == ['q']:
+        elif not self.params or list(self.params.keys()) == ["q"]:
             return 2
         return 3
 
@@ -39,13 +35,21 @@ def satisfies(self, other):
         '*/*'                           >= 'text/plain'
         """
         for key in self.params.keys():
-            if key != 'q' and other.params.get(key, None) != self.params.get(key, None):
+            if key != "q" and other.params.get(key, None) != self.params.get(key, None):
                 return False
 
-        if self.sub_type != '*' and other.sub_type != '*' and other.sub_type != self.sub_type:
+        if (
+            self.sub_type != "*"
+            and other.sub_type != "*"
+            and other.sub_type != self.sub_type
+        ):
             return False
 
-        if self.main_type != '*' and other.main_type != '*' and other.main_type != self.main_type:
+        if (
+            self.main_type != "*"
+            and other.main_type != "*"
+            and other.main_type != self.main_type
+        ):
             return False
 
         return True
@@ -55,15 +59,15 @@ def _parse(self, media_type):
         Parse a media type string, like "application/json; indent=4" into a
         three-tuple, like: ('application', 'json', {'indent': 4})
         """
-        full_type, sep, param_string = media_type.partition(';')
+        full_type, sep, param_string = media_type.partition(";")
         params = {}
-        for token in param_string.strip().split(','):
-            key, sep, value = [s.strip() for s in token.partition('=')]
+        for token in param_string.strip().split(","):
+            key, sep, value = [s.strip() for s in token.partition("=")]
             if value.startswith('"') and value.endswith('"'):
                 value = value[1:-1]
             if key:
                 params[key] = value
-        main_type, sep, sub_type = [s.strip() for s in full_type.partition('/')]
+        main_type, sep, sub_type = [s.strip() for s in full_type.partition("/")]
         return (main_type, sub_type, params)
 
     def __repr__(self):
@@ -75,11 +79,10 @@ def __str__(self):
         Note that this ensures the params are sorted.
         """
         if self.params:
-            params_str = ', '.join([
-                '%s="%s"' % (key, val)
-                for key, val in sorted(self.params.items())
-            ])
-            return self.full_type + '; ' + params_str
+            params_str = ", ".join(
+                ['%s="%s"' % (key, val) for key, val in sorted(self.params.items())]
+            )
+            return self.full_type + "; " + params_str
         return self.full_type
 
     def __hash__(self):
@@ -87,10 +90,7 @@ def __hash__(self):
 
     def __eq__(self, other):
         # Compare two MediaType instances, ignoring parameter ordering.
-        return (
-            self.full_type == other.full_type and
-            self.params == other.params
-        )
+        return self.full_type == other.full_type and self.params == other.params
 
 
 def parse_accept_header(accept):
@@ -106,7 +106,7 @@ def parse_accept_header(accept):
     ]
     """
     ret = [set(), set(), set(), set()]
-    for token in accept.split(','):
+    for token in accept.split(","):
         media_type = MediaType(token.strip())
         ret[3 - media_type.precedence].add(media_type)
     return [media_types for media_types in ret if media_types]
diff --git a/flask_api/negotiation.py b/flask_api/negotiation.py
index 9ce0549..299d3a2 100644
--- a/flask_api/negotiation.py
+++ b/flask_api/negotiation.py
@@ -1,11 +1,10 @@
-# coding: utf8
-from __future__ import unicode_literals
 from flask import request
+
 from flask_api import exceptions
 from flask_api.mediatypes import MediaType, parse_accept_header
 
 
-class BaseNegotiation(object):
+class BaseNegotiation:
     def select_parser(self, parsers):
         msg = '`select_parser()` method must be implemented for class "%s"'
         raise NotImplementedError(msg % self.__class__.__name__)
@@ -36,7 +35,7 @@ def select_renderer(self, renderers):
         Determine which renderer to use for rendering the response body.
         Returns a two-tuple of (renderer, content type).
         """
-        accept_header = request.headers.get('Accept', '*/*')
+        accept_header = request.headers.get("Accept", "*/*")
 
         for client_media_types in parse_accept_header(accept_header):
             for renderer in renderers:
diff --git a/flask_api/parsers.py b/flask_api/parsers.py
index 914fc62..56f45f6 100644
--- a/flask_api/parsers.py
+++ b/flask_api/parsers.py
@@ -1,17 +1,16 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask._compat import text_type
-from flask_api import exceptions
+import json
+
 from werkzeug.formparser import MultiPartParser as WerkzeugMultiPartParser
 from werkzeug.formparser import default_stream_factory
 from werkzeug.urls import url_decode_stream
-import json
+
+from flask_api import exceptions
 
 
-class BaseParser(object):
+class BaseParser:
     media_type = None
     handles_file_uploads = False  # If set then 'request.files' will be populated.
-    handles_form_data = False     # If set then 'request.form' will be populated.
+    handles_form_data = False  # If set then 'request.form' will be populated.
 
     def parse(self, stream, media_type, **options):
         msg = '`parse()` method must be implemented for class "%s"'
@@ -19,46 +18,50 @@ def parse(self, stream, media_type, **options):
 
 
 class JSONParser(BaseParser):
-    media_type = 'application/json'
+    media_type = "application/json"
 
     def parse(self, stream, media_type, **options):
-        data = stream.read().decode('utf-8')
+        data = stream.read().decode("utf-8")
         try:
             return json.loads(data)
         except ValueError as exc:
-            msg = 'JSON parse error - %s' % text_type(exc)
+            msg = "JSON parse error - %s" % str(exc)
             raise exceptions.ParseError(msg)
 
 
 class MultiPartParser(BaseParser):
-    media_type = 'multipart/form-data'
+    media_type = "multipart/form-data"
     handles_file_uploads = True
     handles_form_data = True
 
     def parse(self, stream, media_type, **options):
-        boundary = media_type.params.get('boundary')
+        boundary = media_type.params.get("boundary")
         if boundary is None:
-            msg = 'Multipart message missing boundary in Content-Type header'
+            msg = "Multipart message missing boundary in Content-Type header"
             raise exceptions.ParseError(msg)
-        boundary = boundary.encode('ascii')
+        boundary = boundary.encode("ascii")
 
-        content_length = options.get('content_length')
-        assert content_length is not None, 'MultiPartParser.parse() requires `content_length` argument'
+        content_length = options.get("content_length")
+        assert (
+            content_length is not None
+        ), "MultiPartParser.parse() requires `content_length` argument"
 
         buffer_size = content_length
         while buffer_size % 4 or buffer_size < 1024:
             buffer_size += 1
-        multipart_parser = WerkzeugMultiPartParser(default_stream_factory, buffer_size=buffer_size)
+        multipart_parser = WerkzeugMultiPartParser(
+            default_stream_factory, buffer_size=buffer_size
+        )
 
         try:
             return multipart_parser.parse(stream, boundary, content_length)
         except ValueError as exc:
-            msg = 'Multipart parse error - %s' % text_type(exc)
+            msg = "Multipart parse error - %s" % str(exc)
             raise exceptions.ParseError(msg)
 
 
 class URLEncodedParser(BaseParser):
-    media_type = 'application/x-www-form-urlencoded'
+    media_type = "application/x-www-form-urlencoded"
     handles_form_data = True
 
     def parse(self, stream, media_type, **options):
diff --git a/flask_api/renderers.py b/flask_api/renderers.py
index f84b366..a9aed23 100644
--- a/flask_api/renderers.py
+++ b/flask_api/renderers.py
@@ -1,13 +1,12 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask import request, render_template, current_app
-from flask.globals import _request_ctx_stack
-from flask_api.mediatypes import MediaType
-from flask_api.compat import apply_markdown
-import json
 import pydoc
 import re
 
+from flask import current_app, render_template, request
+from flask.globals import _request_ctx_stack
+
+from flask_api.compat import apply_markdown
+from flask_api.mediatypes import MediaType
+
 
 def dedent(content):
     """
@@ -18,26 +17,29 @@ def dedent(content):
     as it fails to dedent multiline docstrings that include
     unindented text on the initial line.
     """
-    whitespace_counts = [len(line) - len(line.lstrip(' '))
-                         for line in content.splitlines()[1:] if line.lstrip()]
+    whitespace_counts = [
+        len(line) - len(line.lstrip(" "))
+        for line in content.splitlines()[1:]
+        if line.lstrip()
+    ]
 
     # unindent the content if needed
     if whitespace_counts:
-        whitespace_pattern = '^' + (' ' * min(whitespace_counts))
-        content = re.sub(re.compile(whitespace_pattern, re.MULTILINE), '', content)
+        whitespace_pattern = "^" + (" " * min(whitespace_counts))
+        content = re.sub(re.compile(whitespace_pattern, re.MULTILINE), "", content)
 
     return content.strip()
 
 
 def convert_to_title(name):
-    for char in ['-', '_', '.']:
-        name = name.replace(char, ' ')
+    for char in ["-", "_", "."]:
+        name = name.replace(char, " ")
     return name.capitalize()
 
 
-class BaseRenderer(object):
+class BaseRenderer:
     media_type = None
-    charset = 'utf-8'
+    charset = "utf-8"
     handles_empty_responses = False
 
     def render(self, data, media_type, **options):
@@ -46,44 +48,47 @@ def render(self, data, media_type, **options):
 
 
 class JSONRenderer(BaseRenderer):
-    media_type = 'application/json'
+    media_type = "application/json"
     charset = None
 
     def render(self, data, media_type, **options):
         # Requested indentation may be set in the Accept header.
         try:
-            indent = max(min(int(media_type.params['indent']), 8), 0)
+            indent = max(min(int(media_type.params["indent"]), 8), 0)
         except (KeyError, ValueError, TypeError):
             indent = None
         # Indent may be set explicitly, eg when rendered by the browsable API.
-        indent = options.get('indent', indent)
-        return json.dumps(data, cls=current_app.json_encoder, ensure_ascii=False, indent=indent)
+        indent = options.get("indent", indent)
+        return current_app.json.dumps(
+            data, ensure_ascii=False, indent=indent
+        )
 
 
-class HTMLRenderer(object):
-    media_type = 'text/html'
-    charset = 'utf-8'
+class HTMLRenderer:
+    media_type = "text/html"
+    charset = "utf-8"
 
     def render(self, data, media_type, **options):
         return data.encode(self.charset)
 
 
 class BrowsableAPIRenderer(BaseRenderer):
-    media_type = 'text/html'
+    media_type = "text/html"
     handles_empty_responses = True
-    template = 'base.html'
+    template = "base.html"
 
     def render(self, data, media_type, **options):
         # Render the content as it would have been if the client
         # had requested 'Accept: */*'.
         available_renderers = [
-            renderer for renderer in request.renderer_classes
+            renderer
+            for renderer in request.renderer_classes
             if not issubclass(renderer, BrowsableAPIRenderer)
         ]
-        assert available_renderers, 'BrowsableAPIRenderer cannot be the only renderer'
+        assert available_renderers, "BrowsableAPIRenderer cannot be the only renderer"
         mock_renderer = available_renderers[0]()
         mock_media_type = MediaType(mock_renderer.media_type)
-        if data == '' and not mock_renderer.handles_empty_responses:
+        if data == "" and not mock_renderer.handles_empty_responses:
             mock_content = None
         else:
             text = mock_renderer.render(data, mock_media_type, indent=4)
@@ -104,30 +109,26 @@ def render(self, data, media_type, **options):
                 view_description = dedent(view_description)
                 view_description = pydoc.html.preformat(view_description)
 
-        status = options['status']
-        headers = options['headers']
-        headers['Content-Type'] = str(mock_media_type)
+        status = options["status"]
+        headers = options["headers"]
+        headers["Content-Type"] = str(mock_media_type)
 
         from flask_api import __version__
 
         context = {
-            'status': status,
-            'headers': headers,
-            'content': mock_content,
-            'allowed_methods': allowed_methods,
-            'view_name': convert_to_title(view_name),
-            'view_description': view_description,
-            'version': __version__
+            "status": status,
+            "headers": headers,
+            "content": mock_content,
+            "allowed_methods": allowed_methods,
+            "view_name": convert_to_title(view_name),
+            "view_description": view_description,
+            "version": __version__,
         }
         return render_template(self.template, **context)
 
     @staticmethod
     def _html_escape(text):
-        escape_table = [
-            ("&", "&amp;"),
-            ("<", "&lt;"),
-            (">", "&gt;")
-        ]
+        escape_table = [("&", "&amp;"), ("<", "&lt;"), (">", "&gt;")]
 
         for char, replacement in escape_table:
             text = text.replace(char, replacement)
diff --git a/flask_api/request.py b/flask_api/request.py
index aee96ce..33c3eaa 100644
--- a/flask_api/request.py
+++ b/flask_api/request.py
@@ -1,13 +1,12 @@
-# coding: utf8
-from __future__ import unicode_literals
+import io
+
 from flask import Request
-from flask_api.negotiation import DefaultNegotiation
-from flask_api.settings import default_settings
 from werkzeug.datastructures import MultiDict
 from werkzeug.urls import url_decode_stream
 from werkzeug.wsgi import get_content_length
-from werkzeug._compat import to_unicode
-import io
+
+from flask_api.negotiation import DefaultNegotiation
+from flask_api.settings import default_settings
 
 
 class APIRequest(Request):
@@ -20,25 +19,25 @@ class APIRequest(Request):
 
     @property
     def data(self):
-        if not hasattr(self, '_data'):
+        if not hasattr(self, "_data"):
             self._parse()
         return self._data
 
     @property
     def form(self):
-        if not hasattr(self, '_form'):
+        if not hasattr(self, "_form"):
             self._parse()
         return self._form
 
     @property
     def files(self):
-        if not hasattr(self, '_files'):
+        if not hasattr(self, "_files"):
             self._parse()
         return self._files
 
     def _parse(self):
         """
-        Parse the body of the request, using whichever parser satifies the
+        Parse the body of the request, using whichever parser satisfies the
         client 'Content-Type' header.
         """
         if not self.content_type or not self.content_length:
@@ -51,14 +50,16 @@ def _parse(self):
         try:
             parser, media_type = negotiator.select_parser(parsers)
             ret = parser.parse(self.stream, media_type, **options)
-        except:
+        except Exception as e:
             # Ensure that accessing `request.data` again does not reraise
             # the exception, so that eg exceptions can handle properly.
             self._set_empty_data()
-            raise
+            raise e from None
 
         if parser.handles_file_uploads:
-            assert isinstance(ret, tuple) and len(ret) == 2, 'Expected a two-tuple of (data, files)'
+            assert (
+                isinstance(ret, tuple) and len(ret) == 2
+            ), "Expected a two-tuple of (data, files)"
             self._data, self._files = ret
         else:
             self._data = ret
@@ -70,7 +71,7 @@ def _get_parser_options(self):
         """
         Any additional information to pass to the parser.
         """
-        return {'content_length': self.content_length}
+        return {"content_length": self.content_length}
 
     def _set_empty_data(self):
         """
@@ -84,13 +85,13 @@ def _set_empty_data(self):
 
     @property
     def accepted_renderer(self):
-        if not hasattr(self, '_accepted_renderer'):
+        if not hasattr(self, "_accepted_renderer"):
             self._perform_content_negotiation()
         return self._accepted_renderer
 
     @property
     def accepted_media_type(self):
-        if not hasattr(self, '_accepted_media_type'):
+        if not hasattr(self, "_accepted_media_type"):
             self._perform_content_negotiation()
         return self._accepted_media_type
 
@@ -101,31 +102,37 @@ def _perform_content_negotiation(self):
         """
         negotiator = self.negotiator_class()
         renderers = [renderer() for renderer in self.renderer_classes]
-        self._accepted_renderer, self._accepted_media_type = negotiator.select_renderer(renderers)
+        self._accepted_renderer, self._accepted_media_type = negotiator.select_renderer(
+            renderers
+        )
 
     # Method and content type overloading.
 
     @property
     def method(self):
-        if not hasattr(self, '_method'):
+        if not hasattr(self, "_method"):
             self._perform_method_overloading()
         return self._method
 
+    @method.setter
+    def method(self, value):
+        self._method = value
+
     @property
     def content_type(self):
-        if not hasattr(self, '_content_type'):
+        if not hasattr(self, "_content_type"):
             self._perform_method_overloading()
         return self._content_type
 
     @property
     def content_length(self):
-        if not hasattr(self, '_content_length'):
+        if not hasattr(self, "_content_length"):
             self._perform_method_overloading()
         return self._content_length
 
     @property
     def stream(self):
-        if not hasattr(self, '_stream'):
+        if not hasattr(self, "_stream"):
             self._perform_method_overloading()
         return self._stream
 
@@ -134,29 +141,33 @@ def _perform_method_overloading(self):
         Perform method and content type overloading.
 
         Provides support for browser PUT, PATCH, DELETE & other requests,
-        by specifing a '_method' form field.
+        by specifying a '_method' form field.
 
         Also provides support for browser non-form requests (eg JSON),
-        by specifing '_content' and '_content_type' form fields.
+        by specifying '_content' and '_content_type' form fields.
         """
-        self._method = super(APIRequest, self).method
-        self._stream = super(APIRequest, self).stream
-        self._content_type = self.headers.get('Content-Type')
+        if not hasattr(self, "_method"):
+            self.method = super().method
+        self._stream = super().stream
+        self._content_type = self.headers.get("Content-Type")
         self._content_length = get_content_length(self.environ)
 
-        if (self._method == 'POST' and self._content_type == 'application/x-www-form-urlencoded'):
+        if (
+            self._method == "POST"
+            and self._content_type == "application/x-www-form-urlencoded"
+        ):
             # Read the request data, then push it back onto the stream again.
             body = self.get_data()
             data = url_decode_stream(io.BytesIO(body))
             self._stream = io.BytesIO(body)
-            if '_method' in data:
+            if "_method" in data:
                 # Support browser forms with PUT, PATCH, DELETE & other methods.
-                self._method = data['_method']
-            if '_content' in data and '_content_type' in data:
+                self._method = data["_method"]
+            if "_content" in data and "_content_type" in data:
                 # Support browser forms with non-form data, such as JSON.
-                body = data['_content'].encode('utf8')
+                body = data["_content"].encode("utf8")
                 self._stream = io.BytesIO(body)
-                self._content_type = data['_content_type']
+                self._content_type = data["_content_type"]
                 self._content_length = len(body)
 
     # Misc...
@@ -169,7 +180,7 @@ def full_path(self):
         """
         if not self.query_string:
             return self.path
-        return self.path + u'?' + to_unicode(self.query_string, self.url_charset)
+        return self.path + "?" + self.query_string.decode()
 
     # @property
     # def auth(self):
diff --git a/flask_api/response.py b/flask_api/response.py
index 3551158..701c299 100644
--- a/flask_api/response.py
+++ b/flask_api/response.py
@@ -1,7 +1,4 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask import request, Response
-from flask._compat import text_type
+from flask import Response, request
 
 
 class APIResponse(Response):
@@ -9,12 +6,12 @@ class APIResponse(Response):
     api_return_types = (list, dict)
 
     def __init__(self, content=None, *args, **kwargs):
-        super(APIResponse, self).__init__(None, *args, **kwargs)
+        super().__init__(None, *args, **kwargs)
 
         media_type = None
-        if isinstance(content, self.api_return_types) or content == '':
+        if isinstance(content, self.api_return_types) or content == "":
             renderer = request.accepted_renderer
-            if content != '' or renderer.handles_empty_responses:
+            if content != "" or renderer.handles_empty_responses:
                 media_type = request.accepted_media_type
                 options = self.get_renderer_options()
                 content = renderer.render(content, media_type, **options)
@@ -24,17 +21,17 @@ def __init__(self, content=None, *args, **kwargs):
         # From `werkzeug.wrappers.BaseResponse`
         if content is None:
             content = []
-        if isinstance(content, (text_type, bytes, bytearray)):
+        if isinstance(content, (str, bytes, bytearray)):
             self.set_data(content)
         else:
             self.response = content
 
         if media_type is not None:
-            self.headers['Content-Type'] = str(media_type)
+            self.headers["Content-Type"] = str(media_type)
 
     def get_renderer_options(self):
         return {
-            'status': self.status,
-            'status_code': self.status_code,
-            'headers': self.headers
+            "status": self.status,
+            "status_code": self.status_code,
+            "headers": self.headers,
         }
diff --git a/flask_api/settings.py b/flask_api/settings.py
index b48044e..58f02d4 100644
--- a/flask_api/settings.py
+++ b/flask_api/settings.py
@@ -1,4 +1,3 @@
-from flask._compat import string_types
 import importlib
 
 
@@ -7,7 +6,7 @@ def perform_imports(val, setting_name):
     If the given setting is a string import notation,
     then perform the necessary import or imports.
     """
-    if isinstance(val, string_types):
+    if isinstance(val, str):
         return import_from_string(val, setting_name)
     elif isinstance(val, (list, tuple)):
         return [perform_imports(item, setting_name) for item in val]
@@ -20,8 +19,8 @@ def import_from_string(val, setting_name):
     """
     try:
         # Nod to tastypie's use of importlib.
-        parts = val.split('.')
-        module_path, class_name = '.'.join(parts[:-1]), parts[-1]
+        parts = val.split(".")
+        module_path, class_name = ".".join(parts[:-1]), parts[-1]
         module = importlib.import_module(module_path)
         return getattr(module, class_name)
     except ImportError as exc:
@@ -30,28 +29,28 @@ def import_from_string(val, setting_name):
         raise ImportError(msg)
 
 
-class APISettings(object):
+class APISettings:
     def __init__(self, user_config=None):
         self.user_config = user_config or {}
 
     @property
     def DEFAULT_PARSERS(self):
         default = [
-            'flask_api.parsers.JSONParser',
-            'flask_api.parsers.URLEncodedParser',
-            'flask_api.parsers.MultiPartParser'
+            "flask_api.parsers.JSONParser",
+            "flask_api.parsers.URLEncodedParser",
+            "flask_api.parsers.MultiPartParser",
         ]
-        val = self.user_config.get('DEFAULT_PARSERS', default)
-        return perform_imports(val, 'DEFAULT_PARSERS')
+        val = self.user_config.get("DEFAULT_PARSERS", default)
+        return perform_imports(val, "DEFAULT_PARSERS")
 
     @property
     def DEFAULT_RENDERERS(self):
         default = [
-            'flask_api.renderers.JSONRenderer',
-            'flask_api.renderers.BrowsableAPIRenderer'
+            "flask_api.renderers.JSONRenderer",
+            "flask_api.renderers.BrowsableAPIRenderer",
         ]
-        val = self.user_config.get('DEFAULT_RENDERERS', default)
-        return perform_imports(val, 'DEFAULT_RENDERERS')
+        val = self.user_config.get("DEFAULT_RENDERERS", default)
+        return perform_imports(val, "DEFAULT_RENDERERS")
 
 
 default_settings = APISettings()
diff --git a/flask_api/status.py b/flask_api/status.py
index 4163c7b..ffb78a0 100644
--- a/flask_api/status.py
+++ b/flask_api/status.py
@@ -1,4 +1,3 @@
-# coding: utf8
 """
 Descriptive HTTP status codes, for code readability.
 
@@ -7,7 +6,6 @@
 RFC 2616: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
 RFC 6585: http://tools.ietf.org/html/rfc6585
 """
-from __future__ import unicode_literals
 
 
 def is_informational(code):
@@ -67,6 +65,7 @@ def is_server_error(code):
 HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
 HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
 HTTP_417_EXPECTATION_FAILED = 417
+HTTP_418_IM_A_TEAPOT = 418
 HTTP_428_PRECONDITION_REQUIRED = 428
 HTTP_429_TOO_MANY_REQUESTS = 429
 HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
diff --git a/flask_api/templates/base.html b/flask_api/templates/base.html
index c80d7fc..0603943 100644
--- a/flask_api/templates/base.html
+++ b/flask_api/templates/base.html
@@ -31,7 +31,7 @@
         <div class="navbar-inner">
             <div class="container-fluid">
                 <span href="/">
-                    {% block branding %}<a class='brand' rel="nofollow" href='http://www.flaskapi.org'>Flask API <span class="version">{{ version }}</span></a>{% endblock %}
+                    {% block branding %}<a class='brand' rel="nofollow" href='https://flask-api.github.io/flask-api/'>Flask API <span class="version">{{ version }}</span></a>{% endblock %}
                 </span>
                 <ul class="nav pull-right">
                     {% block userlinks %}
diff --git a/flask_api/tests/__init__.py b/flask_api/tests/__init__.py
index 16a018b..ec9ff18 100644
--- a/flask_api/tests/__init__.py
+++ b/flask_api/tests/__init__.py
@@ -1,12 +1,14 @@
 # This is a fudge that allows us to easily specify test modules.
 # For example:
 # ./runtests test_parsers
-# ./runtests test_rendereres.RendererTests.test_render_json
+# ./runtests test_renderers.RendererTests.test_render_json
 import os
 
-modules = [filename.rsplit('.', 1)[0]
-            for filename in os.listdir(os.path.dirname(__file__))
-            if filename.endswith('.py') and filename.startswith('test_')]
+modules = [
+    filename.rsplit(".", 1)[0]
+    for filename in os.listdir(os.path.dirname(__file__))
+    if filename.endswith(".py") and filename.startswith("test_")
+]
 
 for module in modules:
     exec("from flask_api.tests.%s import *" % module)
diff --git a/flask_api/tests/test_app.py b/flask_api/tests/test_app.py
index 5c4bebd..47e167c 100644
--- a/flask_api/tests/test_app.py
+++ b/flask_api/tests/test_app.py
@@ -1,14 +1,13 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask import abort, make_response, request, jsonify
-from flask_api.decorators import set_renderers
-from flask_api import exceptions, renderers, status, FlaskAPI
 import json
 import unittest
 
+from flask import abort, jsonify, make_response, request
+
+from flask_api import FlaskAPI, exceptions, renderers, status
+from flask_api.decorators import set_renderers
 
 app = FlaskAPI(__name__)
-app.config['TESTING'] = True
+app.config["TESTING"] = True
 
 
 class JSONVersion1(renderers.JSONRenderer):
@@ -32,7 +31,7 @@ def __init__(self, message, status_code=None, payload=None):
 
     def to_dict(self):
         rv = dict(self.payload or ())
-        rv['message'] = self.message
+        rv["message"] = self.message
         return rv
 
 
@@ -43,149 +42,151 @@ def handle_invalid_usage(error):
     return response
 
 
-@app.route('/set_status_and_headers/')
+@app.route("/set_status_and_headers/")
 def set_status_and_headers():
-    headers = {'Location': 'http://example.com/456'}
-    return {'example': 'content'}, status.HTTP_201_CREATED, headers
+    headers = {"Location": "http://example.com/456"}
+    return {"example": "content"}, status.HTTP_201_CREATED, headers
 
 
-@app.route('/set_headers/')
+@app.route("/set_headers/")
 def set_headers():
-    headers = {'Location': 'http://example.com/456'}
-    return {'example': 'content'}, headers
+    headers = {"Location": "http://example.com/456"}
+    return {"example": "content"}, headers
 
 
-@app.route('/make_response_view/')
+@app.route("/make_response_view/")
 def make_response_view():
-    response = make_response({'example': 'content'})
-    response.headers['Location'] = 'http://example.com/456'
+    response = make_response({"example": "content"})
+    response.headers["Location"] = "http://example.com/456"
     return response
 
 
-@app.route('/none_204_response/')
+@app.route("/none_204_response/")
 def none_204_response():
     return None, status.HTTP_204_NO_CONTENT
 
 
-@app.route('/none_200_response/')
+@app.route("/none_200_response/")
 def none_200_response():
     return None, status.HTTP_200_OK
 
 
-@app.route('/api_exception/')
+@app.route("/api_exception/")
 def api_exception():
     raise exceptions.PermissionDenied()
 
 
-@app.route('/custom_exception/')
+@app.route("/custom_exception/")
 def custom_exception():
-    raise InvalidUsage('Invalid usage test.', status_code=410)
+    raise InvalidUsage("Invalid usage test.", status_code=410)
 
 
-@app.route('/custom_exception_no_code/')
+@app.route("/custom_exception_no_code/")
 def custom_exception_no_status_code():
-    raise InvalidUsage('Invalid usage test.')
+    raise InvalidUsage("Invalid usage test.")
 
 
-@app.route('/abort_view/')
+@app.route("/abort_view/")
 def abort_view():
     abort(status.HTTP_403_FORBIDDEN)
 
 
-@app.route('/options/')
+@app.route("/options/")
 def options_view():
     return {}
 
 
-@app.route('/accepted_media_type/')
+@app.route("/accepted_media_type/")
 @set_renderers([JSONVersion2, JSONVersion1])
 def accepted_media_type():
-    return {'accepted_media_type': str(request.accepted_media_type)}
+    return {"accepted_media_type": str(request.accepted_media_type)}
 
 
 class AppTests(unittest.TestCase):
     def test_set_status_and_headers(self):
         with app.test_client() as client:
-            response = client.get('/set_status_and_headers/')
+            response = client.get("/set_status_and_headers/")
             self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-            self.assertEqual(response.headers['Location'], 'http://example.com/456')
-            self.assertEqual(response.content_type, 'application/json')
+            self.assertEqual(response.headers["Location"], "http://example.com/456")
+            self.assertEqual(response.content_type, "application/json")
             expected = '{"example": "content"}'
-            self.assertEqual(response.get_data().decode('utf8'), expected)
+            self.assertEqual(response.get_data().decode("utf8"), expected)
 
     def test_set_headers(self):
         with app.test_client() as client:
-            response = client.get('/set_headers/')
+            response = client.get("/set_headers/")
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Location'], 'http://example.com/456')
-            self.assertEqual(response.content_type, 'application/json')
+            self.assertEqual(response.headers["Location"], "http://example.com/456")
+            self.assertEqual(response.content_type, "application/json")
             expected = '{"example": "content"}'
-            self.assertEqual(response.get_data().decode('utf8'), expected)
+            self.assertEqual(response.get_data().decode("utf8"), expected)
 
     def test_make_response(self):
         with app.test_client() as client:
-            response = client.get('/make_response_view/')
-            self.assertEqual(response.content_type, 'application/json')
-            self.assertEqual(response.headers['Location'], 'http://example.com/456')
-            self.assertEqual(response.content_type, 'application/json')
+            response = client.get("/make_response_view/")
+            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual(response.headers["Location"], "http://example.com/456")
+            self.assertEqual(response.content_type, "application/json")
             expected = '{"example": "content"}'
-            self.assertEqual(response.get_data().decode('utf8'), expected)
+            self.assertEqual(response.get_data().decode("utf8"), expected)
 
     def test_none_204_response(self):
         with app.test_client() as client:
-            response = client.get('/none_204_response/')
+            response = client.get("/none_204_response/")
             self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-            expected = ''
-            self.assertEqual(response.get_data().decode('utf8'), expected)
+            expected = ""
+            self.assertEqual(response.get_data().decode("utf8"), expected)
 
     def test_none_200_response(self):
         with app.test_client() as client:
             with self.assertRaises(ValueError):
-                client.get('/none_200_response/')
+                client.get("/none_200_response/")
 
     def test_api_exception(self):
         with app.test_client() as client:
-            response = client.get('/api_exception/')
+            response = client.get("/api_exception/")
             self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-            self.assertEqual(response.content_type, 'application/json')
-            expected = '{"message": "You do not have permission to perform this action."}'
-            self.assertEqual(response.get_data().decode('utf8'), expected)
+            self.assertEqual(response.content_type, "application/json")
+            expected = (
+                '{"message": "You do not have permission to perform this action."}'
+            )
+            self.assertEqual(response.get_data().decode("utf8"), expected)
 
     def test_custom_exception(self):
         with app.test_client() as client:
-            response = client.get('/custom_exception/')
+            response = client.get("/custom_exception/")
             self.assertEqual(response.status_code, status.HTTP_410_GONE)
-            self.assertEqual(response.content_type, 'application/json')
+            self.assertEqual(response.content_type, "application/json")
 
     def test_custom_exception_default_code(self):
         with app.test_client() as client:
-            response = client.get('/custom_exception_no_code/')
+            response = client.get("/custom_exception_no_code/")
             self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-            self.assertEqual(response.content_type, 'application/json')
+            self.assertEqual(response.content_type, "application/json")
 
     def test_abort_view(self):
         with app.test_client() as client:
-            response = client.get('/abort_view/')
+            response = client.get("/abort_view/")
             self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
     def test_options_view(self):
         with app.test_client() as client:
-            response = client.options('/options/')
+            response = client.options("/options/")
         # Errors if `response.response` is `None`
         response.get_data()
 
     def test_accepted_media_type_property(self):
         with app.test_client() as client:
             # Explicitly request the "api-version 1.0" renderer.
-            headers = {'Accept': 'application/json; api-version="1.0"'}
-            response = client.get('/accepted_media_type/', headers=headers)
-            data = json.loads(response.get_data().decode('utf8'))
-            expected = {'accepted_media_type': 'application/json; api-version="1.0"'}
+            headers = {"Accept": 'application/json; api-version="1.0"'}
+            response = client.get("/accepted_media_type/", headers=headers)
+            data = json.loads(response.get_data().decode("utf8"))
+            expected = {"accepted_media_type": 'application/json; api-version="1.0"'}
             self.assertEqual(data, expected)
 
             # Request the default renderer, which is "api-version 2.0".
-            headers = {'Accept': '*/*'}
-            response = client.get('/accepted_media_type/', headers=headers)
-            data = json.loads(response.get_data().decode('utf8'))
-            expected = {'accepted_media_type': 'application/json; api-version="2.0"'}
+            headers = {"Accept": "*/*"}
+            response = client.get("/accepted_media_type/", headers=headers)
+            data = json.loads(response.get_data().decode("utf8"))
+            expected = {"accepted_media_type": 'application/json; api-version="2.0"'}
             self.assertEqual(data, expected)
diff --git a/flask_api/tests/test_exceptions.py b/flask_api/tests/test_exceptions.py
index d334718..ad04c5c 100644
--- a/flask_api/tests/test_exceptions.py
+++ b/flask_api/tests/test_exceptions.py
@@ -1,13 +1,11 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask_api import exceptions
-from flask_api import status
 import unittest
 
+from flask_api import exceptions, status
+
 
 class Conflict(exceptions.APIException):
     status_code = status.HTTP_409_CONFLICT
-    detail = 'Could not update the resource'
+    detail = "Could not update the resource"
 
 
 class TestExceptions(unittest.TestCase):
@@ -15,12 +13,12 @@ def test_custom_exception(self):
         try:
             raise Conflict()
         except Conflict as exc:
-            self.assertEqual(str(exc), 'Could not update the resource')
+            self.assertEqual(str(exc), "Could not update the resource")
             self.assertEqual(exc.status_code, 409)
 
     def test_override_exception_detail(self):
         try:
-            raise Conflict('A widget with this id already exists')
+            raise Conflict("A widget with this id already exists")
         except Conflict as exc:
-            self.assertEqual(str(exc), 'A widget with this id already exists')
+            self.assertEqual(str(exc), "A widget with this id already exists")
             self.assertEqual(exc.status_code, 409)
diff --git a/flask_api/tests/test_mediatypes.py b/flask_api/tests/test_mediatypes.py
index c66fafb..f40c79a 100644
--- a/flask_api/tests/test_mediatypes.py
+++ b/flask_api/tests/test_mediatypes.py
@@ -1,106 +1,106 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask_api.mediatypes import MediaType, parse_accept_header
 import unittest
 
+from flask_api.mediatypes import MediaType, parse_accept_header
+
 
 class MediaTypeParsingTests(unittest.TestCase):
     def test_media_type_with_params(self):
-        media = MediaType('application/xml; schema=foobar, q=0.5')
+        media = MediaType("application/xml; schema=foobar, q=0.5")
         self.assertEqual(str(media), 'application/xml; q="0.5", schema="foobar"')
-        self.assertEqual(media.main_type, 'application')
-        self.assertEqual(media.sub_type, 'xml')
-        self.assertEqual(media.full_type, 'application/xml')
-        self.assertEqual(media.params, {'schema': 'foobar', 'q': '0.5'})
+        self.assertEqual(media.main_type, "application")
+        self.assertEqual(media.sub_type, "xml")
+        self.assertEqual(media.full_type, "application/xml")
+        self.assertEqual(media.params, {"schema": "foobar", "q": "0.5"})
         self.assertEqual(media.precedence, 3)
-        self.assertEqual(repr(media), '<MediaType \'application/xml; q="0.5", schema="foobar"\'>')
+        self.assertEqual(
+            repr(media), '<MediaType \'application/xml; q="0.5", schema="foobar"\'>'
+        )
 
     def test_media_type_with_q_params(self):
-        media = MediaType('application/xml; q=0.5')
+        media = MediaType("application/xml; q=0.5")
         self.assertEqual(str(media), 'application/xml; q="0.5"')
-        self.assertEqual(media.main_type, 'application')
-        self.assertEqual(media.sub_type, 'xml')
-        self.assertEqual(media.full_type, 'application/xml')
-        self.assertEqual(media.params, {'q': '0.5'})
+        self.assertEqual(media.main_type, "application")
+        self.assertEqual(media.sub_type, "xml")
+        self.assertEqual(media.full_type, "application/xml")
+        self.assertEqual(media.params, {"q": "0.5"})
         self.assertEqual(media.precedence, 2)
 
     def test_media_type_without_params(self):
-        media = MediaType('application/xml')
-        self.assertEqual(str(media), 'application/xml')
-        self.assertEqual(media.main_type, 'application')
-        self.assertEqual(media.sub_type, 'xml')
-        self.assertEqual(media.full_type, 'application/xml')
+        media = MediaType("application/xml")
+        self.assertEqual(str(media), "application/xml")
+        self.assertEqual(media.main_type, "application")
+        self.assertEqual(media.sub_type, "xml")
+        self.assertEqual(media.full_type, "application/xml")
         self.assertEqual(media.params, {})
         self.assertEqual(media.precedence, 2)
 
     def test_media_type_with_wildcard_sub_type(self):
-        media = MediaType('application/*')
-        self.assertEqual(str(media), 'application/*')
-        self.assertEqual(media.main_type, 'application')
-        self.assertEqual(media.sub_type, '*')
-        self.assertEqual(media.full_type, 'application/*')
+        media = MediaType("application/*")
+        self.assertEqual(str(media), "application/*")
+        self.assertEqual(media.main_type, "application")
+        self.assertEqual(media.sub_type, "*")
+        self.assertEqual(media.full_type, "application/*")
         self.assertEqual(media.params, {})
         self.assertEqual(media.precedence, 1)
 
     def test_media_type_with_wildcard_main_type(self):
-        media = MediaType('*/*')
-        self.assertEqual(str(media), '*/*')
-        self.assertEqual(media.main_type, '*')
-        self.assertEqual(media.sub_type, '*')
-        self.assertEqual(media.full_type, '*/*')
+        media = MediaType("*/*")
+        self.assertEqual(str(media), "*/*")
+        self.assertEqual(media.main_type, "*")
+        self.assertEqual(media.sub_type, "*")
+        self.assertEqual(media.full_type, "*/*")
         self.assertEqual(media.params, {})
         self.assertEqual(media.precedence, 0)
 
 
 class MediaTypeMatchingTests(unittest.TestCase):
     def test_media_type_includes_params(self):
-        media_type = MediaType('application/json')
-        other = MediaType('application/json; version=1.0')
+        media_type = MediaType("application/json")
+        other = MediaType("application/json; version=1.0")
         self.assertTrue(media_type.satisfies(other))
 
     def test_media_type_missing_params(self):
-        media_type = MediaType('application/json; version=1.0')
-        other = MediaType('application/json')
+        media_type = MediaType("application/json; version=1.0")
+        other = MediaType("application/json")
         self.assertFalse(media_type.satisfies(other))
 
     def test_media_type_matching_params(self):
-        media_type = MediaType('application/json; version=1.0')
-        other = MediaType('application/json; version=1.0')
+        media_type = MediaType("application/json; version=1.0")
+        other = MediaType("application/json; version=1.0")
         self.assertTrue(media_type.satisfies(other))
 
     def test_media_type_non_matching_params(self):
-        media_type = MediaType('application/json; version=1.0')
-        other = MediaType('application/json; version=2.0')
+        media_type = MediaType("application/json; version=1.0")
+        other = MediaType("application/json; version=2.0")
         self.assertFalse(media_type.satisfies(other))
 
     def test_media_type_main_type_match(self):
-        media_type = MediaType('image/*')
-        other = MediaType('image/png')
+        media_type = MediaType("image/*")
+        other = MediaType("image/png")
         self.assertTrue(media_type.satisfies(other))
 
     def test_media_type_sub_type_mismatch(self):
-        media_type = MediaType('image/jpeg')
-        other = MediaType('image/png')
+        media_type = MediaType("image/jpeg")
+        other = MediaType("image/png")
         self.assertFalse(media_type.satisfies(other))
 
     def test_media_type_wildcard_match(self):
-        media_type = MediaType('*/*')
-        other = MediaType('image/png')
+        media_type = MediaType("*/*")
+        other = MediaType("image/png")
         self.assertTrue(media_type.satisfies(other))
 
     def test_media_type_wildcard_mismatch(self):
-        media_type = MediaType('image/*')
-        other = MediaType('audio/*')
+        media_type = MediaType("image/*")
+        other = MediaType("audio/*")
         self.assertFalse(media_type.satisfies(other))
 
 
 class AcceptHeaderTests(unittest.TestCase):
     def test_parse_simple_accept_header(self):
-        parsed = parse_accept_header('*/*, application/json')
-        self.assertEqual(parsed, [
-            set([MediaType('application/json')]),
-            set([MediaType('*/*')])
-        ])
+        parsed = parse_accept_header("*/*, application/json")
+        self.assertEqual(
+            parsed, [set([MediaType("application/json")]), set([MediaType("*/*")])]
+        )
 
     def test_parse_complex_accept_header(self):
         """
@@ -110,10 +110,17 @@ def test_parse_complex_accept_header(self):
         Note that we disregard 'q' values when determining precedence, and
         instead differentiate equal values by using the server preference.
         """
-        header = 'application/xml; schema=foo, application/json; q=0.9, application/xml, */*'
+        header = (
+            "application/xml; schema=foo, application/json; q=0.9, application/xml, */*"
+        )
         parsed = parse_accept_header(header)
-        self.assertEqual(parsed, [
-            set([MediaType('application/xml; schema=foo')]),
-            set([MediaType('application/json; q=0.9'), MediaType('application/xml')]),
-            set([MediaType('*/*')]),
-        ])
+        self.assertEqual(
+            parsed,
+            [
+                set([MediaType("application/xml; schema=foo")]),
+                set(
+                    [MediaType("application/json; q=0.9"), MediaType("application/xml")]
+                ),
+                set([MediaType("*/*")]),
+            ],
+        )
diff --git a/flask_api/tests/test_negotiation.py b/flask_api/tests/test_negotiation.py
index aec99a6..832fc87 100644
--- a/flask_api/tests/test_negotiation.py
+++ b/flask_api/tests/test_negotiation.py
@@ -1,35 +1,33 @@
-# coding: utf8
-from __future__ import unicode_literals
 import unittest
+
 import flask_api
 from flask_api import exceptions
 from flask_api.negotiation import BaseNegotiation, DefaultNegotiation
 
-
 app = flask_api.FlaskAPI(__name__)
 
 
-class JSON(object):
-    media_type = 'application/json'
+class JSON:
+    media_type = "application/json"
 
 
-class HTML(object):
-    media_type = 'application/html'
+class HTML:
+    media_type = "application/html"
 
 
-class URLEncodedForm(object):
-    media_type = 'application/x-www-form-urlencoded'
+class URLEncodedForm:
+    media_type = "application/x-www-form-urlencoded"
 
 
 class TestRendererNegotiation(unittest.TestCase):
     def test_select_renderer_client_preference(self):
         negotiation = DefaultNegotiation()
         renderers = [JSON, HTML]
-        headers = {'Accept': 'application/html'}
+        headers = {"Accept": "application/html"}
         with app.test_request_context(headers=headers):
             renderer, media_type = negotiation.select_renderer(renderers)
             self.assertEqual(renderer, HTML)
-            self.assertEqual(str(media_type), 'application/html')
+            self.assertEqual(str(media_type), "application/html")
 
     def test_select_renderer_no_accept_header(self):
         negotiation = DefaultNegotiation()
@@ -37,21 +35,21 @@ def test_select_renderer_no_accept_header(self):
         with app.test_request_context():
             renderer, media_type = negotiation.select_renderer(renderers)
             self.assertEqual(renderer, JSON)
-            self.assertEqual(str(media_type), 'application/json')
+            self.assertEqual(str(media_type), "application/json")
 
     def test_select_renderer_server_preference(self):
         negotiation = DefaultNegotiation()
         renderers = [JSON, HTML]
-        headers = {'Accept': '*/*'}
+        headers = {"Accept": "*/*"}
         with app.test_request_context(headers=headers):
             renderer, media_type = negotiation.select_renderer(renderers)
             self.assertEqual(renderer, JSON)
-            self.assertEqual(str(media_type), 'application/json')
+            self.assertEqual(str(media_type), "application/json")
 
     def test_select_renderer_failed(self):
         negotiation = DefaultNegotiation()
         renderers = [JSON, HTML]
-        headers = {'Accept': 'application/xml'}
+        headers = {"Accept": "application/xml"}
         with app.test_request_context(headers=headers):
             with self.assertRaises(exceptions.NotAcceptable):
                 renderer, media_type = negotiation.select_renderer(renderers)
@@ -61,7 +59,9 @@ def test_renderer_negotiation_not_implemented(self):
         with self.assertRaises(NotImplementedError) as context:
             negotiation.select_renderer([])
         msg = str(context.exception)
-        expected = '`select_renderer()` method must be implemented for class "BaseNegotiation"'
+        expected = (
+            '`select_renderer()` method must be implemented for class "BaseNegotiation"'
+        )
         self.assertEqual(msg, expected)
 
 
@@ -69,16 +69,16 @@ class TestParserNegotiation(unittest.TestCase):
     def test_select_parser(self):
         negotiation = DefaultNegotiation()
         parsers = [JSON, URLEncodedForm]
-        headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
         with app.test_request_context(headers=headers):
             renderer, media_type = negotiation.select_parser(parsers)
             self.assertEqual(renderer, URLEncodedForm)
-            self.assertEqual(str(media_type), 'application/x-www-form-urlencoded')
+            self.assertEqual(str(media_type), "application/x-www-form-urlencoded")
 
     def test_select_parser_failed(self):
         negotiation = DefaultNegotiation()
         parsers = [JSON, URLEncodedForm]
-        headers = {'Content-Type': 'application/xml'}
+        headers = {"Content-Type": "application/xml"}
         with app.test_request_context(headers=headers):
             with self.assertRaises(exceptions.UnsupportedMediaType):
                 renderer, media_type = negotiation.select_parser(parsers)
@@ -88,5 +88,7 @@ def test_parser_negotiation_not_implemented(self):
         with self.assertRaises(NotImplementedError) as context:
             negotiation.select_parser([])
         msg = str(context.exception)
-        expected = '`select_parser()` method must be implemented for class "BaseNegotiation"'
+        expected = (
+            '`select_parser()` method must be implemented for class "BaseNegotiation"'
+        )
         self.assertEqual(msg, expected)
diff --git a/flask_api/tests/test_parsers.py b/flask_api/tests/test_parsers.py
index 90a6b83..85307aa 100644
--- a/flask_api/tests/test_parsers.py
+++ b/flask_api/tests/test_parsers.py
@@ -1,25 +1,26 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask import request
-from flask_api import exceptions, parsers, status, mediatypes, FlaskAPI
-from flask_api.decorators import set_parsers
 import io
 import json
 import unittest
 
+from flask import request
+
+from flask_api import FlaskAPI, exceptions, mediatypes, parsers, status
+from flask_api.decorators import set_parsers
 
 app = FlaskAPI(__name__)
 
 
-@app.route('/', methods=['POST'])
+@app.route("/", methods=["POST"])
 def data():
     return {
-        'data': request.data,
-        'form': request.form,
-        'files': dict([
-            (key, {'name': val.filename, 'contents': val.read().decode('utf8')})
-            for key, val in request.files.items()
-        ])
+        "data": request.data,
+        "form": request.form,
+        "files": dict(
+            [
+                (key, {"name": val.filename, "contents": val.read().decode("utf8")})
+                for key, val in request.files.items()
+            ]
+        ),
     }
 
 
@@ -27,36 +28,34 @@ class ParserTests(unittest.TestCase):
     def test_valid_json(self):
         parser = parsers.JSONParser()
         stream = io.BytesIO(b'{"key": 1, "other": "two"}')
-        data = parser.parse(stream, 'application/json')
+        data = parser.parse(stream, "application/json")
         self.assertEqual(data, {"key": 1, "other": "two"})
 
     def test_invalid_json(self):
         parser = parsers.JSONParser()
         stream = io.BytesIO(b'{key: 1, "other": "two"}')
         with self.assertRaises(exceptions.ParseError) as context:
-            parser.parse(stream, mediatypes.MediaType('application/json'))
+            parser.parse(stream, mediatypes.MediaType("application/json"))
         detail = str(context.exception)
-        expected_py2 = 'JSON parse error - Expecting property name: line 1 column 1 (char 1)'
-        expected_py3 = 'JSON parse error - Expecting property name enclosed in double quotes: line 1 column 2 (char 1)'
-        self.assertIn(detail, (expected_py2, expected_py3))
+        expected_pypy = "JSON parse error - Key name must be string at char: line 1 column 2 (char 1)"
+        expected_py3 = "JSON parse error - Expecting property name enclosed in double quotes: line 1 column 2 (char 1)"
+        self.assertIn(detail, (expected_pypy, expected_py3))
 
     def test_invalid_multipart(self):
         parser = parsers.MultiPartParser()
-        stream = io.BytesIO(b'invalid')
+        stream = io.BytesIO(b"invalid")
         media_type = mediatypes.MediaType('multipart/form-data; boundary="foo"')
         with self.assertRaises(exceptions.ParseError) as context:
-            parser.parse(stream, media_type, content_length=len('invalid'))
-        detail = str(context.exception)
-        expected = 'Multipart parse error - Expected boundary at start of multipart data'
-        self.assertEqual(detail, expected)
+            parser.parse(stream, media_type, content_length=len("invalid"))
+        self.assertIn("Multipart parse error", str(context.exception))
 
     def test_invalid_multipart_no_boundary(self):
         parser = parsers.MultiPartParser()
-        stream = io.BytesIO(b'invalid')
+        stream = io.BytesIO(b"invalid")
         with self.assertRaises(exceptions.ParseError) as context:
-            parser.parse(stream, mediatypes.MediaType('multipart/form-data'))
+            parser.parse(stream, mediatypes.MediaType("multipart/form-data"))
         detail = str(context.exception)
-        expected = 'Multipart message missing boundary in Content-Type header'
+        expected = "Multipart message missing boundary in Content-Type header"
         self.assertEqual(detail, expected)
 
     def test_renderer_negotiation_not_implemented(self):
@@ -69,43 +68,42 @@ def test_renderer_negotiation_not_implemented(self):
 
     def test_accessing_json(self):
         with app.test_client() as client:
-            data = json.dumps({'example': 'example'})
-            response = client.post('/', data=data, content_type='application/json')
+            data = json.dumps({"example": "example"})
+            response = client.post("/", data=data, content_type="application/json")
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/json')
-            data = json.loads(response.get_data().decode('utf8'))
-            expected = {
-                "data": {"example": "example"},
-                "form": {},
-                "files": {}
-            }
+            self.assertEqual(response.headers["Content-Type"], "application/json")
+            data = json.loads(response.get_data().decode("utf8"))
+            expected = {"data": {"example": "example"}, "form": {}, "files": {}}
             self.assertEqual(data, expected)
 
     def test_accessing_url_encoded(self):
         with app.test_client() as client:
-            data = {'example': 'example'}
-            response = client.post('/', data=data)
+            data = {"example": "example"}
+            response = client.post("/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/json')
-            data = json.loads(response.get_data().decode('utf8'))
+            self.assertEqual(response.headers["Content-Type"], "application/json")
+            data = json.loads(response.get_data().decode("utf8"))
             expected = {
                 "data": {"example": "example"},
                 "form": {"example": "example"},
-                "files": {}
+                "files": {},
             }
             self.assertEqual(data, expected)
 
     def test_accessing_multipart(self):
         with app.test_client() as client:
-            data = {'example': 'example', 'upload': (io.BytesIO(b'file contents'), 'name.txt')}
-            response = client.post('/', data=data)
+            data = {
+                "example": "example",
+                "upload": (io.BytesIO(b"file contents"), "name.txt"),
+            }
+            response = client.post("/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/json')
-            data = json.loads(response.get_data().decode('utf8'))
+            self.assertEqual(response.headers["Content-Type"], "application/json")
+            data = json.loads(response.get_data().decode("utf8"))
             expected = {
                 "data": {"example": "example"},
                 "form": {"example": "example"},
-                "files": {"upload": {"name": "name.txt", "contents": "file contents"}}
+                "files": {"upload": {"name": "name.txt", "contents": "file contents"}},
             }
             self.assertEqual(data, expected)
 
@@ -113,43 +111,43 @@ def test_accessing_multipart(self):
 class OverrideParserSettings(unittest.TestCase):
     def setUp(self):
         class CustomParser1(parsers.BaseParser):
-            media_type = '*/*'
+            media_type = "*/*"
 
             def parse(self, stream, media_type, content_length=None):
-                return 'custom parser 1'
+                return "custom parser 1"
 
         class CustomParser2(parsers.BaseParser):
-            media_type = '*/*'
+            media_type = "*/*"
 
             def parse(self, stream, media_type, content_length=None):
-                return 'custom parser 2'
+                return "custom parser 2"
 
         app = FlaskAPI(__name__)
-        app.config['DEFAULT_PARSERS'] = [CustomParser1]
+        app.config["DEFAULT_PARSERS"] = [CustomParser1]
 
-        @app.route('/custom_parser_1/', methods=['POST'])
+        @app.route("/custom_parser_1/", methods=["POST"])
         def custom_parser_1():
-            return {'data': request.data}
+            return {"data": request.data}
 
-        @app.route('/custom_parser_2/', methods=['POST'])
+        @app.route("/custom_parser_2/", methods=["POST"])
         @set_parsers([CustomParser2])
         def custom_parser_2():
-            return {'data': request.data}
+            return {"data": request.data}
 
-        @app.route('/custom_parser_2_as_args/', methods=['POST'])
+        @app.route("/custom_parser_2_as_args/", methods=["POST"])
         @set_parsers(CustomParser2, CustomParser1)
         def custom_parser_2_as_args():
-            return {'data': request.data}
+            return {"data": request.data}
 
         self.app = app
 
     def test_overridden_parsers_with_settings(self):
         with self.app.test_client() as client:
-            data = {'example': 'example'}
-            response = client.post('/custom_parser_1/', data=data)
+            data = {"example": "example"}
+            response = client.post("/custom_parser_1/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/json')
-            data = json.loads(response.get_data().decode('utf8'))
+            self.assertEqual(response.headers["Content-Type"], "application/json")
+            data = json.loads(response.get_data().decode("utf8"))
             expected = {
                 "data": "custom parser 1",
             }
@@ -157,11 +155,11 @@ def test_overridden_parsers_with_settings(self):
 
     def test_overridden_parsers_with_decorator(self):
         with self.app.test_client() as client:
-            data = {'example': 'example'}
-            response = client.post('/custom_parser_2/', data=data)
+            data = {"example": "example"}
+            response = client.post("/custom_parser_2/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/json')
-            data = json.loads(response.get_data().decode('utf8'))
+            self.assertEqual(response.headers["Content-Type"], "application/json")
+            data = json.loads(response.get_data().decode("utf8"))
             expected = {
                 "data": "custom parser 2",
             }
@@ -169,11 +167,11 @@ def test_overridden_parsers_with_decorator(self):
 
     def test_overridden_parsers_with_decorator_as_args(self):
         with self.app.test_client() as client:
-            data = {'example': 'example'}
-            response = client.post('/custom_parser_2_as_args/', data=data)
+            data = {"example": "example"}
+            response = client.post("/custom_parser_2_as_args/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/json')
-            data = json.loads(response.get_data().decode('utf8'))
+            self.assertEqual(response.headers["Content-Type"], "application/json")
+            data = json.loads(response.get_data().decode("utf8"))
             expected = {
                 "data": "custom parser 2",
             }
diff --git a/flask_api/tests/test_renderers.py b/flask_api/tests/test_renderers.py
index e1cc239..549a3de 100644
--- a/flask_api/tests/test_renderers.py
+++ b/flask_api/tests/test_renderers.py
@@ -1,18 +1,18 @@
-# coding: utf8
-from __future__ import unicode_literals
+import unittest
 from datetime import datetime
-from flask.json import JSONEncoder
-from flask_api import renderers, status, FlaskAPI
+
+from flask.json.provider import DefaultJSONProvider
+
+from flask_api import FlaskAPI, renderers, status
 from flask_api.decorators import set_renderers
 from flask_api.mediatypes import MediaType
-import unittest
 
 
 class RendererTests(unittest.TestCase):
     def _make_app(self):
         app = FlaskAPI(__name__)
 
-        @app.route('/_love', methods=['GET'])
+        @app.route("/_love", methods=["GET"])
         def love():
             return {"test": "I <3 Python"}
 
@@ -22,7 +22,9 @@ def test_render_json(self):
         app = self._make_app()
         renderer = renderers.JSONRenderer()
         with app.app_context():
-            content = renderer.render({'example': 'example'}, MediaType('application/json'))
+            content = renderer.render(
+                {"example": "example"}, MediaType("application/json")
+            )
         expected = '{"example": "example"}'
         self.assertEqual(content, expected)
 
@@ -30,73 +32,75 @@ def test_render_json_with_indent(self):
         app = self._make_app()
         renderer = renderers.JSONRenderer()
         with app.app_context():
-            content = renderer.render({'example': 'example'}, MediaType('application/json; indent=4'))
+            content = renderer.render(
+                {"example": "example"}, MediaType("application/json; indent=4")
+            )
         expected = '{\n    "example": "example"\n}'
         self.assertEqual(content, expected)
 
     def test_render_json_with_custom_encoder(self):
-        class CustomJsonEncoder(JSONEncoder):
+        class CustomJsonProvider(DefaultJSONProvider):
             def default(self, o):
                 if isinstance(o, datetime):
                     return o.isoformat()
-                return super(CustomJsonEncoder, self).default(o)
+                return super().default(o)
 
         app = self._make_app()
-        app.json_encoder = CustomJsonEncoder
+        app.json = CustomJsonProvider(app)
         renderer = renderers.JSONRenderer()
         date = datetime(2017, 10, 5, 15, 22)
         with app.app_context():
-            content = renderer.render(date, MediaType('application/json'))
+            content = renderer.render(date, MediaType("application/json"))
         self.assertEqual(content, '"{}"'.format(date.isoformat()))
 
     def test_render_browsable_encoding(self):
         app = FlaskAPI(__name__)
 
-        @app.route('/_love', methods=['GET'])
+        @app.route("/_love", methods=["GET"])
         def love():
             return {"test": "I <3 Python"}
 
         with app.test_client() as client:
-            response = client.get('/_love', headers={"Accept": "text/html"})
+            response = client.get("/_love", headers={"Accept": "text/html"})
             html = str(response.get_data())
-            self.assertTrue('I &lt;3 Python' in html)
-            self.assertTrue('<h1>Love</h1>' in html)
-            self.assertTrue('/_love' in html)
+            self.assertTrue("I &lt;3 Python" in html)
+            self.assertTrue("<h1>Love</h1>" in html)
+            self.assertTrue("/_love" in html)
 
     def test_render_browsable_encoding_with_markdown(self):
         app = FlaskAPI(__name__)
 
-        @app.route('/_foo', methods=['GET'])
+        @app.route("/_foo", methods=["GET"])
         def foo():
             """Bar:
-              - `qux`
+            - `qux`
             """
             return {"test": "I <3 Python"}
 
         with app.test_client() as client:
-            response = client.get('/_foo', headers={"Accept": "text/html"})
+            response = client.get("/_foo", headers={"Accept": "text/html"})
             html = str(response.get_data())
             print(html)
-            self.assertTrue('<h1>Foo</h1>' in html)
-            self.assertTrue('<p>Bar:' in html)
-            self.assertTrue('<code>qux</code>' in html)
+            self.assertTrue("<h1>Foo</h1>" in html)
+            self.assertTrue("<p>Bar:" in html)
+            self.assertTrue("<code>qux</code>" in html)
 
     def test_render_browsable_linking(self):
         app = FlaskAPI(__name__)
 
-        @app.route('/_happiness', methods=['GET'])
+        @app.route("/_happiness", methods=["GET"])
         def happiness():
-            return {"url": "http://example.org",
-                    "a tag": "<br />"}
+            return {"url": "http://example.org", "a tag": "<br />"}
 
         with app.test_client() as client:
-            response = client.get('/_happiness',
-                                  headers={"Accept": "text/html"})
+            response = client.get("/_happiness", headers={"Accept": "text/html"})
             html = str(response.get_data())
-            self.assertTrue('<a href="http://example.org">http://example.org</a>' in html)
-            self.assertTrue('&lt;br /&gt;'in html)
-            self.assertTrue('<h1>Happiness</h1>' in html)
-            self.assertTrue('/_happiness' in html)
+            self.assertTrue(
+                '<a href="http://example.org">http://example.org</a>' in html
+            )
+            self.assertTrue("&lt;br /&gt;" in html)
+            self.assertTrue("<h1>Happiness</h1>" in html)
+            self.assertTrue("/_happiness" in html)
 
     def test_renderer_negotiation_not_implemented(self):
         renderer = renderers.BaseRenderer()
@@ -110,59 +114,59 @@ def test_renderer_negotiation_not_implemented(self):
 class OverrideParserSettings(unittest.TestCase):
     def setUp(self):
         class CustomRenderer1(renderers.BaseRenderer):
-            media_type = 'application/example1'
+            media_type = "application/example1"
 
             def render(self, data, media_type, **options):
-                return 'custom renderer 1'
+                return "custom renderer 1"
 
         class CustomRenderer2(renderers.BaseRenderer):
-            media_type = 'application/example2'
+            media_type = "application/example2"
 
             def render(self, data, media_type, **options):
-                return 'custom renderer 2'
+                return "custom renderer 2"
 
         app = FlaskAPI(__name__)
-        app.config['DEFAULT_RENDERERS'] = [CustomRenderer1]
-        app.config['PROPAGATE_EXCEPTIONS'] = True
+        app.config["DEFAULT_RENDERERS"] = [CustomRenderer1]
+        app.config["PROPAGATE_EXCEPTIONS"] = True
 
-        @app.route('/custom_renderer_1/', methods=['GET'])
+        @app.route("/custom_renderer_1/", methods=["GET"])
         def custom_renderer_1():
-            return {'data': 'example'}
+            return {"data": "example"}
 
-        @app.route('/custom_renderer_2/', methods=['GET'])
+        @app.route("/custom_renderer_2/", methods=["GET"])
         @set_renderers([CustomRenderer2])
         def custom_renderer_2():
-            return {'data': 'example'}
+            return {"data": "example"}
 
-        @app.route('/custom_renderer_2_as_args/', methods=['GET'])
+        @app.route("/custom_renderer_2_as_args/", methods=["GET"])
         @set_renderers(CustomRenderer2)
         def custom_renderer_2_as_args():
-            return {'data': 'example'}
+            return {"data": "example"}
 
         self.app = app
 
     def test_overridden_parsers_with_settings(self):
         with self.app.test_client() as client:
-            response = client.get('/custom_renderer_1/')
+            response = client.get("/custom_renderer_1/")
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/example1')
-            data = response.get_data().decode('utf8')
+            self.assertEqual(response.headers["Content-Type"], "application/example1")
+            data = response.get_data().decode("utf8")
             self.assertEqual(data, "custom renderer 1")
 
     def test_overridden_parsers_with_decorator(self):
         with self.app.test_client() as client:
-            data = {'example': 'example'}
-            response = client.get('/custom_renderer_2/', data=data)
+            data = {"example": "example"}
+            response = client.get("/custom_renderer_2/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/example2')
-            data = response.get_data().decode('utf8')
+            self.assertEqual(response.headers["Content-Type"], "application/example2")
+            data = response.get_data().decode("utf8")
             self.assertEqual(data, "custom renderer 2")
 
     def test_overridden_parsers_with_decorator_as_args(self):
         with self.app.test_client() as client:
-            data = {'example': 'example'}
-            response = client.get('/custom_renderer_2_as_args/', data=data)
+            data = {"example": "example"}
+            response = client.get("/custom_renderer_2_as_args/", data=data)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual(response.headers['Content-Type'], 'application/example2')
-            data = response.get_data().decode('utf8')
+            self.assertEqual(response.headers["Content-Type"], "application/example2")
+            data = response.get_data().decode("utf8")
             self.assertEqual(data, "custom renderer 2")
diff --git a/flask_api/tests/test_request.py b/flask_api/tests/test_request.py
index f033bb4..900fa9d 100644
--- a/flask_api/tests/test_request.py
+++ b/flask_api/tests/test_request.py
@@ -1,29 +1,29 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask import request
-from flask_api import exceptions
-import flask_api
 import io
 import unittest
 
+from flask import request
+
+import flask_api
+from flask_api import exceptions
+
 app = flask_api.FlaskAPI(__name__)
 
 
 class MediaTypeParsingTests(unittest.TestCase):
     def test_json_request(self):
         kwargs = {
-            'method': 'PUT',
-            'input_stream': io.BytesIO(b'{"key": 1, "other": "two"}'),
-            'content_type': 'application/json'
+            "method": "PUT",
+            "input_stream": io.BytesIO(b'{"key": 1, "other": "two"}'),
+            "content_type": "application/json",
         }
         with app.test_request_context(**kwargs):
             self.assertEqual(request.data, {"key": 1, "other": "two"})
 
     def test_invalid_content_type_request(self):
         kwargs = {
-            'method': 'PUT',
-            'input_stream': io.BytesIO(b'Cannot parse this content type.'),
-            'content_type': 'text/plain'
+            "method": "PUT",
+            "input_stream": io.BytesIO(b"Cannot parse this content type."),
+            "content_type": "text/plain",
         }
         with app.test_request_context(**kwargs):
             with self.assertRaises(exceptions.UnsupportedMediaType):
@@ -34,18 +34,18 @@ def test_no_content_request(self):
         Ensure that requests with no data do not populate the
         `.data`, `.form` or `.files` attributes.
         """
-        with app.test_request_context(method='PUT'):
+        with app.test_request_context(method="PUT"):
             self.assertFalse(request.data)
 
-        with app.test_request_context(method='PUT'):
+        with app.test_request_context(method="PUT"):
             self.assertFalse(request.form)
 
-        with app.test_request_context(method='PUT'):
+        with app.test_request_context(method="PUT"):
             self.assertFalse(request.files)
 
     def test_encode_request(self):
         """
         Ensure that `.full_path` is correctly decoded in python 3
         """
-        with app.test_request_context(method='GET', path='/?a=b'):
-            self.assertEqual(request.full_path, '/?a=b')
+        with app.test_request_context(method="GET", path="/?a=b"):
+            self.assertEqual(request.full_path, "/?a=b")
diff --git a/flask_api/tests/test_settings.py b/flask_api/tests/test_settings.py
index c5cf824..94b8184 100644
--- a/flask_api/tests/test_settings.py
+++ b/flask_api/tests/test_settings.py
@@ -1,12 +1,11 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask_api.settings import APISettings
 import unittest
 
+from flask_api.settings import APISettings
+
 
 class SettingsTests(unittest.TestCase):
     def test_bad_import(self):
-        settings = APISettings({'DEFAULT_PARSERS': 'foobarz.FailedImport'})
+        settings = APISettings({"DEFAULT_PARSERS": "foobarz.FailedImport"})
         with self.assertRaises(ImportError) as context:
             settings.DEFAULT_PARSERS
         msg = str(context.exception)
diff --git a/flask_api/tests/test_status.py b/flask_api/tests/test_status.py
index f6a9c24..7e3667b 100644
--- a/flask_api/tests/test_status.py
+++ b/flask_api/tests/test_status.py
@@ -1,8 +1,7 @@
-# coding: utf8
-from __future__ import unicode_literals
-from flask_api import status
 import unittest
 
+from flask_api import status
+
 
 class TestStatus(unittest.TestCase):
     def test_status_categories(self):
diff --git a/mkdocs.yml b/mkdocs.yml
index 7e1324e..f013496 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -14,4 +14,3 @@ pages:
 
 repo_url: https://github.com/flask-api/flask-api
 copyright: '<a href="/about/license">BSD licensed</a> <b>&middot;</b> Copyright &copy; 2017, <a href="https://twitter.com/_tomchristie">Tom Christie</a>.'
-google_analytics: ['UA-27795084-4', 'flaskapi.org']
diff --git a/scent.py b/scent.py
index 31b9083..fb3aba1 100644
--- a/scent.py
+++ b/scent.py
@@ -1,11 +1,11 @@
-# -*- coding: utf-8 -*-
 """Configuration file for sniffer."""
 # pylint: disable=superfluous-parens,bad-continuation
 
-import time
 import subprocess
+import time
+
+from sniffer.api import file_validator, runnable, select_runnable
 
-from sniffer.api import select_runnable, file_validator, runnable
 try:
     from pync import Notifier
 except ImportError:
@@ -17,34 +17,34 @@
 watch_paths = ["flask_api"]
 
 
-class Options(object):
+class Options:
     group = int(time.time())  # unique per run
     show_coverage = False
     rerun_args = None
 
     targets = [
-        (('make', 'test'), "Run Tests", True),
-        (('make', 'check'), "Static Analysis", True),
-        (('make', 'docs'), None, True),
+        (("make", "test"), "Run Tests", True),
+        (("make", "check"), "Static Analysis", True),
+        (("make", "docs"), None, True),
     ]
 
 
-@select_runnable('run_targets')
+@select_runnable("run_targets")
 @file_validator
 def python_files(filename):
-    return filename.endswith('.py')
+    return filename.endswith(".py")
 
 
-@select_runnable('run_targets')
+@select_runnable("run_targets")
 @file_validator
 def html_files(filename):
-    return filename.split('.')[-1] in ['html', 'css', 'js']
+    return filename.split(".")[-1] in ["html", "css", "js"]
 
 
 @runnable
 def run_targets(*args):
     """Run targets for Python."""
-    Options.show_coverage = 'coverage' in args
+    Options.show_coverage = "coverage" in args
 
     count = 0
     for count, (command, title, retry) in enumerate(Options.targets, start=1):
@@ -74,7 +74,7 @@ def call(command, title, retry):
             return False
 
     print("")
-    print("$ %s" % ' '.join(command))
+    print("$ %s" % " ".join(command))
     failure = subprocess.call(command)
 
     if failure and retry:
@@ -92,6 +92,6 @@ def show_notification(message, title):
 def show_coverage():
     """Launch the coverage report."""
     if Options.show_coverage:
-        subprocess.call(['make', 'read-coverage'])
+        subprocess.call(["make", "read-coverage"])
 
     Options.show_coverage = False
diff --git a/setup.py b/setup.py
index da7bb3e..6039298 100755
--- a/setup.py
+++ b/setup.py
@@ -1,23 +1,19 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+#!/usr/bin/env python3
 
-from __future__ import print_function
-from setuptools import setup
-import re
 import os
+import re
 import sys
 
+from setuptools import setup
 
-name = 'Flask-API'
-package = 'flask_api'
-description = 'Browsable web APIs for Flask.'
-url = 'http://www.flaskapi.org'
-author = 'Tom Christie'
-author_email = 'tom@tomchristie.com'
-license = 'BSD'
-install_requires = [
-    'Flask >= 0.12.3',
-]
+name = "Flask-API"
+package = "flask_api"
+description = "Browsable web APIs for Flask."
+url = "https://flask-api.github.io/flask-api/"
+author = "Tom Christie"
+author_email = "tom@tomchristie.com"
+license = "BSD"
+install_requires = ["Flask >= 2.0.0"]
 
 long_description = """Browsable web APIs for Flask."""
 
@@ -26,17 +22,21 @@ def get_version(package):
     """
     Return package version as listed in `__version__` in `init.py`.
     """
-    init_py = open(os.path.join(package, '__init__.py')).read()
-    return re.search("^__version__ = ['\"]([^'\"]+)['\"]", init_py, re.MULTILINE).group(1)
+    init_py = open(os.path.join(package, "__init__.py")).read()
+    return re.search("^__version__ = ['\"]([^'\"]+)['\"]", init_py, re.MULTILINE).group(
+        1
+    )
 
 
 def get_packages(package):
     """
     Return root package and all sub-packages.
     """
-    return [dirpath
-            for dirpath, dirnames, filenames in os.walk(package)
-            if os.path.exists(os.path.join(dirpath, '__init__.py'))]
+    return [
+        dirpath
+        for dirpath, dirnames, filenames in os.walk(package)
+        if os.path.exists(os.path.join(dirpath, "__init__.py"))
+    ]
 
 
 def get_package_data(package):
@@ -44,16 +44,18 @@ def get_package_data(package):
     Return all files under the root package, that are not in a
     package themselves.
     """
-    walk = [(dirpath.replace(package + os.sep, '', 1), filenames)
-            for dirpath, dirnames, filenames in os.walk(package)
-            if not os.path.exists(os.path.join(dirpath, '__init__.py'))]
+    walk = [
+        (dirpath.replace(package + os.sep, "", 1), filenames)
+        for dirpath, dirnames, filenames in os.walk(package)
+        if not os.path.exists(os.path.join(dirpath, "__init__.py"))
+    ]
 
     filepaths = []
     for base, filenames in walk:
-        filepaths.extend([os.path.join(base, filename)
-                          for filename in filenames])
+        filepaths.extend([os.path.join(base, filename) for filename in filenames])
     return {package: filepaths}
 
+
 setup(
     name=name,
     version=get_version(package),
@@ -67,20 +69,19 @@ def get_package_data(package):
     package_data=get_package_data(package),
     install_requires=install_requires,
     classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Environment :: Web Environment',
-        'Framework :: Flask',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: BSD License',
-        'Natural Language :: English',
-        'Operating System :: OS Independent',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Topic :: Internet :: WWW/HTTP',
-    ]
+        "Development Status :: 5 - Production/Stable",
+        "Environment :: Web Environment",
+        "Framework :: Flask",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: BSD License",
+        "Natural Language :: English",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Topic :: Internet :: WWW/HTTP",
+    ],
 )