gomemory 0.1.0__tar.gz

gomemory-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: gomemory
+Version: 0.1.0
+Summary: Python SDK for the GoMemory AI memory layer
+Author-email: Your Name <your.email@example.com>
+Project-URL: Repository, https://github.com/yourusername/gomemory
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pydantic>=2.0.0

gomemory-0.1.0/gomemory/__init__.py

@@ -0,0 +1,24 @@
+from .client import GoMemoryClient
+from .exceptions import GoMemoryError, APIError
+from .models import (
+    Role,
+    MemoryType,
+    Message,
+    UserResponse,
+    MemoryInsertionResponse,
+    Memory,
+    FullReqStatus
+)
+
+__all__ = [
+    "GoMemoryClient",
+    "GoMemoryError",
+    "APIError",
+    "Role",
+    "MemoryType",
+    "Message",
+    "UserResponse",
+    "MemoryInsertionResponse",
+    "Memory",
+    "FullReqStatus"
+]

gomemory-0.1.0/gomemory/client.py

@@ -0,0 +1,102 @@
+from typing import List, Optional, Union
+import requests
+from pydantic import ValidationError
+
+from .exceptions import APIError, GoMemoryError
+from .models import (
+    FullReqStatus,
+    InsertMemoryRequest,
+    Memory,
+    MemoryInsertionResponse,
+    MemoryRetrievalRequest,
+    Message,
+    UserResponse
+)
+
+class GoMemoryClient:
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip("/")
+        self.session = requests.Session()
+
+    def _handle_response(self, response: requests.Response):
+        """Internal helper to catch APIError structs and raise them as Python exceptions."""
+        try:
+            data = response.json()
+        except ValueError:
+            data = response.text
+
+        if not response.ok:
+            # Check if it matches the APIError struct structure
+            if isinstance(data, dict) and "Status" in data and "Message" in data:
+                raise APIError(
+                    status=data.get("Status", response.status_code),
+                    message=data.get("Message", "Unknown error"),
+                    error_details=str(data.get("Error", ""))
+                )
+            response.raise_for_status()
+            
+        return data
+
+    def health_check(self) -> str:
+        """GET /health"""
+        url = f"{self.base_url}/health"
+        response = self.session.get(url)
+        # Endpoint returns literal string via writeJSON
+        return self._handle_response(response)
+
+    def create_user(self) -> UserResponse:
+        """POST /create/user"""
+        url = f"{self.base_url}/create/user"
+        response = self.session.post(url)
+        data = self._handle_response(response)
+        return UserResponse(**data)
+
+    def add_memory(self, user_id: str, messages: List[Message]) -> MemoryInsertionResponse:
+        """POST /add_memory"""
+        url = f"{self.base_url}/add_memory"
+        
+        # Pydantic validation on input
+        req_data = InsertMemoryRequest(userId=user_id, messages=messages)
+        
+        response = self.session.post(
+            url, 
+            json=req_data.model_dump(by_alias=True)
+        )
+        data = self._handle_response(response)
+        return MemoryInsertionResponse(**data)
+
+    def get_memory(
+        self, 
+        user_id: str, 
+        messages: Optional[List[Message]] = None, 
+        query: Optional[str] = None, 
+        threshold: Optional[float] = None
+    ) -> List[Memory]:
+        """POST /get_memory"""
+        url = f"{self.base_url}/get_memory"
+        
+        # Pydantic handles the XOR validation for messages/query here
+        req_data = MemoryRetrievalRequest(
+            userId=user_id, 
+            messages=messages, 
+            query=query, 
+            threshold=threshold
+        )
+        
+        response = self.session.post(
+            url, 
+            json=req_data.model_dump(by_alias=True, exclude_none=True)
+        )
+        data = self._handle_response(response)
+        
+        # Expected to return a list of memories on success
+        if isinstance(data, list):
+            return [Memory(**m) for m in data]
+        raise GoMemoryError(f"Unexpected response format: {data}")
+
+    def get_status(self, req_id: str) -> FullReqStatus:
+        """GET /get_status/{id}"""
+        url = f"{self.base_url}/get_status/{req_id}"
+        response = self.session.get(url)
+        data = self._handle_response(response)
+        return FullReqStatus(**data)

gomemory-0.1.0/gomemory/exceptions.py

@@ -0,0 +1,11 @@
+class GoMemoryError(Exception):
+    """Base exception for the GoMemory SDK."""
+    pass
+
+class APIError(GoMemoryError):
+    """Exception raised when the server returns an APIError struct."""
+    def __init__(self, status: int, message: str, error_details: str = ""):
+        self.status = status
+        self.message = message
+        self.error_details = error_details
+        super().__init__(f"HTTP {status} - {message} ({error_details})")

gomemory-0.1.0/gomemory/models.py

