tPjhdZddlmZddlmZmZddlmZmZddl m Z edeZ Gdd Z y ) aC DualCache presents a single API for reads and writes, but the two backends behave differently: the in-memory layer can store arbitrary Python objects (including live ``BaseModel`` instances), while Redis persists strings and therefore needs JSON-safe payloads (``json.dumps`` on the Redis side). Call sites therefore see cache ``value`` / ``cached`` as effectively ``Any``: the same key may deserialize to a model on one process (memory hit) or to a ``dict`` after a Redis round-trip. ``CacheCodec`` centralizes encode/decode at that boundary: ``CacheCodec.serialize`` before ``set``, ``CacheCodec.deserialize`` after ``get`` when you need a typed ``BaseModel``. ``dataclasses`` are not supported: only ``dict`` and Pydantic ``BaseModel`` inputs are encoded; pass a Pydantic model or convert with e.g. ``dataclasses.asdict`` first. ) annotations)AnyTypeVar) BaseModelValidationError)verbose_proxy_loggerT)boundc6eZdZdZedddZeddZy) CacheCodeca Encode/decode Pydantic models for DualCache (memory vs Redis safe payloads). Dataclasses are not supported yet (only ``dict`` and ``BaseModel``). Use ``serialize`` with ``model_type`` when writing so the same schema is used as on read (``deserialize``). Pass ``model_type`` whenever you know it (validates ``dict`` payloads and normalizes ``BaseModel`` instances). Nc|Wt||r|jdSt|ttfr!|j |jdS|St|tr|jdS|S)u= Encode a value for DualCache / Redis (``json.dumps``-safe). If ``model_type`` is set, the payload is validated with that model, then ``model_dump(mode="json")`` — symmetric with ``deserialize``. If the value is already an instance of ``model_type`` (or a subclass), ``model_validate`` is skipped to avoid an unnecessary Pydantic copy — the value is dumped directly. If ``model_type`` is omitted, any ``BaseModel`` is dumped as above; other values (e.g. plain ``dict``) are returned unchanged. json)mode) isinstance model_dumpdictrmodel_validate)value model_types t/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/proxy/common_utils/cache_pydantic_utils.py serializezCacheCodec.serialize's~  !%,''V'44%$ !23!007BBBOOL eY '###0 0 c|yt||r|St|tr |j|Sy#t$r+}t j d|j |Yd}~yd}~wwxYw)u Decode a cache entry to ``model_type``. - ``None`` → ``None`` - Already an instance of ``model_type`` (including subclasses) → returned as-is - ``dict`` → ``model_type.model_validate(...)``; on ``ValidationError``, logs a warning and returns ``None`` (treat as cache miss; avoids serving malformed or schema-drifted entries) - Any other type → ``None`` (caller should treat as cache miss or log) Nz5CacheCodec.deserialize: validation failed for %s (%s))rrrrrwarning__name__)cachedres r deserializezCacheCodec.deserializeAst > fj )M fd # !0088# $,,K''   s5 A)!A$$A))N)rrrztype[T] | Nonereturnr)rrrztype[T]rzT | None)r __module__ __qualname____doc__ staticmethodrrrrr r s/2rr N) r" __future__rtypingrrpydanticrrlitellm._loggingrr r r$rrr)s. #/1 Cy!??r