turingpulse-sdk-mistral 1.0.0__tar.gz

turingpulse_sdk_mistral-1.0.0/.gitignore

@@ -0,0 +1,42 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Database files
+*.db
+*.sqlite3
+
+# Environment variables
+.env
+.env.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Logs
+*.log
+logs/
+
+# OS files
+.DS_Store
+Thumbs.db

turingpulse_sdk_mistral-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: turingpulse-sdk-mistral
+Version: 1.0.0
+Summary: TuringPulse SDK integration for Mistral AI
+License-Expression: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: mistralai>=0.4.0
+Requires-Dist: turingpulse-sdk>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'

turingpulse_sdk_mistral-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "turingpulse-sdk-mistral"
+version = "1.0.0"
+description = "TuringPulse SDK integration for Mistral AI"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+dependencies = [
+    "turingpulse-sdk>=1.0.0",
+    "mistralai>=0.4.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]

turingpulse_sdk_mistral-1.0.0/turingpulse_sdk_mistral/__init__.py

@@ -0,0 +1,6 @@
+"""TuringPulse SDK integration for Mistral AI."""
+
+from ._wrapper import patch_mistral, unpatch_mistral
+
+__version__ = "0.1.0"
+__all__ = ["patch_mistral", "unpatch_mistral"]

turingpulse_sdk_mistral-1.0.0/turingpulse_sdk_mistral/_wrapper.py

@@ -0,0 +1,147 @@
+"""Mistral AI monkey-patch instrumentation for TuringPulse."""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextvars import ContextVar
+from typing import Any, Optional
+
+from turingpulse_sdk import instrument, GovernanceDirective
+from turingpulse_sdk.config import MAX_FIELD_SIZE
+from turingpulse_sdk.context import current_context
+from turingpulse_sdk.exceptions import ConfigurationError
+
+logger = logging.getLogger("turingpulse.sdk.mistral")
+
+_INSTRUMENTING: ContextVar[bool] = ContextVar("_tp_mistral_instrumenting", default=False)
+
+_ORIGINAL_COMPLETE: Any = None
+
+
+def patch_mistral(
+    *,
+    name: str | None = None,
+    governance: Optional[GovernanceDirective] = None,
+) -> None:
+    """Monkey-patch ``mistralai.Mistral.chat.complete``."""
+    global _ORIGINAL_COMPLETE
+
+    effective_name = name or os.getenv("TP_WORKFLOW_NAME", "")
+    if not effective_name:
+        raise ConfigurationError(
+            "patch_mistral() requires name= or TP_WORKFLOW_NAME to be set."
+        )
+
+    try:
+        from mistralai import Mistral
+    except ImportError as exc:
+        raise ImportError("mistralai package is required: pip install mistralai>=0.4.0") from exc
+
+    if _ORIGINAL_COMPLETE is not None:
+        logger.warning("Mistral is already patched — skipping")
+        return
+
+    chat_cls = getattr(Mistral, "chat", None)
+    if chat_cls is None:
+        try:
+            from mistralai.chat import Chat
+            chat_cls = Chat
+        except ImportError:
+            logger.warning(
+                "Cannot locate Mistral.chat or Chat class — Mistral SDK version may be incompatible. Skipping patch."
+            )
+            return
+
+    _ORIGINAL_COMPLETE = getattr(chat_cls, "complete", None)
+    if _ORIGINAL_COMPLETE is None or not callable(_ORIGINAL_COMPLETE):
+        _ORIGINAL_COMPLETE = None
+        logger.warning(
+            "Cannot locate Chat.complete — Mistral SDK version may be incompatible. Skipping patch."
+        )
+        return
+
+    @instrument(name=effective_name, governance=governance)
+    def _patched_complete(self_chat, *args: Any, **kwargs: Any) -> Any:
+        if _INSTRUMENTING.get(False):
+            return _ORIGINAL_COMPLETE(self_chat, *args, **kwargs)
+        token = _INSTRUMENTING.set(True)
+        try:
+            response = _ORIGINAL_COMPLETE(self_chat, *args, **kwargs)
+            _record_mistral_span(response, kwargs)
+            return response
+        finally:
+            _INSTRUMENTING.reset(token)
+
+    try:
+        chat_cls.complete = _patched_complete
+    except (AttributeError, TypeError) as exc:
+        _ORIGINAL_COMPLETE = None
+        logger.warning("Failed to patch Chat.complete: %s", type(exc).__name__)
+        return
+    logger.info("Mistral patched for TuringPulse instrumentation")
+
+
+def unpatch_mistral() -> None:
+    """Restore original Mistral methods."""
+    global _ORIGINAL_COMPLETE
+    if _ORIGINAL_COMPLETE is None:
+        return
+    try:
+        from mistralai.chat import Chat
+        Chat.complete = _ORIGINAL_COMPLETE
+    except ImportError:
+        try:
+            from mistralai import Mistral
+            if hasattr(Mistral, "chat"):
+                Mistral.chat.complete = _ORIGINAL_COMPLETE
+        except ImportError:
+            pass
+    _ORIGINAL_COMPLETE = None
+    logger.info("Mistral unpatched — original methods restored")
+
+
+def _record_mistral_span(response: Any, kwargs: dict) -> None:
+    ctx = current_context()
+    if not ctx:
+        return
+    ctx.framework = "mistral"
+    ctx.node_type = "llm"
+
+    usage = getattr(response, "usage", None)
+    if usage:
+        ctx.set_tokens(
+            getattr(usage, "prompt_tokens", 0) or 0,
+            getattr(usage, "completion_tokens", 0) or 0,
+        )
+
+    ctx.set_model(kwargs.get("model", getattr(response, "model", "unknown")), "mistral")
+
+    messages = kwargs.get("messages", [])
+    if messages:
+        last_user = next(
+            (m for m in reversed(messages) if (m.get("role") if isinstance(m, dict) else getattr(m, "role", "")) == "user"),
+            None,
+        )
+        if last_user:
+            content = last_user.get("content", "") if isinstance(last_user, dict) else getattr(last_user, "content", "")
+            ctx.set_prompt(str(content)[:MAX_FIELD_SIZE])
+
+    choices = getattr(response, "choices", [])
+    if choices:
+        message = getattr(choices[0], "message", None)
+        if message:
+            content = getattr(message, "content", "")
+            if content:
+                ctx.set_io(output_data=str(content)[:MAX_FIELD_SIZE])
+
+            tool_calls = getattr(message, "tool_calls", None)
+            if tool_calls:
+                for tc in tool_calls:
+                    func = getattr(tc, "function", None)
+                    if func:
+                        ctx.add_tool_call(
+                            tool_name=getattr(func, "name", "unknown"),
+                            tool_args={"arguments": getattr(func, "arguments", "")},
+                            tool_id=getattr(tc, "id", None),
+                        )