Merge d1f9f08963 into 89f535e265

[ci] Fix `curl-cffi` installation (Bugfix for 02483bea1c)
Authored by: bashonly
2024-04-24 06:01:40 +00:00 · 2024-04-22 20:36:01 +00:00 · 2024-04-21 22:41:40 +00:00 · 2024-04-21 16:05:42 +00:00 · 2024-04-21 13:40:38 +02:00 · 2023-03-08 13:46:03 +01:00
14 changed files with 921 additions and 159 deletions
--- a/.github/workflows/core.yml
+++ b/.github/workflows/core.yml
@ -53,7 +53,7 @@ jobs:
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install test requirements
-      run: python3 ./devscripts/install_deps.py --include dev --include curl_cffi
+      run: python3 ./devscripts/install_deps.py --include dev --include curl-cffi
    - name: Run tests
      continue-on-error: False
      run: |
--- a/test/test_InfoExtractor.py
+++ b/test/test_InfoExtractor.py
@ -1906,6 +1906,15 @@ def test_response_with_expected_status_returns_content(self):
            expected_status=TEAPOT_RESPONSE_STATUS)
        self.assertEqual(content, TEAPOT_RESPONSE_BODY)

+    def test_search_nextjs_data(self):
+        data = '<script id="__NEXT_DATA__" type="application/json">{"props":{}}</script>'
+        self.assertEqual(self.ie._search_nextjs_data(data, None), {'props': {}})
+        self.assertEqual(self.ie._search_nextjs_data('', None, fatal=False), {})
+        self.assertEqual(self.ie._search_nextjs_data('', None, default=None), None)
+        self.assertEqual(self.ie._search_nextjs_data('', None, default={}), {})
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(self.ie._search_nextjs_data('', None, default='{}'), {})
+

 if __name__ == '__main__':
    unittest.main()
