beekeeper-core 1.0.6__tar.gz → 1.0.8__tar.gz

{beekeeper_core-1.0.6 → beekeeper_core-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beekeeper-core
-Version: 1.0.6
+Version: 1.0.8
 Summary: Load any data in one line of code and connect with AI applications
 Project-URL: Repository, https://github.com/beekeeper-ai/beekeeper
 Author-email: Leonardo Furnielis <leonardofurnielis@outlook.com>

beekeeper_core-1.0.8/beekeeper/core/guardrails/__init__.py

@@ -0,0 +1,4 @@
+from beekeeper.core.guardrails.base import BaseGuardrail
+from beekeeper.core.guardrails.types import GuardrailResponse
+
+__all__ = ["BaseGuardrail", "GuardrailResponse"]

beekeeper_core-1.0.8/beekeeper/core/guardrails/base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+from beekeeper.core.guardrails.types import GuardrailResponse
+
+
+class BaseGuardrail(ABC):
+    """Abstract base class defining the interface for LLMs."""
+
+    @classmethod
+    def class_name(cls) -> str:
+        return "BaseGuardrail"
+
+    @abstractmethod
+    def enforce(self, text: str, direction: str) -> GuardrailResponse:
+        """Runs policies enforcement to specified guardrail."""

beekeeper_core-1.0.8/beekeeper/core/guardrails/types.py

@@ -0,0 +1,13 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class GuardrailResponse(BaseModel):
+    """Guardrail response."""
+
+    text: str = Field(..., description="Generated text response")
+    action: Optional[str] = Field(
+        default=None, description="Action taken by the guardrail"
+    )
+    raw: Optional[Any] = Field(default=None)

beekeeper_core-1.0.8/beekeeper/core/llms/decorators.py

@@ -0,0 +1,162 @@
+import asyncio
+import threading
+import time
+from logging import getLogger
+from typing import Callable
+
+from beekeeper.core.llms.types import ChatMessage
+from beekeeper.core.monitors.types import PayloadRecord
+from deprecated import deprecated
+
+logger = getLogger(__name__)
+
+
+@deprecated(
+    reason="'llm_chat_observer()' is deprecated and will be removed in a future version. Use 'llm_chat_monitor()'.",
+    version="1.0.8",
+    action="always",
+)
+def llm_chat_observer() -> Callable:
+    """
+    Decorator to wrap a method with llm handler logic.
+    Looks for observability instances in `self.callback_manager`.
+    """
+
+    def decorator(f: Callable) -> Callable:
+        def async_wrapper(self, *args, **kwargs):
+            callback_manager_fns = getattr(self, "callback_manager", None)
+
+            start_time = time.time()
+            llm_return_val = f(self, *args, **kwargs)
+            response_time = int((time.time() - start_time) * 1000)
+
+            if callback_manager_fns:
+
+                def async_callback_thread():
+                    try:
+                        # Extract input messages
+                        if len(args) > 0 and isinstance(args[0], ChatMessage):
+                            input_chat_messages = args[0]
+                        elif "messages" in kwargs:
+                            input_chat_messages = kwargs["messages"]
+                        else:
+                            raise ValueError(
+                                "No messages provided in positional or keyword arguments"
+                            )
+
+                        # Get the user's latest message after each interaction to chat observability.
+                        user_messages = [
+                            msg for msg in input_chat_messages if msg.role == "user"
+                        ]
+                        last_user_message = (
+                            user_messages[-1].content if user_messages else None
+                        )
+
+                        # Get the system/instruct (first) message to chat observability.
+                        system_messages = [
+                            msg for msg in input_chat_messages if msg.role == "system"
+                        ]
+                        system_message = (
+                            system_messages[0].content if system_messages else None
+                        )
+
+                        callback = callback_manager_fns(
+                            payload=PayloadRecord(
+                                input_text=(system_message or "") + last_user_message,
+                                generated_text=llm_return_val.message.content,
+                                generated_token_count=llm_return_val.raw["usage"][
+                                    "completion_tokens"
+                                ],
+                                input_token_count=llm_return_val.raw["usage"][
+                                    "prompt_tokens"
+                                ],
+                                response_time=response_time,
+                            )
+                        )
+
+                        if asyncio.iscoroutine(callback):
+                            asyncio.run(callback)
+
+                    except Exception as e:
+                        logger.error(f"Observability callback error: {e}")
+
+                threading.Thread(target=async_callback_thread).start()
+
+            return llm_return_val
+
+        return async_wrapper
+
+    return decorator
+
+
+def llm_chat_monitor() -> Callable:
+    """
+    Decorator to wrap a method with llm handler logic.
+    Looks for observability instances in `self.callback_manager`.
+    """
+
+    def decorator(f: Callable) -> Callable:
+        def async_wrapper(self, *args, **kwargs):
+            callback_manager_fns = getattr(self, "callback_manager", None)
+
+            start_time = time.time()
+            llm_return_val = f(self, *args, **kwargs)
+            response_time = int((time.time() - start_time) * 1000)
+
+            if callback_manager_fns:
+
+                def async_callback_thread():
+                    try:
+                        # Extract input messages
+                        if len(args) > 0 and isinstance(args[0], ChatMessage):
+                            input_chat_messages = args[0]
+                        elif "messages" in kwargs:
+                            input_chat_messages = kwargs["messages"]
+                        else:
+                            raise ValueError(
+                                "No messages provided in positional or keyword arguments"
+                            )
+
+                        # Get the user's latest message after each interaction to chat observability.
+                        user_messages = [
+                            msg for msg in input_chat_messages if msg.role == "user"
+                        ]
+                        last_user_message = (
+                            user_messages[-1].content if user_messages else None
+                        )
+
+                        # Get the system/instruct (first) message to chat observability.
+                        system_messages = [
+                            msg for msg in input_chat_messages if msg.role == "system"
+                        ]
+                        system_message = (
+                            system_messages[0].content if system_messages else None
+                        )
+
+                        callback = callback_manager_fns(
+                            payload=PayloadRecord(
+                                input_text=(system_message or "") + last_user_message,
+                                generated_text=llm_return_val.message.content,
+                                generated_token_count=llm_return_val.raw["usage"][
+                                    "completion_tokens"
+                                ],
+                                input_token_count=llm_return_val.raw["usage"][
+                                    "prompt_tokens"
+                                ],
+                                response_time=response_time,
+                            )
+                        )
+
+                        if asyncio.iscoroutine(callback):
+                            asyncio.run(callback)
+
+                    except Exception as e:
+                        logger.error(f"Observability callback error: {e}")
+
+                threading.Thread(target=async_callback_thread).start()
+
+            return llm_return_val
+
+        return async_wrapper
+
+    return decorator

{beekeeper_core-1.0.6 → beekeeper_core-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "beekeeper-core"
-version = "1.0.6"
+version = "1.0.8"
 description = "Load any data in one line of code and connect with AI applications"
 authors = [{ name = "Leonardo Furnielis", email = "leonardofurnielis@outlook.com" }]
 license = { text = "Apache-2.0" }

beekeeper_core-1.0.6/beekeeper/core/llms/decorators.py

@@ -1,83 +0,0 @@
-import asyncio
-import threading
-import time
-from logging import getLogger
-from typing import Callable
-
-from beekeeper.core.llms.types import ChatMessage
-from beekeeper.core.observers.types import PayloadRecord
-
-logger = getLogger(__name__)
-
-
-def llm_chat_observer() -> Callable:
-    """
-    Decorator to wrap a method with llm handler logic.
-    Looks for observability instances in `self.callback_manager`.
-    """
-
-    def decorator(f: Callable) -> Callable:
-        def async_wrapper(self, *args, **kwargs):
-            callback_manager_fns = getattr(self, "callback_manager", None)
-
-            start_time = time.time()
-            llm_return_val = f(self, *args, **kwargs)
-            response_time = int((time.time() - start_time) * 1000)
-
-            if callback_manager_fns:
-
-                def async_callback_thread():
-                    try:
-                        # Extract input messages
-                        if len(args) > 0 and isinstance(args[0], ChatMessage):
-                            input_chat_messages = args[0]
-                        elif "messages" in kwargs:
-                            input_chat_messages = kwargs["messages"]
-                        else:
-                            raise ValueError(
-                                "No messages provided in positional or keyword arguments"
-                            )
-
-                        # Get the user's latest message after each interaction to chat observability.
-                        user_messages = [
-                            msg for msg in input_chat_messages if msg.role == "user"
-                        ]
-                        last_user_message = (
-                            user_messages[-1].content if user_messages else None
-                        )
-
-                        # Get the system/instruct (first) message to chat observability.
-                        system_messages = [
-                            msg for msg in input_chat_messages if msg.role == "system"
-                        ]
-                        system_message = (
-                            system_messages[0].content if system_messages else None
-                        )
-
-                        callback = callback_manager_fns(
-                            payload=PayloadRecord(
-                                input_text=(system_message or "") + last_user_message,
-                                generated_text=llm_return_val.message.content,
-                                generated_token_count=llm_return_val.raw["usage"][
-                                    "completion_tokens"
-                                ],
-                                input_token_count=llm_return_val.raw["usage"][
-                                    "prompt_tokens"
-                                ],
-                                response_time=response_time,
-                            )
-                        )
-
-                        if asyncio.iscoroutine(callback):
-                            asyncio.run(callback)
-
-                    except Exception as e:
-                        logger.error(f"Observability callback error: {e}")
-
-                threading.Thread(target=async_callback_thread).start()
-
-            return llm_return_val
-
-        return async_wrapper
-
-    return decorator