memside 0.1.0__tar.gz

memside-0.1.0/LICENSE.md

@@ -0,0 +1,11 @@
+# Memside Python SDK License
+
+Copyright (c) 2026 Memside. All rights reserved.
+
+This package is provided to help developers connect applications, scripts, and tools to the public Memside API.
+
+You may use this package to integrate with Memside. You may not use this package, its documentation, or its structure to build or market a competing product or service.
+
+This package does not grant rights to private Memside application source code, backend services, APIs outside the public API contract, infrastructure, trademarks, product designs, databases, private documentation, or proprietary systems.
+
+This package is provided without warranties or guarantees of any kind.

memside-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: memside
+Version: 0.1.0
+Summary: Lightweight Python client for the public Memside API.
+Author-email: Memside <support@memside.com>
+License: # Memside Python SDK License
+        
+        Copyright (c) 2026 Memside. All rights reserved.
+        
+        This package is provided to help developers connect applications, scripts, and tools to the public Memside API.
+        
+        You may use this package to integrate with Memside. You may not use this package, its documentation, or its structure to build or market a competing product or service.
+        
+        This package does not grant rights to private Memside application source code, backend services, APIs outside the public API contract, infrastructure, trademarks, product designs, databases, private documentation, or proprietary systems.
+        
+        This package is provided without warranties or guarantees of any kind.
+        
+Project-URL: Homepage, https://github.com/memside/memside
+Project-URL: Repository, https://github.com/memside/memside
+Project-URL: Issues, https://github.com/memside/memside/issues
+Keywords: memside,ai,memory,mcp,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# Memside Python SDK
+
+Lightweight Python client for the public Memside API.
+
+## Install
+
+```bash
+pip install memside
+```
+
+## Usage
+
+```python
+from memside import MemsideClient
+
+client = MemsideClient(api_key="mem_sk_your_key_here")
+
+startup = client.context_startup()
+print(startup)
+```
+
+You can also set the API key through the environment:
+
+```bash
+MEMSIDE_API_KEY=mem_sk_your_key_here
+```
+
+## Supported API Areas
+
+This package wraps public Memside API-key routes:
+
+- startup context
+- resume context
+- workspace profile
+- memory listing
+- memory search
+- memory fetch
+- memory create
+- memory update
+- memory delete, when allowed by the API
+
+This package does not include private Memside application source, account/session internals, billing internals, admin routes, database details, or MCP server implementation.
+
+## Requirements
+
+Python 3.9 or newer.

memside-0.1.0/README.md

@@ -0,0 +1,46 @@
+# Memside Python SDK
+
+Lightweight Python client for the public Memside API.
+
+## Install
+
+```bash
+pip install memside
+```
+
+## Usage
+
+```python
+from memside import MemsideClient
+
+client = MemsideClient(api_key="mem_sk_your_key_here")
+
+startup = client.context_startup()
+print(startup)
+```
+
+You can also set the API key through the environment:
+
+```bash
+MEMSIDE_API_KEY=mem_sk_your_key_here
+```
+
+## Supported API Areas
+
+This package wraps public Memside API-key routes:
+
+- startup context
+- resume context
+- workspace profile
+- memory listing
+- memory search
+- memory fetch
+- memory create
+- memory update
+- memory delete, when allowed by the API
+
+This package does not include private Memside application source, account/session internals, billing internals, admin routes, database details, or MCP server implementation.
+
+## Requirements
+
+Python 3.9 or newer.

memside-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "memside"
+version = "0.1.0"
+description = "Lightweight Python client for the public Memside API."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE.md" }
+authors = [
+  { name = "Memside", email = "support@memside.com" }
+]
+keywords = ["memside", "ai", "memory", "mcp", "sdk"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13"
+]
+
+[project.urls]
+Homepage = "https://github.com/memside/memside"
+Repository = "https://github.com/memside/memside"
+Issues = "https://github.com/memside/memside/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

memside-0.1.0/setup.cfg

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

memside-0.1.0/src/memside/__init__.py

@@ -0,0 +1,3 @@
+from .client import MemsideClient, MemsideError
+
+__all__ = ["MemsideClient", "MemsideError"]

memside-0.1.0/src/memside/client.py

