refactor(crates/yt_dlp): Port to `pyo3` again

Rustpyton is slower, does not implement everything correctly and worst
of all, contains code produced by LLM's.

Using the freethreaded mode of pyo3 also works nicely around the GIL,
and enables parallel execution.

1 files changed, 8 insertions, 83 deletions

diff --git a/crates/yt_dlp/src/post_processors/mod.rs b/crates/yt_dlp/src/post_processors/mod.rs
index 00b0ad5..d9be3f5 100644
--- a/crates/yt_dlp/src/post_processors/mod.rs
+++ b/crates/yt_dlp/src/post_processors/mod.rs
@@ -12,8 +12,9 @@ pub mod dearrow;
 
 #[macro_export]
 macro_rules! pydict_get {
-    (@$vm:expr, $value:expr, $name:literal, $into:ident) => {{
-        match $value.get_item($name, $vm) {
+    ($value:expr, $name:literal, $into:ty) => {{
+        let item = $value.get_item(pyo3::intern!($value.py(), $name));
+        match &item {
             Ok(val) => $crate::pydict_cast!(val, $into),
             Err(_) => panic!(
                 concat!(
@@ -31,93 +32,17 @@ macro_rules! pydict_get {
 
 #[macro_export]
 macro_rules! pydict_cast {
-    ($value:expr, $into:ident) => {{
-        match $value.downcast::<$into>() {
+    ($value:expr, $into:ty) => {{
+        match $value.extract::<$into>() {
             Ok(result) => result,
             Err(val) => panic!(
                 concat!(
-                    "Expected to be able to downcast value ({:#?}) as ",
-                    stringify!($into)
+                    "Expected to be able to extract ",
+                    stringify!($into),
+                    " from value ({:#?})."
                 ),
                 val
             ),
         }
     }};
-    (@ref $value:expr, $into:ident) => {{
-        match $value.downcast_ref::<$into>() {
-            Some(result) => result,
-            None => panic!(
-                concat!(
-                    "Expected to be able to downcast value ({:#?}) as ",
-                    stringify!($into)
-                ),
-                $value
-            ),
-        }
-    }};
-}
-
-#[macro_export]
-macro_rules! wrap_post_processor {
-    ($name:literal, $unwrap:ident, $wrapped:ident) => {
-        use $crate::progress_hook::__priv::vm;
-
-        /// # Errors
-        /// - If the underlying function returns an error.
-        /// - If python operations fail.
-        pub fn $wrapped(vm: &vm::VirtualMachine) -> vm::PyResult<vm::PyObjectRef> {
-            fn actual_processor(
-                mut input: vm::function::FuncArgs,
-                vm: &vm::VirtualMachine,
-            ) -> vm::PyResult<vm::PyRef<vm::builtins::PyDict>> {
-                let input = input
-                    .args
-                    .remove(0)
-                    .downcast::<vm::builtins::PyDict>()
-                    .expect("Should be a py dict");
-
-                let output = match unwrapped_process(input, vm) {
-                    Ok(ok) => ok,
-                    Err(err) => {
-                        return Err(vm.new_runtime_error(err.to_string()));
-                    }
-                };
-
-                Ok(output)
-            }
-
-            let scope = vm.new_scope_with_builtins();
-
-            scope.globals.set_item(
-                "actual_processor",
-                vm.new_function("actual_processor", actual_processor).into(),
-                vm,
-            )?;
-
-            let local_scope = scope.clone();
-            vm.run_code_string(
-                local_scope,
-                format!(
-                    "
-import yt_dlp
-
-class {}(yt_dlp.postprocessor.PostProcessor):
-    def run(self, info):
-        info = actual_processor(info)
-        return [], info
-
-inst = {}()
-",
-                    $name, $name
-                )
-                .as_str(),
-                "<embedded post processor initializing code>".to_owned(),
-            )?;
-
-            Ok(scope
-                .globals
-                .get_item("inst", vm)
-                .expect("We just declared it"))
-        }
-    };
 }