beekeeper-core 1.0.4__tar.gz → 1.0.12__tar.gz

{beekeeper_core-1.0.4 → beekeeper_core-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beekeeper-core
-Version: 1.0.4
+Version: 1.0.12
 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>
@@ -9,14 +9,14 @@ Keywords: AI,LLM,QA,RAG,data,observability,retrieval,semantic-search
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <4.0,>=3.10
-Requires-Dist: deprecated<2.0.0,>=1.2.18
+Requires-Python: <3.14,>=3.11
+Requires-Dist: deprecated<2.0.0,>=1.3.1
 Requires-Dist: nltk<4.0.0,>=3.9.2
 Requires-Dist: numpy<1.27.0,>=1.26.4
-Requires-Dist: pydantic<3.0.0,>=2.11.10
-Requires-Dist: tiktoken<0.10.0,>=0.9.0
+Requires-Dist: pydantic<3.0.0,>=2.12.5
+Requires-Dist: tiktoken<0.13.0,>=0.12.0
 Provides-Extra: dev
-Requires-Dist: ruff>=0.11.13; extra == 'dev'
+Requires-Dist: ruff>=0.14.9; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Beekeeper Core

beekeeper_core-1.0.12/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.12/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.12/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.4 → beekeeper_core-1.0.12}/beekeeper/core/llms/base.py

@@ -1,35 +1,40 @@
 from abc import ABC, abstractmethod
-from typing import Any, List, Optional
+from typing import Any, Optional
 
 from beekeeper.core.llms.types import ChatMessage, ChatResponse, GenerateResponse
 from beekeeper.core.monitors import BaseMonitor
 from pydantic import BaseModel
 
 
-class BaseLLM(ABC, BaseModel):
+class BaseLLM(BaseModel, ABC):
     """Abstract base class defining the interface for LLMs."""
 
     model_config = {"arbitrary_types_allowed": True}
+    model: str
     callback_manager: Optional[BaseMonitor] = None
 
     @classmethod
     def class_name(cls) -> str:
         return "BaseLLM"
 
-    def convert_chat_messages(self, messages: List[ChatMessage]) -> List[dict]:
-        """Convert ChatMessage to LLM message dict format."""
-        return [message.model_dump() for message in messages]
+    def text_completion(self, prompt: str, **kwargs: Any) -> str:
+        """
+        Generates a chat completion for LLM. Using OpenAI's standard endpoint (/completions).
+
+        Args:
+            prompt (str): The input prompt to generate a completion for.
+            **kwargs (Any): Additional keyword arguments to customize the LLM completion request.
+        """
+        response = self.completion(prompt=prompt, **kwargs)
+
+        return response.text
 
     @abstractmethod
     def completion(self, prompt: str, **kwargs: Any) -> GenerateResponse:
         """Generates a completion for LLM."""
 
-    @abstractmethod
-    def text_completion(self, prompt: str, **kwargs: Any) -> str:
-        """Generates a text completion for LLM."""
-
     @abstractmethod
     def chat_completion(
-        self, messages: List[ChatMessage], **kwargs: Any
+        self, messages: list[ChatMessage | dict], **kwargs: Any
     ) -> ChatResponse:
         """Generates a chat completion for LLM."""

{beekeeper_core-1.0.4 → beekeeper_core-1.0.12}/beekeeper/core/llms/decorators.py

@@ -5,12 +5,13 @@ from logging import getLogger
 from typing import Callable
 
 from beekeeper.core.llms.types import ChatMessage
-from beekeeper.core.observers.types import PayloadRecord
+from beekeeper.core.monitors.types import PayloadRecord
+from beekeeper.core.prompts.utils import extract_template_vars
 
 logger = getLogger(__name__)
 
 