@@ -0,0 +1,155 @@
+import json
+import os
+from urllib.error import HTTPError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+
+DEFAULT_BASE_URL = "https://api.memside.com"
+
+
+class MemsideError(Exception):
+    def __init__(
+        self,
+        message,
+        *,
+        status=None,
+        code=None,
+        retryable=None,
+        request_id=None,
+        details=None,
+    ):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.retryable = retryable
+        self.request_id = request_id
+        self.details = details
+
+
+class MemsideClient:
+    def __init__(self, api_key=None, base_url=DEFAULT_BASE_URL, timeout=30, transport=None):
+        self.api_key = api_key or os.getenv("MEMSIDE_API_KEY")
+        if not self.api_key:
+            raise MemsideError(
+                "Missing Memside API key",
+                status=401,
+                code="missing_api_key",
+                retryable=False,
+            )
+
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.transport = transport
+
+    def context_startup(self, **params):
+        return self.request("GET", "/context/startup", params=params)
+
+    def context_resume(self, **params):
+        return self.request("GET", "/context/resume", params=params)
+
+    def context_workspace_profile(self, **params):
+        return self.request("GET", "/context/workspace-profile", params=params)
+
+    def memories_list(self, **params):
+        return self.request("GET", "/memories", params=params)
+
+    def memories_search(self, **params):
+        return self.request("GET", "/memories/search", params=params)
+
+    def memories_get(self, memory_id):
+        return self.request("GET", f"/memories/{memory_id}")
+
+    def memories_create(self, memory):
+        return self.request("POST", "/memories", json_body=memory)
+
+    def memories_update(self, memory_id, patch):
+        return self.request("PATCH", f"/memories/{memory_id}", json_body=patch)
+
+    def memories_delete(self, memory_id):
+        return self.request("DELETE", f"/memories/{memory_id}")
+
+    def request(self, method, path, *, params=None, json_body=None, headers=None):
+        url = self._build_url(path, params)
+        request_headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            **(headers or {}),
+        }
+        body = None
+
+        if json_body is not None:
+            body = json.dumps(json_body).encode("utf-8")
+            request_headers["Content-Type"] = "application/json"
+
+        if self.transport:
+            status, response_headers, response_body = self.transport(
+                method,
+                url,
+                request_headers,
+                body,
+                self.timeout,
+            )
+            payload = _read_payload(response_body)
+            if status >= 400:
+                raise _to_memside_error(status, payload)
+            return payload
+
+        request = Request(url, data=body, headers=request_headers, method=method)
+
+        try:
+            with urlopen(request, timeout=self.timeout) as response:
+                payload = _read_payload(response.read())
+                return payload
+        except HTTPError as error:
+            payload = _read_payload(error.read())
+            raise _to_memside_error(error.code, payload) from error
+
+    def _build_url(self, path, params=None):
+        clean_params = {
+            key: value
+            for key, value in (params or {}).items()
+            if value is not None
+        }
+
+        query = urlencode(clean_params, doseq=True)
+        url = f"{self.base_url}{path}"
+        return f"{url}?{query}" if query else url
+
+
+def _read_payload(body):
+    if body is None or body == b"":
+        return None
+
+    if isinstance(body, bytes):
+        body = body.decode("utf-8")
+
+    if body == "":
+        return None
+
+    try:
+        return json.loads(body)
+    except json.JSONDecodeError:
+        return body
+
+
+def _to_memside_error(status, payload):
+    error = payload.get("error") if isinstance(payload, dict) else None
+    message = None
+    code = "request_failed"
+    retryable = False
+
+    if isinstance(error, dict):
+        message = error.get("message")
+        code = error.get("code") or code
+        status = error.get("status") or status
+        retryable = bool(error.get("retryable"))
+
+    return MemsideError(
+        message or "Memside API request failed",
+        status=status,
+        code=code,
+        retryable=retryable,
+        request_id=payload.get("request_id") if isinstance(payload, dict) else None,
+        details=payload,
+    )