@@ -0,0 +1,55 @@
+from enum import Enum
+from typing import List, Optional
+from pydantic import BaseModel, Field, model_validator
+
+class Role(str, Enum):
+    USER = "user"
+    ASSISTANT = "model"
+    SYSTEM = "system"
+
+class MemoryType(str, Enum):
+    # Add actual memory types based on your Go definitions
+    CORE = "core"
+    GENERAL = "general" 
+
+class Message(BaseModel):
+    role: Role
+    content: str
+
+class UserResponse(BaseModel):
+    user_id: str = Field(alias="userId")
+
+class InsertMemoryRequest(BaseModel):
+    user_id: str = Field(alias="userId")
+    messages: List[Message]
+
+class MemoryInsertionResponse(BaseModel):
+    req_id: str = Field(alias="ReqId")
+    msg: str = Field(alias="Msg")
+
+class MemoryRetrievalRequest(BaseModel):
+    user_id: str = Field(alias="userId")
+    messages: Optional[List[Message]] = None
+    query: Optional[str] = None
+    threshold: Optional[float] = None
+
+    @model_validator(mode='after')
+    def check_query_or_messages(self):
+        # Enforces XOR logic: exactly one must be provided, but not both.
+        has_messages = bool(self.messages)
+        has_query = bool(self.query)
+        
+        if has_messages == has_query:
+            raise ValueError("Exactly one of 'messages' or 'query' must be provided. Cannot provide both or neither.")
+        return self
+
+class Memory(BaseModel):
+    memory_text: str = Field(alias="Memory_text")
+    type: str = Field(alias="Type")  # Or MemoryType if enum is strictly enforced
+    memory_id: str = Field(alias="Memory_Id")
+    user_id: str = Field(alias="UserId")
+
+class FullReqStatus(BaseModel):
+    status: str  # Assuming types.ReqStatus resolves to a string. Use Enum if strict.
+    error: Optional[str] = None
+    created_at: str = Field(alias="createdAt")

gomemory-0.1.0/gomemory.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: gomemory
+Version: 0.1.0
+Summary: Python SDK for the GoMemory AI memory layer
+Author-email: Your Name <your.email@example.com>
+Project-URL: Repository, https://github.com/yourusername/gomemory
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pydantic>=2.0.0

gomemory-0.1.0/gomemory.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+gomemory/__init__.py
+gomemory/client.py
+gomemory/exceptions.py
+gomemory/models.py
+gomemory/py.typed
+gomemory.egg-info/PKG-INFO
+gomemory.egg-info/SOURCES.txt
+gomemory.egg-info/dependency_links.txt
+gomemory.egg-info/requires.txt
+gomemory.egg-info/top_level.txt
+tests/test_client.py

gomemory-0.1.0/gomemory.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gomemory-0.1.0/gomemory.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.31.0
+pydantic>=2.0.0

gomemory-0.1.0/gomemory.egg-info/top_level.txt

@@ -0,0 +1 @@
+gomemory

gomemory-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gomemory" 
+version = "0.1.0"
+description = "Python SDK for the GoMemory AI memory layer"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+dependencies = [
+    "requests>=2.31.0",
+    "pydantic>=2.0.0"
+]
+
+[project.urls]
+Repository = "https://github.com/yourusername/gomemory" # Update this to your actual GitHub repo
+
+[tool.setuptools.packages.find]
+include = ["gomemory*"]

gomemory-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gomemory-0.1.0/tests/test_client.py

@@ -0,0 +1,65 @@
+import os
+import pytest
+from gomemory import GoMemoryClient, Role, Message
+from gomemory.exceptions import APIError
+from pydantic import ValidationError
+
+# Default to localhost if not set in the environment
+BASE_URL = os.getenv("GOMEMORY_BASE_URL", "http://localhost:9000")
+
+@pytest.fixture(scope="module")
+def client():
+    return GoMemoryClient(base_url=BASE_URL)
+
+def test_health_check(client):
+    response = client.health_check()
+    assert response == "Server is healthy!"
+
+def test_create_user(client):
+    response = client.create_user()
+    assert response.user_id is not None
+    assert isinstance(response.user_id, str)
+
+def test_add_memory(client):
+    # Setup: need a user first
+    user = client.create_user()
+    
+    messages = [
+        Message(role=Role.USER, content="Hey man what's up! My name is mario .. my brother's name is Wario!"),
+        Message(role=Role.ASSISTANT, content="I will remember that.")
+    ]
+    
+    response = client.add_memory(user_id=user.user_id, messages=messages)
+    assert response.req_id is not None
+    assert response.msg is not None
+
+def test_get_memory_validation(client):
+    # Test the Pydantic XOR validation (should fail before hitting the server)
+    with pytest.raises(ValidationError) as exc_info:
+        client.get_memory(
+            user_id="4bdc091b-eaa5-4d42-bbba-3cd798b9d294", 
+        )
+    assert "Exactly one of 'messages' or 'query' must be provided. Cannot provide both or neither." in str(exc_info.value)
+
+def test_get_memory_success(client):
+    user = client.create_user()
+    
+    # Optional: Wait for your Go server's worker pool to process embeddings 
+    # if add_memory is asynchronous before calling get_memory.
+    
+    # Using query
+    memories = client.get_memory(
+        user_id="4bdc091b-eaa5-4d42-bbba-3cd798b9d294",
+        query="I like dogs",
+        threshold=0.7
+    )
+    assert isinstance(memories, list)
+
+def test_get_status(client):
+    user = client.create_user()
+    messages = [Message(role=Role.USER, content="Test memory status")]
+    insert_res = client.add_memory(user_id=user.user_id, messages=messages)
+    
+    status_res = client.get_status(req_id=insert_res.req_id)
+    assert status_res.status is not None
+    assert status_res.created_at is not None