-def llm_chat_observer() -> Callable:
+def llm_chat_monitor() -> Callable:
     """
     Decorator to wrap a method with llm handler logic.
     Looks for observability instances in `self.callback_manager`.
@@ -54,16 +55,29 @@ def llm_chat_observer() -> Callable:
                             system_messages[0].content if system_messages else None
                         )
 
+                        # Extract template variables values from the prompt template if available
+                        template_var_values = (
+                            extract_template_vars(
+                                callback_manager_fns.prompt_template.template,
+                                (system_message or ""),
+                            )
+                            if callback_manager_fns.prompt_template
+                            else {}
+                        )
+
                         callback = callback_manager_fns(
                             payload=PayloadRecord(
-                                input_text=(system_message or "") + last_user_message,
+                                system_prompt=(system_message or ""),
+                                input_text=last_user_message,
+                                prompt_variables=list(template_var_values.keys()),
+                                prompt_variable_values=template_var_values,
                                 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"
                                 ],
+                                generated_token_count=llm_return_val.raw["usage"][
+                                    "completion_tokens"
+                                ],
                                 response_time=response_time,
                             )
                         )
@@ -72,7 +86,7 @@ def llm_chat_observer() -> Callable:
                             asyncio.run(callback)
 
                     except Exception as e:
-                        logger.error(f"Observability callback error: {e}")
+                        logger.error(f"Observability callback: {e}")
 
                 threading.Thread(target=async_callback_thread).start()
 

beekeeper_core-1.0.12/beekeeper/core/llms/types.py

@@ -0,0 +1,57 @@
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class MessageRole(str, Enum):
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    USER = "user"
+    TOOL = "tool"
+
+
+class ChatMessage(BaseModel):
+    """Chat message."""
+
+    model_config = {"use_enum_values": True}
+    role: MessageRole = Field(default=MessageRole.USER)
+    content: Optional[str] = Field(default=None)
+
+    def to_dict(self) -> dict:
+        """Convert ChatMessage to dict."""
+        return self.model_dump(exclude_none=True)
+
+    @classmethod
+    def from_value(cls, value: dict) -> "ChatMessage":
+        if value is None:
+            raise ValueError("Invalid 'ChatMessage', cannot be None")
+
+        if isinstance(value, cls):
+            return value
+
+        if isinstance(value, dict):
+            try:
+                return cls.model_validate(value)
+            except Exception as e:
+                raise ValueError(
+                    "Invalid 'ChatMessage' dict. Received: '{}'.".format(e)
+                )
+
+        raise TypeError(
+            f"Invalid 'ChatMessage' type. Expected dict or ChatMessage, but received {type(value).__name__}."
+        )
+
+
+class GenerateResponse(BaseModel):
+    """Generate response."""
+
+    text: str = Field(..., description="Generated text response")
+    raw: Optional[Any] = Field(default=None)
+
+
+class ChatResponse(BaseModel):
+    """Chat completion response."""
+
+    message: ChatMessage
+    raw: Optional[Any] = None

{beekeeper_core-1.0.4 → beekeeper_core-1.0.12}/beekeeper/core/monitors/base.py

@@ -17,7 +17,7 @@ class PromptMonitor(BaseMonitor):
     """Abstract base class defining the interface for prompt observability."""
 
     def __init__(self, prompt_template: Optional[PromptTemplate] = None) -> None:
-        self.prompt_template = prompt_template
+        self.prompt_template = PromptTemplate.from_value(prompt_template)
 
     @classmethod
     def class_name(cls) -> str:

beekeeper_core-1.0.12/beekeeper/core/monitors/types.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+
+class PayloadRecord(BaseModel):
+    """Payload record."""
+
+    system_prompt: str | None = None
+    input_text: str
+    prompt_variables: list[str] | None = None
+    prompt_variable_values: dict[str, str] | None = None
+    generated_text: str
+    input_token_count: int
+    generated_token_count: int
+    response_time: int

{beekeeper_core-1.0.4 → beekeeper_core-1.0.12}/beekeeper/core/prompts/base.py

@@ -22,6 +22,18 @@ class PromptTemplate(BaseModel):
     def __init__(self, template: str):
         super().__init__(template=template)
 
+    @classmethod
+    def from_value(cls, value: str) -> "PromptTemplate":
+        if isinstance(value, cls):
+            return value
+
+        if isinstance(value, str):
+            return cls(value)
+
+        raise TypeError(
+            f"Invalid type for parameter 'prompt_template'. Expected str or PromptTemplate, but received {type(value).__name__}."
+        )
+
     def format(self, **kwargs):
         """
         Formats the template using the provided dynamic variables.

{beekeeper_core-1.0.4 → beekeeper_core-1.0.12}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "beekeeper-core"
-version = "1.0.4"
+version = "1.0.12"
 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" }
 readme = "README.md"
-requires-python = ">=3.10,<4.0"
+requires-python = ">=3.11,<3.14"
 keywords = ["AI", "LLM", "QA", "RAG", "data", "observability", "retrieval", "semantic-search"]
 classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
@@ -17,16 +17,16 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Application Frameworks",
 ]
 dependencies = [
-    "deprecated>=1.2.18,<2.0.0",
+    "deprecated>=1.3.1,<2.0.0",
     "nltk>=3.9.2,<4.0.0",
     "numpy>=1.26.4,<1.27.0",
-    "pydantic>=2.11.10,<3.0.0",
-    "tiktoken>=0.9.0,<0.10.0",
+    "pydantic>=2.12.5,<3.0.0",
+    "tiktoken>=0.12.0,<0.13.0",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "ruff>=0.11.13",
+    "ruff>=0.14.9",
 ]
 
 [project.urls]

beekeeper_core-1.0.4/beekeeper/core/llms/types.py

@@ -1,33 +0,0 @@
-from enum import Enum
-from typing import Any, Optional
-
-from pydantic import BaseModel, Field
-
-
-class MessageRole(str, Enum):
-    ASSISTANT = "assistant"
-    SYSTEM = "system"
-    USER = "user"
-    TOOL = "tool"
-
-
-class ChatMessage(BaseModel):
-    """Chat message."""
-
-    model_config = {"use_enum_values": True}
-    role: MessageRole = Field(default=MessageRole.USER)
-    content: Optional[str] = Field(default=None)
-
-
-class GenerateResponse(BaseModel):
-    """Generate response."""
-
-    text: str = Field(..., description="Generated text response")
-    raw: Optional[Any] = Field(default=None)
-
-
-class ChatResponse(BaseModel):
-    """Chat completion response."""
-
-    message: ChatMessage
-    raw: Optional[Any] = None