memorydb-django 0.2.1__tar.gz

memorydb_django-0.2.1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: memorydb-django
+Version: 0.2.1
+Summary: Django cache and session backends for MemoryDB (SQLite-style drop-in for the settings file)
+Author: humaniods
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/humaniods/MemoryDB
+Project-URL: Repository, https://github.com/humaniods/MemoryDB
+Project-URL: Issues, https://github.com/humaniods/MemoryDB/issues
+Keywords: django,cache,sessions,database,agent-memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: superb-memory
+Requires-Dist: Django>=4.2
+
+# memorydb-django
+
+Django cache and session backends for [MemoryDB](https://github.com/humaniods/MemoryDB).
+Two lines in `settings.py`, the way `sqlite3` is a drop-in for Django itself — no models, no
+migrations, no new code in your views.
+
+```bash
+pip install memorydb-django
+```
+
+```python
+# settings.py
+CACHES = {"default": {
+    "BACKEND": "memorydb_django.MemoryDBCache",
+    "LOCATION": "memorydb://TOKEN@127.0.0.1:8080",   # or leave empty and set MEMORYDB_URL
+}}
+
+SESSION_ENGINE = "memorydb_django.sessions"
+```
+
+Then use Django's own API:
+
+```python
+from django.core.cache import cache
+cache.set("hero", {"name": "Karna"}, timeout=30)   # one record; the TTL is the record's expiry
+cache.get("hero")
+
+request.session["user_id"] = 42                    # SESSION_COOKIE_AGE enforced server-side
+request.session.save()
+```
+
+Details worth knowing:
+
+- Each cache key and each session is one MemoryDB document in the `django_cache` /
+  `django_sessions` collection (typed, unique and indexed; created on first use).
+- `timeout=` and `SESSION_COOKIE_AGE` are stored as the record's own `expires` field, so the
+  server stops serving them at the deadline. No cleanup cron, and `clear_expired()` is a no-op.
+- Concurrent writers use optimistic versions and retry, so there are no row locks or deadlocks.
+- Set `MEMORYDB_SESSIONS_COLLECTION` / `OPTIONS["collection"]` to move either store elsewhere, so
+  two Django projects on one server stay apart.
+- Session values are stored through Django's own `SESSION_SERIALIZER` and signed with your
+  `SECRET_KEY`, exactly as the database-backed store signs them, so sessions your site already
+  issued keep working when you switch engines.
+
+This is a cache/session backend, **not** a `django.db` backend — models, migrations, the admin
+and ORM queries still need Postgres or SQLite.

memorydb_django-0.2.1/README.md

@@ -0,0 +1,46 @@
+# memorydb-django
+
+Django cache and session backends for [MemoryDB](https://github.com/humaniods/MemoryDB).
+Two lines in `settings.py`, the way `sqlite3` is a drop-in for Django itself — no models, no
+migrations, no new code in your views.
+
+```bash
+pip install memorydb-django
+```
+
+```python
+# settings.py
+CACHES = {"default": {
+    "BACKEND": "memorydb_django.MemoryDBCache",
+    "LOCATION": "memorydb://TOKEN@127.0.0.1:8080",   # or leave empty and set MEMORYDB_URL
+}}
+
+SESSION_ENGINE = "memorydb_django.sessions"
+```
+
+Then use Django's own API:
+
+```python
+from django.core.cache import cache
+cache.set("hero", {"name": "Karna"}, timeout=30)   # one record; the TTL is the record's expiry
+cache.get("hero")
+
+request.session["user_id"] = 42                    # SESSION_COOKIE_AGE enforced server-side
+request.session.save()
+```
+
+Details worth knowing:
+
+- Each cache key and each session is one MemoryDB document in the `django_cache` /
+  `django_sessions` collection (typed, unique and indexed; created on first use).
+- `timeout=` and `SESSION_COOKIE_AGE` are stored as the record's own `expires` field, so the
+  server stops serving them at the deadline. No cleanup cron, and `clear_expired()` is a no-op.
+- Concurrent writers use optimistic versions and retry, so there are no row locks or deadlocks.
+- Set `MEMORYDB_SESSIONS_COLLECTION` / `OPTIONS["collection"]` to move either store elsewhere, so
+  two Django projects on one server stay apart.
+- Session values are stored through Django's own `SESSION_SERIALIZER` and signed with your
+  `SECRET_KEY`, exactly as the database-backed store signs them, so sessions your site already
+  issued keep working when you switch engines.
+
+This is a cache/session backend, **not** a `django.db` backend — models, migrations, the admin
+and ORM queries still need Postgres or SQLite.

memorydb_django-0.2.1/memorydb_django/__init__.py

@@ -0,0 +1,13 @@
+"""Django integration for MemoryDB: cache and session backends that drop into settings.py.
+
+    CACHES = {"default": {"BACKEND": "memorydb_django.MemoryDBCache",
+                          "LOCATION": "memorydb://TOKEN@127.0.0.1:8080"}}
+    SESSION_ENGINE = "django.contrib.sessions.backends.memorydb"  # via this package's session module
+
+Values expire through the engine's own record expiry, not a swept key table:
+an expired record stops being readable server-side.
+"""
+from memorydb_django.cache import MemoryDBCache
+from memorydb_django.sessions import SessionStore
+
+__all__ = ["MemoryDBCache", "SessionStore"]

memorydb_django-0.2.1/memorydb_django/cache.py

@@ -0,0 +1,118 @@
+"""Cache backend: Django's cache API on top of MemoryDB records.
+
+settings.py:
+    CACHES = {"default": {
+        "BACKEND": "memorydb_django.MemoryDBCache",
+        "LOCATION": "memorydb://TOKEN@127.0.0.1:8080",   # or set MEMORYDB_URL
+        "OPTIONS": {"collection": "django_cache"},
+    }}
+"""
+import base64
+import pickle
+from datetime import datetime, timedelta, timezone
+
+from django.core.cache.backends.base import BaseCache, DEFAULT_TIMEOUT
+from memorydb import MemoryDB, MemoryDBError
+
+MAX_PAGE = 500
+
+
+class MemoryDBCache(BaseCache):
+    def __init__(self, server, params):
+        super().__init__(params)
+        options = params.get("OPTIONS", {})
+        location = server if isinstance(server, str) else options.get("url", "")
+        if location.startswith("memorydb"):
+            self.db = MemoryDB.from_url(location)
+        elif location:
+            self.db = MemoryDB(location, token=options.get("token"))
+        else:
+            self.db = MemoryDB()  # reads MEMORYDB_URL
+        self.collection = options.get("collection", "django_cache")
+        self._ensure_collection()
+
+    # -- engine plumbing ----------------------------------------------------
+    def _ensure_collection(self):
+        try:
+            self.db.collections.create(self.collection,
+                                       fields={"cache_key": {"type": "string", "required": True},
+                                               "payload": {"type": "string"}},
+                                       unique=["cache_key"], indexes=["cache_key"])
+        except MemoryDBError as exc:
+            if exc.status != 409:  # already exists
+                raise
+
+    def _find(self, key):
+        page = self.db.request("POST", "query/" + self.collection + "/",
+                               {"where": [{"field": "cache_key", "op": "eq", "value": key}], "limit": 1})
+        return page["results"][0] if page["results"] else None
+
+    def _write(self, key, value, timeout):
+        payload = base64.b64encode(pickle.dumps(value)).decode()
+        expires = None
+        deadline = self.get_backend_timeout(timeout)
+        if deadline:
+            expires = datetime.fromtimestamp(deadline, timezone.utc).isoformat()
+        for attempt in range(3):
+            record = self._find(key)
+            try:
+                if record is None:
+                    self.db.request("POST", "documents/" + self.collection + "/",
+                                    {"data": {"cache_key": key, "payload": payload}, "expires": expires})
+                else:
+                    updated = dict(record)
+                    updated["data"] = {"cache_key": key, "payload": payload}
+                    updated["expires"] = expires
+                    self.db.request("PUT", "documents/" + self.collection + "/" + record["id"] + "/", updated)
+                return
+            except MemoryDBError as exc:
+                if exc.status != 409 or attempt == 2:
+                    raise  # concurrent writer bumped the version; re-read and retry
+
+    def _read(self, key):
+        record = self._find(key)
+        if record is None:
+            return None
+        return pickle.loads(base64.b64decode(record["data"]["payload"]))
+
+    # -- BaseCache contract ---------------------------------------------------
+    def get(self, key, default=None, version=None):
+        envelope = self._read(self.make_key(key, version=version))
+        if envelope is None:
+            return default
+        value, flags = envelope
+        return value if flags == "c" else default
+
+    def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
+        self._write(self.make_key(key, version=version), (value, "c"), timeout)
+
+    def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
+        full = self.make_key(key, version=version)
+        if self._read(full) is None:
+            self.set(key, value, timeout=timeout, version=version)
+            return True
+        return False
+
+    def delete(self, key, version=None):
+        record = self._find(self.make_key(key, version=version))
+        if record is None:
+            return
+        self.db.request("DELETE", "documents/" + self.collection + "/" + record["id"] + "/",
+                        headers={"If-Match": str(record["version"])})
+
+    def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None):
+        full = self.make_key(key, version=version)
+        envelope = self._read(full)
+        if envelope is None:
+            return False
+        self._write(full, envelope, timeout)
+        return True
+
+    def clear(self):
+        while True:
+            page = self.db.request("POST", "query/" + self.collection + "/", {"limit": MAX_PAGE})
+            if not page["results"]:
+                return
+            for record in page["results"]:
+                self.db.request("DELETE", "documents/" + self.collection + "/" + record["id"] + "/",
+                                headers={"If-Match": str(record["version"])})

memorydb_django-0.2.1/memorydb_django/sessions.py

@@ -0,0 +1,103 @@
+"""Session backend: django.contrib.sessions storage on MemoryDB records.
+
+settings.py:
+    SESSION_ENGINE = "memorydb_django.sessions"
+
+Sessions expire through the engine's own record expiry (SESSION_COOKIE_AGE);
+expired sessions stop being readable server-side with no sweep cron.
+"""
+from datetime import datetime, timedelta, timezone
+
+from django.conf import settings
+from django.contrib.sessions.backends.base import CreateError, SessionBase
+from memorydb import MemoryDB, MemoryDBError
+
+
+def _client():
+    location = getattr(settings, "MEMORYDB_URL", "")
+    if location.startswith("memorydb"):
+        return MemoryDB.from_url(location)
+    if location:
+        return MemoryDB(location, token=getattr(settings, "MEMORYDB_TOKEN", None))
+    return MemoryDB()  # reads the MEMORYDB_URL env var
+
+
+def _collection():
+    return getattr(settings, "MEMORYDB_SESSIONS_COLLECTION", "django_sessions")
+
+
+class SessionStore(SessionBase):
+    def __init__(self, session_key=None):
+        super().__init__(session_key)
+        self.db = _client()
+        self.collection = _collection()
+        try:
+            self.db.collections.create(self.collection,
+                                       fields={"session_key": {"type": "string", "required": True},
+                                               "payload": {"type": "string"}},
+                                       unique=["session_key"], indexes=["session_key"])
+        except MemoryDBError as exc:
+            if exc.status != 409:
+                raise
+
+    def _find(self, session_key):
+        page = self.db.request("POST", "query/" + self.collection + "/",
+                               {"where": [{"field": "session_key", "op": "eq", "value": session_key}], "limit": 1})
+        return page["results"][0] if page["results"] else None
+
+    def load(self):
+        record = self._find(self.session_key) if self.session_key else None
+        if record is None:
+            self._session_key = None
+            return {}
+        return self.decode(record["data"]["payload"])
+
+    def exists(self, session_key):
+        return self._find(session_key) is not None
+
+    def create(self):
+        while True:
+            self._session_key = self._get_new_session_key()
+            try:
+                self.save(must_create=True)
+            except CreateError:
+                continue  # key collision; try another
+            self.modified = True
+            return
+
+    def save(self, must_create=False):
+        if self.session_key is None:
+            return self.create()
+        payload = self.encode(self._get_session(no_load=must_create))
+        expires = (datetime.now(timezone.utc) + timedelta(seconds=self.get_expiry_age())).isoformat()
+        for attempt in range(3):
+            record = self._find(self.session_key)
+            try:
+                if record is None:
+                    self.db.request("POST", "documents/" + self.collection + "/",
+                                    {"data": {"session_key": self.session_key, "payload": payload}, "expires": expires})
+                    return
+                if must_create:
+                    raise CreateError
+                updated = dict(record)
+                updated["data"] = {"session_key": self.session_key, "payload": payload}
+                updated["expires"] = expires
+                self.db.request("PUT", "documents/" + self.collection + "/" + record["id"] + "/", updated)
+                return
+            except MemoryDBError as exc:
+                if exc.status != 409 or attempt == 2:
+                    raise
+
+    def delete(self, session_key=None):
+        if session_key is None:
+            if self.session_key is None:
+                return
+            session_key = self.session_key
+        record = self._find(session_key)
+        if record is not None:
+            self.db.request("DELETE", "documents/" + self.collection + "/" + record["id"] + "/",
+                            headers={"If-Match": str(record["version"])})
+
+    @classmethod
+    def clear_expired(cls):
+        pass  # expiry is enforced by the engine at read time; nothing to sweep

memorydb_django-0.2.1/memorydb_django.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: memorydb-django
+Version: 0.2.1
+Summary: Django cache and session backends for MemoryDB (SQLite-style drop-in for the settings file)
+Author: humaniods
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/humaniods/MemoryDB
+Project-URL: Repository, https://github.com/humaniods/MemoryDB
+Project-URL: Issues, https://github.com/humaniods/MemoryDB/issues
+Keywords: django,cache,sessions,database,agent-memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: superb-memory
+Requires-Dist: Django>=4.2
+
+# memorydb-django
+
+Django cache and session backends for [MemoryDB](https://github.com/humaniods/MemoryDB).
+Two lines in `settings.py`, the way `sqlite3` is a drop-in for Django itself — no models, no
+migrations, no new code in your views.
+
+```bash
+pip install memorydb-django
+```
+
+```python
+# settings.py
+CACHES = {"default": {
+    "BACKEND": "memorydb_django.MemoryDBCache",
+    "LOCATION": "memorydb://TOKEN@127.0.0.1:8080",   # or leave empty and set MEMORYDB_URL
+}}
+
+SESSION_ENGINE = "memorydb_django.sessions"
+```
+
+Then use Django's own API:
+
+```python
+from django.core.cache import cache
+cache.set("hero", {"name": "Karna"}, timeout=30)   # one record; the TTL is the record's expiry
+cache.get("hero")
+
+request.session["user_id"] = 42                    # SESSION_COOKIE_AGE enforced server-side
+request.session.save()
+```
+
+Details worth knowing:
+
+- Each cache key and each session is one MemoryDB document in the `django_cache` /
+  `django_sessions` collection (typed, unique and indexed; created on first use).
+- `timeout=` and `SESSION_COOKIE_AGE` are stored as the record's own `expires` field, so the
+  server stops serving them at the deadline. No cleanup cron, and `clear_expired()` is a no-op.
+- Concurrent writers use optimistic versions and retry, so there are no row locks or deadlocks.
+- Set `MEMORYDB_SESSIONS_COLLECTION` / `OPTIONS["collection"]` to move either store elsewhere, so
+  two Django projects on one server stay apart.
+- Session values are stored through Django's own `SESSION_SERIALIZER` and signed with your
+  `SECRET_KEY`, exactly as the database-backed store signs them, so sessions your site already
+  issued keep working when you switch engines.
+
+This is a cache/session backend, **not** a `django.db` backend — models, migrations, the admin
+and ORM queries still need Postgres or SQLite.

memorydb_django-0.2.1/memorydb_django.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+memorydb_django/__init__.py
+memorydb_django/cache.py
+memorydb_django/sessions.py
+memorydb_django.egg-info/PKG-INFO
+memorydb_django.egg-info/SOURCES.txt
+memorydb_django.egg-info/dependency_links.txt
+memorydb_django.egg-info/requires.txt
+memorydb_django.egg-info/top_level.txt

memorydb_django-0.2.1/memorydb_django.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

memorydb_django-0.2.1/memorydb_django.egg-info/requires.txt

@@ -0,0 +1,2 @@
+superb-memory
+Django>=4.2

memorydb_django-0.2.1/memorydb_django.egg-info/top_level.txt

@@ -0,0 +1 @@
+memorydb_django

memorydb_django-0.2.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "memorydb-django"
+version = "0.2.1"
+description = "Django cache and session backends for MemoryDB (SQLite-style drop-in for the settings file)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "humaniods" }]
+keywords = ["django", "cache", "sessions", "database", "agent-memory"]
+classifiers = ["Development Status :: 4 - Beta", "Framework :: Django",
+               "Intended Audience :: Developers", "Operating System :: POSIX",
+               "Programming Language :: Python :: 3", "Topic :: Database"]
+dependencies = ["superb-memory", "Django>=4.2"]
+[tool.setuptools]
+packages = ["memorydb_django"]
+[project.urls]
+Homepage = "https://github.com/humaniods/MemoryDB"
+Repository = "https://github.com/humaniods/MemoryDB"
+Issues = "https://github.com/humaniods/MemoryDB/issues"

memorydb_django-0.2.1/setup.cfg

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