treechain-adapters 1.0.0__tar.gz

treechain_adapters-1.0.0/LICENSE

@@ -0,0 +1,12 @@
+Proprietary License
+Copyright (c) 2026 TreeChain Labs
+Patent Pending — EP26025007.1
+
+All rights reserved. This software and associated documentation
+files are proprietary and confidential. Unauthorized copying,
+modification, distribution, or use of this software, in whole
+or in part, is strictly prohibited without explicit written
+permission from TreeChain Labs.
+
+For licensing inquiries: security@treechain.ai
+For more information: treechain.ai

treechain_adapters-1.0.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: treechain-adapters
+Version: 1.0.0
+Summary: TreeChain database adapters — drop-in encryption for MongoDB, PostgreSQL, MySQL, Redis, SQLite, Supabase. Patent Pending — EP26025007.1
+Author-email: TreeChain Labs <security@treechain.ai>
+License: Proprietary
+Project-URL: Homepage, https://treechain.ai
+Project-URL: Documentation, https://api-eu.treechain.ai/docs
+Keywords: encryption,database,mongodb,postgresql,mysql,redis,steganography,hipaa,zero-knowledge
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+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: Topic :: Database
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: treechain>=4.0.0
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: mongodb
+Requires-Dist: motor>=3.0.0; extra == "mongodb"
+Provides-Extra: postgresql
+Requires-Dist: asyncpg>=0.27.0; extra == "postgresql"
+Provides-Extra: mysql
+Requires-Dist: aiomysql>=0.1.1; extra == "mysql"
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite>=0.19.0; extra == "sqlite"
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == "redis"
+Provides-Extra: supabase
+Requires-Dist: supabase>=1.0.0; extra == "supabase"
+Provides-Extra: all
+Requires-Dist: treechain-adapters[mongodb,mysql,postgresql,redis,sqlite,supabase]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# TreeChain Database Adapters
+
+**Patent Pending — EP26025007.1**
+
+Drop-in encryption for any database. Three lines of code.
+Every field auto-encrypts with the Polyglottal Cipher.
+Your database stays exactly as is — TreeChain wraps it transparently.
+
+## Supported Databases
+
+- **MongoDB** (via Motor async client)
+- **PostgreSQL** (via asyncpg)
+- **MySQL** (via aiomysql)
+- **SQLite** (via aiosqlite)
+- **Redis** (via redis-py async)
+- **Supabase** (via supabase-py)
+
+## Installation
+
+```bash
+pip install treechain-adapters
+
+# With specific database support:
+pip install treechain-adapters[mongodb]
+pip install treechain-adapters[postgresql]
+pip install treechain-adapters[all]
+```
+
+## Usage
+
+```python
+# Before TreeChain:
+client = AsyncIOMotorClient(MONGO_URI)
+db = client.mydb
+
+# After TreeChain (3 lines changed):
+from treechain_adapters import MongoDBAdapter
+
+tc = MongoDBAdapter(api_key="gj_live_...", customer_id="jordan")
+db = tc.wrap(client.mydb)
+
+# Everything else stays identical.
+# Every write auto-encrypts via GlyphJammer.
+# Every read auto-decrypts transparently.
+# Portal populates in real time.
+await db.patients.insert_one({"name": "John Smith", "ssn": "123-45-6789"})
+# Stored as: {"name": "馏𜽡㌎𬵃...", "ssn": "𘫙𡢽甎똂..."}
+```
+
+## What Happens Under the Hood
+
+1. You write data to your database as normal
+2. The adapter intercepts string fields and encrypts them with GlyphJammer
+3. Your database stores multilingual poetry instead of plaintext
+4. On read, fields are transparently decrypted back
+5. Your TreeChain portal shows all records in real time
+6. DuckDB local copy created for redundancy
+
+## Performance
+
+- Zero blocking on writes — encryption runs in-line, portal population is fire-and-forget
+- 68ms average encrypt latency on primary node
+- Your application code does not change
+
+## Links
+
+- Website: [treechain.ai](https://treechain.ai)
+- API Docs: [api-eu.treechain.ai/docs](https://api-eu.treechain.ai/docs)
+- Support: security@treechain.ai
+
+## License
+
+Proprietary — TreeChain Labs
+Patent Pending — EP26025007.1
+
+See [LICENSE](LICENSE) for full terms.

treechain_adapters-1.0.0/README.md

@@ -0,0 +1,76 @@
+# TreeChain Database Adapters
+
+**Patent Pending — EP26025007.1**
+
+Drop-in encryption for any database. Three lines of code.
+Every field auto-encrypts with the Polyglottal Cipher.
+Your database stays exactly as is — TreeChain wraps it transparently.
+
+## Supported Databases
+
+- **MongoDB** (via Motor async client)
+- **PostgreSQL** (via asyncpg)
+- **MySQL** (via aiomysql)
+- **SQLite** (via aiosqlite)
+- **Redis** (via redis-py async)
+- **Supabase** (via supabase-py)
+
+## Installation
+
+```bash
+pip install treechain-adapters
+
+# With specific database support:
+pip install treechain-adapters[mongodb]
+pip install treechain-adapters[postgresql]
+pip install treechain-adapters[all]
+```
+
+## Usage
+
+```python
+# Before TreeChain:
+client = AsyncIOMotorClient(MONGO_URI)
+db = client.mydb
+
+# After TreeChain (3 lines changed):
+from treechain_adapters import MongoDBAdapter
+
+tc = MongoDBAdapter(api_key="gj_live_...", customer_id="jordan")
+db = tc.wrap(client.mydb)
+
+# Everything else stays identical.
+# Every write auto-encrypts via GlyphJammer.
+# Every read auto-decrypts transparently.
+# Portal populates in real time.
+await db.patients.insert_one({"name": "John Smith", "ssn": "123-45-6789"})
+# Stored as: {"name": "馏𜽡㌎𬵃...", "ssn": "𘫙𡢽甎똂..."}
+```
+
+## What Happens Under the Hood
+
+1. You write data to your database as normal
+2. The adapter intercepts string fields and encrypts them with GlyphJammer
+3. Your database stores multilingual poetry instead of plaintext
+4. On read, fields are transparently decrypted back
+5. Your TreeChain portal shows all records in real time
+6. DuckDB local copy created for redundancy
+
+## Performance
+
+- Zero blocking on writes — encryption runs in-line, portal population is fire-and-forget
+- 68ms average encrypt latency on primary node
+- Your application code does not change
+
+## Links
+
+- Website: [treechain.ai](https://treechain.ai)
+- API Docs: [api-eu.treechain.ai/docs](https://api-eu.treechain.ai/docs)
+- Support: security@treechain.ai
+
+## License
+
+Proprietary — TreeChain Labs
+Patent Pending — EP26025007.1
+
+See [LICENSE](LICENSE) for full terms.

treechain_adapters-1.0.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "treechain-adapters"
+version = "1.0.0"
+description = "TreeChain database adapters — drop-in encryption for MongoDB, PostgreSQL, MySQL, Redis, SQLite, Supabase. Patent Pending — EP26025007.1"
+readme = "README.md"
+license = {text = "Proprietary"}
+authors = [
+    {name = "TreeChain Labs", email = "security@treechain.ai"}
+]
+keywords = [
+    "encryption",
+    "database",
+    "mongodb",
+    "postgresql",
+    "mysql",
+    "redis",
+    "steganography",
+    "hipaa",
+    "zero-knowledge",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: Other/Proprietary License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Security :: Cryptography",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "treechain>=4.0.0",
+    "httpx>=0.24.0",
+]
+
+[project.optional-dependencies]
+mongodb = ["motor>=3.0.0"]
+postgresql = ["asyncpg>=0.27.0"]
+mysql = ["aiomysql>=0.1.1"]
+sqlite = ["aiosqlite>=0.19.0"]
+redis = ["redis>=5.0.0"]
+supabase = ["supabase>=1.0.0"]
+all = [
+    "treechain-adapters[mongodb,postgresql,mysql,sqlite,redis,supabase]",
+]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+]
+
+[project.urls]
+Homepage = "https://treechain.ai"
+Documentation = "https://api-eu.treechain.ai/docs"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["treechain_adapters*"]

treechain_adapters-1.0.0/setup.cfg

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

treechain_adapters-1.0.0/src/treechain_adapters/TEMPLATE.py

@@ -0,0 +1,68 @@
+"""
+TreeChain [DATABASE_NAME] Adapter — TEMPLATE
+
+Copy this file and implement 3 things:
+1. Wrap the client class to intercept writes
+2. Call self._adapter._auto_populate() on every write
+3. Increment self._adapter._write_count / _read_count
+
+Time to implement: ~20 minutes for a new database.
+
+Steps:
+    1. Copy this file as yourdb_adapter.py
+    2. Replace _WrappedClient with your DB's client wrapper
+    3. Intercept the write methods (insert, execute, set, etc.)
+    4. Call _auto_populate with the data and a source name
+    5. Add to __init__.py exports
+    6. Test with: python -m pytest sdk/tests/test_adapters.py
+"""
+
+from typing import Any, Dict
+from .base import TreeChainDBAdapter
+
+
+class _WrappedClient:
+    """Wrap the database client. Intercept writes, pass through reads."""
+
+    def __init__(self, client, adapter: 'YourDBAdapter'):
+        self._client = client
+        self._adapter = adapter
+
+    async def your_write_method(self, *args, **kwargs):
+        """Replace with the actual write method name (insert, execute, set, etc.)"""
+        # 1. Call the original method first — never block the customer
+        result = await self._client.your_write_method(*args, **kwargs)
+
+        # 2. Increment write counter
+        self._adapter._write_count += 1
+
+        # 3. Auto-populate portal (fire-and-forget, never throws)
+        await self._adapter._auto_populate(
+            {"data": str(args)[:500]},  # Extract meaningful fields from args
+            "your_table_writes",         # Collection name in portal
+        )
+
+        # 4. Return original result — customer sees no difference
+        return result
+
+    async def your_read_method(self, *args, **kwargs):
+        """Reads just pass through with a counter increment."""
+        self._adapter._read_count += 1
+        return await self._client.your_read_method(*args, **kwargs)
+
+    def __getattr__(self, name):
+        """Pass through anything we don't intercept."""
+        return getattr(self._client, name)
+
+
+class YourDBAdapter(TreeChainDBAdapter):
+    """
+    [DATABASE_NAME] adapter for TreeChain.
+
+    Usage:
+        tc = YourDBAdapter(api_key="gj_live_...", customer_id="jordan")
+        client = tc.wrap(your_db_client)
+    """
+
+    def wrap(self, client) -> _WrappedClient:
+        return _WrappedClient(client, self)

treechain_adapters-1.0.0/src/treechain_adapters/__init__.py

@@ -0,0 +1,30 @@
+"""
+TreeChain Database Adapters
+
+Drop-in wrappers for every major database. 3 lines to integrate:
+
+    from treechain.db_adapters import MongoDBAdapter
+    tc = MongoDBAdapter(api_key="gj_live_...", customer_id="jordan")
+    db = tc.wrap(your_existing_db_client)
+
+Every write auto-encrypts and populates your TreeChain portal.
+Zero latency impact. Zero code changes beyond the 3 lines above.
+"""
+
+from .base import TreeChainDBAdapter
+from .mongodb_adapter import MongoDBAdapter
+from .postgresql_adapter import PostgreSQLAdapter
+from .mysql_adapter import MySQLAdapter
+from .sqlite_adapter import SQLiteAdapter
+from .redis_adapter import RedisAdapter
+from .supabase_adapter import SupabaseAdapter
+
+__all__ = [
+    "TreeChainDBAdapter",
+    "MongoDBAdapter",
+    "PostgreSQLAdapter",
+    "MySQLAdapter",
+    "SQLiteAdapter",
+    "RedisAdapter",
+    "SupabaseAdapter",
+]

treechain_adapters-1.0.0/src/treechain_adapters/base.py

@@ -0,0 +1,214 @@
+"""
+TreeChain DB Adapter — Base Class
+
+Every database adapter inherits from this. Intercept writes,
+encrypt fields via GlyphJammer, auto-populate the customer portal
+in real time. Zero latency impact. Zero code change for the customer.
+
+Usage:
+    from treechain.db_adapters import MongoDBAdapter
+    tc = MongoDBAdapter(api_key="gj_live_...", customer_id="jordan")
+    db = tc.wrap(client.mydb)
+    # Everything else stays identical — every write auto-populates
+"""
+
+import asyncio
+import hashlib
+import json
+import logging
+import os
+import threading
+import time
+from abc import ABC, abstractmethod
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+log = logging.getLogger("treechain.db_adapter")
+
+
+class TreeChainDBAdapter(ABC):
+    """
+    Base class for all TreeChain database adapters.
+
+    Drop-in wrapper: intercepts reads/writes, encrypts field values
+    via GlyphJammer, and fires async hooks to populate the customer's
+    encrypted database portal. The main database operation is never
+    blocked or slowed.
+    """
+
+    def __init__(
+        self,
+        api_key: str = None,
+        customer_id: str = None,
+        collection_prefix: str = "cdb",
+        mongo_uri: str = None,
+        master_key: str = None,
+        auto_populate: bool = True,
+        encrypt_fields: bool = True,
+    ):
+        self.api_key = api_key
+        self.customer_id = customer_id or self._resolve_customer_id(api_key)
+        self.collection_prefix = collection_prefix
+        self.auto_populate = auto_populate
+        self.encrypt_fields = encrypt_fields
+        self._mongo_uri = mongo_uri or os.getenv("MONGODB_URI") or os.getenv("MONGO_URI")
+        self._master_key = master_key or os.getenv("TREECHAIN_MASTER_KEY")
+        self._jammer = None
+        self._mongo_client = None
+        self._mongo_db = None
+        self._duckdb = None
+        self._write_count = 0
+        self._read_count = 0
+        self._populate_count = 0
+        self._error_count = 0
+
+    def _resolve_customer_id(self, api_key: str) -> str:
+        """Derive customer_id from API key hash if not provided."""
+        if not api_key:
+            return "anonymous"
+        raw = api_key.strip()
+        if raw.startswith("tc_"):
+            raw = raw[3:]
+        return hashlib.sha256(raw.encode()).hexdigest()[:12]
+
+    def _get_jammer(self):
+        """Lazy-init GlyphJammer."""
+        if self._jammer is None and self._master_key:
+            try:
+                import sys
+                for p in [
+                    os.path.join(os.path.dirname(__file__), "..", "..", "vendor", "treechain_sdk", "treechain-sdk-v4"),
+                    os.path.join(os.path.dirname(__file__), "..", "..", "treechain-sdk-v4"),
+                ]:
+                    if os.path.exists(p) and p not in sys.path:
+                        sys.path.insert(0, p)
+                from treechain.core.encryption import GlyphJammer
+                self._jammer = GlyphJammer(master_key=self._master_key)
+            except Exception as e:
+                log.warning("GlyphJammer init failed: %s", e)
+        return self._jammer
+
+    def _get_mongo(self):
+        """Lazy-init MongoDB client for portal writes."""
+        if self._mongo_client is None and self._mongo_uri:
+            try:
+                from motor.motor_asyncio import AsyncIOMotorClient
+                self._mongo_client = AsyncIOMotorClient(
+                    self._mongo_uri, maxPoolSize=5, minPoolSize=1,
+                    serverSelectionTimeoutMS=5000,
+                )
+                self._mongo_db = self._mongo_client[os.getenv("MONGO_DB", "glyphjammer")]
+            except Exception as e:
+                log.warning("MongoDB portal connection failed: %s", e)
+        return self._mongo_db
+
+    def _get_duckdb(self):
+        """Lazy-init DuckDB for local redundancy."""
+        if self._duckdb is None:
+            try:
+                from stores.duckdb_store import DuckDBProvenanceStore
+                self._duckdb = DuckDBProvenanceStore(
+                    master_key=self._master_key,
+                    node_id=os.getenv("NODE_ID", "unknown"),
+                )
+            except Exception:
+                pass
+        return self._duckdb
+
+    def _ns(self, source: str) -> str:
+        """Build namespaced collection name."""
+        safe_cust = "".join(c for c in self.customer_id if c.isalnum() or c in ("_", "-"))[:64]
+        safe_src = "".join(c for c in source if c.isalnum() or c in ("_", "-"))[:64]
+        return f"{self.collection_prefix}_{safe_cust}_{safe_src}"
+
+    def _encrypt_doc(self, data: Dict) -> tuple:
+        """Encrypt all string values in a document. Returns (encrypted_doc, encrypted_fields_meta)."""
+        jammer = self._get_jammer()
+        if not jammer or not self.encrypt_fields:
+            return data, {}
+
+        doc = {}
+        ef = {}
+        for k, v in data.items():
+            if k.startswith("_"):
+                doc[k] = v
+                continue
+            if isinstance(v, str) and v:
+                try:
+                    result = jammer.encrypt(str(v), emotion="love")
+                    doc[k] = getattr(result, "glyph_payload", str(result))
+                    ef[k] = {
+                        "shield_id": getattr(result, "shield_id", ""),
+                        "meta": getattr(result, "metadata", {}),
+                    }
+                except Exception:
+                    doc[k] = v
+            else:
+                doc[k] = v
+        return doc, ef
+
+    async def _auto_populate(self, data: Dict, source: str, operation: str = "write"):
+        """
+        Fire-and-forget portal population.
+        Never blocks. Never throws. Never slows the customer's operation.
+        """
+        if not self.auto_populate:
+            return
+
+        try:
+            enc_doc, ef = self._encrypt_doc(data)
+            enc_doc["_encrypted_fields"] = ef
+            enc_doc["_created_at"] = datetime.now(timezone.utc)
+            enc_doc["_customer_id"] = self.customer_id
+            enc_doc["_source_adapter"] = self.__class__.__name__
+            enc_doc["_operation"] = operation
+
+            ns = self._ns(source)
+
+            # MongoDB async write
+            db = self._get_mongo()
+            if db is not None:
+                asyncio.ensure_future(db[ns].insert_one(enc_doc))
+
+            # DuckDB local write
+            ddb = self._get_duckdb()
+            if ddb:
+                ddb.store_async(ns, json.dumps(ef, default=str)[:200], enc_doc)
+
+            self._populate_count += 1
+        except Exception as e:
+            self._error_count += 1
+            log.debug("Auto-populate failed (non-fatal): %s", e)
+
+    def _auto_populate_sync(self, data: Dict, source: str, operation: str = "write"):
+        """Sync wrapper for auto_populate — used by sync adapters."""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                asyncio.ensure_future(self._auto_populate(data, source, operation))
+            else:
+                loop.run_until_complete(self._auto_populate(data, source, operation))
+        except RuntimeError:
+            # No event loop — fire in background thread
+            threading.Thread(
+                target=lambda: asyncio.run(self._auto_populate(data, source, operation)),
+                daemon=True,
+            ).start()
+
+    def stats(self) -> Dict:
+        """Adapter statistics."""
+        return {
+            "adapter": self.__class__.__name__,
+            "customer_id": self.customer_id,
+            "writes": self._write_count,
+            "reads": self._read_count,
+            "populated": self._populate_count,
+            "errors": self._error_count,
+            "auto_populate": self.auto_populate,
+            "encrypt_fields": self.encrypt_fields,
+        }
+
+    @abstractmethod
+    def wrap(self, client: Any) -> Any:
+        """Wrap the customer's database client. Returns the wrapped client."""
+        ...