mirror of
https://github.com/BerriAI/litellm.git
synced 2026-10-18 04:44:37 +00:00
8302f006dd
* refactor(rust-bridge): return an unstarted Execution from native entrypoints and drive it in Python Rust's run_call built Python streams itself and imported litellm.rust_bridge.streams by name, so sync calls were driven in Rust while async calls came back as a Rust-made coroutine. Every native inference entrypoint now returns one unstarted Execution and public_execution.py drives it with lifecycle.run or lifecycle.drive, wrapping streams and _hidden_params on the Python side. Rust only imports the lifecycle step classes through StepTypes, and python-bridge/src/lifecycle.rs, PythonLifecycle and streams.py are gone. The adapter trusts the _native.pyi contract with a single cast instead of a per-request runtime_checkable isinstance. Binding tests assert the adapter starts the execution and returns its completed value rather than checking callable identity. * refactor(rust-bridge): fold lifecycle and public_execution into one execution module The public stream wrappers only forwarded to the lifecycle streams and added the header dict, so the streams now carry _hidden_params themselves. lifecycle.py no longer held any call lifecycle, just the Execution driver, so it is renamed to execution.py and absorbs the synchronous and asynchronous adapters Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(rust-bridge): keep execution.py free of third-party imports The host-python tests load execution.py into a bare interpreter, so the pydantic header validation broke them. The stream head comes from the binding's encode_stream_head, which always builds a str-keyed dict Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(host-python): preserve pre-async hook coverage after execution handoff * style(rust-bridge): sort litellm_host_python imports Co-Authored-By: Yujong Lee <yujong@berri.ai> * test(rust-bridge): drive unstarted native calls through execution in the split lifecycle tests Co-Authored-By: Yujong Lee <yujong@berri.ai> * fix(rust-bridge): mark execution TypeVar as Final Co-Authored-By: Yujong Lee <yujong@berri.ai> * test(rust-bridge): cover stream close, read failure, and sync suspension in execution Co-Authored-By: Yujong Lee <yujong@berri.ai> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
76 lines
2.4 KiB
Rust
76 lines
2.4 KiB
Rust
//! The CPython runtime adapter: value marshalling, interpreter detachment, the tokio and
|
|
//! asyncio glue, and the driver that runs a native [`Machine`](litellm_host::machine::Machine)
|
|
//! against a Python binding, host services and active call hooks. Everything here is Python-specific by
|
|
//! construction; another host language gets its own crate of the same shape.
|
|
|
|
mod argument;
|
|
mod binding;
|
|
mod caller;
|
|
mod conversion_cache;
|
|
mod driver;
|
|
mod error;
|
|
mod file_reader;
|
|
mod fork_gate;
|
|
mod gil;
|
|
mod handle;
|
|
mod hooks;
|
|
mod marshal;
|
|
mod native;
|
|
mod owned;
|
|
mod runtime;
|
|
mod services;
|
|
|
|
pub use argument::{effective_py_args, lookup, present};
|
|
pub use binding::PythonBinding;
|
|
pub use conversion_cache::{FromPythonCache, ToPythonCache};
|
|
pub use driver::{CallOptions, run_call};
|
|
pub use error::{Error, InvokeError};
|
|
pub use file_reader::{FileContent, PythonFileReader, py_bytes};
|
|
pub use fork_gate::RuntimeAlreadyStarted;
|
|
pub use gil::{PythonContext, attach_blocking, release_count, release_gil};
|
|
pub use handle::{Execution, ExecutionBody, ExecutionStep, StepTypes, Suspension};
|
|
pub use hooks::{HookChain, HookResume, HookStep, PythonCallEvent, PythonCallHooks, PythonRuntime};
|
|
pub use marshal::{
|
|
Pythonized, from_py, from_py_argument, json_loads, json_object_field, panic_to_pyerr, to_py,
|
|
};
|
|
pub use owned::PythonOwned;
|
|
pub use runtime::{
|
|
ForkedAfterNativeRuntimeStarted, ProcessReservedForForking, enter_native, poll_async_value,
|
|
ready_future, reserve_process_for_forking, run_async, run_async_value, run_sync,
|
|
run_sync_value, runtime_started,
|
|
};
|
|
pub use services::PythonHostCalls;
|
|
|
|
/// Starts the interpreter and imports the standard modules the tests share, once, so
|
|
/// parallel test threads never race a first import of `asyncio`.
|
|
#[cfg(test)]
|
|
pub(crate) fn initialize_python() {
|
|
static IMPORTED: std::sync::Once = std::sync::Once::new();
|
|
pyo3::Python::initialize();
|
|
IMPORTED.call_once(|| {
|
|
pyo3::Python::attach(|py| {
|
|
py.import("asyncio").expect("asyncio imports");
|
|
});
|
|
});
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) struct InitializedPython;
|
|
|
|
#[cfg(test)]
|
|
impl InitializedPython {
|
|
pub(crate) fn attach<F, R>(&self, f: F) -> R
|
|
where
|
|
F: for<'py> FnOnce(pyo3::Python<'py>) -> R,
|
|
{
|
|
pyo3::Python::attach(f)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[rstest::fixture]
|
|
#[once]
|
|
pub(crate) fn initialized_python() -> InitializedPython {
|
|
initialize_python();
|
|
InitializedPython
|
|
}
|