mirror of
https://github.com/BerriAI/litellm.git
synced 2026-09-29 01:42:19 +00:00
e4190d86a6
* refactor(rust): extract litellm-host-native as the shared Rust host driver Move service and hook dispatch out of host-http into a Driver that owns the machine and Rust handlers, returning at completion or a stream boundary and holding the demand reply until the consumer advances. Move the in-process runner onto the same driver. host-http now layers encoding, SSE, body polling and lifecycle observation over it. host-python keeps driving litellm-host directly Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * fix(rust): interrupt the machine when the in-process stream consumer fails Restores the pre-refactor interruption path for StreamConsumer errors via Driver::fail and ports the generic run lifecycle tests into host-native. Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * refactor(rust): separate the machine contract from coroutine execution * auth update * refactor(rust): use standard flow control for host requests * style(rust): keep host driver imports formatted * chores * mostly relocation * refactor(rust): separate interceptors from queued observers * refactor(rust): centralize legacy callback mappings and lifecycle * docs: define Python host boundaries and migration plan * refactor: enforce Python host and bridge boundaries * refactor(rust): separate operations from callback composition * refactor(rust): compose SDK policy through call hooks --------- Co-authored-by: Yujong Lee <yujong@berri.ai> Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
73 lines
2.3 KiB
Rust
73 lines
2.3 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 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::lookup;
|
|
pub use binding::PythonBinding;
|
|
pub use driver::{CallOptions, run_call};
|
|
pub use error::{InvokeError, missing_state};
|
|
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, PythonLifecycle};
|
|
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
|
|
}
|