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, 0 insertions, 171 deletions

diff --git a/crates/yt_dlp/src/logging.rs b/crates/yt_dlp/src/logging.rs
deleted file mode 100644
index 112836e..0000000
--- a/crates/yt_dlp/src/logging.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-// yt - A fully featured command line YouTube client
-//
-// Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This file is part of Yt.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
-
-// This file is taken from: https://github.com/dylanbstorey/pyo3-pylogger/blob/d89e0d6820ebc4f067647e3b74af59dbc4941dd5/src/lib.rs
-// It is licensed under the Apache 2.0 License, copyright up to 2024 by Dylan Storey
-// It was modified by Benedikt Peetz 2024, 2025
-
-use log::{Level, MetadataBuilder, Record, logger};
-use rustpython::vm::{
-    PyObjectRef, PyRef, PyResult, VirtualMachine,
-    builtins::{PyInt, PyStr},
-    convert::ToPyObject,
-    function::FuncArgs,
-};
-
-/// Consume a Python `logging.LogRecord` and emit a Rust `Log` instead.
-fn host_log(mut input: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-    let record = input.args.remove(0);
-    let rust_target = {
-        let base: PyRef<PyStr> = input.args.remove(0).downcast().expect("Should be a string");
-        base.as_str().to_owned()
-    };
-
-    let level = {
-        let level: PyRef<PyInt> = record
-            .get_attr("levelno", vm)?
-            .downcast()
-            .expect("Should always be an int");
-        level.as_u32_mask()
-    };
-    let message = {
-        let get_message = record.get_attr("getMessage", vm)?;
-        let message: PyRef<PyStr> = get_message
-            .call((), vm)?
-            .downcast()
-            .expect("Downcasting works");
-
-        message.as_str().to_owned()
-    };
-
-    let pathname = {
-        let pathname: PyRef<PyStr> = record
-            .get_attr("pathname", vm)?
-            .downcast()
-            .expect("Is a string");
-
-        pathname.as_str().to_owned()
-    };
-
-    let lineno = {
-        let lineno: PyRef<PyInt> = record
-            .get_attr("lineno", vm)?
-            .downcast()
-            .expect("Is a number");
-
-        lineno.as_u32_mask()
-    };
-
-    let logger_name = {
-        let name: PyRef<PyStr> = record
-            .get_attr("name", vm)?
-            .downcast()
-            .expect("Should be a string");
-        name.as_str().to_owned()
-    };
-
-    let full_target: Option<String> = if logger_name.trim().is_empty() || logger_name == "root" {
-        None
-    } else {
-        // Libraries (ex: tracing_subscriber::filter::Directive) expect rust-style targets like foo::bar,
-        // and may not deal well with "." as a module separator:
-        let logger_name = logger_name.replace('.', "::");
-        Some(format!("{rust_target}::{logger_name}"))
-    };
-
-    let target = full_target.as_deref().unwrap_or(&rust_target);
-
-    // error
-    let error_metadata = if level >= 40 {
-        MetadataBuilder::new()
-            .target(target)
-            .level(Level::Error)
-            .build()
-    } else if level >= 30 {
-        MetadataBuilder::new()
-            .target(target)
-            .level(Level::Warn)
-            .build()
-    } else if level >= 20 {
-        MetadataBuilder::new()
-            .target(target)
-            .level(Level::Info)
-            .build()
-    } else if level >= 10 {
-        MetadataBuilder::new()
-            .target(target)
-            .level(Level::Debug)
-            .build()
-    } else {
-        MetadataBuilder::new()
-            .target(target)
-            .level(Level::Trace)
-            .build()
-    };
-
-    logger().log(
-        &Record::builder()
-            .metadata(error_metadata)
-            .args(format_args!("{}", &message))
-            .line(Some(lineno))
-            .file(None)
-            .module_path(Some(&pathname))
-            .build(),
-    );
-
-    Ok(())
-}
-
-/// Registers the `host_log` function in rust as the event handler for Python's logging logger
-/// This function needs to be called from within a pyo3 context as early as possible to ensure logging messages
-/// arrive to the rust consumer.
-///
-/// # Panics
-/// Only if internal assertions fail.
-#[allow(clippy::module_name_repetitions)]
-pub(super) fn setup_logging(vm: &VirtualMachine, target: &str) -> PyResult<PyObjectRef> {
-    let logging = vm.import("logging", 0)?;
-
-    let scope = vm.new_scope_with_builtins();
-
-    for (key, value) in logging.dict().expect("Should be a dict") {
-        let key: PyRef<PyStr> = key.downcast().expect("Is a string");
-
-        scope.globals.set_item(key.as_str(), value, vm)?;
-    }
-    scope
-        .globals
-        .set_item("host_log", vm.new_function("host_log", host_log).into(), vm)?;
-
-    let local_scope = scope.clone();
-    vm.run_code_string(
-        local_scope,
-        format!(
-            r#"
-class HostHandler(Handler):
-    def __init__(self, level=0):
-        super().__init__(level=level)
-
-    def emit(self, record):
-        host_log(record,"{target}")
-
-oldBasicConfig = basicConfig
-def basicConfig(*pargs, **kwargs):
-    if "handlers" not in kwargs:
-        kwargs["handlers"] = [HostHandler()]
-    return oldBasicConfig(*pargs, **kwargs)
-"#
-        )
-        .as_str(),
-        "<embedded logging inintializing code>".to_owned(),
-    )?;
-
-    Ok(scope.globals.to_pyobject(vm))
-}