--- a/yt_dlp/blowfish.py
+++ b/yt_dlp/blowfish.py
@ -0,0 +1,309 @@
+from .compat import compat_struct_unpack, compat_struct_pack
+
+# Blowfish implementation, translated from original C code by Bruce Schneier.
+
+N = 16
+
+# the initialization data is the binary representation of PI - 3
+
+# N+2 words
+P0 = [
+    0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822,
+    0x299f31d0, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377,
+    0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5,
+    0xb5470917, 0x9216d5d9, 0x8979fb1b,
+]
+
+
+# 4 * 256 words
+S0 = [
+    [
+        0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
+        0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+        0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658,
+        0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+        0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e,
+        0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+        0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6,
+        0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+        0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c,
+        0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+        0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1,
+        0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+        0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a,
+        0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+        0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176,
+        0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+        0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706,
+        0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+        0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b,
+        0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+        0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c,
+        0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+        0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a,
+        0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+        0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760,
+        0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+        0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8,
+        0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+        0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33,
+        0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+        0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0,
+        0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+        0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777,
+        0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+        0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705,
+        0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+        0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e,
+        0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+        0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9,
+        0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+        0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f,
+        0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+        0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
+    ],
+    [
+        0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d,
+        0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+        0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65,
+        0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+        0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9,
+        0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+        0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d,
+        0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+        0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc,
+        0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+        0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908,
+        0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+        0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124,
+        0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+        0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908,
+        0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+        0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b,
+        0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+        0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa,
+        0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+        0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d,
+        0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+        0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5,
+        0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+        0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96,
+        0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+        0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca,
+        0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+        0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77,
+        0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+        0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054,
+        0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+        0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea,
+        0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+        0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646,
+        0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+        0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea,
+        0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+        0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e,
+        0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+        0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd,
+        0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+        0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
+    ],
+    [
+        0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7,
+        0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+        0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af,
+        0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+        0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4,
+        0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+        0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec,
+        0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+        0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332,
+        0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+        0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58,
+        0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+        0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22,
+        0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+        0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60,
+        0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+        0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99,
+        0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+        0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74,
+        0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+        0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3,
+        0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+        0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
+        0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+        0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa,
+        0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+        0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086,
+        0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+        0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24,
+        0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+        0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84,
+        0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+        0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
+        0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+        0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe,
+        0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+        0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0,
+        0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+        0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188,
+        0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+        0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8,
+        0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+        0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
+    ],
+    [
+        0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742,
+        0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+        0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79,
+        0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+        0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a,
+        0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+        0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1,
+        0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+        0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797,
+        0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+        0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6,
+        0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+        0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba,
+        0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+        0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5,
+        0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+        0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce,
+        0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+        0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd,
+        0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+        0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb,
+        0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+        0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc,
+        0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+        0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc,
+        0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+        0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a,
+        0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+        0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a,
+        0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+        0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b,
+        0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+        0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e,
+        0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+        0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623,
+        0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+        0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a,
+        0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+        0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3,
+        0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+        0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c,
+        0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+        0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+    ],
+]
+
+
+class Blowfish:
+    def __init__(self, key):
+        j = [0]
+
+        def nextkeybyte():
+            data = key[j[0]]
+            j[0] += 1
+            if j[0] >= len(key):
+                j[0] = 0
+            if type(data) != int:
+                data = ord(data)
+            return data
+
+        def nextkeyword():
+            data = 0
+            for _ in range(4):
+                data <<= 8
+                data |= nextkeybyte()
+            return data
+
+        self.P = [p ^ nextkeyword() for p in P0]
+        self.S = [[s for s in sblock] for sblock in S0]
+
+        datal, datar = 0, 0
+        for i in range(0, N + 2, 2):
+            datal, datar = self.encipher(datal, datar)
+            self.P[i] = datal
+            self.P[i + 1] = datar
+
+        for i in range(4):
+            for j in range(0, 256, 2):
+                datal, datar = self.encipher(datal, datar)
+                self.S[i][j] = datal
+                self.S[i][j + 1] = datar
+
+    def F(self, x):
+        d = x & 0xFF
+        x >>= 8
+        c = x & 0xFF
+        x >>= 8
+        b = x & 0xFF
+        x >>= 8
+        a = x & 0xFF
+
+        y = self.S[0][a] + self.S[1][b]
+        y = y ^ self.S[2][c]
+        y = y + self.S[3][d]
+
+        return y & 0xFFFFFFFF
+
+    def encipher(self, Xl, Xr):
+        for i in range(N):
+            Xl = Xl ^ self.P[i]
+            Xr = self.F(Xl) ^ Xr
+
+            Xl, Xr = Xr, Xl
+
+        Xl, Xr = Xr, Xl
+
+        Xr = Xr ^ self.P[N]
+        Xl = Xl ^ self.P[N + 1]
+
+        return Xl, Xr
+
+    def decipher(self, Xl, Xr):
+        for i in range(N + 1, 1, -1):
+            Xl = Xl ^ self.P[i]
+            Xr = self.F(Xl) ^ Xr
+
+            Xl, Xr = Xr, Xl
+
+        Xl, Xr = Xr, Xl
+
+        Xr = Xr ^ self.P[1]
+        Xl = Xl ^ self.P[0]
+
+        return Xl, Xr
+
+
+def blowfish_cbc_decrypt(data, key, iv):
+    """
+    Decrypt with blowfish in CBC mode
+
+    @param {int[]} data        cipher
+    @param {int[]} key         variable length key
+    @param {int[]} iv          8-Byte IV
+    @returns {int[]}           decrypted data
+    """
+    fmt = ">%dL" % (len(data) // 4)
+    c = Blowfish(key)
+    ivl, ivr = compat_struct_unpack(">LL", iv)
+    out = []
+    ind = compat_struct_unpack(fmt, data)
+
+    for i in range(0, len(ind), 2):
+        l, r = c.decipher(ind[i], ind[i + 1])
+        l ^= ivl
+        r ^= ivr
+        ivl, ivr = ind[i], ind[i + 1]
+
+        out.append(l)
+        out.append(r)
+
+    return compat_struct_pack(fmt, *out)
+
+
+__all__ = ['blowfish_cbc_decrypt']
--- a/yt_dlp/downloader/init.py
+++ b/yt_dlp/downloader/init.py
@ -23,6 +23,7 @@ def get_suitable_downloader(info_dict, params={}, default=NO_DEFAULT, protocol=N
 # Some of these require get_suitable_downloader
 from .common import FileDownloader
 from .dash import DashSegmentsFD
+from .deezer import DeezerFD
 from .external import FFmpegFD, get_external_downloader
 from .f4m import F4mFD
 from .fc2 import FC2LiveFD
@ -45,6 +46,7 @@ def get_suitable_downloader(info_dict, params={}, default=NO_DEFAULT, protocol=N
    'mms': RtspFD,
    'rtsp': RtspFD,
    'f4m': F4mFD,
+    'deezer': DeezerFD,
    'http_dash_segments': DashSegmentsFD,
    'http_dash_segments_generator': DashSegmentsFD,
    'ism': IsmFD,
--- a/yt_dlp/downloader/deezer.py
+++ b/yt_dlp/downloader/deezer.py
@ -0,0 +1,121 @@
+from __future__ import unicode_literals
+
+from ..blowfish import blowfish_cbc_decrypt
+from .common import FileDownloader
+from ..utils import sanitized_Request, sanitize_open
+from ..compat import compat_struct_pack
+import time
+
+
+def writeid3v1(fo, info_dict):
+    data = compat_struct_pack("3s" "30s" "30s" "30s" "4s" "28s" "BB" "B",
+                              b"TAG",
+                              info_dict["track"].encode('utf-8'),
+                              info_dict["artist"].encode('utf-8'),
+                              info_dict["album"].encode('utf-8'),
+                              b"",   # year
+                              b"",   # comment
+                              0, int(info_dict["track_number"] or 0),  # tracknum
+                              255)   # genre
+    fo.write(data)
+
+
+def writeid3v2(fo, info_dict, ydl):
+    def make28bit(x):
+        return ((x << 3) & 0x7F000000) | ((x << 2) & 0x7F0000) | ((x << 1) & 0x7F00) | (x & 127)
+
+    def maketag(tag, content):
+        return compat_struct_pack(">4sLH", tag, len(content), 0) + content
+
+    def makeutf8(txt):
+        return b"\x03" + (txt.encode('utf-8'))
+
+    def makepic(data):
+        imgframe = (b"\x00",          # text encoding
+                    b"image/jpeg\x00",     # mime type
+                    b"\x00",               # picture type: 'other'
+                    b"\x00",               # description
+                    data)
+        return b''.join(imgframe)
+
+    id3 = [
+        maketag(b"TRCK", makeutf8("%02s" % str(info_dict["track_number"]))),  # decimal, no term NUL
+        maketag(b"TIT2", makeutf8(info_dict["track"])),     # tern NUL ?
+        maketag(b"TPE1", makeutf8(info_dict["artist"])),    # tern NUL ?
+        maketag(b"TALB", makeutf8(info_dict["album"])),     # tern NUL ?
+    ]
+    try:
+        fh = ydl.urlopen(info_dict["thumbnail"])
+        id3.append(maketag(b"APIC", makepic(fh.read())))
+    except Exception:
+        pass
+
+    id3data = b"".join(id3)
+
+    hdr = compat_struct_pack(">3s" "H" "B" "L",
+                             b"ID3",
+                             0x400,   # version
+                             0x00,    # flags
+                             make28bit(len(id3data)))
+
+    fo.write(hdr)
+    fo.write(id3data)
+
+
+def decryptfile(fh, key, fo, progressupdate):
+    """
+    Decrypt data from file <fh>, and write to file <fo>.
+    decrypt using blowfish with <key>.
+    Only every third 2048 byte block is encrypted.
+    """
+    i = 0
+    byte_counter = 0
+    while True:
+        data = fh.read(2048)
+        if not data:
+            break
+
+        if (i % 3) == 0 and len(data) == 2048:
+            data = blowfish_cbc_decrypt(data, key, b"\x00\x01\x02\x03\x04\x05\x06\x07")
+        fo.write(data)
+        i += 1
+
+        byte_counter += len(data)
+
+        if (i % 16) == 0:
+            progressupdate(byte_counter)
+
+
+class DeezerFD(FileDownloader):
+    def real_download(self, filename, info_dict):
+        url = info_dict['url']
+        request = sanitized_Request(url, None, {})
+        data = self.ydl.urlopen(request)
+        tstart = time.time()
+        data_len = int(data.info().get('Content-length', 0))
+
+        def progressupdate(byte_counter):
+            self._hook_progress({
+                'filename': filename,
+                'status': 'downloading',
+                'downloaded_bytes': byte_counter,
+                'total_bytes': data_len,
+                'eta': self.calc_eta(tstart, time.time(), data_len, byte_counter),
+                'speed': self.calc_speed(tstart, time.time(), byte_counter),
+            }, info_dict)
+
+        def progressfinished():
+            self._hook_progress({
+                'filename': filename,
+                'status': 'finished',
+                'downloaded_bytes': data_len,
+                'total_bytes': data_len,
+            }, info_dict)
+
+        stream, realfilename = sanitize_open(filename, "wb")
+        try:
+            decryptfile(data, info_dict['key'], stream, progressupdate)
+            progressfinished()
+        finally:
+            if realfilename != '-':
+                stream.close()
--- a/yt_dlp/extractor/_extractors.py
+++ b/yt_dlp/extractor/_extractors.py
@ -460,8 +460,12 @@
 from .dbtv import DBTVIE
 from .dctp import DctpTvIE
 from .deezer import (
+    DeezerArtistIE,
    DeezerPlaylistIE,
    DeezerAlbumIE,
+    DeezerTrackIE,
+    DeezerEpisodeIE,
+    DeezerShowIE,
 )
 from .democracynow import DemocracynowIE
 from .detik import DetikEmbedIE
--- a/yt_dlp/extractor/asobistage.py
+++ b/yt_dlp/extractor/asobistage.py
@ -105,7 +105,7 @@ def _real_extract(self, url):
        video_type = {'archive': 'archives', 'player': 'broadcasts'}[type_]
        webpage = self._download_webpage(url, video_id)
        event_data = traverse_obj(
-            self._search_nextjs_data(webpage, video_id, default='{}'),
+            self._search_nextjs_data(webpage, video_id, default={}),
            ('props', 'pageProps', 'eventCMSData', {
                'title': ('event_name', {str}),
                'thumbnail': ('event_thumbnail_image', {url_or_none}),
--- a/yt_dlp/extractor/common.py
+++ b/yt_dlp/extractor/common.py
@ -1738,12 +1738,16 @@ def traverse_json_ld(json_ld, at_top_level=True):
        traverse_json_ld(json_ld)
        return filter_dict(info)

-    def _search_nextjs_data(self, webpage, video_id, *, transform_source=None, fatal=True, **kw):
-        return self._parse_json(
-            self._search_regex(
-                r'(?s)<script[^>]+id=[\'"]__NEXT_DATA__[\'"][^>]*>([^<]+)</script>',
-                webpage, 'next.js data', fatal=fatal, **kw),
-            video_id, transform_source=transform_source, fatal=fatal)
+    def _search_nextjs_data(self, webpage, video_id, *, fatal=True, default=NO_DEFAULT, **kw):
+        if default == '{}':
+            self._downloader.deprecation_warning('using `default=\'{}\'` is deprecated, use `default={}` instead')
+            default = {}
+        if default is not NO_DEFAULT:
+            fatal = False
+
+        return self._search_json(
+            r'<script[^>]+id=[\'"]__NEXT_DATA__[\'"][^>]*>', webpage, 'next.js data',
+            video_id, end_pattern='</script>', fatal=fatal, default=default, **kw)

    def _search_nuxt_data(self, webpage, video_id, context_name='__NUXT__', *, fatal=True, traverse=('data', 0)):
        """Parses Nuxt.js metadata. This works as long as the function __NUXT__ invokes is a pure function"""
--- a/yt_dlp/extractor/crunchyroll.py
+++ b/yt_dlp/extractor/crunchyroll.py
@ -24,11 +24,15 @@ class CrunchyrollBaseIE(InfoExtractor):
    _BASE_URL = 'https://www.crunchyroll.com'
    _API_BASE = 'https://api.crunchyroll.com'
    _NETRC_MACHINE = 'crunchyroll'
+    _REFRESH_TOKEN = None
    _AUTH_HEADERS = None
+    _AUTH_EXPIRY = None
    _API_ENDPOINT = None
-    _BASIC_AUTH = None
+    _BASIC_AUTH = 'Basic ' + base64.b64encode(':'.join((
+        't-kdgp2h8c3jub8fn0fq',
+        'yfLDfMfrYvKXh4JXS1LEI2cCqu1v5Wan',
+    )).encode()).decode()
    _IS_PREMIUM = None
-    _CLIENT_ID = ('cr_web', 'noaihdevm_6iyg0a8l0q')
    _LOCALE_LOOKUP = {
        'ar': 'ar-SA',
        'de': 'de-DE',
@ -43,69 +47,74 @@ class CrunchyrollBaseIE(InfoExtractor):
        'hi': 'hi-IN',
    }

-    @property
-    def is_logged_in(self):
-        return bool(self._get_cookies(self._BASE_URL).get('etp_rt'))
+    def _set_auth_info(self, response):
+        CrunchyrollBaseIE._IS_PREMIUM = 'cr_premium' in traverse_obj(response, ('access_token', {jwt_decode_hs256}, 'benefits', ...))
+        CrunchyrollBaseIE._AUTH_HEADERS = {'Authorization': response['token_type'] + ' ' + response['access_token']}
+        CrunchyrollBaseIE._AUTH_EXPIRY = time_seconds(seconds=traverse_obj(response, ('expires_in', {float_or_none}), default=300) - 10)
+
+    def _request_token(self, headers, data, note='Requesting token', errnote='Failed to request token'):
+        try:  # TODO: Add impersonation support here
+            return self._download_json(
+                f'{self._BASE_URL}/auth/v1/token', None, note=note, errnote=errnote,
+                headers=headers, data=urlencode_postdata(data))
+        except ExtractorError as error:
+            if not isinstance(error.cause, HTTPError) or error.cause.status != 403:
+                raise
+            raise ExtractorError(
+                'Request blocked by Cloudflare; navigate to Crunchyroll in your browser, '
+                'then pass the fresh cookies (with --cookies-from-browser or --cookies) '
+                'and your browser\'s User-Agent (with --user-agent)', expected=True)

    def _perform_login(self, username, password):
-        if self.is_logged_in:
+        if not CrunchyrollBaseIE._REFRESH_TOKEN:
+            CrunchyrollBaseIE._REFRESH_TOKEN = self.cache.load(self._NETRC_MACHINE, username)
+        if CrunchyrollBaseIE._REFRESH_TOKEN:
            return

-        upsell_response = self._download_json(
-            f'{self._API_BASE}/get_upsell_data.0.json', None, 'Getting session id',
-            query={
-                'sess_id': 1,
-                'device_id': 'whatvalueshouldbeforweb',
-                'device_type': 'com.crunchyroll.static',
-                'access_token': 'giKq5eY27ny3cqz',
-                'referer': f'{self._BASE_URL}/welcome/login'
-            })
-        if upsell_response['code'] != 'ok':
-            raise ExtractorError('Could not get session id')
-        session_id = upsell_response['data']['session_id']
-
-        login_response = self._download_json(
-            f'{self._API_BASE}/login.1.json', None, 'Logging in',
-            data=urlencode_postdata({
-                'account': username,
-                'password': password,
-                'session_id': session_id
-            }))
-        if login_response['code'] != 'ok':
-            raise ExtractorError('Login failed. Server message: %s' % login_response['message'], expected=True)
-        if not self.is_logged_in:
-            raise ExtractorError('Login succeeded but did not set etp_rt cookie')
-
-    def _update_auth(self):
-        if CrunchyrollBaseIE._AUTH_HEADERS and CrunchyrollBaseIE._AUTH_REFRESH > time_seconds():
-            return
-
-        if not CrunchyrollBaseIE._BASIC_AUTH:
-            cx_api_param = self._CLIENT_ID[self.is_logged_in]
-            self.write_debug(f'Using cxApiParam={cx_api_param}')
-            CrunchyrollBaseIE._BASIC_AUTH = 'Basic ' + base64.b64encode(f'{cx_api_param}:'.encode()).decode()
-
-        auth_headers = {'Authorization': CrunchyrollBaseIE._BASIC_AUTH}
-        if self.is_logged_in:
-            grant_type = 'etp_rt_cookie'
-        else:
-            grant_type = 'client_id'
-            auth_headers['ETP-Anonymous-ID'] = uuid.uuid4()
        try:
-            auth_response = self._download_json(
-                f'{self._BASE_URL}/auth/v1/token', None, note=f'Authenticating with grant_type={grant_type}',
-                headers=auth_headers, data=f'grant_type={grant_type}'.encode())
+            login_response = self._request_token(
+                headers={'Authorization': self._BASIC_AUTH}, data={
+                    'username': username,
+                    'password': password,
+                    'grant_type': 'password',
+                    'scope': 'offline_access',
+                }, note='Logging in', errnote='Failed to log in')
        except ExtractorError as error:
-            if isinstance(error.cause, HTTPError) and error.cause.status == 403:
-                raise ExtractorError(
-                    'Request blocked by Cloudflare; navigate to Crunchyroll in your browser, '
-                    'then pass the fresh cookies (with --cookies-from-browser or --cookies) '
-                    'and your browser\'s User-Agent (with --user-agent)', expected=True)
+            if isinstance(error.cause, HTTPError) and error.cause.status == 401:
+                raise ExtractorError('Invalid username and/or password', expected=True)
            raise

-        CrunchyrollBaseIE._IS_PREMIUM = 'cr_premium' in traverse_obj(auth_response, ('access_token', {jwt_decode_hs256}, 'benefits', ...))
-        CrunchyrollBaseIE._AUTH_HEADERS = {'Authorization': auth_response['token_type'] + ' ' + auth_response['access_token']}
-        CrunchyrollBaseIE._AUTH_REFRESH = time_seconds(seconds=traverse_obj(auth_response, ('expires_in', {float_or_none}), default=300) - 10)
+        CrunchyrollBaseIE._REFRESH_TOKEN = login_response['refresh_token']
+        self.cache.store(self._NETRC_MACHINE, username, CrunchyrollBaseIE._REFRESH_TOKEN)
+        self._set_auth_info(login_response)
+
+    def _update_auth(self):
+        if CrunchyrollBaseIE._AUTH_HEADERS and CrunchyrollBaseIE._AUTH_EXPIRY > time_seconds():
+            return
+
+        auth_headers = {'Authorization': self._BASIC_AUTH}
+        if CrunchyrollBaseIE._REFRESH_TOKEN:
+            data = {
+                'refresh_token': CrunchyrollBaseIE._REFRESH_TOKEN,
+                'grant_type': 'refresh_token',
+                'scope': 'offline_access',
+            }
+        else:
+            data = {'grant_type': 'client_id'}
+            auth_headers['ETP-Anonymous-ID'] = uuid.uuid4()
+        try:
+            auth_response = self._request_token(auth_headers, data)
+        except ExtractorError as error:
+            username, password = self._get_login_info()
+            if not username or not isinstance(error.cause, HTTPError) or error.cause.status != 400:
+                raise
+            self.to_screen('Refresh token has expired. Re-logging in')
+            CrunchyrollBaseIE._REFRESH_TOKEN = None
+            self.cache.store(self._NETRC_MACHINE, username, None)
+            self._perform_login(username, password)
+            return
+
+        self._set_auth_info(auth_response)

    def _locale_from_language(self, language):
        config_locale = self._configuration_arg('metadata', ie_key=CrunchyrollBetaIE, casesense=True)
@ -168,7 +177,8 @@ def _extract_stream(self, identifier, display_id=None):
        self._update_auth()
        stream_response = self._download_json(
            f'https://cr-play-service.prd.crunchyrollsvc.com/v1/{identifier}/console/switch/play',
-            display_id, note='Downloading stream info', headers=CrunchyrollBaseIE._AUTH_HEADERS)
+            display_id, note='Downloading stream info', errnote='Failed to download stream info',
+            headers=CrunchyrollBaseIE._AUTH_HEADERS)

        available_formats = {'': ('', '', stream_response['url'])}
        for hardsub_lang, stream in traverse_obj(stream_response, ('hardSubs', {dict.items}, lambda _, v: v[1]['url'])):
@ -383,9 +393,9 @@ def entries():

        if not self._IS_PREMIUM and traverse_obj(response, (f'{object_type}_metadata', 'is_premium_only')):
            message = f'This {object_type} is for premium members only'
-            if self.is_logged_in:
+            if CrunchyrollBaseIE._REFRESH_TOKEN:
                raise ExtractorError(message, expected=True)
-            self.raise_login_required(message)
+            self.raise_login_required(message, method='password')

        result['formats'], result['subtitles'] = self._extract_stream(internal_id)

@ -575,9 +585,9 @@ def _real_extract(self, url):

        if not self._IS_PREMIUM and response.get('isPremiumOnly'):
            message = f'This {response.get("type") or "media"} is for premium members only'
-            if self.is_logged_in:
+            if CrunchyrollBaseIE._REFRESH_TOKEN:
                raise ExtractorError(message, expected=True)
-            self.raise_login_required(message)
+            self.raise_login_required(message, method='password')

        result = self._transform_music_response(response)
        result['formats'], _ = self._extract_stream(f'music/{internal_id}', internal_id)
--- a/yt_dlp/extractor/deezer.py
+++ b/yt_dlp/extractor/deezer.py
@ -1,78 +1,280 @@
 import json
-
+import re
+from hashlib import md5
 from .common import InfoExtractor
 from ..utils import (
-    ExtractorError,
-    int_or_none,
-    orderedSet,
+    str_to_int,
+    traverse_obj,
 )


 class DeezerBaseInfoExtractor(InfoExtractor):
+
+    GW_LIGHT_URL = "https://www.deezer.com/ajax/gw-light.php"
+    GET_URL = "https://media.deezer.com/v1/get_url"
+    EXPLORE_URL = "https://www.deezer.com/en/channels/explore"
+
+    def get_key_dynamically(self):
+        explore_webpage = self._download_webpage(self.EXPLORE_URL, 1)
+        app_url = self._html_search_regex(r'(?<=script src=\")(https:\/\/[a-z-\.\/]+app-web[a-z0-9\.]+)', explore_webpage, 'explore_webpage')
+
+        app_webpage = self._download_webpage(app_url, 1)
+
+        t1 = self._html_search_regex(r'(%5B0x61(%2C0x[0-9a-z+]+)+%2C0x67%5D)', app_webpage, 'app_webpage')
+        t1 = t1.replace("%5B", "").replace("%2C", "").replace("%5D", "").replace("%5B", "").replace("0x", "")
+        t1 = bytes.fromhex(t1).decode('utf-8')
+
+        t2 = self._html_search_regex(r'(%5B0x31(%2C0x[0-9a-z+]+)+%2C0x34%5D)', app_webpage, 'app_webpage')
+        t2 = t2.replace("%5B", "").replace("%2C", "").replace("%5D", "").replace("%5B", "").replace("0x", "")
+        t2 = bytes.fromhex(t2).decode('utf-8')
+
+        if (len(t1) != 8 or len(t2) != 8):
+            raise Exception("Dynamic key is incorrect")
+
+        key = ""
+        for i in range(1, 9):
+            key += t1[-i] + t2[-i]
+
+        self.blowfish_key = key.encode('utf-8')
+
+    def compute_blowfish_key(self, songid):
+
+        h = md5(str(songid).encode('ascii')).hexdigest().encode('utf-8')
+        return "".join(chr(h[i] ^ h[i + 16] ^ self.blowfish_key[i]) for i in range(16))
+
    def get_data(self, url):
-        if not self.get_param('test'):
-            self.report_warning('For now, this extractor only supports the 30 second previews. Patches welcome!')

-        mobj = self._match_valid_url(url)
+        mobj = re.match(self._VALID_URL, url)
        data_id = mobj.group('id')
+        country = mobj.group('country')
+        url = self._API_URL.format(data_id)
+        response = self._download_json(url, data_id)
+        return data_id, country, response

-        webpage = self._download_webpage(url, data_id)
-        geoblocking_msg = self._html_search_regex(
-            r'<p class="soon-txt">(.*?)</p>', webpage, 'geoblocking message',
-            default=None)
-        if geoblocking_msg is not None:
-            raise ExtractorError(
-                'Deezer said: %s' % geoblocking_msg, expected=True)
+    def get_api_license_tokens(self, data_id):

-        data_json = self._search_regex(
-            (r'__DZR_APP_STATE__\s*=\s*({.+?})\s*</script>',
-             r'naboo\.display\(\'[^\']+\',\s*(.*?)\);\n'),
-            webpage, 'data JSON')
-        data = json.loads(data_json)
-        return data_id, webpage, data
+        url = self.GW_LIGHT_URL + "?" + \
+            "api_token=&" + \
+            "method=deezer.getUserData&" + \
+            "input=3&" + \
+            "api_version=1.0&" + \
+            "cid=550330597"
+
+        response = self._download_json(url, data_id)
+        api_token = traverse_obj(response, ('results', 'checkForm'))
+        license_token = traverse_obj(response, ('results', 'USER', 'OPTIONS', 'license_token'))
+
+        return api_token, license_token


-class DeezerPlaylistIE(DeezerBaseInfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(../)?playlist/(?P<id>[0-9]+)'
+class DeezerMusicExtractor(DeezerBaseInfoExtractor):
+
+    def get_entries(self, data_id, data, json_data):
+
+        #################################
+        # GET API TOKEN & LICENSE TOKEN #
+        #################################
+
+        api_token, license_token = self.get_api_license_tokens(data_id)
+
+        #####################
+        # GET DIRECT STREAM #
+        #####################
+
+        url = self.GW_LIGHT_URL + "?" + \
+            "api_token=" + api_token + "&" + \
+            "method=" + self._METHOD + "&" + \
+            "input=3&" + \
+            "api_version=1.0&" + \
+            "cid=550330597"
+
+        response = self._download_json(url, data_id, data=json.dumps(json_data).encode('utf-8'))
+
+        entries = []
+        for track in traverse_obj(response, ('results', 'data')):
+
+            entries.append({
+                'id': track.get('SNG_ID'),
+                'duration': str_to_int(track.get('DURATION')),
+                'title': track.get('SNG_TITLE'),
+                'uploader': track.get('ART_NAME'),
+                'artist': track.get('ART_NAME'),
+                'uploader_id': track.get('ART_ID'),
+                'track_number': str_to_int(track.get('TRACK_NUMBER')),
+                'release_date': str_to_int(track.get('DIGITAL_RELEASE_DATE', '').replace(' ', '')),
+                'album': track.get('ALB_TITLE'),
+                'formats': [{
+                    'format_id': 'MP3_PREVIEW',
+                    'url': track.get('MEDIA', [{}])[0].get('HREF'),
+                    'preference': -3,
+                    'ext': 'mp3',
+                    'track_token': track.get('TRACK_TOKEN'),
+                }]
+            })
+
+        ###############
+        # GET FORMATS #
+        ###############
+
+        track_tokens = [entry.get('formats', [{}])[0].get('track_token') for entry in entries]
+
+        data = {
+            "license_token": license_token,
+            "media": [{
+                "formats": [
+                    {"cipher": "BF_CBC_STRIPE", "format": "MP3_128"},
+                    {"cipher": "BF_CBC_STRIPE", "format": "MP3_64"}
+                ],
+                "type": "FULL"}
+            ],
+            "track_tokens": track_tokens
+        }
+
+        self.get_key_dynamically()
+        response = self._download_json(self.GET_URL, data_id, data=json.dumps(data).encode('utf-8'))
+
+        for i in range(len(entries)):
+            media = response.get('data', [{}])[i].get('media', [{}])[0]
+            formats = entries[i].get('formats', [{}])
+            format_id = media.get('format')
+
+            for source in media.get('sources', {}):
+
+                format_preference = -1 if '128' in format_id else -2
+                format_url = source.get('url')
+                format_key = self.compute_blowfish_key(entries[i].get('id'))
+
+                formats.append({
+                    'format_id': format_id,
+                    'url': format_url,
+                    'preference': format_preference,
+                    'ext': 'mp3',
+                    'key': format_key,
+                    'protocol': 'deezer',
+                })
+
+            self._sort_formats(formats)
+
+        return entries
+
+
+class DeezerPodcastExtractor(DeezerBaseInfoExtractor):
+
+    def get_entries(self, data_id, data, json_data):
+
+        #################################
+        # GET API TOKEN & LICENSE TOKEN #
+        #################################
+
+        api_token, license_token = self.get_api_license_tokens(data_id)
+
+        #################################
+        # GET TRACK TOKENS AND PREVIEWS #
+        #################################
+
+        url = self.GW_LIGHT_URL + "?" + \
+            "api_token=" + api_token + "&" + \
+            "method=" + self._METHOD + "&" + \
+            "input=3&" + \
+            "api_version=1.0&" + \
+            "cid=550330597"
+
+        response = self._download_json(url, data_id, data=json.dumps(json_data).encode('utf-8'))
+
+        entries = []
+        if ('data' in response.get('results')):
+            episodes = traverse_obj(response, ('results', 'data'))
+        else:
+            episodes = [response.get('results')]
+
+        for episode in episodes:
+
+            entries.append({
+                'id': episode.get('EPISODE_ID'),
+                'duration': str_to_int(episode.get('DURATION')),
+                'title': episode.get('EPISODE_TITLE'),
+                'uploader': episode.get('SHOW_NAME'),
+                'artist': episode.get('SHOW_NAME'),
+                'uploader_id': episode.get('SHOW_ID'),
+                'release_timestamp': str_to_int(episode.get('EPISODE_PUBLISHED_TIMESTAMP')),
+                'formats': [{
+                    'format_id': 'MP3_DIRECT_STREAM',
+                    'url': episode.get('EPISODE_DIRECT_STREAM_URL'),
+                    'preference': -3,
+                    'ext': 'mp3',
+                    'track_token': episode.get('TRACK_TOKEN'),
+                }]
+            })
+
+        return entries
+
+
+class DeezerArtistIE(DeezerMusicExtractor):
+    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(?P<country>..+)/artist/(?P<id>[0-9]+)'
+    _TEST = {
+        'url': 'https://www.deezer.com/fr/artist/1711511',
+        'info_dict': {
+            'id': '1711511',
+            'title': 'Top tracks',
+            'uploader': 'Bolivard',
+            'thumbnail': r're:^https?://(e-)?cdns-images\.dzcdn\.net/images/artist/.*\.jpg$',
+        },
+        'playlist_count': 27,
+    }
+    _API_URL = "https://api.deezer.com/artist/{0}?limit=-1"
+    _METHOD = "artist.getTopTrack"
+
+    def _real_extract(self, url):
+
+        artist_id, country, artist_data = self.get_data(url)
+        artist_name = artist_data.get('name')
+        artist_thumbnail = artist_data.get('picture_medium')
+
+        json_data = {
+            'nb': 10000,
+            'art_id': artist_id,
+            'start': 0
+        }
+        artist_entries = self.get_entries(artist_id, artist_data, json_data)
+
+        return {
+            '_type': 'playlist',
+            'id': artist_id,
+            'title': 'Top tracks',
+            'uploader': artist_name,
+            'thumbnail': artist_thumbnail,
+            'entries': artist_entries,
+        }
+
+
+class DeezerPlaylistIE(DeezerMusicExtractor):
+    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(?P<country>..+)/playlist/(?P<id>[0-9]+)'
    _TEST = {
        'url': 'http://www.deezer.com/playlist/176747451',
        'info_dict': {
            'id': '176747451',
            'title': 'Best!',
-            'uploader': 'anonymous',
+            'uploader': 'Anonymous',
            'thumbnail': r're:^https?://(e-)?cdns-images\.dzcdn\.net/images/cover/.*\.jpg$',
        },
-        'playlist_count': 29,
+        'playlist_count': 30,
    }
+    _API_URL = "https://api.deezer.com/playlist/{0}?limit=-1"
+    _METHOD = "playlist.getSongs"

    def _real_extract(self, url):
-        playlist_id, webpage, data = self.get_data(url)

-        playlist_title = data.get('DATA', {}).get('TITLE')
-        playlist_uploader = data.get('DATA', {}).get('PARENT_USERNAME')
-        playlist_thumbnail = self._search_regex(
-            r'<img id="naboo_playlist_image".*?src="([^"]+)"', webpage,
-            'playlist thumbnail')
+        playlist_id, country, playlist_data = self.get_data(url)
+        playlist_title = playlist_data.get('title')
+        playlist_uploader = traverse_obj(playlist_data, ('creator', 'name'))
+        playlist_thumbnail = playlist_data.get('picture_medium')

-        entries = []
-        for s in data.get('SONGS', {}).get('data'):
-            formats = [{
-                'format_id': 'preview',
-                'url': s.get('MEDIA', [{}])[0].get('HREF'),
-                'preference': -100,  # Only the first 30 seconds
-                'ext': 'mp3',
-            }]
-            artists = ', '.join(
-                orderedSet(a.get('ART_NAME') for a in s.get('ARTISTS')))
-            entries.append({
-                'id': s.get('SNG_ID'),
-                'duration': int_or_none(s.get('DURATION')),
-                'title': '%s - %s' % (artists, s.get('SNG_TITLE')),
-                'uploader': s.get('ART_NAME'),
-                'uploader_id': s.get('ART_ID'),
-                'age_limit': 16 if s.get('EXPLICIT_LYRICS') == '1' else 0,
-                'formats': formats,
-            })
+        json_data = {
+            'nb': 2000,
+            'playlist_id': playlist_id,
+            'start': 0
+        }
+        playlist_entries = self.get_entries(playlist_id, playlist_data, json_data)

        return {
            '_type': 'playlist',
@ -80,12 +282,12 @@ def _real_extract(self, url):
            'title': playlist_title,
            'uploader': playlist_uploader,
            'thumbnail': playlist_thumbnail,
-            'entries': entries,
+            'entries': playlist_entries,
        }


-class DeezerAlbumIE(DeezerBaseInfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(../)?album/(?P<id>[0-9]+)'
+class DeezerAlbumIE(DeezerMusicExtractor):
+    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(?P<country>..+)/album/(?P<id>[0-9]+)'
    _TEST = {
        'url': 'https://www.deezer.com/fr/album/67505622',
        'info_dict': {
@ -96,41 +298,22 @@ class DeezerAlbumIE(DeezerBaseInfoExtractor):
        },
        'playlist_count': 7,
    }
+    _API_URL = "https://api.deezer.com/album/{0}?limit=-1"
+    _METHOD = "song.getListByAlbum"

    def _real_extract(self, url):
-        album_id, webpage, data = self.get_data(url)

-        album_title = data.get('DATA', {}).get('ALB_TITLE')
-        album_uploader = data.get('DATA', {}).get('ART_NAME')
-        album_thumbnail = self._search_regex(
-            r'<img id="naboo_album_image".*?src="([^"]+)"', webpage,
-            'album thumbnail')
+        album_id, country, album_data = self.get_data(url)
+        album_title = album_data.get('title')
+        album_uploader = traverse_obj(album_data, ('artist', 'name'))
+        album_thumbnail = album_data.get('cover_medium')

-        entries = []
-        for s in data.get('SONGS', {}).get('data'):
-            formats = [{
-                'format_id': 'preview',
-                'url': s.get('MEDIA', [{}])[0].get('HREF'),
-                'preference': -100,  # Only the first 30 seconds
-                'ext': 'mp3',
-            }]
-            artists = ', '.join(
-                orderedSet(a.get('ART_NAME') for a in s.get('ARTISTS')))
-            entries.append({
-                'id': s.get('SNG_ID'),
-                'duration': int_or_none(s.get('DURATION')),
-                'title': '%s - %s' % (artists, s.get('SNG_TITLE')),
-                'uploader': s.get('ART_NAME'),
-                'uploader_id': s.get('ART_ID'),
-                'age_limit': 16 if s.get('EXPLICIT_LYRICS') == '1' else 0,
-                'formats': formats,
-                'track': s.get('SNG_TITLE'),
-                'track_number': int_or_none(s.get('TRACK_NUMBER')),
-                'track_id': s.get('SNG_ID'),
-                'artist': album_uploader,
-                'album': album_title,
-                'album_artist': album_uploader,
-            })
+        json_data = {
+            'nb': 500,
+            'alb_id': album_id,
+            'start': 0
+        }
+        album_entries = self.get_entries(album_id, album_data, json_data)

        return {
            '_type': 'playlist',
@ -138,5 +321,119 @@ def _real_extract(self, url):
            'title': album_title,
            'uploader': album_uploader,
            'thumbnail': album_thumbnail,
-            'entries': entries,
+            'entries': album_entries,
+        }
+
+
+class DeezerTrackIE(DeezerMusicExtractor):
+    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(?P<country>..+)/track/(?P<id>[0-9]+)'
+    _TEST = {
+        'url': 'https://www.deezer.com/fr/track/675631092',
+        'info_dict': {
+            'id': '675631092',
+            'title': 'La vie',
+            'uploader': 'Bolivard',
+            'thumbnail': r're:^https?://(e-)?cdns-images\.dzcdn\.net/images/cover/.*\.jpg$',
+        },
+        'playlist_count': 1,
+    }
+    _API_URL = "https://api.deezer.com/track/{0}?limit=-1"
+    _METHOD = "song.getListData"
+
+    def _real_extract(self, url):
+
+        self.get_key_dynamically()
+
+        track_id, country, track_data = self.get_data(url)
+        track_title = track_data.get('title')
+        track_uploader = traverse_obj(track_data, ('artist', 'name'))
+        track_thumbnail = traverse_obj(track_data, ('album', 'cover_medium'))
+
+        json_data = {
+            'sng_ids': [track_id]
+        }
+        track_entries = self.get_entries(track_id, track_data, json_data)
+
+        return {
+            '_type': 'playlist',
+            'id': track_id,
+            'title': track_title,
+            'uploader': track_uploader,
+            'thumbnail': track_thumbnail,
+            'entries': track_entries,
+        }
+
+
+class DeezerEpisodeIE(DeezerPodcastExtractor):
+    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(?P<country>..+)/episode/(?P<id>[0-9]+)'
+    _TEST = {
+        'url': 'https://www.deezer.com/fr/episode/432949767',
+        'info_dict': {
+            'id': '432949767',
+            'title': 'FAQ ETH 2.0 : Comment profiter du MERGE ? Tout comprendre sur la MAJ HISTORIQUE',
+            'uploader': 'Cryptoast - Bitcoin et Cryptomonnaies',
+            'thumbnail': r're:^https?://(e-)?cdns-images\.dzcdn\.net/images/talk/.*\.jpg$',
+        },
+        'playlist_count': 1,
+    }
+    _API_URL = "https://api.deezer.com/episode/{0}?limit=-1"
+    _METHOD = "episode.getData"
+
+    def _real_extract(self, url):
+
+        episode_id, country, episode_data = self.get_data(url)
+        episode_title = episode_data.get('title')
+        episode_uploader = traverse_obj(episode_data, ('podcast', 'title'))
+        episode_thumbnail = episode_data.get('picture_medium')
+
+        json_data = {
+            'episode_id': episode_id
+        }
+        episode_entries = self.get_entries(episode_id, episode_data, json_data)
+
+        return {
+            '_type': 'playlist',
+            'id': episode_id,
+            'title': episode_title,
+            'uploader': episode_uploader,
+            'thumbnail': episode_thumbnail,
+            'entries': episode_entries,
+        }
+
+
+class DeezerShowIE(DeezerPodcastExtractor):
+    _VALID_URL = r'https?://(?:www\.)?deezer\.com/(?P<country>..+)/show/(?P<id>[0-9]+)'
+    _TEST = {
+        'url': 'https://www.deezer.com/fr/show/1805732',
+        'info_dict': {
+            'id': '1805732',
+            'title': 'Cryptoast - Bitcoin et Cryptomonnaies',
+            'uploader': 'Cryptoast - Bitcoin et Cryptomonnaies',
+            'thumbnail': r're:^https?://(e-)?cdns-images\.dzcdn\.net/images/talk/.*\.jpg$',
+        },
+        'playlist_count': 129,
+    }
+    _API_URL = "https://api.deezer.com/podcast/{0}?limit=-1"
+    _METHOD = "episode.getListByShow"
+
+    def _real_extract(self, url):
+
+        show_id, country, show_data = self.get_data(url)
+        show_title = show_data.get('title')
+        show_thumbnail = show_data.get('picture_medium')
+
+        json_data = {
+            'nb': 1000,
+            'show_id': show_id,
+            'start': 0
+        }
+        show_entries = self.get_entries(show_id, show_data, json_data)
+
+        return {
+            '_type': 'playlist',
+            'id': show_id,
+            'title': show_title,
+            'uploader': show_title,
+            'thumbnail': show_thumbnail,
+            'entries': show_entries,
        }
--- a/yt_dlp/extractor/stacommu.py
+++ b/yt_dlp/extractor/stacommu.py
@ -174,7 +174,7 @@ class TheaterComplexTownBaseIE(StacommuBaseIE):


 class TheaterComplexTownVODIE(TheaterComplexTownBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?theater-complex\.town/(?:en/)?videos/episodes/(?P<id>\w+)'
+    _VALID_URL = r'https?://(?:www\.)?theater-complex\.town/(?:(?:en|ja)/)?videos/episodes/(?P<id>\w+)'
    IE_NAME = 'theatercomplextown:vod'
    _TESTS = [{
        'url': 'https://www.theater-complex.town/videos/episodes/hoxqidYNoAn7bP92DN6p78',
@ -195,6 +195,9 @@ class TheaterComplexTownVODIE(TheaterComplexTownBaseIE):
    }, {
        'url': 'https://www.theater-complex.town/en/videos/episodes/6QT7XYwM9dJz5Gf9VB6K5y',
        'only_matching': True,
+    }, {
+        'url': 'https://www.theater-complex.town/ja/videos/episodes/hoxqidYNoAn7bP92DN6p78',
+        'only_matching': True,
    }]

    _API_PATH = 'videoEpisodes'
@ -204,7 +207,7 @@ def _real_extract(self, url):


 class TheaterComplexTownPPVIE(TheaterComplexTownBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?theater-complex\.town/(?:en/)?ppv/(?P<id>\w+)'
+    _VALID_URL = r'https?://(?:www\.)?theater-complex\.town/(?:(?:en|ja)/)?ppv/(?P<id>\w+)'
    IE_NAME = 'theatercomplextown:ppv'
    _TESTS = [{
        'url': 'https://www.theater-complex.town/ppv/wytW3X7khrjJBUpKuV3jen',
@ -223,6 +226,9 @@ class TheaterComplexTownPPVIE(TheaterComplexTownBaseIE):
    }, {
        'url': 'https://www.theater-complex.town/en/ppv/wytW3X7khrjJBUpKuV3jen',
        'only_matching': True,
+    }, {
+        'url': 'https://www.theater-complex.town/ja/ppv/qwUVmLmGEiZ3ZW6it9uGys',
+        'only_matching': True,
    }]

    _API_PATH = 'events'
--- a/yt_dlp/extractor/stv.py
+++ b/yt_dlp/extractor/stv.py
@ -41,7 +41,7 @@ def _real_extract(self, url):
        ptype, video_id = self._match_valid_url(url).groups()

        webpage = self._download_webpage(url, video_id, fatal=False) or ''
-        props = self._search_nextjs_data(webpage, video_id, default='{}').get('props') or {}
+        props = self._search_nextjs_data(webpage, video_id, default={}).get('props') or {}
        player_api_cache = try_get(
            props, lambda x: x['initialReduxState']['playerApiCache']) or {}

--- a/yt_dlp/extractor/tiktok.py
+++ b/yt_dlp/extractor/tiktok.py
@ -776,7 +776,7 @@ def _real_extract(self, url):
            status = traverse_obj(sigi_data, ('VideoPage', 'statusCode', {int})) or 0
            video_data = traverse_obj(sigi_data, ('ItemModule', video_id, {dict}))

-        elif next_data := self._search_nextjs_data(webpage, video_id, default='{}'):
+        elif next_data := self._search_nextjs_data(webpage, video_id, default={}):
            self.write_debug('Found next.js data')
            status = traverse_obj(next_data, ('props', 'pageProps', 'statusCode', {int})) or 0
            video_data = traverse_obj(next_data, ('props', 'pageProps', 'itemInfo', 'itemStruct', {dict}))
--- a/yt_dlp/extractor/wrestleuniverse.py
+++ b/yt_dlp/extractor/wrestleuniverse.py
@ -147,7 +147,7 @@ def _download_metadata(self, url, video_id, lang, props_keys):
        metadata = self._call_api(video_id, msg='metadata', query={'al': lang or 'ja'}, auth=False, fatal=False)
        if not metadata:
            webpage = self._download_webpage(url, video_id)
-            nextjs_data = self._search_nextjs_data(webpage, video_id)
+            nextjs_data = self._search_nextjs_data(webpage, video_id, fatal=False)
            metadata = traverse_obj(nextjs_data, (
                'props', 'pageProps', *variadic(props_keys, (str, bytes, dict, set)), {dict})) or {}
        return metadata
Author	SHA1	Message	Date
LucBerge	e282a5fd1f	Merge `d1f9f08963` into `89f535e265`	2024-04-24 06:01:40 +00:00
bashonly	89f535e265	[ci] Fix `curl-cffi` installation (Bugfix for `02483bea1c`) Authored by: bashonly	2024-04-22 20:36:01 +00:00
bashonly	ff38a011d5	[ie/crunchyroll] Fix auth and remove cookies support (#9749 ) Closes #9745 Authored by: bashonly	2024-04-21 22:41:40 +00:00
bashonly	8056a3026e	[ie/theatercomplextown] Fix extractors (#9754 ) Authored by: bashonly	2024-04-21 16:05:42 +00:00
Simon Sawicki	3ee1194288	[ie] Make `_search_nextjs_data` non fatal (#8937 ) Authored by: Grub4K	2024-04-21 13:40:38 +02:00
LucBerge	d1f9f08963	Merge branch 'master' into deezer	2023-03-08 13:46:03 +01:00
Lucas Bergeron	122ff0ae15	Generate key dynamically	2023-03-08 13:38:24 +01:00
Lucas Bergeron	98c9aee726	Minor changes - Remove useless impot - Fix tracks number for extractors - Fix comment	2023-03-08 12:30:15 +01:00
Lucas Bergeron	34996fb38f	Reviews - Remove utf-8 encoding sys reconfiguration - Do not use compat functions anymore - Blowfish key calculation in the extractor - Minor fixes	2022-09-15 21:57:45 +02:00
Lucas Bergeron	72df4f6515	flake8	2022-09-15 19:23:01 +02:00
Lucas Bergeron	2d06167e01	Code convention and flake8	2022-09-15 19:19:49 +02:00
Lucas Bergeron	797283b88f	Fix deezer extractor - Add blowfish encipher - Add deezer downloader - Add full song support - Add artist extractor - Add track extractor - Add episode extractor - Add show extractor	2022-09-15 18:46:30 +02:00