xeze-dbr-core 0.1.0__tar.gz

xeze_dbr_core-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: xeze-dbr-core
+Version: 0.1.0
+Summary: Official unified database wrapper for the Xeze infrastructure.
+Author-email: Xeze <dev@xeze.org>
+License: MIT
+Project-URL: Homepage, https://code.xeze.org/xeze/xeze-dbr-core
+Project-URL: Repository, https://code.xeze.org/xeze/xeze-dbr-core
+Project-URL: Bug Tracker, https://code.xeze.org/xeze/xeze-dbr-core/issues
+Keywords: xeze,database,grpc,postgres,mongodb,redis,vault
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: hvac>=1.1.0
+Requires-Dist: grpcio>=1.50.0
+Requires-Dist: protobuf>=4.21.0
+Requires-Dist: xeze-dbr
+Dynamic: requires-python
+
+# xeze-dbr-core
+
+Official unified database wrapper for the Xeze infrastructure. Provides a single, heavily-abstracted client for **PostgreSQL**, **MongoDB**, and **Redis** over mTLS via HashiCorp Vault.
+
+## Installation
+
+```bash
+pip install git+https://code.xeze.org/xeze/xeze-dbr-core.git
+```
+
+Or install locally for development:
+
+```bash
+pip install .
+```
+
+## Quick Start
+
+```python
+from xeze_core import XezeCoreClient
+
+db = XezeCoreClient(app_namespace="xms")
+db.init_workspace()  # Ensures the 'xms_pg' database exists
+
+# Postgres
+db.pg_insert("students", {"name": "Ayush", "grade": "A"})
+
+# MongoDB
+db.mongo_insert("audit_logs", {"action": "student_added", "timestamp": "2026-04-05"})
+
+# Redis
+db.redis_set("cache:student:latest", "Ayush", ttl=300)
+```
+
+## Environment Variables
+
+| Variable           | Default                    | Description                |
+| ------------------ | -------------------------- | -------------------------- |
+| `VAULT_ADDR`       | `http://127.0.0.1:8200`   | HashiCorp Vault address    |
+| `VAULT_TOKEN`      | `dev-root-token`           | Vault authentication token |
+| `DB_ROUTER_HOST`   | `db.0.xeze.org:443`       | Database Router gRPC host  |
+
+## Architecture
+
+- **Database-per-Service isolation** — each `app_namespace` gets its own `{ns}_pg`, `{ns}_mongo`, and `{ns}:` Redis prefix.
+- **Vault mTLS** — client certs are fetched from Vault KV at `dbrouter/certs` and loaded in-memory only.
+- **gRPC/Protobuf abstraction** — all Protobuf packing is handled internally; developers work with native Python dicts.

xeze_dbr_core-0.1.0/README.md

@@ -0,0 +1,47 @@
+# xeze-dbr-core
+
+Official unified database wrapper for the Xeze infrastructure. Provides a single, heavily-abstracted client for **PostgreSQL**, **MongoDB**, and **Redis** over mTLS via HashiCorp Vault.
+
+## Installation
+
+```bash
+pip install git+https://code.xeze.org/xeze/xeze-dbr-core.git
+```
+
+Or install locally for development:
+
+```bash
+pip install .
+```
+
+## Quick Start
+
+```python
+from xeze_core import XezeCoreClient
+
+db = XezeCoreClient(app_namespace="xms")
+db.init_workspace()  # Ensures the 'xms_pg' database exists
+
+# Postgres
+db.pg_insert("students", {"name": "Ayush", "grade": "A"})
+
+# MongoDB
+db.mongo_insert("audit_logs", {"action": "student_added", "timestamp": "2026-04-05"})
+
+# Redis
+db.redis_set("cache:student:latest", "Ayush", ttl=300)
+```
+
+## Environment Variables
+
+| Variable           | Default                    | Description                |
+| ------------------ | -------------------------- | -------------------------- |
+| `VAULT_ADDR`       | `http://127.0.0.1:8200`   | HashiCorp Vault address    |
+| `VAULT_TOKEN`      | `dev-root-token`           | Vault authentication token |
+| `DB_ROUTER_HOST`   | `db.0.xeze.org:443`       | Database Router gRPC host  |
+
+## Architecture
+
+- **Database-per-Service isolation** — each `app_namespace` gets its own `{ns}_pg`, `{ns}_mongo`, and `{ns}:` Redis prefix.
+- **Vault mTLS** — client certs are fetched from Vault KV at `dbrouter/certs` and loaded in-memory only.
+- **gRPC/Protobuf abstraction** — all Protobuf packing is handled internally; developers work with native Python dicts.

