acontext 0.0.13__tar.gz

acontext-0.0.13/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.3
+Name: acontext
+Version: 0.0.13
+Summary: Python SDK for the Acontext API
+Keywords: acontext,sdk,client,api
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: openai>=2.6.1
+Requires-Dist: anthropic>=0.72.0
+Requires-Dist: pydantic>=2.12.3
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/memodb-io/Acontext
+Project-URL: Issues, https://github.com/memodb-io/Acontext/issues
+Project-URL: Repository, https://github.com/memodb-io/Acontext
+Description-Content-Type: text/markdown
+
+## acontext client for python
+
+Python SDK for interacting with the Acontext REST API.
+
+### Installation
+
+```bash
+pip install acontext
+```
+
+> Requires Python 3.10 or newer.
+
+
+
+
+
+# 🔍 Document
+
+To understand more about this SDK, please view [our docs](https://docs.acontext.io/) and [api references](https://docs.acontext.io/api-reference/introduction)

acontext-0.0.13/README.md

@@ -0,0 +1,19 @@
+## acontext client for python
+
+Python SDK for interacting with the Acontext REST API.
+
+### Installation
+
+```bash
+pip install acontext
+```
+
+> Requires Python 3.10 or newer.
+
+
+
+
+
+# 🔍 Document
+
+To understand more about this SDK, please view [our docs](https://docs.acontext.io/) and [api references](https://docs.acontext.io/api-reference/introduction)

acontext-0.0.13/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "acontext"
+version = "0.0.13"
+description = "Python SDK for the Acontext API"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.28.1",
+    "openai>=2.6.1",
+    "anthropic>=0.72.0",
+    "pydantic>=2.12.3",
+]
+keywords = ["acontext", "sdk", "client", "api"]
+
+[project.urls]
+Homepage = "https://github.com/memodb-io/Acontext"
+Repository = "https://github.com/memodb-io/Acontext"
+Issues = "https://github.com/memodb-io/Acontext/issues"
+
+[dependency-groups]
+dev = ["pytest", "ruff", "pytest-asyncio"]
+
+[build-system]
+requires = ["uv_build>=0.9.2,<0.10.0"]
+build-backend = "uv_build"

acontext-0.0.13/src/acontext/__init__.py

@@ -0,0 +1,48 @@
+"""
+Python SDK for the Acontext API.
+"""
+
+from importlib import metadata as _metadata
+
+from .async_client import AcontextAsyncClient
+from .client import AcontextClient, FileUpload, MessagePart
+from .messages import AcontextMessage
+from .resources import (
+    AsyncBlocksAPI,
+    AsyncDiskArtifactsAPI,
+    AsyncDisksAPI,
+    AsyncSessionsAPI,
+    AsyncSpacesAPI,
+    BlocksAPI,
+    DiskArtifactsAPI,
+    DisksAPI,
+    SessionsAPI,
+    SpacesAPI,
+)
+from .types import Task, TaskData
+
+__all__ = [
+    "AcontextClient",
+    "AcontextAsyncClient",
+    "FileUpload",
+    "MessagePart",
+    "AcontextMessage",
+    "DisksAPI",
+    "DiskArtifactsAPI",
+    "BlocksAPI",
+    "SessionsAPI",
+    "SpacesAPI",
+    "AsyncDisksAPI",
+    "AsyncDiskArtifactsAPI",
+    "AsyncBlocksAPI",
+    "AsyncSessionsAPI",
+    "AsyncSpacesAPI",
+    "Task",
+    "TaskData",
+    "__version__",
+]
+
+try:
+    __version__ = _metadata.version("acontext")
+except _metadata.PackageNotFoundError:  # pragma: no cover - local/checkout usage
+    __version__ = "0.0.0"

acontext-0.0.13/src/acontext/_constants.py

@@ -0,0 +1,14 @@
+"""
+Internal constants shared across the Python SDK.
+"""
+
+from importlib import metadata as _metadata
+
+DEFAULT_BASE_URL = "https://api.acontext.app/api/v1"
+
+try:
+    _VERSION = _metadata.version("acontext-py")
+except _metadata.PackageNotFoundError:  # pragma: no cover - local/checkout usage
+    _VERSION = "0.0.0"
+
+DEFAULT_USER_AGENT = f"acontext-py/{_VERSION}"

acontext-0.0.13/src/acontext/_utils.py

@@ -0,0 +1,42 @@
+"""Utility functions for the acontext Python client."""
+
+from typing import Any
+
+
+def bool_to_str(value: bool) -> str:
+    """Convert a boolean value to string representation used by the API.
+    
+    Args:
+        value: The boolean value to convert.
+        
+    Returns:
+        "true" if value is True, "false" otherwise.
+    """
+    return "true" if value else "false"
+
+
+def build_params(**kwargs: Any) -> dict[str, Any]:
+    """Build query parameters dictionary, filtering None values and converting booleans.
+    
+    This function filters out None values and converts boolean values to their
+    string representations ("true" or "false") as expected by the API.
+    
+    Args:
+        **kwargs: Keyword arguments to build parameters from.
+        
+    Returns:
+        Dictionary with non-None parameters, with booleans converted to strings.
+        
+    Example:
+        >>> build_params(limit=10, cursor=None, time_desc=True)
+        {'limit': 10, 'time_desc': 'true'}
+    """
+    params: dict[str, Any] = {}
+    for key, value in kwargs.items():
+        if value is not None:
+            if isinstance(value, bool):
+                params[key] = bool_to_str(value)
+            else:
+                params[key] = value
+    return params
+

acontext-0.0.13/src/acontext/agent/base.py

@@ -0,0 +1,106 @@
+class BaseContext:
+    pass
+
+
+class BaseConverter:
+    def to_openai_tool_schema(self) -> dict:
+        raise NotImplementedError
+
+    def to_anthropic_tool_schema(self) -> dict:
+        raise NotImplementedError
+
+    def to_gemini_tool_schema(self) -> dict:
+        raise NotImplementedError
+
+
+class BaseTool(BaseConverter):
+    @property
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def description(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def arguments(self) -> dict:
+        raise NotImplementedError
+
+    @property
+    def required_arguments(self) -> list[str]:
+        raise NotImplementedError
+
+    def execute(self, ctx: BaseContext, llm_arguments: dict) -> str:
+        raise NotImplementedError
+
+    def to_openai_tool_schema(self) -> dict:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": self.arguments,
+                    "required": self.required_arguments,
+                },
+            },
+        }
+
+    def to_anthropic_tool_schema(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": {
+                "type": "object",
+                "properties": self.arguments,
+                "required": self.required_arguments,
+            },
+        }
+
+    def to_gemini_tool_schema(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": {
+                "type": "object",
+                "properties": self.arguments,
+                "required": self.required_arguments,
+            },
+        }
+
+
+class BaseToolPool(BaseConverter):
+    def __init__(self):
+        self.tools: dict[str, BaseTool] = {}
+
+    def add_tool(self, tool: BaseTool):
+        self.tools[tool.name] = tool
+
+    def remove_tool(self, tool_name: str):
+        self.tools.pop(tool_name)
+
+    def extent_tool_pool(self, pool: "BaseToolPool"):
+        self.tools.update(pool.tools)
+
+    def execute_tool(
+        self, ctx: BaseContext, tool_name: str, llm_arguments: dict
+    ) -> str:
+        tool = self.tools[tool_name]
+        r = tool.execute(ctx, llm_arguments)
+        return r.strip()
+
+    def tool_exists(self, tool_name: str) -> bool:
+        return tool_name in self.tools
+
+    def to_openai_tool_schema(self) -> list[dict]:
+        return [tool.to_openai_tool_schema() for tool in self.tools.values()]
+
+    def to_anthropic_tool_schema(self) -> list[dict]:
+        return [tool.to_anthropic_tool_schema() for tool in self.tools.values()]
+
+    def to_gemini_tool_schema(self) -> list[dict]:
+        return [tool.to_gemini_tool_schema() for tool in self.tools.values()]
+
+    def format_context(self, *args, **kwargs) -> BaseContext:
+        raise NotImplementedError

