mirror of
https://github.com/BerriAI/litellm.git
synced 2026-10-02 02:11:58 +00:00
ec605826d4
* refactor: separate OTLP HTTP decoding from trace codec * feat: complete trace ingestion and read paths * fix: encode OTLP protobuf errors in Rust * fix: raise OTLP body limit to 16 MiB * test: cover OTLP auth body parsing boundary * refactor: parse OTLP media type into enum * fix: enforce OTLP body size at HTTP boundary * perf: preserve shared OTLP metadata across ingestion * bench: compare owned and shared trace resource fanout * refactor: extract shared storage and Python conversion caches * refactor: keep shared storage owned by traces * test: keep trace loopback coverage in Rust * test(proxy): adapt trace coverage to injected access context * fix(tracing): satisfy stacked branch lint checks * refactor(tracing): use immutable ingestion payloads * fix(tracing): declare native error encoder export * test(proxy): resolve trace access through dependency * fix(tracing): align merged normalizer types and bridge tests * fix(tracing): address ingestion and diagnostic review findings * fix(proxy): preserve body parsing for partial request scopes * test(proxy): use valid HTTP scopes in request fixtures * test(proxy): complete auth request flow scopes
75 lines
2.3 KiB
Rust
75 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 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::lookup;
|
|
pub use binding::PythonBinding;
|
|
pub use conversion_cache::{FromPythonCache, ToPythonCache};
|
|
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
|
|
}
|