trodo-python 2.22.0__tar.gz → 2.23.1__tar.gz

{trodo_python-2.22.0 → trodo_python-2.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.22.0
+Version: 2.23.1
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side

{trodo_python-2.22.0 → trodo_python-2.23.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trodo-python"
-version = "2.22.0"
+version = "2.23.1"
 description = "Trodo Analytics SDK for Python — server-side event tracking"
 readme = "README.md"
 license = { text = "ISC" }

{trodo_python-2.22.0 → trodo_python-2.23.1}/tests/test_instrumentor_resolution.py

@@ -107,3 +107,82 @@ def test_a_missing_module_still_raises_importerror(_clean):
     """The caller relies on ImportError to mean "skip this framework"."""
     with pytest.raises(ImportError):
         _instrument('module_that_does_not_exist_xyz', 'AnyInstrumentor')
+
+
+# ── Version conflicts must not be reported as active ────────────────────────
+#
+# An instrumentor whose target library is the wrong VERSION does not raise:
+# OpenTelemetry logs a DependencyConflict and returns without patching. We then
+# appended it to `active` and reported auto-capture that was not happening.
+# Found live: cohere 7.0.9 against the instrumentor's ">=4.2.7, <6" was listed
+# as active while producing no spans — the same lie as Node listing `openai`
+# for a version its instrumentation cannot patch.
+
+@pytest.fixture
+def fake_conflict_checker():
+    """Stand in for opentelemetry.instrumentation.dependencies.
+
+    OpenTelemetry is an OPTIONAL dependency of this SDK, so the suite must not
+    require it to be installed — injecting the module is how these tests stay
+    runnable in a bare environment.
+    """
+    made = []
+
+    def install(result):
+        for mod in ('opentelemetry', 'opentelemetry.instrumentation',
+                    'opentelemetry.instrumentation.dependencies'):
+            if mod not in sys.modules:
+                sys.modules[mod] = types.ModuleType(mod)
+                made.append(mod)
+        sys.modules['opentelemetry.instrumentation.dependencies'].get_dependency_conflicts = (
+            lambda deps: result
+        )
+    yield install
+    for m in made:
+        sys.modules.pop(m, None)
+
+
+def test_a_version_conflict_is_raised_not_swallowed(_clean, fake_conflict_checker):
+    name = 'fake_instr_conflict'
+    _clean.append(name)
+
+    class Conflicted(_Recorder):
+        instrumented = False
+
+        def instrumentation_dependencies(self):
+            return ('somelib >=1, <2',)
+
+    _fake_module(name, ConflictedInstrumentor=Conflicted)
+    fake_conflict_checker('DependencyConflict: requested "somelib >=1, <2" but found "somelib 3.0"')
+    from trodo.otel.auto_instrument import _IncompatibleInstrumentation
+
+    with pytest.raises(_IncompatibleInstrumentation, match='somelib 3.0'):
+        _instrument(name, 'ConflictedInstrumentor')
+    assert Conflicted.instrumented is False   # and it never patched
+
+
+def test_no_conflict_instruments_normally(_clean, fake_conflict_checker):
+    name = 'fake_instr_ok'
+    _clean.append(name)
+
+    class Fine(_Recorder):
+        instrumented = False
+
+        def instrumentation_dependencies(self):
+            return ('somelib >=1',)
+
+    _fake_module(name, FineInstrumentor=Fine)
+    fake_conflict_checker(None)
+    _instrument(name, 'FineInstrumentor')
+    assert Fine.instrumented is True
+
+
+def test_unknowable_conflict_state_fails_open(_clean):
+    """No dependency helper, or an instrumentor that declares nothing, must not
+    be condemned — falsely reporting a working setup as broken is worse."""
+    name = 'fake_instr_nodeps'
+    _clean.append(name)
+    cls = type('NoDepsInstrumentor', (_Recorder,), {'instrumented': False})
+    _fake_module(name, NoDepsInstrumentor=cls)
+    _instrument(name, 'NoDepsInstrumentor')
+    assert cls.instrumented is True

{trodo_python-2.22.0 → trodo_python-2.23.1}/tests/test_prompts.py

@@ -408,3 +408,27 @@ def test_list_returns_empty_on_error():
             return {"__error": True}
 
     assert PromptManager(Err()).list() == []
+
+
+# ── Shared vectors: COMPILE layer ═══════════════════════════════════════════
+#
+# Declared-variable semantics (defaults, explicit null, per-type coercion) are
+# where the three engines actually drifted -- THIS engine substituted the
+# default for an explicit ``None`` and coerced string-typed values with
+# ``str()`` instead of JS ``String()``, so the same call rendered different
+# text in Python than in the playground. The backend and Node suites run the
+# SAME cases from the same file.
+
+with open(_VECTORS_PATH, encoding="utf-8") as _f:
+    _COMPILE_CASES = json.load(_f).get("compileCases", [])
+
+
+@pytest.mark.parametrize("case", _COMPILE_CASES, ids=lambda c: c["name"])
+def test_compile_vectors(case):
+    prompt = {
+        "messages": [{"role": "user", "content": [{"type": "text", "text": case["template"]}]}],
+        "model": {}, "tools": [], "response_format": None,
+        "variables": case["variables"],
+    }
+    out = compile_prompt(prompt, case["values"])
+    assert out.messages[0]["content"][0]["text"] == case["expect"]

{trodo_python-2.22.0 → trodo_python-2.23.1}/trodo/otel/auto_instrument.py

@@ -438,7 +438,44 @@ def _instrument(module_name: str, *preferred: str) -> None:
             )
     if cls is None:
         raise ImportError(f"no Instrumentor class exported by {module_name}")
-    cls().instrument()
+
+    instr = cls()
+
+    # An instrumentor whose target library is the wrong VERSION does not raise:
+    # OpenTelemetry logs a DependencyConflict and returns without patching
+    # anything. We would then append it to `active` and report auto-capture that
+    # is not happening -- the same lie as listing a framework whose
+    # instrumentation cannot patch the installed SDK. Ask first, and let the
+    # caller report it honestly.
+    conflict = _dependency_conflict(instr)
+    if conflict is not None:
+        raise _IncompatibleInstrumentation(str(conflict))
+
+    instr.instrument()
+
+
+class _IncompatibleInstrumentation(ImportError):
+    """The instrumentor loaded, but its target library is an unsupported version."""
+
+
+def _dependency_conflict(instr: Any) -> Any:
+    """The version conflict OpenTelemetry would hit, or None.
+
+    Returns None when we cannot tell -- an older OTel without the helper, or an
+    instrumentor that declares nothing. Falsely reporting a working setup as
+    broken is worse than the silence this replaces.
+    """
+    try:
+        from opentelemetry.instrumentation.dependencies import (  # type: ignore
+            get_dependency_conflicts,
+        )
+
+        deps = instr.instrumentation_dependencies()
+        if not deps:
+            return None
+        return get_dependency_conflicts(deps)
+    except Exception:  # noqa: BLE001
+        return None
 
 
 _INSTRUMENTORS: List[tuple[str, Callable[[], Any]]] = []
@@ -556,6 +593,17 @@ def enable_auto_instrument(
         try:
             register()
             active.append(name)
+        except _IncompatibleInstrumentation as e:
+            # Loud, because this is the case where everything LOOKS installed:
+            # the package is present, the import worked, and no spans will ever
+            # appear. Silence here is what costs people an afternoon.
+            _warn_once(
+                f"version-{name}",
+                f"auto-instrument: {name} will NOT be auto-captured and is not "
+                f"reported as active -- {e}. Wrap the call with trodo.llm(...) "
+                f"to capture it, or pin the library to a supported version.",
+            )
+            continue
         except Exception:
             continue
     return active

{trodo_python-2.22.0 → trodo_python-2.23.1}/trodo/prompts/compile.py

@@ -36,6 +36,36 @@ def _q(value: Any) -> str:
     except (TypeError, ValueError):
         return repr(value)
 
+def _js_string(value: Any) -> str:
+    """JavaScript ``String()`` semantics, byte-for-byte.
+
+    A non-string passed for a string-typed variable is a caller type mismatch,
+    but all three engines must agree on what it renders as -- the backend
+    reference (which powers the playground) and the Node SDK both go through
+    JS ``String()``, so ``True`` must render ``true``, ``3.0`` must render
+    ``3``, a list joins with commas, and a dict renders the infamous
+    ``[object Object]``. The JSON rendering callers actually want lives on the
+    ``json`` variable type, where all three engines already emit compact JSON.
+    """
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, float) and value.is_integer() and abs(value) < 1e21:
+        return str(int(value))
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (list, tuple)):
+        # Array.prototype.toString: elements joined by ',', null/undefined
+        # rendering empty, recursively.
+        return ",".join(_js_string(x) for x in value)
+    if isinstance(value, dict):
+        return "[object Object]"
+    return str(value)
+
+
 def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
     """Coerce a caller value to the declared type.
 
@@ -71,7 +101,7 @@ def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
         return value
 
     if type_ == "string":
-        return value if isinstance(value, str) else str(value)
+        return value if isinstance(value, str) else _js_string(value)
 
     if type_ == "messages":
         if not isinstance(value, list):
@@ -119,7 +149,13 @@ def build_scope(
         # empty. That IS the point of declaring a default -- there is no third
         # case where the caller has to have supplied something, and adding one
         # would turn an empty render into a crash for no gain.
-        if not has or value is None:
+        #
+        # The default applies to an ABSENT key only. An explicit ``None`` is a
+        # value -- "render this empty" -- exactly as ``null`` is in the backend
+        # reference engine and the Node SDK. This engine used to substitute the
+        # default for an explicit ``None``, so the same call rendered different
+        # text in Python than everywhere else, including the playground.
+        if not has:
             value = default if has_default else ([] if type_ == "messages" else "")
 
         scope[name] = _coerce(value, type_, name, errors)

{trodo_python-2.22.0 → trodo_python-2.23.1}/trodo/prompts/template.py

@@ -159,6 +159,21 @@ def _lookup(path: str, scopes: Sequence[Any]) -> Tuple[bool, Any]:
     return False, None
 
 
+def _jsonable(value):
+    """Normalise for JSON.stringify parity: JS has one number type, so a float
+    that is a whole number must serialise as ``1`` and not ``1.0`` -- at any
+    depth. Everything else passes through untouched."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, float) and value.is_integer() and abs(value) < 1e21:
+        return int(value)
+    if isinstance(value, dict):
+        return {k: _jsonable(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(v) for v in value]
+    return value
+
+
 def _stringify(value: Any) -> str:
     if value is None:
         return ""
@@ -173,7 +188,7 @@ def _stringify(value: Any) -> str:
             return str(int(value))
         return str(value)
     try:
-        return json.dumps(value, separators=(",", ":"))
+        return json.dumps(_jsonable(value), separators=(",", ":"), ensure_ascii=False)
     except (TypeError, ValueError):
         return str(value)
 

{trodo_python-2.22.0 → trodo_python-2.23.1}/trodo_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.22.0
+Version: 2.23.1
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side