xeze_dbr_core-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xeze-dbr-core"
+version = "0.1.0"
+description = "Official unified database wrapper for the Xeze infrastructure."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+authors = [
+    { name = "Xeze", email = "dev@xeze.org" }
+]
+keywords = ["xeze", "database", "grpc", "postgres", "mongodb", "redis", "vault"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "hvac>=1.1.0",
+    "grpcio>=1.50.0",
+    "protobuf>=4.21.0",
+    "xeze-dbr",
+]
+
+[project.urls]
+Homepage = "https://code.xeze.org/xeze/xeze-dbr-core"
+Repository = "https://code.xeze.org/xeze/xeze-dbr-core"
+"Bug Tracker" = "https://code.xeze.org/xeze/xeze-dbr-core/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]

xeze_dbr_core-0.1.0/setup.cfg

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

xeze_dbr_core-0.1.0/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="xeze-dbr-core",
+    version="0.1.0",
+    description="Official unified database wrapper for the Xeze infrastructure.",
+    packages=find_packages(),
+    install_requires=[
+        "hvac>=1.1.0",
+        "grpcio>=1.50.0",
+        "protobuf>=4.21.0",
+        "xeze-dbr"  # Your underlying gRPC router SDK
+    ],
+    python_requires=">=3.8",
+)

xeze_dbr_core-0.1.0/xeze_core/__init__.py

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

xeze_dbr_core-0.1.0/xeze_core/client.py