memside-0.1.0/src/memside.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: memside
+Version: 0.1.0
+Summary: Lightweight Python client for the public Memside API.
+Author-email: Memside <support@memside.com>
+License: # Memside Python SDK License
+        
+        Copyright (c) 2026 Memside. All rights reserved.
+        
+        This package is provided to help developers connect applications, scripts, and tools to the public Memside API.
+        
+        You may use this package to integrate with Memside. You may not use this package, its documentation, or its structure to build or market a competing product or service.
+        
+        This package does not grant rights to private Memside application source code, backend services, APIs outside the public API contract, infrastructure, trademarks, product designs, databases, private documentation, or proprietary systems.
+        
+        This package is provided without warranties or guarantees of any kind.
+        
+Project-URL: Homepage, https://github.com/memside/memside
+Project-URL: Repository, https://github.com/memside/memside
+Project-URL: Issues, https://github.com/memside/memside/issues
+Keywords: memside,ai,memory,mcp,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# Memside Python SDK
+
+Lightweight Python client for the public Memside API.
+
+## Install
+
+```bash
+pip install memside
+```
+
+## Usage
+
+```python
+from memside import MemsideClient
+
+client = MemsideClient(api_key="mem_sk_your_key_here")
+
+startup = client.context_startup()
+print(startup)
+```
+
+You can also set the API key through the environment:
+
+```bash
+MEMSIDE_API_KEY=mem_sk_your_key_here
+```
+
+## Supported API Areas
+
+This package wraps public Memside API-key routes:
+
+- startup context
+- resume context
+- workspace profile
+- memory listing
+- memory search
+- memory fetch
+- memory create
+- memory update
+- memory delete, when allowed by the API
+
+This package does not include private Memside application source, account/session internals, billing internals, admin routes, database details, or MCP server implementation.
+
+## Requirements
+
+Python 3.9 or newer.

memside-0.1.0/src/memside.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE.md
+README.md
+pyproject.toml
+src/memside/__init__.py
+src/memside/client.py
+src/memside.egg-info/PKG-INFO
+src/memside.egg-info/SOURCES.txt
+src/memside.egg-info/dependency_links.txt
+src/memside.egg-info/top_level.txt
+tests/test_client.py

memside-0.1.0/src/memside.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

memside-0.1.0/src/memside.egg-info/top_level.txt

@@ -0,0 +1 @@
+memside

memside-0.1.0/tests/test_client.py

@@ -0,0 +1,69 @@
+import unittest
+
+from memside import MemsideClient, MemsideError
+
+
+class MemsideClientTests(unittest.TestCase):
+    def test_startup_sends_bearer_auth(self):
+        calls = []
+
+        def transport(method, url, headers, body, timeout):
+            calls.append((method, url, headers, body, timeout))
+            return 200, {}, b'{"ok": true}'
+
+        client = MemsideClient(api_key="mem_sk_test_key", transport=transport)
+
+        self.assertEqual(client.context_startup(), {"ok": True})
+        self.assertEqual(calls[0][0], "GET")
+        self.assertEqual(calls[0][1], "https://api.memside.com/context/startup")
+        self.assertEqual(calls[0][2]["Authorization"], "Bearer mem_sk_test_key")
+
+    def test_search_serializes_query_params(self):
+        calls = []
+
+        def transport(method, url, headers, body, timeout):
+            calls.append((method, url, headers, body, timeout))
+            return 200, {}, b'{"matches": []}'
+
+        client = MemsideClient(api_key="mem_sk_test_key", transport=transport)
+
+        self.assertEqual(client.memories_search(q="launch", limit=5), {"matches": []})
+        self.assertEqual(
+            calls[0][1],
+            "https://api.memside.com/memories/search?q=launch&limit=5",
+        )
+
+    def test_create_sends_json_body(self):
+        calls = []
+
+        def transport(method, url, headers, body, timeout):
+            calls.append((method, url, headers, body, timeout))
+            return 201, {}, b'{"id": "mem_123"}'
+
+        client = MemsideClient(api_key="mem_sk_test_key", transport=transport)
+
+        self.assertEqual(client.memories_create({"content": "Remember this"}), {"id": "mem_123"})
+        self.assertEqual(calls[0][0], "POST")
+        self.assertEqual(calls[0][2]["Content-Type"], "application/json")
+        self.assertEqual(calls[0][3], b'{"content": "Remember this"}')
+
+    def test_failed_requests_raise_memside_error(self):
+        def transport(method, url, headers, body, timeout):
+            return (
+                401,
+                {},
+                b'{"ok": false, "request_id": "req_test", "error": {"code": "unauthorized", "message": "Invalid API key", "status": 401, "retryable": false}}',
+            )
+
+        client = MemsideClient(api_key="mem_sk_test_key", transport=transport)
+
+        with self.assertRaises(MemsideError) as raised:
+            client.context_startup()
+
+        self.assertEqual(raised.exception.status, 401)
+        self.assertEqual(raised.exception.code, "unauthorized")
+        self.assertEqual(raised.exception.request_id, "req_test")
+
+
+if __name__ == "__main__":
+    unittest.main()