amrita_core 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

amrita_core/__init__.py

@@ -13,7 +13,7 @@ from .libchat import (
 from .logging import debug_log, logger
 from .preset import PresetManager, PresetReport
 from .tools import mcp
-from .tools.manager import ToolsManager, on_tools
+from .tools.manager import ToolsManager, on_tools, simple_tool
 from .tools.models import (
     FunctionDefinitionSchema,
     FunctionParametersSchema,
@@ -73,6 +73,7 @@ __all__ = [
     "on_precompletion",
     "on_tools",
     "set_config",
+    "simple_tool",
     "text_generator",
     "tools_caller",
 ]

amrita_core/chatmanager.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import copy
 from abc import ABC, abstractmethod
@@ -434,10 +436,9 @@ class ChatObject:
     _is_running: bool = False  # Whether it is running
     _is_done: bool = False  # Whether it has completed
     _task: Task[None]
-    _has_task: bool = False
     _err: BaseException | None = None
-    _wait: bool = True
     _queue_done: bool = False
+    _has_consumer: bool = False
     __done_marker = object()
 
     def __init__(
@@ -446,7 +447,6 @@ class ChatObject:
         user_input: USER_INPUT,
         context: Memory,
         session_id: str,
-        run_blocking: bool = True,
         queue_size: int = 25,
         overflow_queue_size: int = 45,
     ) -> None:
@@ -468,7 +468,6 @@ class ChatObject:
         self.time = datetime.now(utc)
         self.config: AmritaConfig = get_config()
         self.last_call = datetime.now(utc)
-        self._wait = run_blocking
 
         # Initialize async queue for streaming responses
         self.response_queue = asyncio.Queue(queue_size)
@@ -484,15 +483,6 @@ class ChatObject:
         """
         return self._err
 
-    def call(self):
-        """
-        Get callable object
-
-        Returns:
-            Callable object (usually the class's __call__ method)
-        """
-        return self.__call__()
-
     def is_running(self) -> bool:
         """
         Check if the task is running
@@ -518,14 +508,31 @@ class ChatObject:
         """
         self._is_done = True
         self._is_running = False
-        self._task.cancel()
+        if hasattr(self, "_task") and not self._task.done():
+            self._task.cancel()
 
     def __await__(self):
         if not hasattr(self, "_task"):
             raise RuntimeError("ChatObject not running")
         return self._task.__await__()
 
-    async def __call__(self) -> None:
+    async def __aenter__(self) -> Self:
+        if not hasattr(self, "_task"):
+            raise RuntimeError("ChatObject not running")
+        if self._has_consumer:
+            raise RuntimeError("ChatObject already has a consumer")
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.terminate()
+
+    def begin(self) -> Self:
+        if not hasattr(self, "_task"):
+            logger.debug("Starting chat object task...")
+            self._task = asyncio.create_task(self._entry())
+        return self
+
+    async def _entry(self) -> None:
         """Call chat object to process messages
 
         Args:
@@ -533,11 +540,6 @@ class ChatObject:
             matcher: Matcher
             bot: Bot instance
         """
-        if not self._has_task:
-            logger.debug("Starting chat object task...")
-            self._has_task = True
-            self._task = asyncio.create_task(self.__call__())
-            return await self._task if self._wait else None
         if not self._is_running and not self._is_done:
             self.stream_id = uuid4().hex
             logger.debug(f"Starting chat processing, stream ID:{self.stream_id}")
@@ -553,6 +555,7 @@ class ChatObject:
                 self._is_done = True
                 self.end_at = datetime.now(utc)
                 chat_manager.running_chat_object_id2map.pop(self.stream_id, None)
+                chat_manager.clean_obj(self.session_id, 1000)  # To avoid memory leaks
                 logger.debug("Chat event processing completed")
 
         else:
@@ -686,6 +689,9 @@ class ChatObject:
         Yields:
             Either a string or MessageContent object from the response queue
         """
+        if self._has_consumer:
+            raise RuntimeError("Queue is already being consumed.")
+        self._has_consumer = True
         return self._response_generator()
 
     async def full_response(self) -> str:

amrita_core/tools/manager.py

@@ -1,10 +1,22 @@
+import inspect
+import re
 import typing
+from asyncio import iscoroutinefunction
 from collections.abc import Awaitable, Callable
-from typing import Any, ClassVar, overload
+from functools import wraps
+from typing import Any, ClassVar, get_args, get_origin, get_type_hints, overload
 
 from typing_extensions import Self
 
-from .models import FunctionDefinitionSchema, ToolContext, ToolData, ToolFunctionSchema
+from .models import (
+    JSON_OBJECT_TYPE,
+    FunctionDefinitionSchema,
+    FunctionParametersSchema,
+    FunctionPropertySchema,
+    ToolContext,
+    ToolData,
+    ToolFunctionSchema,
+)
 
 T = typing.TypeVar("T")
 
@@ -128,6 +140,199 @@ class ToolsManager:
         return list(self._disabled_tools)
 
 
+def _parse_google_docstring(docstring: str | None) -> tuple[str, dict[str, str]]:
+    """
+    Parse Google-style docstring to extract function description and parameter descriptions.
+
+    Args:
+        docstring: The docstring to parse
+
+    Returns:
+        A tuple containing (function_description, parameter_descriptions_dict)
+    """
+    if not docstring:
+        return "(no description provided for this tool)", {}
+
+    # Clean up the docstring
+    lines = [line.strip() for line in docstring.split("\n") if line.strip()]
+
+    # Find the index where Args section starts
+    args_start_idx = -1
+    for i, line in enumerate(lines):
+        if line.lower().startswith("args:"):
+            args_start_idx = i
+            break
+
+    # Extract function description (everything before Args section)
+    if args_start_idx != -1:
+        func_desc_lines = lines[:args_start_idx]
+        func_desc = " ".join(func_desc_lines).strip()
+
+        # Extract Args section
+        args_lines = lines[args_start_idx + 1 :]
+    else:
+        # No Args section found
+        func_desc = " ".join(lines).strip()
+        args_lines = []
+
+    # Process Args section
+    param_descriptions = {}
+
+    # Pattern to match parameter descriptions in the format:
+    # param_name (type): description
+    # or
+    # param_name: description
+    param_pattern = r"^([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*:\s*(.*)"
+
+    for line in args_lines:
+        # Look for parameter pattern at the beginning of the line or after whitespace
+        match = re.match(param_pattern, line)
+        if match:
+            param_name = match.group(1)
+            # param_type = match.group(2)  # We don't need the type since it's in the annotation
+            param_desc = match.group(3).strip()
+
+            if param_desc:
+                param_descriptions[param_name] = param_desc
+            else:
+                param_descriptions[param_name] = f"Parameter {param_name}"
+
+    if not func_desc:
+        func_desc = "(no description provided for this tool)"
+
+    return func_desc, param_descriptions
+
+
+def simple_tool(func: Callable[..., Any | Awaitable[Any]]):
+    """
+    A decorator that creates a ToolData object based on the function signature and annotations.
+    It automatically generates parameter descriptions and metadata.
+
+    Here is an example of how to use this decorator:
+
+    ```python
+    @simple_tool
+    def add(a: int, b: int) -> int:
+        \"""Add two numbers together.
+
+        Args:
+            a (int): The first number.
+            b (int): The second number.
+
+        Returns:
+            int: The sum of the two numbers.
+        \"""
+        return a + b
+    ```
+    """
+    signature: inspect.Signature = inspect.signature(func)
+
+    # Parse Google-style docstring to get function and parameter descriptions
+    func_desc, param_descriptions = _parse_google_docstring(func.__doc__)
+
+    # Get the type hints for the function
+    type_hints: dict[str, Any] = get_type_hints(
+        func, globalns=globals(), localns=locals()
+    )
+
+    # Prepare parameters schema
+    properties = {}
+    required = []
+
+    for param_name, param in signature.parameters.items():
+        # Skip 'self' parameter for methods
+        if param_name == "self":
+            continue
+
+        # Determine parameter type from type hints
+        param_type = type_hints.get(param_name)
+
+        # If parameter has no type hint, default to string
+        json_type: JSON_OBJECT_TYPE = "string"
+        if param_type:
+            # Map Python types to JSON schema types
+            if hasattr(param_type, "__origin__"):
+                origin = get_origin(param_type)
+                if origin is not None:
+                    if issubclass(origin, list):
+                        json_type = "array"
+                    elif issubclass(origin, dict):
+                        json_type = "object"
+                    elif origin is typing.Union:
+                        args = get_args(param_type)
+                        if type(None) in args:
+                            # Handle Optional types - don't add to required
+                            pass
+                        else:
+                            # For Union types, use the first non-None type if available
+                            non_none_types = [
+                                arg for arg in args if arg is not type(None)
+                            ]
+                            if non_none_types:
+                                param_type = non_none_types[0]
+                                json_type = _python_type_to_json_type(param_type)
+                else:
+                    json_type = _python_type_to_json_type(param_type)
+            else:
+                json_type = _python_type_to_json_type(param_type)
+
+        # Get parameter description from parsed docstring if available
+        param_desc = param_descriptions.get(param_name, f"Parameter {param_name}")
+
+        # Check if parameter is required (no default value)
+        is_required = param.default == inspect.Parameter.empty
+        if is_required:
+            required.append(param_name)
+        property_schema = FunctionPropertySchema(type=json_type, description=param_desc)
+
+        properties[param_name] = property_schema
+
+    parameters_schema = FunctionParametersSchema(
+        type="object", properties=properties if properties else None, required=required
+    )
+
+    function_def = FunctionDefinitionSchema(
+        name=func.__name__, description=func_desc, parameters=parameters_schema
+    )
+
+    # Create a wrapper function that accepts a dictionary of parameters
+    @on_tools(function_def, strict=True)
+    @wraps(func)
+    async def tool_wrapper(params: dict[str, Any]) -> str:
+        bound_args: inspect.BoundArguments = signature.bind(**params)
+        bound_args.apply_defaults()
+
+        result = (
+            await func(**bound_args.arguments)
+            if iscoroutinefunction(func)
+            else func(**bound_args.arguments)
+        )
+
+        # Convert result to string as expected by the schema
+        return str(result)
+
+    return tool_wrapper
+
+
+def _python_type_to_json_type(python_type: type[Any]) -> JSON_OBJECT_TYPE:
+    """Convert Python type to JSON schema type."""
+    if python_type is str:
+        return "string"
+    elif python_type is int:
+        return "integer"
+    elif python_type is float:
+        return "number"
+    elif python_type is bool:
+        return "boolean"
+    elif python_type is list:
+        return "array"
+    elif python_type is dict:
+        return "object"
+    else:
+        # Default to string for unrecognized types
+        return "string"
+
+
 def on_tools(
     data: FunctionDefinitionSchema,
     custom_run: bool = False,

{amrita_core-0.1.0.dist-info → amrita_core-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amrita_core
-Version: 0.1.0
+Version: 0.2.0
 Summary: Agent core of Project Amrita
 Project-URL: Homepage, https://github.com/AmritaBot/AmritaCore
 Project-URL: Source, https://github.com/AmritaBot/AmritaCore
@@ -60,6 +60,8 @@ This repository contains documentation organized as follows:
 
 Documentation is currently under construction. For quick start, please refer to the examples in the `demo/` folder.
 
+Please view [Docs](https://amrita-core.suggar.top) for more information.
+
 ## 🛠️ Quick Start
 
 To quickly start using AmritaCore, check out the examples in the [demo](./demo/) directory. The basic example demonstrates how to initialize the core, configure settings, and run a simple chat session with the AI assistant.

{amrita_core-0.1.0.dist-info → amrita_core-0.2.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-amrita_core/__init__.py,sha256=uNev8VnIbKg6CcdsaB_H7DgTLTNXLyTRoOqlAOYaBu8,2329
-amrita_core/chatmanager.py,sha256=PV_IfEBiWfjIjKykaJ4XtcEHFYKCvMrwDy2eHVVy5kQ,32436
+amrita_core/__init__.py,sha256=C-dVBkL3Zb03KpkIaJtDlInTMfhBWVA9-Nn0WrFk61Q,2361
+amrita_core/chatmanager.py,sha256=3l48yc_LBWvlQfA-5Tu4CIKo3Q34ukOczERXcjE7Nag,32780
 amrita_core/config.py,sha256=T8SAH5-ND496nMEQ-b-VGnmDdaGixlDVCSLZ985f860,5377
 amrita_core/libchat.py,sha256=bM-WhD6BGvn_aFHAkywYGaU6vF67QAfudsHfB2Ia-M4,5614
 amrita_core/logging.py,sha256=aUPGGMntZq-r5i60DAvTXfMaeD5ac93Nxus8rcIWw_8,1724
@@ -16,11 +16,11 @@ amrita_core/hook/event.py,sha256=GoyV4M93BE8MwGcp_nJwduyib3DW1NTNe31RfWSGUQw,224
 amrita_core/hook/exception.py,sha256=Q4U8Vd8fZursEnuCwDyFjJizJGW75coj_0Gik4jERoM,226
 amrita_core/hook/matcher.py,sha256=NGU6ClyIaNMWMdFduZkLTXm1st2YpgVFJIyn45Qu31M,7666
 amrita_core/hook/on.py,sha256=C9Z66Nliy6Rq4xyn4CZt3V8NXWPEHPuavp8tDBXcP0w,451
-amrita_core/tools/manager.py,sha256=SwFjopuTa2OqV6bEXRtRaP81d9T3nLiQI5sHvge5NO4,5229
+amrita_core/tools/manager.py,sha256=EllKJMpok6uTe3pcq5UziPSfambk8xsUQWJBl7iqePE,12094
 amrita_core/tools/mcp.py,sha256=K-6SjsD-KUfRgII7HuX2AADClD79qwy2DyxXbSpjyYk,12739
 amrita_core/tools/models.py,sha256=lUpdYSOh-rzOM1jIJURBYgqaZGHWOznnGGyGJExGFeI,12246
-amrita_core-0.1.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-amrita_core-0.1.0.dist-info/METADATA,sha256=AFHnyDC6XTdxH4LJf3toCJQzfkTsP2Brs5oFXAwZuSA,4125
-amrita_core-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-amrita_core-0.1.0.dist-info/top_level.txt,sha256=7mB9cYXC_VZ73UXo6DXplcfSvMGeP1sTNHza46x2FTk,12
-amrita_core-0.1.0.dist-info/RECORD,,
+amrita_core-0.2.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+amrita_core-0.2.0.dist-info/METADATA,sha256=KOPOEh1k-vtf76fWfnusb0dwLFnejziJtzVqcWFL9Ws,4199
+amrita_core-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+amrita_core-0.2.0.dist-info/top_level.txt,sha256=7mB9cYXC_VZ73UXo6DXplcfSvMGeP1sTNHza46x2FTk,12
+amrita_core-0.2.0.dist-info/RECORD,,