@@ -0,0 +1,137 @@
+import os
+import hvac
+import grpc
+from xeze_dbr import connect
+from google.protobuf import struct_pb2
+
+
+class XezeCoreClient:
+    """
+    Unified client for Postgres, MongoDB, and Redis over mTLS via HashiCorp Vault.
+    Enforces database isolation per application namespace.
+    """
+
+    def __init__(self, app_namespace):
+        if not app_namespace or not isinstance(app_namespace, str):
+            raise ValueError("A strict app_namespace (e.g., 'xms', 'selfnote') is required.")
+
+        self.app_namespace = app_namespace
+        # Automatic isolated routing paths
+        self.pg_db = f"{app_namespace}_pg"
+        self.mongo_db = f"{app_namespace}_mongo"
+        self.redis_prefix = f"{app_namespace}:"
+
+        self._connect_via_vault()
+
+    def _connect_via_vault(self):
+        """Silently handles Vault authentication and memory-only cert loading."""
+        vault_addr = os.environ.get("VAULT_ADDR", "http://127.0.0.1:8200")
+        vault_token = os.environ.get("VAULT_TOKEN", "dev-root-token")
+        host = os.environ.get("DB_ROUTER_HOST", "db.0.xeze.org:443")
+
+        vault = hvac.Client(url=vault_addr, token=vault_token)
+        if not vault.is_authenticated():
+            raise Exception("Critical: Vault authentication failed.")
+
+        secret = vault.secrets.kv.v2.read_secret_version(path="dbrouter/certs")
+        cert_data = secret["data"]["data"]["client_cert"].encode()
+        key_data = secret["data"]["data"]["client_key"].encode()
+
+        self.client = connect(host=host, cert_data=cert_data, key_data=key_data)
+
+    def init_workspace(self):
+        """
+        Attempts to create the isolated Postgres database for this namespace.
+        Safe to call on application startup.
+        """
+        try:
+            req = self.client.pb2.CreateDatabaseRequest(name=self.pg_db)
+            self.client.postgres.CreateDatabase(req)
+            print(f"[OK] Provisioned workspace: {self.pg_db}")
+        except grpc.RpcError as e:
+            if "already exists" in e.details().lower():
+                pass  # Expected behavior if already provisioned
+            else:
+                print(f"[WARN] Workspace check failed: {e.details()}")
+
+    def _pack_pg_dict(self, data_dict):
+        """Internal helper for PostgreSQL Protobuf typing."""
+        packed = {}
+        for k, v in data_dict.items():
+            if isinstance(v, str):
+                packed[k] = struct_pb2.Value(string_value=v)
+            elif isinstance(v, bool):
+                packed[k] = struct_pb2.Value(bool_value=v)
+            elif isinstance(v, (int, float)):
+                packed[k] = struct_pb2.Value(number_value=float(v))
+            else:
+                packed[k] = struct_pb2.Value(string_value=str(v))
+        return packed
+
+    # --- POSTGRESQL API -------------------------------------------------------
+
+    def pg_query(self, query):
+        """Executes raw SQL returning a list of native Python dictionaries."""
+        req = self.client.pb2.ExecuteQueryRequest(database=self.pg_db, query=query)
+        resp = self.client.postgres.ExecuteQuery(req)
+
+        results = []
+        for row in resp.rows:
+            row_data = {}
+            for key, val in row.fields.items():
+                if val.HasField("string_value"):
+                    row_data[key] = val.string_value
+                elif val.HasField("number_value"):
+                    row_data[key] = val.number_value
+                elif val.HasField("bool_value"):
+                    row_data[key] = val.bool_value
+            results.append(row_data)
+        return results
+
+    def pg_insert(self, table, data_dict):
+        """Inserts a native Python dict into PostgreSQL."""
+        req = self.client.pb2.InsertDataRequest(
+            database=self.pg_db,
+            table=table,
+            data=self._pack_pg_dict(data_dict)
+        )
+        resp = self.client.postgres.InsertData(req)
+        return resp.inserted_id
+
+    # --- MONGODB API ----------------------------------------------------------
+
+    def mongo_insert(self, collection, doc_dict):
+        """Inserts a native Python dictionary into MongoDB."""
+        doc = struct_pb2.Struct()
+        doc.update(doc_dict)
+
+        req = self.client.pb2.InsertDocumentRequest(
+            database=self.mongo_db,
+            collection=collection,
+            document=doc
+        )
+        resp = self.client.mongo.InsertDocument(req)
+        return resp.inserted_id
+
+    # --- REDIS API ------------------------------------------------------------
+
+    def redis_set(self, key, value, ttl=3600):
+        """Sets a prefixed key with a default 1-hour TTL."""
+        namespaced_key = f"{self.redis_prefix}{key}"
+        req = self.client.pb2.SetValueRequest(key=namespaced_key, value=str(value), ttl=ttl)
+        self.client.redis.SetValue(req)
+
+    def redis_get(self, key):
+        """Fetches a prefixed key gracefully."""
+        namespaced_key = f"{self.redis_prefix}{key}"
+        try:
+            req = self.client.pb2.GetValueRequest(key=namespaced_key)
+            return self.client.redis.GetValue(req).value
+        except grpc.RpcError as e:
+            if "not found" in e.details().lower():
+                return None
+            raise e
+
+    def close(self):
+        """Closes the underlying gRPC connection."""
+        self.client.close()

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

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: xeze-dbr-core
+Version: 0.1.0
+Summary: Official unified database wrapper for the Xeze infrastructure.
+Author-email: Xeze <dev@xeze.org>
+License: MIT
+Project-URL: Homepage, https://code.xeze.org/xeze/xeze-dbr-core
+Project-URL: Repository, https://code.xeze.org/xeze/xeze-dbr-core
+Project-URL: Bug Tracker, https://code.xeze.org/xeze/xeze-dbr-core/issues
+Keywords: xeze,database,grpc,postgres,mongodb,redis,vault
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: hvac>=1.1.0
+Requires-Dist: grpcio>=1.50.0
+Requires-Dist: protobuf>=4.21.0
+Requires-Dist: xeze-dbr
+Dynamic: requires-python
+
+# xeze-dbr-core
+
+Official unified database wrapper for the Xeze infrastructure. Provides a single, heavily-abstracted client for **PostgreSQL**, **MongoDB**, and **Redis** over mTLS via HashiCorp Vault.
+
+## Installation
+
+```bash
+pip install git+https://code.xeze.org/xeze/xeze-dbr-core.git
+```
+
+Or install locally for development:
+
+```bash
+pip install .
+```
+
+## Quick Start
+
+```python
+from xeze_core import XezeCoreClient
+
+db = XezeCoreClient(app_namespace="xms")
+db.init_workspace()  # Ensures the 'xms_pg' database exists
+
+# Postgres
+db.pg_insert("students", {"name": "Ayush", "grade": "A"})
+
+# MongoDB
+db.mongo_insert("audit_logs", {"action": "student_added", "timestamp": "2026-04-05"})
+
+# Redis
+db.redis_set("cache:student:latest", "Ayush", ttl=300)
+```
+
+## Environment Variables
+
+| Variable           | Default                    | Description                |
+| ------------------ | -------------------------- | -------------------------- |
+| `VAULT_ADDR`       | `http://127.0.0.1:8200`   | HashiCorp Vault address    |
+| `VAULT_TOKEN`      | `dev-root-token`           | Vault authentication token |
+| `DB_ROUTER_HOST`   | `db.0.xeze.org:443`       | Database Router gRPC host  |
+
+## Architecture
+
+- **Database-per-Service isolation** — each `app_namespace` gets its own `{ns}_pg`, `{ns}_mongo`, and `{ns}:` Redis prefix.
+- **Vault mTLS** — client certs are fetched from Vault KV at `dbrouter/certs` and loaded in-memory only.
+- **gRPC/Protobuf abstraction** — all Protobuf packing is handled internally; developers work with native Python dicts.

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+xeze_core/__init__.py
+xeze_core/client.py
+xeze_dbr_core.egg-info/PKG-INFO
+xeze_dbr_core.egg-info/SOURCES.txt
+xeze_dbr_core.egg-info/dependency_links.txt
+xeze_dbr_core.egg-info/requires.txt
+xeze_dbr_core.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,4 @@
+hvac>=1.1.0
+grpcio>=1.50.0
+protobuf>=4.21.0
+xeze-dbr

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

@@ -0,0 +1,3 @@
+build
+dist
+xeze_core