black formatting

.flake8

@@ -0,0 +1,3 @@
+[flake8]
+ignore = E231,E203,W605
+max-line-length = 88

Pipfile.lock

@@ -1,11 +1,11 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "5a2d404725db87789c428cc6fb3f2945c4232b4838e18c4ad95d5f07d002315a"
+            "sha256": "c5544cbf0a2e670df097b55640123acd8cff56464512bc7b53d1692f2c1c0823"
         },
         "pipfile-spec": 6,
         "requires": {
-            "python_version": "3.6"
+            "python_version": "3.7"
         },
         "sources": [
             {
@@ -19,24 +19,17 @@
     "develop": {
         "aspy.yaml": {
             "hashes": [
-                "sha256:ae249074803e8b957c83fdd82a99160d0d6d26dff9ba81ba608b42eebd7d8cd3",
-                "sha256:c7390d79f58eb9157406966201abf26da0d56c07e0ff0deadc39c8f4dbc13482"
-            ],
-            "version": "==1.2.0"
-        },
-        "atomicwrites": {
-            "hashes": [
-                "sha256:03472c30eb2c5d1ba9227e4c2ca66ab8287fbfbbda3888aa93dc2e28fc6811b4",
-                "sha256:75a9445bac02d8d058d5e1fe689654ba5a6556a1dfd8ce6ec55a0ed79866cfa6"
+                "sha256:463372c043f70160a9ec950c3f1e4c3a82db5fca01d334b6bc89c7164d744bdc",
+                "sha256:e7c742382eff2caed61f87a39d13f99109088e5e93f04d76eb8d4b28aa143f45"
             ],
             "version": "==1.3.0"
         },
         "attrs": {
             "hashes": [
-                "sha256:69c0dbf2ed392de1cb5ec704444b08a5ef81680a61cb899dc08127123af36a79",
-                "sha256:f0b870f674851ecbfbbbd364d6b5cbdff9dcedbc7f3f5e18a6891057f21fe399"
+                "sha256:08a96c641c3a74e44eb59afb61a24f2cb9f4d7188748e76ba4bb5edfa3cb7d1c",
+                "sha256:f7b7ce16570fe9965acd6d30101a28f62fb4a7f9e926b3bbc9b61f8b04247e72"
             ],
-            "version": "==19.1.0"
+            "version": "==19.3.0"
         },
         "bleach": {
             "hashes": [
@@ -55,17 +48,17 @@
         },
         "certifi": {
             "hashes": [
-                "sha256:59b7658e26ca9c7339e00f8f4636cdfe59d34fa37b9b04f6f9e9926b3cece1a5",
-                "sha256:b26104d6835d1f5e49452a26eb2ff87fe7090b89dfcaee5ea2212697e1e1d7ae"
+                "sha256:017c25db2a153ce562900032d5bc68e9f191e44e9a0f762f373977de9df1fbb3",
+                "sha256:25b64c7da4cd7479594d035c08c2d809eb4aab3a26e5a990ea98cc450c320f1f"
             ],
-            "version": "==2019.3.9"
+            "version": "==2019.11.28"
         },
         "cfgv": {
             "hashes": [
-                "sha256:6e9f2feea5e84bc71e56abd703140d7a2c250fc5ba38b8702fd6a68ed4e3b2ef",
-                "sha256:e7f186d4a36c099a9e20b04ac3108bd8bb9b9257e692ce18c8c3764d5cb12172"
+                "sha256:edb387943b665bf9c434f717bf630fa78aecd53d5900d2e05da6ad6048553144",
+                "sha256:fbd93c9ab0a523bf7daec408f3be2ed99a980e20b2d19b50fc184ca6b820d289"
             ],
-            "version": "==1.6.0"
+            "version": "==2.0.1"
         },
         "chardet": {
             "hashes": [
@@ -76,47 +69,47 @@
         },
         "coverage": {
             "hashes": [
-                "sha256:3684fabf6b87a369017756b551cef29e505cb155ddb892a7a29277b978da88b9",
-                "sha256:39e088da9b284f1bd17c750ac672103779f7954ce6125fd4382134ac8d152d74",
-                "sha256:3c205bc11cc4fcc57b761c2da73b9b72a59f8d5ca89979afb0c1c6f9e53c7390",
-                "sha256:465ce53a8c0f3a7950dfb836438442f833cf6663d407f37d8c52fe7b6e56d7e8",
-                "sha256:48020e343fc40f72a442c8a1334284620f81295256a6b6ca6d8aa1350c763bbe",
-                "sha256:5296fc86ab612ec12394565c500b412a43b328b3907c0d14358950d06fd83baf",
-                "sha256:5f61bed2f7d9b6a9ab935150a6b23d7f84b8055524e7be7715b6513f3328138e",
-                "sha256:68a43a9f9f83693ce0414d17e019daee7ab3f7113a70c79a3dd4c2f704e4d741",
-                "sha256:6b8033d47fe22506856fe450470ccb1d8ba1ffb8463494a15cfc96392a288c09",
-                "sha256:7ad7536066b28863e5835e8cfeaa794b7fe352d99a8cded9f43d1161be8e9fbd",
-                "sha256:7bacb89ccf4bedb30b277e96e4cc68cd1369ca6841bde7b005191b54d3dd1034",
-                "sha256:839dc7c36501254e14331bcb98b27002aa415e4af7ea039d9009409b9d2d5420",
-                "sha256:8f9a95b66969cdea53ec992ecea5406c5bd99c9221f539bca1e8406b200ae98c",
-                "sha256:932c03d2d565f75961ba1d3cec41ddde00e162c5b46d03f7423edcb807734eab",
-                "sha256:988529edadc49039d205e0aa6ce049c5ccda4acb2d6c3c5c550c17e8c02c05ba",
-                "sha256:998d7e73548fe395eeb294495a04d38942edb66d1fa61eb70418871bc621227e",
-                "sha256:9de60893fb447d1e797f6bf08fdf0dbcda0c1e34c1b06c92bd3a363c0ea8c609",
-                "sha256:9e80d45d0c7fcee54e22771db7f1b0b126fb4a6c0a2e5afa72f66827207ff2f2",
-                "sha256:a545a3dfe5082dc8e8c3eb7f8a2cf4f2870902ff1860bd99b6198cfd1f9d1f49",
-                "sha256:a5d8f29e5ec661143621a8f4de51adfb300d7a476224156a39a392254f70687b",
-                "sha256:aca06bfba4759bbdb09bf52ebb15ae20268ee1f6747417837926fae990ebc41d",
-                "sha256:bb23b7a6fd666e551a3094ab896a57809e010059540ad20acbeec03a154224ce",
-                "sha256:bfd1d0ae7e292105f29d7deaa9d8f2916ed8553ab9d5f39ec65bcf5deadff3f9",
-                "sha256:c62ca0a38958f541a73cf86acdab020c2091631c137bd359c4f5bddde7b75fd4",
-                "sha256:c709d8bda72cf4cd348ccec2a4881f2c5848fd72903c185f363d361b2737f773",
-                "sha256:c968a6aa7e0b56ecbd28531ddf439c2ec103610d3e2bf3b75b813304f8cb7723",
-                "sha256:df785d8cb80539d0b55fd47183264b7002077859028dfe3070cf6359bf8b2d9c",
-                "sha256:f406628ca51e0ae90ae76ea8398677a921b36f0bd71aab2099dfed08abd0322f",
-                "sha256:f46087bbd95ebae244a0eda01a618aff11ec7a069b15a3ef8f6b520db523dcf1",
-                "sha256:f8019c5279eb32360ca03e9fac40a12667715546eed5c5eb59eb381f2f501260",
-                "sha256:fc5f4d209733750afd2714e9109816a29500718b32dd9a5db01c0cb3a019b96a"
-            ],
-            "version": "==4.5.3"
+                "sha256:15cf13a6896048d6d947bf7d222f36e4809ab926894beb748fc9caa14605d9c3",
+                "sha256:1daa3eceed220f9fdb80d5ff950dd95112cd27f70d004c7918ca6dfc6c47054c",
+                "sha256:1e44a022500d944d42f94df76727ba3fc0a5c0b672c358b61067abb88caee7a0",
+                "sha256:25dbf1110d70bab68a74b4b9d74f30e99b177cde3388e07cc7272f2168bd1477",
+                "sha256:3230d1003eec018ad4a472d254991e34241e0bbd513e97a29727c7c2f637bd2a",
+                "sha256:3dbb72eaeea5763676a1a1efd9b427a048c97c39ed92e13336e726117d0b72bf",
+                "sha256:5012d3b8d5a500834783689a5d2292fe06ec75dc86ee1ccdad04b6f5bf231691",
+                "sha256:51bc7710b13a2ae0c726f69756cf7ffd4362f4ac36546e243136187cfcc8aa73",
+                "sha256:527b4f316e6bf7755082a783726da20671a0cc388b786a64417780b90565b987",
+                "sha256:722e4557c8039aad9592c6a4213db75da08c2cd9945320220634f637251c3894",
+                "sha256:76e2057e8ffba5472fd28a3a010431fd9e928885ff480cb278877c6e9943cc2e",
+                "sha256:77afca04240c40450c331fa796b3eab6f1e15c5ecf8bf2b8bee9706cd5452fef",
+                "sha256:7afad9835e7a651d3551eab18cbc0fdb888f0a6136169fbef0662d9cdc9987cf",
+                "sha256:9bea19ac2f08672636350f203db89382121c9c2ade85d945953ef3c8cf9d2a68",
+                "sha256:a8b8ac7876bc3598e43e2603f772d2353d9931709345ad6c1149009fd1bc81b8",
+                "sha256:b0840b45187699affd4c6588286d429cd79a99d509fe3de0f209594669bb0954",
+                "sha256:b26aaf69713e5674efbde4d728fb7124e429c9466aeaf5f4a7e9e699b12c9fe2",
+                "sha256:b63dd43f455ba878e5e9f80ba4f748c0a2156dde6e0e6e690310e24d6e8caf40",
+                "sha256:be18f4ae5a9e46edae3f329de2191747966a34a3d93046dbdf897319923923bc",
+                "sha256:c312e57847db2526bc92b9bfa78266bfbaabac3fdcd751df4d062cd4c23e46dc",
+                "sha256:c60097190fe9dc2b329a0eb03393e2e0829156a589bd732e70794c0dd804258e",
+                "sha256:c62a2143e1313944bf4a5ab34fd3b4be15367a02e9478b0ce800cb510e3bbb9d",
+                "sha256:cc1109f54a14d940b8512ee9f1c3975c181bbb200306c6d8b87d93376538782f",
+                "sha256:cd60f507c125ac0ad83f05803063bed27e50fa903b9c2cfee3f8a6867ca600fc",
+                "sha256:d513cc3db248e566e07a0da99c230aca3556d9b09ed02f420664e2da97eac301",
+                "sha256:d649dc0bcace6fcdb446ae02b98798a856593b19b637c1b9af8edadf2b150bea",
+                "sha256:d7008a6796095a79544f4da1ee49418901961c97ca9e9d44904205ff7d6aa8cb",
+                "sha256:da93027835164b8223e8e5af2cf902a4c80ed93cb0909417234f4a9df3bcd9af",
+                "sha256:e69215621707119c6baf99bda014a45b999d37602cb7043d943c76a59b05bf52",
+                "sha256:ea9525e0fef2de9208250d6c5aeeee0138921057cd67fcef90fbed49c4d62d37",
+                "sha256:fca1669d464f0c9831fd10be2eef6b86f5ebd76c724d1e0706ebdff86bb4adf0"
+            ],
+            "version": "==5.0.3"
         },
         "coveralls": {
             "hashes": [
-                "sha256:baa26648430d5c2225ab12d7e2067f75597a4b967034bba7e3d5ab7501d207a1",
-                "sha256:ff9b7823b15070f26f654837bb02a201d006baaf2083e0514ffd3b34a3ffed81"
+                "sha256:2da39aeaef986757653f0a442ba2bef22a8ec602c8bacbc69d39f468dfae12ec",
+                "sha256:906e07a12b2ac04b8ad782d06173975fe5ff815fe9df3bfedd2c099bc5791aec"
             ],
             "index": "pypi",
-            "version": "==1.7.0"
+            "version": "==1.10.0"
         },
         "docopt": {
             "hashes": [
@@ -126,11 +119,10 @@
         },
         "docutils": {
             "hashes": [
-                "sha256:02aec4bd92ab067f6ff27a38a38a41173bf01bed8f89157768c1573f53e474a6",
-                "sha256:51e64ef2ebfb29cae1faa133b3710143496eca21c530f3f71424d77687764274",
-                "sha256:7a4bd47eaf6596e1295ecb11361139febe29b084a87bf005bf899f9a42edc3c6"
+                "sha256:0c5b78adfbf7762415433f5515cd5c9e762339e23369dbe8000d84a4bf4ab3af",
+                "sha256:c2de3a60e9e7d07be26b7f2b00ca0309c207e06c100f9cc2a94931fc75a478fc"
             ],
-            "version": "==0.14"
+            "version": "==0.16"
         },
         "entrypoints": {
             "hashes": [
@@ -151,18 +143,18 @@
         },
         "flake8": {
             "hashes": [
-                "sha256:859996073f341f2670741b51ec1e67a01da142831aa1fdc6242dbf88dffbe661",
-                "sha256:a796a115208f5c03b18f332f7c11729812c8c3ded6c46319c59b53efd3819da8"
+                "sha256:45681a117ecc81e870cbf1262835ae4af5e7a8b08e40b944a8a6e6b895914cfb",
+                "sha256:49356e766643ad15072a789a20915d3c91dc89fd313ccd71802303fd67e4deca"
             ],
             "index": "pypi",
-            "version": "==3.7.7"
+            "version": "==3.7.9"
         },
         "identify": {
             "hashes": [
-                "sha256:443f419ca6160773cbaf22dbb302b1e436a386f23129dbb5482b68a147c2eca9",
-                "sha256:bd7f15fe07112b713fb68fbdde3a34dd774d9062128f2c398104889f783f989d"
+                "sha256:418f3b2313ac0b531139311a6b426854e9cbdfcfb6175447a5039aa6291d8b30",
+                "sha256:8ad99ed1f3a965612dcb881435bf58abcfbeb05e230bb8c352b51e8eac103360"
             ],
-            "version": "==1.4.2"
+            "version": "==1.4.10"
         },
         "idna": {
             "hashes": [
@@ -173,18 +165,18 @@
         },
         "importlib-metadata": {
             "hashes": [
-                "sha256:46fc60c34b6ed7547e2a723fc8de6dc2e3a1173f8423246b3ce497f064e9c3de",
-                "sha256:bc136180e961875af88b1ab85b4009f4f1278f8396a60526c0009f503a1a96ca"
+                "sha256:bdd9b7c397c273bcc9a11d6629a38487cd07154fa255a467bf704cd2c258e359",
+                "sha256:f17c015735e1a88296994c0697ecea7e11db24290941983b08c9feb30921e6d8"
             ],
-            "version": "==0.9"
+            "markers": "python_version < '3.8'",
+            "version": "==1.4.0"
         },
-        "importlib-resources": {
+        "keyring": {
             "hashes": [
-                "sha256:6e2783b2538bd5a14678284a3962b0660c715e5a0f10243fd5e00a4b5974f50b",
-                "sha256:d3279fd0f6f847cced9f7acc19bd3e5df54d34f93a2e7bb5f238f81545787078"
+                "sha256:1f393f7466314068961c7e1d508120c092bd71fa54e3d93b76180b526d4abc56",
+                "sha256:24ae23ab2d6adc59138339e56843e33ec7b0a6b2f06302662477085c6c0aca00"
             ],
-            "markers": "python_version < '3.7'",
-            "version": "==1.0.2"
+            "version": "==21.1.0"
         },
         "mccabe": {
             "hashes": [
@@ -195,11 +187,11 @@
         },
         "mock": {
             "hashes": [
-                "sha256:5ce3c71c5545b472da17b72268978914d0252980348636840bd34a00b5cc96c1",
-                "sha256:b158b6df76edd239b8208d481dc46b6afd45a846b7812ff0ce58971cf5bc8bba"
+                "sha256:83657d894c90d5681d62155c82bda9c1187827525880eda8ff5df4ec813437c3",
+                "sha256:d157e52d4e5b938c550f39eb2fd15610db062441a9c2747d3dbfa9298211d0f8"
             ],
             "index": "pypi",
-            "version": "==2.0.0"
+            "version": "==3.0.5"
         },
         "more-itertools": {
             "hashes": [
@@ -212,24 +204,24 @@
         },
         "nodeenv": {
             "hashes": [
-                "sha256:ad8259494cf1c9034539f6cced78a1da4840a4b157e23640bc4a0c0546b0cb7a"
+                "sha256:561057acd4ae3809e665a9aaaf214afff110bbb6a6d5c8a96121aea6878408b3"
             ],
-            "version": "==1.3.3"
+            "version": "==1.3.4"
         },
-        "pathlib2": {
+        "packaging": {
             "hashes": [
-                "sha256:25199318e8cc3c25dcb45cbe084cc061051336d5a9ea2a12448d3d8cb748f742",
-                "sha256:5887121d7f7df3603bca2f710e7219f3eca0eb69e0b7cc6e0a022e155ac931a7"
+                "sha256:aec3fdbb8bc9e4bb65f0634b9f551ced63983a529d6a8931817d52fdd0816ddb",
+                "sha256:fe1d8331dfa7cc0a883b49d75fc76380b2ab2734b220fbb87d774e4fd4b851f8"
             ],
-            "index": "pypi",
-            "version": "==2.3.3"
+            "version": "==20.0"
         },
-        "pbr": {
+        "pathlib2": {
             "hashes": [
-                "sha256:6901995b9b686cb90cceba67a0f6d4d14ae003cd59bc12beb61549bdfbe3bc89",
-                "sha256:d950c64aeea5456bbd147468382a5bb77fe692c13c9f00f0219814ce5b642755"
+                "sha256:0ec8205a157c80d7acc301c0b18fbd5d44fe655968f5d947b6ecef5290fc35db",
+                "sha256:6cd9a47b597b37cc57de1c05e56fb1a1c9cc9fab04fe78c29acd090418529868"
             ],
-            "version": "==5.2.0"
+            "index": "pypi",
+            "version": "==2.3.5"
         },
         "pkginfo": {
             "hashes": [
@@ -240,25 +232,25 @@
         },
         "pluggy": {
             "hashes": [
-                "sha256:19ecf9ce9db2fce065a7a0586e07cfb4ac8614fe96edf628a264b1c70116cf8f",
-                "sha256:84d306a647cc805219916e62aab89caa97a33a1dd8c342e87a37f91073cd4746"
+                "sha256:15b2acde666561e1298d71b523007ed7364de07029219b604cf808bfa1c765b0",
+                "sha256:966c145cd83c96502c3c3868f50408687b38434af77734af1e9ca461a4081d2d"
             ],
-            "version": "==0.9.0"
+            "version": "==0.13.1"
         },
         "pre-commit": {
             "hashes": [
-                "sha256:2576a2776098f3902ef9540a84696e8e06bf18a337ce43a6a889e7fa5d26c4c5",
-                "sha256:82f2f2d657d7f9280de9f927ae56886d60b9ef7f3714eae92d12713cd9cb9e11"
+                "sha256:8f48d8637bdae6fa70cc97db9c1dd5aa7c5c8bf71968932a380628c25978b850",
+                "sha256:f92a359477f3252452ae2e8d3029de77aec59415c16ae4189bcfba40b757e029"
             ],
             "index": "pypi",
-            "version": "==1.15.2"
+            "version": "==1.21.0"
         },
         "py": {
             "hashes": [
-                "sha256:64f65755aee5b381cea27766a3a147c3f15b9b6b9ac88676de66ba2ae36793fa",
-                "sha256:dc639b046a6e2cff5bbe40194ad65936d6ba360b52b3c3fe1d08a82dd50b5e53"
+                "sha256:5e27081401262157467ad6e7f851b7aa402c5852dbcb3dae06768434de5752aa",
+                "sha256:c20fdd83a5dbc0af9efd622bee9a5564e278f6380fffcacc43ba6f43db2813b0"
             ],
-            "version": "==1.8.0"
+            "version": "==1.8.1"
         },
         "pycodestyle": {
             "hashes": [
@@ -276,50 +268,57 @@
         },
         "pygments": {
             "hashes": [
-                "sha256:5ffada19f6203563680669ee7f53b64dabbeb100eb51b61996085e99c03b284a",
-                "sha256:e8218dd399a61674745138520d0d4cf2621d7e032439341bc3f647bff125818d"
+                "sha256:2a3fe295e54a20164a9df49c75fa58526d3be48e14aceba6d6b1e8ac0bfd6f1b",
+                "sha256:98c8aa5a9f778fcd1026a17361ddaf7330d1b7c62ae97c3bb0ae73e0b9b6b0fe"
             ],
-            "version": "==2.3.1"
+            "version": "==2.5.2"
+        },
+        "pyparsing": {
+            "hashes": [
+                "sha256:4c830582a84fb022400b85429791bc551f1f4871c33f23e44f353119e92f969f",
+                "sha256:c342dccb5250c08d45fd6f8b4a559613ca603b57498511740e65cd11a2e7dcec"
+            ],
+            "version": "==2.4.6"
         },
         "pytest": {
             "hashes": [
-                "sha256:3773f4c235918987d51daf1db66d51c99fac654c81d6f2f709a046ab446d5e5d",
-                "sha256:b7802283b70ca24d7119b32915efa7c409982f59913c1a6c0640aacf118b95f5"
+                "sha256:6b571215b5a790f9b41f19f3531c53a45cf6bb8ef2988bc1ff9afb38270b25fa",
+                "sha256:e41d489ff43948babd0fad7ad5e49b8735d5d55e26628a58673c39ff61d95de4"
             ],
             "index": "pypi",
-            "version": "==4.4.1"
+            "version": "==5.3.2"
         },
         "pytest-cov": {
             "hashes": [
-                "sha256:0ab664b25c6aa9716cbf203b17ddb301932383046082c081b9848a0edf5add33",
-                "sha256:230ef817450ab0699c6cc3c9c8f7a829c34674456f2ed8df1fe1d39780f7c87f"
+                "sha256:cc6742d8bac45070217169f5f72ceee1e0e55b0221f54bcf24845972d3a47f2b",
+                "sha256:cdbdef4f870408ebdbfeb44e63e07eb18bb4619fae852f6e760645fa36172626"
             ],
             "index": "pypi",
-            "version": "==2.6.1"
+            "version": "==2.8.1"
         },
         "pytest-mock": {
             "hashes": [
-                "sha256:43ce4e9dd5074993e7c021bb1c22cbb5363e612a2b5a76bc6d956775b10758b7",
-                "sha256:5bf5771b1db93beac965a7347dc81c675ec4090cb841e49d9d34637a25c30568"
+                "sha256:b35eb281e93aafed138db25c8772b95d3756108b601947f89af503f8c629413f",
+                "sha256:cb67402d87d5f53c579263d37971a164743dc33c159dfb4fb4a86f37c5552307"
             ],
             "index": "pypi",
-            "version": "==1.10.4"
+            "version": "==2.0.0"
         },
         "pyyaml": {
             "hashes": [
-                "sha256:1adecc22f88d38052fb787d959f003811ca858b799590a5eaa70e63dca50308c",
-                "sha256:436bc774ecf7c103814098159fbb84c2715d25980175292c648f2da143909f95",
-                "sha256:460a5a4248763f6f37ea225d19d5c205677d8d525f6a83357ca622ed541830c2",
-                "sha256:5a22a9c84653debfbf198d02fe592c176ea548cccce47553f35f466e15cf2fd4",
-                "sha256:7a5d3f26b89d688db27822343dfa25c599627bc92093e788956372285c6298ad",
-                "sha256:9372b04a02080752d9e6f990179a4ab840227c6e2ce15b95e1278456664cf2ba",
-                "sha256:a5dcbebee834eaddf3fa7366316b880ff4062e4bcc9787b78c7fbb4a26ff2dd1",
-                "sha256:aee5bab92a176e7cd034e57f46e9df9a9862a71f8f37cad167c6fc74c65f5b4e",
-                "sha256:c51f642898c0bacd335fc119da60baae0824f2cde95b0330b56c0553439f0673",
-                "sha256:c68ea4d3ba1705da1e0d85da6684ac657912679a649e8868bd850d2c299cce13",
-                "sha256:e23d0cc5299223dcc37885dae624f382297717e459ea24053709675a976a3e19"
+                "sha256:059b2ee3194d718896c0ad077dd8c043e5e909d9180f387ce42012662a4946d6",
+                "sha256:1cf708e2ac57f3aabc87405f04b86354f66799c8e62c28c5fc5f88b5521b2dbf",
+                "sha256:24521fa2890642614558b492b473bee0ac1f8057a7263156b02e8b14c88ce6f5",
+                "sha256:4fee71aa5bc6ed9d5f116327c04273e25ae31a3020386916905767ec4fc5317e",
+                "sha256:70024e02197337533eef7b85b068212420f950319cc8c580261963aefc75f811",
+                "sha256:74782fbd4d4f87ff04159e986886931456a1894c61229be9eaf4de6f6e44b99e",
+                "sha256:940532b111b1952befd7db542c370887a8611660d2b9becff75d39355303d82d",
+                "sha256:cb1f2f5e426dc9f07a7681419fe39cee823bb74f723f36f70399123f439e9b20",
+                "sha256:dbbb2379c19ed6042e8f11f2a2c66d39cceb8aeace421bfc29d085d93eda3689",
+                "sha256:e3a057b7a64f1222b56e47bcff5e4b94c4f61faac04c7c4ecb1985e18caa3994",
+                "sha256:e9f45bd5b92c7974e59bcd2dcc8631a6b6cc380a904725fce7bc08872e691615"
             ],
-            "version": "==5.1"
+            "version": "==5.3"
         },
         "readme-renderer": {
             "hashes": [
@@ -330,10 +329,10 @@
         },
         "requests": {
             "hashes": [
-                "sha256:502a824f31acdacb3a35b6690b5fbf0bc41d63a24a45c4004352b0242707598e",
-                "sha256:7bf2a778576d825600030a110f3c0e3e8edc51dfaafe1c146e39a2027784957b"
+                "sha256:11e007a8a2aa0323f5a921e9e6a2d7e4e67d9877e85773fba9ba6419025cbeb4",
+                "sha256:9cf5292fcd0f598c671cfc1e0d7d1a7f13bb8085e9a590f48c010551dc6c4b31"
             ],
-            "version": "==2.21.0"
+            "version": "==2.22.0"
         },
         "requests-toolbelt": {
             "hashes": [
@@ -361,10 +360,10 @@
         },
         "six": {
             "hashes": [
-                "sha256:3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c",
-                "sha256:d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"
+                "sha256:1f1b7d42e254082a9db6279deae68afb421ceba6158efa6131de7b3003ee93fd",
+                "sha256:30f610279e8b2578cab6db20741130331735c781b56053c59c4076da27f06b66"
             ],
-            "version": "==1.12.0"
+            "version": "==1.13.0"
         },
         "toml": {
             "hashes": [
@@ -375,32 +374,39 @@
         },
         "tqdm": {
             "hashes": [
-                "sha256:d385c95361699e5cf7622485d9b9eae2d4864b21cd5a2374a9c381ffed701021",
-                "sha256:e22977e3ebe961f72362f6ddfb9197cc531c9737aaf5f607ef09740c849ecd05"
+                "sha256:4789ccbb6fc122b5a6a85d512e4e41fc5acad77216533a6f2b8ce51e0f265c23",
+                "sha256:efab950cf7cc1e4d8ee50b2bb9c8e4a89f8307b49e0b2c9cfef3ec4ca26655eb"
             ],
-            "version": "==4.31.1"
+            "version": "==4.41.1"
         },
         "twine": {
             "hashes": [
-                "sha256:0fb0bfa3df4f62076cab5def36b1a71a2e4acb4d1fa5c97475b048117b1a6446",
-                "sha256:d6c29c933ecfc74e9b1d9fa13aa1f87c5d5770e119f5a4ce032092f0ff5b14dc"
+                "sha256:c1af8ca391e43b0a06bbc155f7f67db0bf0d19d284bfc88d1675da497a946124",
+                "sha256:d561a5e511f70275e5a485a6275ff61851c16ffcb3a95a602189161112d9f160"
             ],
             "index": "pypi",
-            "version": "==1.13.0"
+            "version": "==3.1.1"
         },
         "urllib3": {
             "hashes": [
-                "sha256:4c291ca23bbb55c76518905869ef34bdd5f0e46af7afe6861e8375643ffee1a0",
-                "sha256:9a247273df709c4fedb38c711e44292304f73f39ab01beda9f6b9fc375669ac3"
+                "sha256:a8a318824cc77d1fd4b2bec2ded92646630d7fe8619497b142c84a9e6f5a7293",
+                "sha256:f3c5fd51747d450d4dcf6f923c81f78f811aab8205fda64b0aba34a4e48b0745"
             ],
-            "version": "==1.24.2"
+            "version": "==1.25.7"
         },
         "virtualenv": {
             "hashes": [
-                "sha256:15ee248d13e4001a691d9583948ad3947bcb8a289775102e4c4aa98a8b7a6d73",
-                "sha256:bfc98bb9b42a3029ee41b96dc00a34c2f254cbf7716bec824477b2c82741a5c4"
+                "sha256:0d62c70883c0342d59c11d0ddac0d954d0431321a41ab20851facf2b222598f3",
+                "sha256:55059a7a676e4e19498f1aad09b8313a38fcc0cdbe4fdddc0e9b06946d21b4bb"
+            ],
+            "version": "==16.7.9"
+        },
+        "wcwidth": {
+            "hashes": [
+                "sha256:8fd29383f539be45b20bd4df0dc29c20ba48654a41e661925e612311e9f3c603",
+                "sha256:f28b3e8a6483e5d49e7f8949ac1a78314e740333ae305b4ba5defd3e74fb37a8"
             ],
-            "version": "==16.5.0"
+            "version": "==0.1.8"
         },
         "webencodings": {
             "hashes": [
@@ -411,10 +417,10 @@
         },
         "zipp": {
             "hashes": [
-                "sha256:139391b239594fd8b91d856bc530fbd2df0892b17dd8d98a91f018715954185f",
-                "sha256:8047e4575ce8d700370a3301bbfc972896a5845eb62dd535da395b86be95dfad"
+                "sha256:8dda78f06bd1674bd8720df8a50bb47b6e1233c503a4eed8e7810686bde37656",
+                "sha256:d38fbe01bbf7a3593a32bc35a9c4453c32bc42b98c377f9bff7e9f8da157786c"
             ],
-            "version": "==0.4.0"
+            "version": "==1.0.0"
         }
     }
 }

pytube/__init__.py

@@ -4,11 +4,11 @@
 """
 Pytube: a very serious Python library for downloading YouTube Videos.
 """
-__title__ = 'pytube'
-__version__ = '9.5.3'
-__author__ = 'Nick Ficano'
-__license__ = 'MIT License'
-__copyright__ = 'Copyright 2019 Nick Ficano'
+__title__ = "pytube"
+__version__ = "9.5.3"
+__author__ = "Nick Ficano"
+__license__ = "MIT License"
+__copyright__ = "Copyright 2019 Nick Ficano"
 
 from pytube.logging import create_logger
 from pytube.query import CaptionQuery
@@ -19,4 +19,4 @@ from pytube.contrib.playlist import Playlist
 from pytube.__main__ import YouTube
 
 logger = create_logger()
-logger.info('%s v%s', __title__, __version__)
+logger.info("%s v%s", __title__, __version__)

pytube/__main__.py

@@ -12,6 +12,7 @@ from __future__ import absolute_import
 import json
 import logging
 from urllib.parse import parse_qsl
+from html import unescape
 
 from pytube import Caption
 from pytube import CaptionQuery
@@ -31,8 +32,12 @@ class YouTube(object):
     """Core developer interface for pytube."""
 
     def __init__(
-        self, url=None, defer_prefetch_init=False, on_progress_callback=None,
-        on_complete_callback=None, proxies=None,
+        self,
+        url=None,
+        defer_prefetch_init=False,
+        on_progress_callback=None,
+        on_complete_callback=None,
+        proxies=None,
     ):
         """Construct a :class:`YouTube <YouTube>`.
 
@@ -48,16 +53,16 @@ class YouTube(object):
             complete events.
 
         """
-        self.js = None      # js fetched by js_url
+        self.js = None  # js fetched by js_url
         self.js_url = None  # the url to the js, parsed from watch html
 
         # note: vid_info may eventually be removed. It sounds like it once had
         # additional formats, but that doesn't appear to still be the case.
 
-        self.vid_info = None      # content fetched by vid_info_url
+        self.vid_info = None  # content fetched by vid_info_url
         self.vid_info_url = None  # the url to vid info, parsed from watch html
 
-        self.watch_html = None     # the html of /watch?v=<video_id>
+        self.watch_html = None  # the html of /watch?v=<video_id>
         self.embed_html = None
         self.player_config_args = None  # inline js in the html containing
         # streams
@@ -77,8 +82,8 @@ class YouTube(object):
         # (Borg pattern).
         self.stream_monostate = {
             # user defined callback functions.
-            'on_progress': on_progress_callback,
-            'on_complete': on_complete_callback,
+            "on_progress": on_progress_callback,
+            "on_complete": on_complete_callback,
         }
 
         if proxies:
@@ -107,34 +112,30 @@ class YouTube(object):
         :rtype: None
 
         """
-        logger.info('init started')
+        logger.info("init started")
 
         self.vid_info = {k: v for k, v in parse_qsl(self.vid_info)}
         if self.age_restricted:
             self.player_config_args = self.vid_info
         else:
-            self.player_config_args = extract.get_ytplayer_config(
-                self.watch_html,
-            )['args']
+            self.player_config_args = extract.get_ytplayer_config(self.watch_html,)[
+                "args"
+            ]
 
             # Fix for KeyError: 'title' issue #434
-            if 'title' not in self.player_config_args:
-                i_start = (
-                    self.watch_html
-                    .lower()
-                    .index('<title>') + len('<title>')
-                )
-                i_end = self.watch_html.lower().index('</title>')
+            if "title" not in self.player_config_args:
+                i_start = self.watch_html.lower().index("<title>") + len("<title>")
+                i_end = self.watch_html.lower().index("</title>")
                 title = self.watch_html[i_start:i_end].strip()
-                index = title.lower().rfind(' - youtube')
+                index = title.lower().rfind(" - youtube")
                 title = title[:index] if index > 0 else title
-                self.player_config_args['title'] = title
+                self.player_config_args["title"] = unescape(title)
 
         self.vid_descr = extract.get_vid_descr(self.watch_html)
         # https://github.com/nficano/pytube/issues/165
-        stream_maps = ['url_encoded_fmt_stream_map']
-        if 'adaptive_fmts' in self.player_config_args:
-            stream_maps.append('adaptive_fmts')
+        stream_maps = ["url_encoded_fmt_stream_map"]
+        if "adaptive_fmts" in self.player_config_args:
+            stream_maps.append("adaptive_fmts")
 
         # unscramble the progressive and adaptive stream manifests.
         for fmt in stream_maps:
@@ -145,9 +146,7 @@ class YouTube(object):
             try:
                 mixins.apply_signature(self.player_config_args, fmt, self.js)
             except TypeError:
-                self.js_url = extract.js_url(
-                    self.embed_html, self.age_restricted,
-                )
+                self.js_url = extract.js_url(self.embed_html, self.age_restricted,)
                 self.js = request.get(self.js_url)
                 mixins.apply_signature(self.player_config_args, fmt, self.js)
 
@@ -155,10 +154,10 @@ class YouTube(object):
             self.initialize_stream_objects(fmt)
 
         # load the player_response object (contains subtitle information)
-        apply_mixin(self.player_config_args, 'player_response', json.loads)
+        apply_mixin(self.player_config_args, "player_response", json.loads)
 
         self.initialize_caption_objects()
-        logger.info('init finished successfully')
+        logger.info("init finished successfully")
 
     def prefetch(self):
         """Eagerly download all necessary data.
@@ -172,7 +171,7 @@ class YouTube(object):
         """
         self.watch_html = request.get(url=self.watch_url)
         if '<img class="icon meh" src="/yts/img' not in self.watch_html:
-            raise VideoUnavailable('This video is unavailable.')
+            raise VideoUnavailable("This video is unavailable.")
         self.embed_html = request.get(url=self.embed_url)
         self.age_restricted = extract.is_age_restricted(self.watch_html)
         self.vid_info_url = extract.video_info_url(
@@ -219,15 +218,14 @@ class YouTube(object):
         :rtype: None
 
         """
-        if 'captions' not in self.player_config_args['player_response']:
+        if "captions" not in self.player_config_args["player_response"]:
             return
         # https://github.com/nficano/pytube/issues/167
         caption_tracks = (
-            self.player_config_args
-            .get('player_response', {})
-            .get('captions', {})
-            .get('playerCaptionsTracklistRenderer', {})
-            .get('captionTracks', [])
+            self.player_config_args.get("player_response", {})
+            .get("captions", {})
+            .get("playerCaptionsTracklistRenderer", {})
+            .get("captionTracks", [])
         )
         for caption_track in caption_tracks:
             self.caption_tracks.append(Caption(caption_track))
@@ -255,7 +253,7 @@ class YouTube(object):
         :rtype: str
 
         """
-        return self.player_config_args['thumbnail_url']
+        return self.player_config_args["thumbnail_url"]
 
     @property
     def title(self):
@@ -264,7 +262,7 @@ class YouTube(object):
         :rtype: str
 
         """
-        return self.player_config_args['title']
+        return self.player_config_args["title"]
 
     @property
     def description(self):
@@ -283,10 +281,9 @@ class YouTube(object):
 
         """
         return (
-            self.player_config_args
-            .get('player_response', {})
-            .get('videoDetails', {})
-            .get('averageRating')
+            self.player_config_args.get("player_response", {})
+            .get("videoDetails", {})
+            .get("averageRating")
         )
 
     @property
@@ -296,7 +293,7 @@ class YouTube(object):
         :rtype: str
 
         """
-        return self.player_config_args['length_seconds']
+        return self.player_config_args["length_seconds"]
 
     @property
     def views(self):
@@ -306,10 +303,9 @@ class YouTube(object):
 
         """
         return (
-            self.player_config_args
-            .get('player_response', {})
-            .get('videoDetails', {})
-            .get('viewCount')
+            self.player_config_args.get("player_response", {})
+            .get("videoDetails", {})
+            .get("viewCount")
         )
 
     def register_on_progress_callback(self, func):
@@ -322,7 +318,7 @@ class YouTube(object):
         :rtype: None
 
         """
-        self.stream_monostate['on_progress'] = func
+        self.stream_monostate["on_progress"] = func
 
     def register_on_complete_callback(self, func):
         """Register a download complete callback function post initialization.
@@ -333,4 +329,4 @@ class YouTube(object):
         :rtype: None
 
         """
-        self.stream_monostate['on_complete'] = func
+        self.stream_monostate["on_complete"] = func

pytube/captions.py

@@ -7,6 +7,7 @@ import xml.etree.ElementTree as ElementTree
 from pytube import request
 from html import unescape
 
+
 class Caption:
     """Container for caption tracks."""
 
@@ -16,9 +17,9 @@ class Caption:
         :param dict caption_track:
             Caption track data extracted from ``watch_html``.
         """
-        self.url = caption_track.get('baseUrl')
-        self.name = caption_track['name']['simpleText']
-        self.code = caption_track['languageCode']
+        self.url = caption_track.get("baseUrl")
+        self.name = caption_track["name"]["simpleText"]
+        self.code = caption_track["languageCode"]
 
     @property
     def xml_captions(self):
@@ -44,8 +45,8 @@ class Caption:
         '00:00:03,890'
         """
         frac, whole = math.modf(d)
-        time_fmt = time.strftime('%H:%M:%S,', time.gmtime(whole))
-        ms = '{:.3f}'.format(frac).replace('0.', '')
+        time_fmt = time.strftime("%H:%M:%S,", time.gmtime(whole))
+        ms = "{:.3f}".format(frac).replace("0.", "")
         return time_fmt + ms
 
     def xml_caption_to_srt(self, xml_captions):
@@ -57,27 +58,21 @@ class Caption:
         segments = []
         root = ElementTree.fromstring(xml_captions)
         for i, child in enumerate(root.getchildren()):
-            text = child.text or ''
-            caption = unescape(
-                text
-                .replace('\n', ' ')
-                .replace('  ', ' '),
-            )
-            duration = float(child.attrib['dur'])
-            start = float(child.attrib['start'])
+            text = child.text or ""
+            caption = unescape(text.replace("\n", " ").replace("  ", " "),)
+            duration = float(child.attrib["dur"])
+            start = float(child.attrib["start"])
             end = start + duration
             sequence_number = i + 1  # convert from 0-indexed to 1.
-            line = (
-                '{seq}\n{start} --> {end}\n{text}\n'.format(
-                    seq=sequence_number,
-                    start=self.float_to_srt_time_format(start),
-                    end=self.float_to_srt_time_format(end),
-                    text=caption,
-                )
+            line = "{seq}\n{start} --> {end}\n{text}\n".format(
+                seq=sequence_number,
+                start=self.float_to_srt_time_format(start),
+                end=self.float_to_srt_time_format(end),
+                text=caption,
             )
             segments.append(line)
-        return '\n'.join(segments).strip()
+        return "\n".join(segments).strip()
 
     def __repr__(self):
         """Printable object representation."""
-        return'<Caption lang="{s.name}" code="{s.code}">'.format(s=self)
+        return '<Caption lang="{s.name}" code="{s.code}">'.format(s=self)

pytube/cipher.py

@@ -37,20 +37,20 @@ def get_initial_function_name(js):
     # c&&d.set("signature", EE(c));
 
     pattern = [
-        r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
-        r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
+        r"\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        r"\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
         r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',  # noqa: E501
         r'(["\'])signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
-        r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
-        r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<si$',  # noqa: E501
-        r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
-        r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
-        r'\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
-        r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
-        r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',  # noqa: E501
+        r"\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(",
+        r"yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<si$",  # noqa: E501
+        r"\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        r"\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        r"\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        r"\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        r"\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
     ]
 
-    logger.debug('finding initial function name')
+    logger.debug("finding initial function name")
     return regex_search(pattern, js, group=1)
 
 
@@ -76,9 +76,9 @@ def get_transform_plan(js):
     'DE.kT(a,21)']
     """
     name = re.escape(get_initial_function_name(js))
-    pattern = r'%s=function\(\w\){[a-z=\.\(\"\)]*;(.*);(?:.+)}' % name
-    logger.debug('getting transform plan')
-    return regex_search(pattern, js, group=1).split(';')
+    pattern = r"%s=function\(\w\){[a-z=\.\(\"\)]*;(.*);(?:.+)}" % name
+    logger.debug("getting transform plan")
+    return regex_search(pattern, js, group=1).split(";")
 
 
 def get_transform_object(js, var):
@@ -103,12 +103,12 @@ def get_transform_object(js, var):
     'kT:function(a,b){var c=a[0];a[0]=a[b%a.length];a[b]=c}']
 
     """
-    pattern = r'var %s={(.*?)};' % re.escape(var)
-    logger.debug('getting transform object')
+    pattern = r"var %s={(.*?)};" % re.escape(var)
+    logger.debug("getting transform object")
     return (
         regex_search(pattern, js, group=1, flags=re.DOTALL)
-        .replace('\n', ' ')
-        .split(', ')
+        .replace("\n", " ")
+        .split(", ")
     )
 
 
@@ -129,7 +129,7 @@ def get_transform_map(js, var):
     mapper = {}
     for obj in transform_object:
         # AJ:function(a){a.reverse()} => AJ, function(a){a.reverse()}
-        name, function = obj.split(':', 1)
+        name, function = obj.split(":", 1)
         fn = map_functions(function)
         mapper[name] = fn
     return mapper
@@ -169,7 +169,7 @@ def splice(arr, b):
     >>> splice([1, 2, 3, 4], 2)
     [1, 2]
     """
-    return arr[:b] + arr[b * 2:]
+    return arr[:b] + arr[b * 2 :]
 
 
 def swap(arr, b):
@@ -187,7 +187,7 @@ def swap(arr, b):
     [3, 2, 1, 4]
     """
     r = b % len(arr)
-    return list(chain([arr[r]], arr[1:r], [arr[0]], arr[r + 1:]))
+    return list(chain([arr[r]], arr[1:r], [arr[0]], arr[r + 1 :]))
 
 
 def map_functions(js_func):
@@ -199,15 +199,15 @@ def map_functions(js_func):
     """
     mapper = (
         # function(a){a.reverse()}
-        ('{\w\.reverse\(\)}', reverse),
+        ("{\w\.reverse\(\)}", reverse),
         # function(a,b){a.splice(0,b)}
-        ('{\w\.splice\(0,\w\)}', splice),
+        ("{\w\.splice\(0,\w\)}", splice),
         # function(a,b){var c=a[0];a[0]=a[b%a.length];a[b]=c}
-        ('{var\s\w=\w\[0\];\w\[0\]=\w\[\w\%\w.length\];\w\[\w\]=\w}', swap),
+        ("{var\s\w=\w\[0\];\w\[0\]=\w\[\w\%\w.length\];\w\[\w\]=\w}", swap),
         # function(a,b){var c=a[0];a[0]=a[b%a.length];a[b%a.length]=c}
         (
-            '{var\s\w=\w\[0\];\w\[0\]=\w\[\w\%\w.length\];'
-            '\w\[\w\%\w.length\]=\w}', swap,
+            "{var\s\w=\w\[0\];\w\[0\]=\w\[\w\%\w.length\];" "\w\[\w\%\w.length\]=\w}",
+            swap,
         ),
     )
 
@@ -215,8 +215,7 @@ def map_functions(js_func):
         if re.search(pattern, js_func):
             return fn
     raise RegexMatchError(
-        'could not find python equivalent function for: ',
-        js_func,
+        "could not find python equivalent function for: ", js_func,
     )
 
 
@@ -238,8 +237,8 @@ def parse_function(js_func):
     ('AJ', 15)
 
     """
-    logger.debug('parsing transform function')
-    return regex_search(r'\w+\.(\w+)\(\w,(\d+)\)', js_func, groups=True)
+    logger.debug("parsing transform function")
+    return regex_search(r"\w+\.(\w+)\(\w,(\d+)\)", js_func, groups=True)
 
 
 def get_signature(js, ciphered_signature):
@@ -258,7 +257,7 @@ def get_signature(js, ciphered_signature):
     """
     tplan = get_transform_plan(js)
     # DE.AJ(a,15) => DE, AJ(a,15)
-    var, _ = tplan[0].split('.')
+    var, _ = tplan[0].split(".")
     tmap = get_transform_map(js, var)
     signature = [s for s in ciphered_signature]
 
@@ -266,13 +265,15 @@ def get_signature(js, ciphered_signature):
         name, argument = parse_function(js_func)
         signature = tmap[name](signature, int(argument))
         logger.debug(
-            'applied transform function\n%s', pprint.pformat(
+            "applied transform function\n%s",
+            pprint.pformat(
                 {
-                    'output': ''.join(signature),
-                    'js_function': name,
-                    'argument': int(argument),
-                    'function': tmap[name],
-                }, indent=2,
+                    "output": "".join(signature),
+                    "js_function": name,
+                    "argument": int(argument),
+                    "function": tmap[name],
+                },
+                indent=2,
             ),
         )
-    return ''.join(signature)
+    return "".join(signature)

pytube/cli.py

@@ -21,30 +21,34 @@ logger = logging.getLogger(__name__)
 def main():
     """Command line application to download youtube videos."""
     parser = argparse.ArgumentParser(description=main.__doc__)
-    parser.add_argument('url', help='The YouTube /watch url', nargs='?')
+    parser.add_argument("url", help="The YouTube /watch url", nargs="?")
     parser.add_argument(
-        '--version', action='version',
-        version='%(prog)s ' + __version__,
+        "--version", action="version", version="%(prog)s " + __version__,
     )
     parser.add_argument(
-        '--itag', type=int, help=(
-            'The itag for the desired stream'
-        ),
+        "--itag", type=int, help=("The itag for the desired stream"),
     )
     parser.add_argument(
-        '-l', '--list', action='store_true', help=(
-            'The list option causes pytube cli to return a list of streams '
-            'available to download'
+        "-l",
+        "--list",
+        action="store_true",
+        help=(
+            "The list option causes pytube cli to return a list of streams "
+            "available to download"
         ),
     )
     parser.add_argument(
-        '-v', '--verbose', action='count', default=0, dest='verbosity',
-        help='Verbosity level',
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        dest="verbosity",
+        help="Verbosity level",
     )
     parser.add_argument(
-        '--build-playback-report', action='store_true', help=(
-            'Save the html and js to disk'
-        ),
+        "--build-playback-report",
+        action="store_true",
+        help=("Save the html and js to disk"),
     )
 
     args = parser.parse_args()
@@ -73,33 +77,33 @@ def build_playback_report(url):
     yt = YouTube(url)
     ts = int(dt.datetime.utcnow().timestamp())
     fp = os.path.join(
-        os.getcwd(),
-        'yt-video-{yt.video_id}-{ts}.json.gz'.format(yt=yt, ts=ts),
+        os.getcwd(), "yt-video-{yt.video_id}-{ts}.json.gz".format(yt=yt, ts=ts),
     )
 
     js = yt.js
     watch_html = yt.watch_html
     vid_info = yt.vid_info
 
-    with gzip.open(fp, 'wb') as fh:
+    with gzip.open(fp, "wb") as fh:
         fh.write(
-            json.dumps({
-                'url': url,
-                'js': js,
-                'watch_html': watch_html,
-                'video_info': vid_info,
-            })
-            .encode('utf8'),
+            json.dumps(
+                {
+                    "url": url,
+                    "js": js,
+                    "watch_html": watch_html,
+                    "video_info": vid_info,
+                }
+            ).encode("utf8"),
         )
 
 
 def get_terminal_size():
     """Return the terminal size in rows and columns."""
-    rows, columns = os.popen('stty size', 'r').read().split()
+    rows, columns = os.popen("stty size", "r").read().split()
     return int(rows), int(columns)
 
 
-def display_progress_bar(bytes_received, filesize, ch='█', scale=0.55):
+def display_progress_bar(bytes_received, filesize, ch="█", scale=0.55):
     """Display a simple, pretty progress bar.
 
     Example:
@@ -123,9 +127,9 @@ def display_progress_bar(bytes_received, filesize, ch='█', scale=0.55):
 
     filled = int(round(max_width * bytes_received / float(filesize)))
     remaining = max_width - filled
-    bar = ch * filled + ' ' * remaining
+    bar = ch * filled + " " * remaining
     percent = round(100.0 * bytes_received / float(filesize), 1)
-    text = ' ↳ |{bar}| {percent}%\r'.format(bar=bar, percent=percent)
+    text = " ↳ |{bar}| {percent}%\r".format(bar=bar, percent=percent)
     sys.stdout.write(text)
     sys.stdout.flush()
 
@@ -161,13 +165,10 @@ def download(url, itag):
     # TODO(nficano): allow dash itags to be selected
     yt = YouTube(url, on_progress_callback=on_progress)
     stream = yt.streams.get_by_itag(itag)
-    print('\n{fn} | {fs} bytes'.format(
-        fn=stream.default_filename,
-        fs=stream.filesize,
-    ))
+    print("\n{fn} | {fs} bytes".format(fn=stream.default_filename, fs=stream.filesize,))
     try:
         stream.download()
-        sys.stdout.write('\n')
+        sys.stdout.write("\n")
     except KeyboardInterrupt:
         sys.exit()
 
@@ -184,5 +185,5 @@ def display_streams(url):
         print(stream)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

pytube/contrib/playlist.py

@@ -31,9 +31,9 @@ class Playlist(object):
         :return: playlist url
         """
 
-        if 'watch?v=' in self.playlist_url:
-            base_url = 'https://www.youtube.com/playlist?list='
-            playlist_code = self.playlist_url.split('&list=')[1]
+        if "watch?v=" in self.playlist_url:
+            base_url = "https://www.youtube.com/playlist?list="
+            playlist_code = self.playlist_url.split("&list=")[1]
             return base_url + playlist_code
 
         # url is already in the desired format, so just return it
@@ -44,12 +44,13 @@ class Playlist(object):
         and returns the "load more" url if found.
         """
         try:
-            load_more_url = 'https://www.youtube.com' + re.search(
-                r'data-uix-load-more-href=\"(/browse_ajax\?'
-                'action_continuation=.*?)\"', req,
+            load_more_url = "https://www.youtube.com" + re.search(
+                r"data-uix-load-more-href=\"(/browse_ajax\?"
+                'action_continuation=.*?)"',
+                req,
             ).group(1)
         except AttributeError:
-            load_more_url = ''
+            load_more_url = ""
         return load_more_url
 
     def parse_links(self):
@@ -62,25 +63,22 @@ class Playlist(object):
         req = request.get(url)
 
         # split the page source by line and process each line
-        content = [x for x in req.split('\n') if 'pl-video-title-link' in x]
-        link_list = [x.split('href="', 1)[1].split('&', 1)[0] for x in content]
+        content = [x for x in req.split("\n") if "pl-video-title-link" in x]
+        link_list = [x.split('href="', 1)[1].split("&", 1)[0] for x in content]
 
         # The above only returns 100 or fewer links
         # Simulating a browser request for the load more link
         load_more_url = self._load_more_url(req)
-        while len(load_more_url):   # there is an url found
-            logger.debug('load more url: %s' % load_more_url)
+        while len(load_more_url):  # there is an url found
+            logger.debug("load more url: %s" % load_more_url)
             req = request.get(load_more_url)
             load_more = json.loads(req)
             videos = re.findall(
-                r'href=\"(/watch\?v=[\w-]*)',
-                load_more['content_html'],
+                r"href=\"(/watch\?v=[\w-]*)", load_more["content_html"],
             )
             # remove duplicates
             link_list.extend(list(OrderedDict.fromkeys(videos)))
-            load_more_url = self._load_more_url(
-                load_more['load_more_widget_html'],
-            )
+            load_more_url = self._load_more_url(load_more["load_more_widget_html"],)
 
         return link_list
 
@@ -91,7 +89,7 @@ class Playlist(object):
         :return: urls -> string
         """
 
-        base_url = 'https://www.youtube.com'
+        base_url = "https://www.youtube.com"
         link_list = self.parse_links()
 
         for video_id in link_list:
@@ -117,10 +115,7 @@ class Playlist(object):
         return (str(i).zfill(digits) for i in range(start, stop, step))
 
     def download_all(
-        self,
-        download_path=None,
-        prefix_number=True,
-        reverse_numbering=False,
+        self, download_path=None, prefix_number=True, reverse_numbering=False,
     ):
         """Download all the videos in the the playlist. Initially, download
         resolution is 720p (or highest available), later more option
@@ -144,8 +139,8 @@ class Playlist(object):
         """
 
         self.populate_video_urls()
-        logger.debug('total videos found: %d', len(self.video_urls))
-        logger.debug('starting download')
+        logger.debug("total videos found: %d", len(self.video_urls))
+        logger.debug("starting download")
 
         prefix_gen = self._path_num_prefix_generator(reverse_numbering)
 
@@ -157,22 +152,25 @@ class Playlist(object):
                 if not self.suppress_exception:
                     raise e
                 else:
-                    logger.debug('Exception suppressed')
+                    logger.debug("Exception suppressed")
             else:
                 # TODO: this should not be hardcoded to a single user's
                 # preference
-                dl_stream = yt.streams.filter(
-                    progressive=True, subtype='mp4',
-                ).order_by('resolution').desc().first()
-
-                logger.debug('download path: %s', download_path)
+                dl_stream = (
+                    yt.streams.filter(progressive=True, subtype="mp4",)
+                    .order_by("resolution")
+                    .desc()
+                    .first()
+                )
+
+                logger.debug("download path: %s", download_path)
                 if prefix_number:
                     prefix = next(prefix_gen)
-                    logger.debug('file prefix is: %s', prefix)
+                    logger.debug("file prefix is: %s", prefix)
                     dl_stream.download(download_path, filename_prefix=prefix)
                 else:
                     dl_stream.download(download_path)
-                logger.debug('download complete')
+                logger.debug("download complete")
 
     def title(self):
         """return playlist title (name)
@@ -180,13 +178,13 @@ class Playlist(object):
         try:
             url = self.construct_playlist_url()
             req = request.get(url)
-            open_tag = '<title>'
-            end_tag = '</title>'
-            matchresult = re.compile(open_tag + '(.+?)' + end_tag)
+            open_tag = "<title>"
+            end_tag = "</title>"
+            matchresult = re.compile(open_tag + "(.+?)" + end_tag)
             matchresult = matchresult.search(req).group()
-            matchresult = matchresult.replace(open_tag, '')
-            matchresult = matchresult.replace(end_tag, '')
-            matchresult = matchresult.replace('- YouTube', '')
+            matchresult = matchresult.replace(open_tag, "")
+            matchresult = matchresult.replace(end_tag, "")
+            matchresult = matchresult.replace("- YouTube", "")
             matchresult = matchresult.strip()
 
             return matchresult

pytube/exceptions.py

@@ -24,7 +24,7 @@ class ExtractError(PytubeError):
             A YouTube video identifier.
         """
         if video_id is not None:
-            msg = '{video_id}: {msg}'.format(video_id=video_id, msg=msg)
+            msg = "{video_id}: {msg}".format(video_id=video_id, msg=msg)
 
         super(ExtractError, self).__init__(msg)
 

pytube/extract.py

@@ -13,25 +13,25 @@ from pytube.helpers import regex_search
 class PytubeHTMLParser(HTMLParser):
     in_vid_descr = False
     in_vid_descr_br = False
-    vid_descr = ''
+    vid_descr = ""
 
     def handle_starttag(self, tag, attrs):
-        if tag == 'p':
+        if tag == "p":
             for attr in attrs:
-                if attr[0] == 'id' and attr[1] == 'eow-description':
+                if attr[0] == "id" and attr[1] == "eow-description":
                     self.in_vid_descr = True
 
     def handle_endtag(self, tag):
-        if self.in_vid_descr and tag == 'p':
+        if self.in_vid_descr and tag == "p":
             self.in_vid_descr = False
 
     def handle_startendtag(self, tag, attrs):
-        if self.in_vid_descr and tag == 'br':
+        if self.in_vid_descr and tag == "br":
             self.in_vid_descr_br = True
 
     def handle_data(self, data):
         if self.in_vid_descr_br:
-            self.vid_descr += '\n{}'.format(data)
+            self.vid_descr += "\n{}".format(data)
             self.in_vid_descr_br = False
         elif self.in_vid_descr:
             self.vid_descr += data
@@ -47,7 +47,7 @@ def is_age_restricted(watch_html):
         Whether or not the content is age restricted.
     """
     try:
-        regex_search(r'og:restrictions:age', watch_html, group=0)
+        regex_search(r"og:restrictions:age", watch_html, group=0)
     except RegexMatchError:
         return False
     return True
@@ -68,7 +68,7 @@ def video_id(url):
     :returns:
         YouTube video id.
     """
-    return regex_search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', url, group=1)
+    return regex_search(r"(?:v=|\/)([0-9A-Za-z_-]{11}).*", url, group=1)
 
 
 def watch_url(video_id):
@@ -80,20 +80,19 @@ def watch_url(video_id):
     :returns:
         Sanitized YouTube watch url.
     """
-    return 'https://youtube.com/watch?v=' + video_id
+    return "https://youtube.com/watch?v=" + video_id
 
 
 def embed_url(video_id):
-    return 'https://www.youtube.com/embed/{}'.format(video_id)
+    return "https://www.youtube.com/embed/{}".format(video_id)
 
 
 def eurl(video_id):
-    return 'https://youtube.googleapis.com/v/{}'.format(video_id)
+    return "https://youtube.googleapis.com/v/{}".format(video_id)
 
 
 def video_info_url(
-    video_id, watch_url, watch_html, embed_html,
-    age_restricted,
+    video_id, watch_url, watch_html, embed_html, age_restricted,
 ):
     """Construct the video_info url.
 
@@ -116,20 +115,20 @@ def video_info_url(
         sts = regex_search(r'"sts"\s*:\s*(\d+)', embed_html, group=1)
         # Here we use ``OrderedDict`` so that the output is consistent between
         # Python 2.7+.
-        params = OrderedDict([
-            ('video_id', video_id),
-            ('eurl', eurl(video_id)),
-            ('sts', sts),
-        ])
+        params = OrderedDict(
+            [("video_id", video_id), ("eurl", eurl(video_id)), ("sts", sts),]
+        )
     else:
-        params = OrderedDict([
-            ('video_id', video_id),
-            ('el', '$el'),
-            ('ps', 'default'),
-            ('eurl', quote(watch_url)),
-            ('hl', 'en_US'),
-        ])
-    return 'https://youtube.com/get_video_info?' + urlencode(params)
+        params = OrderedDict(
+            [
+                ("video_id", video_id),
+                ("el", "$el"),
+                ("ps", "default"),
+                ("eurl", quote(watch_url)),
+                ("hl", "en_US"),
+            ]
+        )
+    return "https://youtube.com/get_video_info?" + urlencode(params)
 
 
 def js_url(html, age_restricted=False):
@@ -145,8 +144,8 @@ def js_url(html, age_restricted=False):
 
     """
     ytplayer_config = get_ytplayer_config(html, age_restricted)
-    base_js = ytplayer_config['assets']['js']
-    return 'https://youtube.com' + base_js
+    base_js = ytplayer_config["assets"]["js"]
+    return "https://youtube.com" + base_js
 
 
 def mime_type_codec(mime_type_codec):
@@ -168,9 +167,9 @@ def mime_type_codec(mime_type_codec):
         The mime type and a list of codecs.
 
     """
-    pattern = r'(\w+\/\w+)\;\scodecs=\"([a-zA-Z-0-9.,\s]*)\"'
+    pattern = r"(\w+\/\w+)\;\scodecs=\"([a-zA-Z-0-9.,\s]*)\""
     mime_type, codecs = regex_search(pattern, mime_type_codec, groups=True)
-    return mime_type, [c.strip() for c in codecs.split(',')]
+    return mime_type, [c.strip() for c in codecs.split(",")]
 
 
 def get_ytplayer_config(html, age_restricted=False):
@@ -191,7 +190,7 @@ def get_ytplayer_config(html, age_restricted=False):
     if age_restricted:
         pattern = r";yt\.setConfig\(\{'PLAYER_CONFIG':\s*({.*})(,'EXPERIMENT_FLAGS'|;)"  # noqa: E501
     else:
-        pattern = r';ytplayer\.config\s*=\s*({.*?});'
+        pattern = r";ytplayer\.config\s*=\s*({.*?});"
     yt_player_config = regex_search(pattern, html, group=1)
     return json.loads(yt_player_config)
 

pytube/helpers.py

@@ -36,17 +36,13 @@ def regex_search(pattern, string, groups=False, group=None, flags=0):
             results = regex.search(string)
             if not results:
                 raise RegexMatchError(
-                    'regex pattern ({pattern}) had zero matches'
-                    .format(pattern=p),
+                    "regex pattern ({pattern}) had zero matches".format(pattern=p),
                 )
             else:
                 logger.debug(
-                    'finished regex search: %s',
+                    "finished regex search: %s",
                     pprint.pformat(
-                        {
-                            'pattern': p,
-                            'results': results.group(0),
-                        }, indent=2,
+                        {"pattern": p, "results": results.group(0),}, indent=2,
                     ),
                 )
                 if groups:
@@ -60,17 +56,13 @@ def regex_search(pattern, string, groups=False, group=None, flags=0):
         results = regex.search(string)
         if not results:
             raise RegexMatchError(
-                'regex pattern ({pattern}) had zero matches'
-                .format(pattern=pattern),
+                "regex pattern ({pattern}) had zero matches".format(pattern=pattern),
             )
         else:
             logger.debug(
-                'finished regex search: %s',
+                "finished regex search: %s",
                 pprint.pformat(
-                    {
-                        'pattern': pattern,
-                        'results': results.group(0),
-                    }, indent=2,
+                    {"pattern": pattern, "results": results.group(0),}, indent=2,
                 ),
             )
             if groups:
@@ -117,10 +109,28 @@ def safe_filename(s, max_length=255):
     # Characters in range 0-31 (0x00-0x1F) are not allowed in ntfs filenames.
     ntfs_chrs = [chr(i) for i in range(0, 31)]
     chrs = [
-        '\"', '\#', '\$', '\%', '\'', '\*', '\,', '\.', '\/', '\:', '"',
-        '\;', '\<', '\>', '\?', '\\', '\^', '\|', '\~', '\\\\',
+        '"',
+        "\#",
+        "\$",
+        "\%",
+        "'",
+        "\*",
+        "\,",
+        "\.",
+        "\/",
+        "\:",
+        '"',
+        "\;",
+        "\<",
+        "\>",
+        "\?",
+        "\\",
+        "\^",
+        "\|",
+        "\~",
+        "\\\\",
     ]
-    pattern = '|'.join(ntfs_chrs + chrs)
+    pattern = "|".join(ntfs_chrs + chrs)
     regex = re.compile(pattern, re.UNICODE)
-    filename = regex.sub('', s)
-    return filename[:max_length].rsplit(' ', 0)[0]
+    filename = regex.sub("", s)
+    return filename[:max_length].rsplit(" ", 0)[0]

pytube/itags.py

@@ -2,91 +2,89 @@
 """This module contains a lookup table of YouTube's itag values."""
 
 ITAGS = {
-    5: ('240p', '64kbps'),
-    6: ('270p', '64kbps'),
-    13: ('144p', None),
-    17: ('144p', '24kbps'),
-    18: ('360p', '96kbps'),
-    22: ('720p', '192kbps'),
-    34: ('360p', '128kbps'),
-    35: ('480p', '128kbps'),
-    36: ('240p', None),
-    37: ('1080p', '192kbps'),
-    38: ('3072p', '192kbps'),
-    43: ('360p', '128kbps'),
-    44: ('480p', '128kbps'),
-    45: ('720p', '192kbps'),
-    46: ('1080p', '192kbps'),
-    59: ('480p', '128kbps'),
-    78: ('480p', '128kbps'),
-    82: ('360p', '128kbps'),
-    83: ('480p', '128kbps'),
-    84: ('720p', '192kbps'),
-    85: ('1080p', '192kbps'),
-    91: ('144p', '48kbps'),
-    92: ('240p', '48kbps'),
-    93: ('360p', '128kbps'),
-    94: ('480p', '128kbps'),
-    95: ('720p', '256kbps'),
-    96: ('1080p', '256kbps'),
-    100: ('360p', '128kbps'),
-    101: ('480p', '192kbps'),
-    102: ('720p', '192kbps'),
-    132: ('240p', '48kbps'),
-    151: ('720p', '24kbps'),
-
+    5: ("240p", "64kbps"),
+    6: ("270p", "64kbps"),
+    13: ("144p", None),
+    17: ("144p", "24kbps"),
+    18: ("360p", "96kbps"),
+    22: ("720p", "192kbps"),
+    34: ("360p", "128kbps"),
+    35: ("480p", "128kbps"),
+    36: ("240p", None),
+    37: ("1080p", "192kbps"),
+    38: ("3072p", "192kbps"),
+    43: ("360p", "128kbps"),
+    44: ("480p", "128kbps"),
+    45: ("720p", "192kbps"),
+    46: ("1080p", "192kbps"),
+    59: ("480p", "128kbps"),
+    78: ("480p", "128kbps"),
+    82: ("360p", "128kbps"),
+    83: ("480p", "128kbps"),
+    84: ("720p", "192kbps"),
+    85: ("1080p", "192kbps"),
+    91: ("144p", "48kbps"),
+    92: ("240p", "48kbps"),
+    93: ("360p", "128kbps"),
+    94: ("480p", "128kbps"),
+    95: ("720p", "256kbps"),
+    96: ("1080p", "256kbps"),
+    100: ("360p", "128kbps"),
+    101: ("480p", "192kbps"),
+    102: ("720p", "192kbps"),
+    132: ("240p", "48kbps"),
+    151: ("720p", "24kbps"),
     # DASH Video
-    133: ('240p', None),
-    134: ('360p', None),
-    135: ('480p', None),
-    136: ('720p', None),
-    137: ('1080p', None),
-    138: ('2160p', None),
-    160: ('144p', None),
-    167: ('360p', None),
-    168: ('480p', None),
-    169: ('720p', None),
-    170: ('1080p', None),
-    212: ('480p', None),
-    218: ('480p', None),
-    219: ('480p', None),
-    242: ('240p', None),
-    243: ('360p', None),
-    244: ('480p', None),
-    245: ('480p', None),
-    246: ('480p', None),
-    247: ('720p', None),
-    248: ('1080p', None),
-    264: ('1440p', None),
-    266: ('2160p', None),
-    271: ('1440p', None),
-    272: ('2160p', None),
-    278: ('144p', None),
-    298: ('720p', None),
-    299: ('1080p', None),
-    302: ('720p', None),
-    303: ('1080p', None),
-    308: ('1440p', None),
-    313: ('2160p', None),
-    315: ('2160p', None),
-    330: ('144p', None),
-    331: ('240p', None),
-    332: ('360p', None),
-    333: ('480p', None),
-    334: ('720p', None),
-    335: ('1080p', None),
-    336: ('1440p', None),
-    337: ('2160p', None),
-
+    133: ("240p", None),
+    134: ("360p", None),
+    135: ("480p", None),
+    136: ("720p", None),
+    137: ("1080p", None),
+    138: ("2160p", None),
+    160: ("144p", None),
+    167: ("360p", None),
+    168: ("480p", None),
+    169: ("720p", None),
+    170: ("1080p", None),
+    212: ("480p", None),
+    218: ("480p", None),
+    219: ("480p", None),
+    242: ("240p", None),
+    243: ("360p", None),
+    244: ("480p", None),
+    245: ("480p", None),
+    246: ("480p", None),
+    247: ("720p", None),
+    248: ("1080p", None),
+    264: ("1440p", None),
+    266: ("2160p", None),
+    271: ("1440p", None),
+    272: ("2160p", None),
+    278: ("144p", None),
+    298: ("720p", None),
+    299: ("1080p", None),
+    302: ("720p", None),
+    303: ("1080p", None),
+    308: ("1440p", None),
+    313: ("2160p", None),
+    315: ("2160p", None),
+    330: ("144p", None),
+    331: ("240p", None),
+    332: ("360p", None),
+    333: ("480p", None),
+    334: ("720p", None),
+    335: ("1080p", None),
+    336: ("1440p", None),
+    337: ("2160p", None),
     # DASH Audio
-    139: (None, '48kbps'),
-    140: (None, '128kbps'),
-    141: (None, '256kbps'),
-    171: (None, '128kbps'),
-    172: (None, '256kbps'),
-    249: (None, '50kbps'),
-    250: (None, '70kbps'),
-    251: (None, '160kbps'),
+    139: (None, "48kbps"),
+    140: (None, "128kbps"),
+    141: (None, "256kbps"),
+    171: (None, "128kbps"),
+    172: (None, "256kbps"),
+    249: (None, "50kbps"),
+    250: (None, "70kbps"),
+    251: (None, "160kbps"),
     256: (None, None),
     258: (None, None),
     325: (None, None),
@@ -111,10 +109,10 @@ def get_format_profile(itag):
     else:
         res, bitrate = None, None
     return {
-        'resolution': res,
-        'abr': bitrate,
-        'is_live': itag in LIVE,
-        'is_3d': itag in _3D,
-        'is_hdr': itag in HDR,
-        'fps': 60 if itag in _60FPS else 30,
+        "resolution": res,
+        "abr": bitrate,
+        "is_live": itag in LIVE,
+        "is_3d": itag in _3D,
+        "is_hdr": itag in HDR,
+        "fps": 60 if itag in _60FPS else 30,
     }

pytube/logging.py

@@ -11,15 +11,15 @@ def create_logger(level=logging.ERROR):
     :param int level:
         Describe the severity level of the logs to handle.
     """
-    fmt = '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
-    date_fmt = '%H:%M:%S'
+    fmt = "[%(asctime)s] %(levelname)s in %(module)s: %(message)s"
+    date_fmt = "%H:%M:%S"
     formatter = logging.Formatter(fmt, datefmt=date_fmt)
 
     handler = logging.StreamHandler()
     handler.setFormatter(formatter)
 
     # https://github.com/nficano/pytube/issues/163
-    logger = logging.getLogger('pytube')
+    logger = logging.getLogger("pytube")
     logger.addHandler(handler)
     logger.setLevel(level)
     return logger

pytube/mixins.py

@@ -31,46 +31,41 @@ def apply_signature(config_args, fmt, js):
 
     """
     stream_manifest = config_args[fmt]
-    live_stream = json.loads(config_args['player_response']).get(
-        'playabilityStatus', {},
-    ).get('liveStreamability')
+    live_stream = (
+        json.loads(config_args["player_response"])
+        .get("playabilityStatus", {},)
+        .get("liveStreamability")
+    )
     for i, stream in enumerate(stream_manifest):
-        if 'url' in stream:
-            url = stream['url']
+        if "url" in stream:
+            url = stream["url"]
         elif live_stream:
-            raise LiveStreamError('Video is currently being streamed live')
+            raise LiveStreamError("Video is currently being streamed live")
         # 403 Forbidden fix.
-        if (
-            'signature' in url or (
-                's' not in stream and (
-                    '&sig=' in url or '&lsig=' in url
-                )
-            )
+        if "signature" in url or (
+            "s" not in stream and ("&sig=" in url or "&lsig=" in url)
         ):
             # For certain videos, YouTube will just provide them pre-signed, in
             # which case there's no real magic to download them and we can skip
             # the whole signature descrambling entirely.
-            logger.debug('signature found, skip decipher')
+            logger.debug("signature found, skip decipher")
             continue
 
         if js is not None:
-            signature = cipher.get_signature(js, stream['s'])
+            signature = cipher.get_signature(js, stream["s"])
         else:
             # signature not present in url (line 33), need js to descramble
             # TypeError caught in __main__
-            raise TypeError('JS is None')
+            raise TypeError("JS is None")
 
         logger.debug(
-            'finished descrambling signature for itag=%s\n%s',
-            stream['itag'], pprint.pformat(
-                {
-                    's': stream['s'],
-                    'signature': signature,
-                }, indent=2,
-            ),
+            "finished descrambling signature for itag=%s\n%s",
+            stream["itag"],
+            pprint.pformat({"s": stream["s"], "signature": signature,}, indent=2,),
         )
         # 403 forbidden fix
-        stream_manifest[i]['url'] = url + '&sig=' + signature
+        stream_manifest[i]["url"] = url + "&sig=" + signature
+
 
 def apply_descrambler(stream_data, key):
     """Apply various in-place transforms to YouTube's media stream data.
@@ -92,33 +87,49 @@ def apply_descrambler(stream_data, key):
     {'foo': [{'bar': '1', 'var': 'test'}, {'em': '5', 't': 'url encoded'}]}
 
     """
-    if key == 'url_encoded_fmt_stream_map' and not stream_data.get('url_encoded_fmt_stream_map'):
-        formats = json.loads(stream_data['player_response'])[
-            'streamingData']['formats']
-        formats.extend(json.loads(stream_data['player_response'])[
-                       'streamingData']['adaptiveFormats'])
+    if key == "url_encoded_fmt_stream_map" and not stream_data.get(
+        "url_encoded_fmt_stream_map"
+    ):
+        formats = json.loads(stream_data["player_response"])["streamingData"]["formats"]
+        formats.extend(
+            json.loads(stream_data["player_response"])["streamingData"][
+                "adaptiveFormats"
+            ]
+        )
         try:
-            stream_data[key] = [{u'url': format_item[u'url'],
-                                 u'type': format_item[u'mimeType'],
-                                 u'quality': format_item[u'quality'],
-                                 u'itag': format_item[u'itag']} for format_item in formats]
+            stream_data[key] = [
+                {
+                    u"url": format_item[u"url"],
+                    u"type": format_item[u"mimeType"],
+                    u"quality": format_item[u"quality"],
+                    u"itag": format_item[u"itag"],
+                }
+                for format_item in formats
+            ]
         except KeyError:
-            cipher_url = [parse_qs(formats[i]['cipher']) for i, data in enumerate(formats)]
-            stream_data[key] = [{u'url': cipher_url[i][u'url'][0],
-                                 u's': cipher_url[i][u's'][0],
-                                 u'type': format_item[u'mimeType'],
-                                 u'quality': format_item[u'quality'],
-                                 u'itag': format_item[u'itag']} for i, format_item in enumerate(formats)]
+            cipher_url = [
+                parse_qs(formats[i]["cipher"]) for i, data in enumerate(formats)
+            ]
+            stream_data[key] = [
+                {
+                    u"url": cipher_url[i][u"url"][0],
+                    u"s": cipher_url[i][u"s"][0],
+                    u"type": format_item[u"mimeType"],
+                    u"quality": format_item[u"quality"],
+                    u"itag": format_item[u"itag"],
+                }
+                for i, format_item in enumerate(formats)
+            ]
     else:
         stream_data[key] = [
             {k: unquote(v) for k, v in parse_qsl(i)}
-            for i in stream_data[key].split(',')
+            for i in stream_data[key].split(",")
         ]
     logger.debug(
-        'applying descrambler\n%s',
-        pprint.pformat(stream_data[key], indent=2),
+        "applying descrambler\n%s", pprint.pformat(stream_data[key], indent=2),
     )
 
+
 def install_proxy(proxy_handler):
     proxy_support = request.ProxyHandler(proxy_handler)
     opener = request.build_opener(proxy_support)

pytube/query.py

@@ -15,12 +15,23 @@ class StreamQuery:
         self.itag_index = {int(s.itag): s for s in fmt_streams}
 
     def filter(
-            self, fps=None, res=None, resolution=None, mime_type=None,
-            type=None, subtype=None, file_extension=None, abr=None,
-            bitrate=None, video_codec=None, audio_codec=None,
-            only_audio=None, only_video=None,
-            progressive=None, adaptive=None,
-            custom_filter_functions=None,
+        self,
+        fps=None,
+        res=None,
+        resolution=None,
+        mime_type=None,
+        type=None,
+        subtype=None,
+        file_extension=None,
+        abr=None,
+        bitrate=None,
+        video_codec=None,
+        audio_codec=None,
+        only_audio=None,
+        only_video=None,
+        progressive=None,
+        adaptive=None,
+        custom_filter_functions=None,
     ):
         """Apply the given filtering criterion.
 
@@ -129,16 +140,12 @@ class StreamQuery:
 
         if only_audio:
             filters.append(
-                lambda s: (
-                    s.includes_audio_track and not s.includes_video_track
-                ),
+                lambda s: (s.includes_audio_track and not s.includes_video_track),
             )
 
         if only_video:
             filters.append(
-                lambda s: (
-                    s.includes_video_track and not s.includes_audio_track
-                ),
+                lambda s: (s.includes_video_track and not s.includes_audio_track),
             )
 
         if progressive:
@@ -167,21 +174,21 @@ class StreamQuery:
             attr = getattr(stream, attribute_name)
             if attr is None:
                 break
-            num = ''.join(x for x in attr if x.isdigit())
-            integer_attr_repr[attr] = int(''.join(num)) if num else None
+            num = "".join(x for x in attr if x.isdigit())
+            integer_attr_repr[attr] = int("".join(num)) if num else None
 
         # if every attribute has an integer representation
         if integer_attr_repr and all(integer_attr_repr.values()):
+
             def key(s):
                 return integer_attr_repr[getattr(s, attribute_name)]
+
         else:
+
             def key(s):
                 return getattr(s, attribute_name)
 
-        fmt_streams = sorted(
-            self.fmt_streams,
-            key=key,
-        )
+        fmt_streams = sorted(self.fmt_streams, key=key,)
         return StreamQuery(fmt_streams)
 
     def desc(self):

pytube/request.py

@@ -2,12 +2,12 @@
 """Implements a simple wrapper around urlopen."""
 from urllib.request import Request
 from urllib.request import urlopen
+
 # 403 forbidden fix
 
 
 def get(
-    url=None, headers=False,
-    streaming=False, chunk_size=8 * 1024,
+    url=None, headers=False, streaming=False, chunk_size=8 * 1024,
 ):
     """Send an http GET request.
 
@@ -22,7 +22,7 @@ def get(
     """
 
     # https://github.com/nficano/pytube/pull/465
-    req = Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+    req = Request(url, headers={"User-Agent": "Mozilla/5.0"})
     response = urlopen(req)
 
     if streaming:
@@ -30,11 +30,7 @@ def get(
     elif headers:
         # https://github.com/nficano/pytube/issues/160
         return {k.lower(): v for k, v in response.info().items()}
-    return (
-        response
-        .read()
-        .decode('utf-8')
-    )
+    return response.read().decode("utf-8")
 
 
 def stream_response(response, chunk_size=8 * 1024):

pytube/streams.py

@@ -42,18 +42,18 @@ class Stream(object):
         # (Borg pattern).
         self._monostate = monostate
 
-        self.abr = None   # average bitrate (audio streams only)
-        self.fps = None   # frames per second (video streams only)
+        self.abr = None  # average bitrate (audio streams only)
+        self.fps = None  # frames per second (video streams only)
         self.itag = None  # stream format id (youtube nomenclature)
-        self.res = None   # resolution (e.g.: 480p, 720p, 1080p)
-        self.url = None   # signed download url
+        self.res = None  # resolution (e.g.: 480p, 720p, 1080p)
+        self.url = None  # signed download url
 
         self._filesize = None  # filesize in bytes
         self.mime_type = None  # content identifier (e.g.: video/mp4)
-        self.type = None       # the part of the mime before the slash
-        self.subtype = None    # the part of the mime after the slash
+        self.type = None  # the part of the mime before the slash
+        self.subtype = None  # the part of the mime after the slash
 
-        self.codecs = []         # audio/video encoders (e.g.: vp8, mp4a)
+        self.codecs = []  # audio/video encoders (e.g.: vp8, mp4a)
         self.audio_codec = None  # audio codec of the stream (e.g.: vorbis)
         self.video_codec = None  # video codec of the stream (e.g.: vp8)
 
@@ -77,7 +77,7 @@ class Stream(object):
         self.mime_type, self.codecs = extract.mime_type_codec(self.type)
 
         # 'video/webm' -> 'video', 'webm'
-        self.type, self.subtype = self.mime_type.split('/')
+        self.type, self.subtype = self.mime_type.split("/")
 
         # ['vp8', 'vorbis'] -> video_codec: vp8, audio_codec: vorbis. DASH
         # streams return NoneType for audio/video depending.
@@ -117,7 +117,7 @@ class Stream(object):
         """
         if self.is_progressive:
             return True
-        return self.type == 'audio'
+        return self.type == "audio"
 
     @property
     def includes_video_track(self):
@@ -127,7 +127,7 @@ class Stream(object):
         """
         if self.is_progressive:
             return True
-        return self.type == 'video'
+        return self.type == "video"
 
     def parse_codecs(self):
         """Get the video/audio codecs from list of codecs.
@@ -162,7 +162,7 @@ class Stream(object):
         """
         if self._filesize is None:
             headers = request.get(self.url, headers=True)
-            self._filesize = int(headers['content-length'])
+            self._filesize = int(headers["content-length"])
         return self._filesize
 
     @property
@@ -175,17 +175,17 @@ class Stream(object):
         """
         player_config_args = self.player_config_args or {}
 
-        if 'title' in player_config_args:
-            return player_config_args['title']
+        if "title" in player_config_args:
+            return player_config_args["title"]
 
-        details = self.player_config_args.get(
-            'player_response', {},
-        ).get('videoDetails', {})
+        details = self.player_config_args.get("player_response", {},).get(
+            "videoDetails", {}
+        )
 
-        if 'title' in details:
-            return details['title']
+        if "title" in details:
+            return details["title"]
 
-        return 'Unknown YouTube Video Title'
+        return "Unknown YouTube Video Title"
 
     @property
     def default_filename(self):
@@ -197,7 +197,7 @@ class Stream(object):
         """
 
         filename = safe_filename(self.title)
-        return '{filename}.{s.subtype}'.format(filename=filename, s=self)
+        return "{filename}.{s.subtype}".format(filename=filename, s=self)
 
     def download(self, output_path=None, filename=None, filename_prefix=None):
         """Write the media stream to disk.
@@ -224,25 +224,22 @@ class Stream(object):
         output_path = output_path or os.getcwd()
         if filename:
             safe = safe_filename(filename)
-            filename = '{filename}.{s.subtype}'.format(filename=safe, s=self)
+            filename = "{filename}.{s.subtype}".format(filename=safe, s=self)
         filename = filename or self.default_filename
 
         if filename_prefix:
-            filename = '{prefix}{filename}'\
-                .format(
-                    prefix=safe_filename(filename_prefix),
-                    filename=filename,
-                )
+            filename = "{prefix}{filename}".format(
+                prefix=safe_filename(filename_prefix), filename=filename,
+            )
 
         # file path
         fp = os.path.join(output_path, filename)
         bytes_remaining = self.filesize
         logger.debug(
-            'downloading (%s total bytes) file to %s',
-            self.filesize, fp,
+            "downloading (%s total bytes) file to %s", self.filesize, fp,
         )
 
-        with open(fp, 'wb') as fh:
+        with open(fp, "wb") as fh:
             for chunk in request.get(self.url, streaming=True):
                 # reduce the (bytes) remainder by the length of the chunk.
                 bytes_remaining -= len(chunk)
@@ -259,8 +256,7 @@ class Stream(object):
         buffer = io.BytesIO()
         bytes_remaining = self.filesize
         logger.debug(
-            'downloading (%s total bytes) file to BytesIO buffer',
-            self.filesize,
+            "downloading (%s total bytes) file to BytesIO buffer", self.filesize,
         )
 
         for chunk in request.get(self.url, streaming=True):
@@ -293,17 +289,15 @@ class Stream(object):
         """
         file_handler.write(chunk)
         logger.debug(
-            'download progress\n%s',
+            "download progress\n%s",
             pprint.pformat(
-                {
-                    'chunk_size': len(chunk),
-                    'bytes_remaining': bytes_remaining,
-                }, indent=2,
+                {"chunk_size": len(chunk), "bytes_remaining": bytes_remaining,},
+                indent=2,
             ),
         )
-        on_progress = self._monostate['on_progress']
+        on_progress = self._monostate["on_progress"]
         if on_progress:
-            logger.debug('calling on_progress callback %s', on_progress)
+            logger.debug("calling on_progress callback %s", on_progress)
             on_progress(self, chunk, file_handler, bytes_remaining)
 
     def on_complete(self, file_handle):
@@ -317,10 +311,10 @@ class Stream(object):
         :rtype: None
 
         """
-        logger.debug('download finished')
-        on_complete = self._monostate['on_complete']
+        logger.debug("download finished")
+        on_complete = self._monostate["on_complete"]
         if on_complete:
-            logger.debug('calling on_complete callback %s', on_complete)
+            logger.debug("calling on_complete callback %s", on_complete)
             on_complete(self, file_handle)
 
     def __repr__(self):
@@ -335,13 +329,12 @@ class Stream(object):
         if self.includes_video_track:
             parts.extend(['res="{s.resolution}"', 'fps="{s.fps}fps"'])
             if not self.is_adaptive:
-                parts.extend([
-                    'vcodec="{s.video_codec}"',
-                    'acodec="{s.audio_codec}"',
-                ])
+                parts.extend(
+                    ['vcodec="{s.video_codec}"', 'acodec="{s.audio_codec}"',]
+                )
             else:
                 parts.extend(['vcodec="{s.video_codec}"'])
         else:
             parts.extend(['abr="{s.abr}"', 'acodec="{s.audio_codec}"'])
-        parts = ' '.join(parts).format(s=self)
-        return '<Stream: {parts}>'.format(parts=parts)
+        parts = " ".join(parts).format(s=self)
+        return "<Stream: {parts}>".format(parts=parts)