acontext-0.0.13/src/acontext/agent/disk.py

@@ -0,0 +1,325 @@
+from dataclasses import dataclass
+
+from .base import BaseContext, BaseTool, BaseToolPool
+from ..client import AcontextClient
+from ..uploads import FileUpload
+
+
+@dataclass
+class DiskContext(BaseContext):
+    client: AcontextClient
+    disk_id: str
+
+
+def _normalize_path(path: str | None) -> str:
+    """Normalize a file path to ensure it starts with '/'."""
+    if not path:
+        return "/"
+    normalized = path if path.startswith("/") else f"/{path}"
+    if not normalized.endswith("/"):
+        normalized += "/"
+    return normalized
+
+
+class WriteFileTool(BaseTool):
+    """Tool for writing text content to a file on the Acontext disk."""
+
+    @property
+    def name(self) -> str:
+        return "write_file"
+
+    @property
+    def description(self) -> str:
+        return "Write text content to a file in the file system. Creates the file if it doesn't exist, overwrites if it does."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional folder path to organize files, e.g. '/notes/' or '/documents/'. Defaults to root '/' if not specified.",
+            },
+            "filename": {
+                "type": "string",
+                "description": "Filename such as 'report.md' or 'demo.txt'.",
+            },
+            "content": {
+                "type": "string",
+                "description": "Text content to write to the file.",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["filename", "content"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """Write text content to a file."""
+        filename = llm_arguments.get("filename")
+        content = llm_arguments.get("content")
+        file_path = llm_arguments.get("file_path")
+
+        if not filename:
+            raise ValueError("filename is required")
+        if not content:
+            raise ValueError("content is required")
+
+        normalized_path = _normalize_path(file_path)
+        payload = FileUpload(filename=filename, content=content.encode("utf-8"))
+        artifact = ctx.client.disks.artifacts.upsert(
+            ctx.disk_id,
+            file=payload,
+            file_path=normalized_path,
+        )
+        return f"File '{artifact.filename}' written successfully to '{artifact.path}'"
+
+
+class ReadFileTool(BaseTool):
+    """Tool for reading a text file from the Acontext disk."""
+
+    @property
+    def name(self) -> str:
+        return "read_file"
+
+    @property
+    def description(self) -> str:
+        return "Read a text file from the file system and return its content."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional directory path where the file is located, e.g. '/notes/'. Defaults to root '/' if not specified.",
+            },
+            "filename": {
+                "type": "string",
+                "description": "Filename to read.",
+            },
+            "line_offset": {
+                "type": "integer",
+                "description": "The line number to start reading from. Default to 0",
+            },
+            "line_limit": {
+                "type": "integer",
+                "description": "The maximum number of lines to return. Default to 100",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["filename"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """Read a text file and return its content preview."""
+        filename = llm_arguments.get("filename")
+        file_path = llm_arguments.get("file_path")
+        line_offset = llm_arguments.get("line_offset", 0)
+        line_limit = llm_arguments.get("line_limit", 100)
+
+        if not filename:
+            raise ValueError("filename is required")
+
+        normalized_path = _normalize_path(file_path)
+        result = ctx.client.disks.artifacts.get(
+            ctx.disk_id,
+            file_path=normalized_path,
+            filename=filename,
+            with_content=True,
+        )
+
+        if not result.content:
+            raise RuntimeError("Failed to read file: server did not return content.")
+
+        content_str = result.content.raw
+        lines = content_str.split("\n")
+        line_start = min(line_offset, len(lines) - 1)
+        line_end = min(line_start + line_limit, len(lines))
+        preview = "\n".join(lines[line_start:line_end])
+        return f"[{normalized_path}{filename} - showing L{line_start}-{line_end} of {len(lines)} lines]\n{preview}"
+
+
+class ReplaceStringTool(BaseTool):
+    """Tool for replacing an old string with a new string in a file on the Acontext disk."""
+
+    @property
+    def name(self) -> str:
+        return "replace_string"
+
+    @property
+    def description(self) -> str:
+        return "Replace an old string with a new string in a file. Reads the file, performs the replacement, and writes it back."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional directory path where the file is located, e.g. '/notes/'. Defaults to root '/' if not specified.",
+            },
+            "filename": {
+                "type": "string",
+                "description": "Filename to modify.",
+            },
+            "old_string": {
+                "type": "string",
+                "description": "The string to be replaced.",
+            },
+            "new_string": {
+                "type": "string",
+                "description": "The string to replace the old_string with.",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["filename", "old_string", "new_string"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """Replace an old string with a new string in a file."""
+        filename = llm_arguments.get("filename")
+        file_path = llm_arguments.get("file_path")
+        old_string = llm_arguments.get("old_string")
+        new_string = llm_arguments.get("new_string")
+
+        if not filename:
+            raise ValueError("filename is required")
+        if old_string is None:
+            raise ValueError("old_string is required")
+        if new_string is None:
+            raise ValueError("new_string is required")
+
+        normalized_path = _normalize_path(file_path)
+
+        # Read the file content
+        result = ctx.client.disks.artifacts.get(
+            ctx.disk_id,
+            file_path=normalized_path,
+            filename=filename,
+            with_content=True,
+        )
+
+        if not result.content:
+            raise RuntimeError("Failed to read file: server did not return content.")
+
+        content_str = result.content.raw
+
+        # Perform the replacement
+        if old_string not in content_str:
+            return f"String '{old_string}' not found in file '{filename}'"
+
+        updated_content = content_str.replace(old_string, new_string)
+        replacement_count = content_str.count(old_string)
+
+        # Write the updated content back
+        payload = FileUpload(filename=filename, content=updated_content.encode("utf-8"))
+        ctx.client.disks.artifacts.upsert(
+            ctx.disk_id,
+            file=payload,
+            file_path=normalized_path,
+        )
+
+        return f"Found {replacement_count} old_string in {normalized_path}{filename} and replaced it."
+
+
+class ListTool(BaseTool):
+    """Tool for listing files in a directory on the Acontext disk."""
+
+    @property
+    def name(self) -> str:
+        return "list_artifacts"
+
+    @property
+    def description(self) -> str:
+        return "List all files and directories in a specified path on the disk."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional directory path to list, e.g. '/todo/' or '/notes/'. Root is '/'",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["file_path"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """List all files in a specified path."""
+        file_path = llm_arguments.get("file_path")
+        normalized_path = _normalize_path(file_path)
+
+        result = ctx.client.disks.artifacts.list(
+            ctx.disk_id,
+            path=normalized_path,
+        )
+
+        artifacts_list = [artifact.filename for artifact in result.artifacts]
+
+        if not artifacts_list and not result.directories:
+            return f"No files or directories found in '{normalized_path}'"
+
+        output_parts = []
+        if artifacts_list:
+            output_parts.append(f"Files: {', '.join(artifacts_list)}")
+        if result.directories:
+            output_parts.append(f"Directories: {', '.join(result.directories)}")
+
+        ls_sect = "\n".join(output_parts)
+        return f"""[Listing in {normalized_path}]
+{ls_sect}"""
+
+
+class DiskToolPool(BaseToolPool):
+    """Tool pool for disk operations on Acontext disks."""
+
+    def format_context(self, client: AcontextClient, disk_id: str) -> DiskContext:
+        return DiskContext(client=client, disk_id=disk_id)
+
+
+DISK_TOOLS = DiskToolPool()
+DISK_TOOLS.add_tool(WriteFileTool())
+DISK_TOOLS.add_tool(ReadFileTool())
+DISK_TOOLS.add_tool(ReplaceStringTool())
+DISK_TOOLS.add_tool(ListTool())
+
+
+if __name__ == "__main__":
+    client = AcontextClient(
+        api_key="sk-ac-your-root-api-bearer-token",
+        base_url="http://localhost:8029/api/v1",
+    )
+    print(client.ping())
+    new_disk = client.disks.create()
+
+    ctx = DISK_TOOLS.format_context(client, new_disk.id)
+    r = DISK_TOOLS.execute_tool(
+        ctx,
+        "write_file",
+        {"filename": "test.txt", "file_path": "/try/", "content": "Hello, world!"},
+    )
+    print(r)
+    r = DISK_TOOLS.execute_tool(
+        ctx, "read_file", {"filename": "test.txt", "file_path": "/try/"}
+    )
+    print(r)
+    r = DISK_TOOLS.execute_tool(ctx, "list_artifacts", {"file_path": "/"})
+    print(r)
+
+    r = DISK_TOOLS.execute_tool(
+        ctx,
+        "replace_string",
+        {
+            "filename": "test.txt",
+            "file_path": "/try/",
+            "old_string": "Hello",
+            "new_string": "Hi",
+        },
+    )
+    print(r)
+    r = DISK_TOOLS.execute_tool(
+        ctx, "read_file", {"filename": "test.txt", "file_path": "/try/"}
+    )
+    print(r)