Skip to content

CubeLoop — a Pythonic, async-native agent harness core designed for high performance, readability, and production-grade persistence.

refactor(base): inline chain-skip warning; drop _log_chain_skip helper

xf gong86a7bbd6f961
diff --git a/cubepi/providers/base.py b/cubepi/providers/base.py
index 276a376..589da86 100644
--- a/cubepi/providers/base.py
+++ b/cubepi/providers/base.py
@@ -815,33 +815,6 @@ class BaseProvider:
await _fire_chunk_listeners(self._chunk_listeners, event, model)
-def _log_chain_skip(idx: int, provider_type: str) -> None:
- """Warn that a chain leg's provider isn't a BaseProvider and was skipped.
-
- Tries loguru first (matches the rest of ``cubepi.providers``) and falls
- back to stdlib logging so the warning is never silently lost when loguru
- isn't installed.
- """
- try:
- from loguru import logger # pragma: no cover — loguru is an optional dep
-
- logger.warning( # pragma: no cover
- "cubepi.providers.base.chain_providers: chain[{}] provider {} is not "
- "a BaseProvider; tracing/metrics will skip this leg",
- idx,
- provider_type,
- )
- except ImportError:
- import logging
-
- logging.getLogger("cubepi.providers.base").warning(
- "cubepi.providers.base.chain_providers: chain[%d] provider %s is not "
- "a BaseProvider; tracing/metrics will skip this leg",
- idx,
- provider_type,
- )
-
-
def chain_providers(model: object) -> list["BaseProvider"]:
"""Return the unique BaseProvider instances backing a bound model.
@@ -853,10 +826,11 @@ def chain_providers(model: object) -> list["BaseProvider"]:
For ``FallbackBoundModel``-like inputs, iterates the chain and dedupes
providers by identity. Chain entries whose ``.provider`` isn't a
- ``BaseProvider`` are logged at WARNING via :func:`_log_chain_skip` and
+ ``BaseProvider`` are logged at WARNING via stdlib ``logging`` and
skipped — tracing / metrics need the ``subscribe_request`` /
``subscribe_chunk`` / ``subscribe_response`` interface that only
- ``BaseProvider`` exposes.
+ ``BaseProvider`` exposes. (cubepi does not depend on loguru; hosts that
+ use it can intercept stdlib logging.)
For plain bound models, returns ``[model.provider]`` if it is a
``BaseProvider``. For ``None`` or any other input, returns ``[]``.
@@ -866,6 +840,8 @@ def chain_providers(model: object) -> list["BaseProvider"]:
fallback chain so post-failover provider events land in the trace /
metric stream.
"""
+ import logging
+
if model is None:
return []
chain = getattr(model, "chain", None)
@@ -875,7 +851,12 @@ def chain_providers(model: object) -> list["BaseProvider"]:
for idx, bm in enumerate(chain):
p = getattr(bm, "provider", None)
if not isinstance(p, BaseProvider):
- _log_chain_skip(idx, type(p).__name__)
+ logging.getLogger("cubepi.providers.base").warning(
+ "cubepi.providers.base.chain_providers: chain[%d] provider "
+ "%s is not a BaseProvider; tracing/metrics will skip this leg",
+ idx,
+ type(p).__name__,
+ )
continue
if id(p) not in seen:
seen.add(id(p))
diff --git a/tests/providers/test_fallback.py b/tests/providers/test_fallback.py
index 37d5c2c..6c44af4 100644
--- a/tests/providers/test_fallback.py
+++ b/tests/providers/test_fallback.py
@@ -455,51 +455,14 @@ def test_chain_providers_warns_when_chain_leg_is_not_base_provider(caplog) -> No
duck_bound = BoundModel(provider=duck, spec=real.model("m").spec) # type: ignore[arg-type]
fbm = FallbackBoundModel(chain=(real.model("m"), duck_bound))
- # loguru bridges into stdlib logging if a propagation handler is set;
- # to keep the test independent of optional loguru config, just assert
- # the dropped leg is absent from the output and accept either backend.
with caplog.at_level(logging.WARNING, logger="cubepi.providers.base"):
out = chain_providers(fbm)
assert out == [real], "duck-typed leg should be dropped"
- # Warning is emitted either via loguru or stdlib logging. Don't pin
- # the backend; just check at least one of them carries the message.
- warned = any(
+ assert any(
"chain[1]" in record.message and "_DuckProvider" in record.message
for record in caplog.records
- )
- # If loguru is installed it may not propagate to caplog; in that case
- # we accept the assertion-free path (we already verified the leg was
- # dropped above). Treat this as best-effort signal.
- if not warned:
- try:
- import loguru # noqa: F401
-
- # loguru is installed → message went to loguru, not caplog;
- # the drop assertion above is sufficient evidence the warning
- # branch executed.
- except ImportError:
- raise AssertionError(
- "expected a WARNING-level log mentioning chain[1] / _DuckProvider"
- )
-
-
-def test_log_chain_skip_loguru_branch_invokable_directly() -> None:
- """Cover the loguru happy-path inside _log_chain_skip.
-
- The standard chain_providers warn-path test uses caplog (stdlib
- logging). When loguru is installed (the default test environment),
- the loguru branch fires but caplog cannot capture loguru messages
- without bridge configuration. Call _log_chain_skip directly so the
- loguru `logger.warning(...)` lines execute and the code path is
- recorded by coverage.
- """
- from cubepi.providers.base import _log_chain_skip
-
- # No assertion needed — just exercising the path. If loguru is
- # absent (extreme edge case), the stdlib fallback runs instead and
- # still covers the function body.
- _log_chain_skip(0, "object")
+ ), "expected a WARNING-level log mentioning chain[1] / _DuckProvider"
def test_chain_providers_returns_empty_for_object_without_provider_or_chain() -> None: