jac-scale 0.1.1__py3-none-any.whl

jac_scale/impl/memory_hierarchy.main.impl.jac

@@ -0,0 +1,63 @@
+"""ScaleTieredMemory Implementation - Multi-tier storage coordination.
+
+Storage configuration comes from environment variables or jac.toml.
+"""
+import logging;
+import from jaclang.runtimelib.memory { SqliteMemory }
+
+glob logger = logging.getLogger(__name__);
+
+"""Initialize ScaleTieredMemory with distributed backends."""
+impl ScaleTieredMemory.init(use_cache: bool = True) -> None {
+    # L1: Initialize volatile memory (inherited from VolatileMemory via TieredMemory)
+    self.__mem__ = {};
+    self.__gc__ = set();
+    # L2: Try to initialize Redis cache (replaces LocalCacheMemory)
+    redis_backend = RedisBackend();
+    self._cache_available = redis_backend.is_available();
+    if self._cache_available and use_cache {
+        self.l2 = redis_backend;
+        logger.debug("Redis cache backend initialized");
+    } else {
+        self.l2 = None;
+        logger.debug("Redis not available, running without distributed cache");
+    }
+    # L3: Try MongoDB first (replaces SqliteMemory), fall back to SqliteMemory
+    mongo_backend = MongoBackend();
+    if mongo_backend.is_available() {
+        self.l3 = mongo_backend;
+        self._persistence_type = PersistenceType.MONGODB;
+        logger.debug("MongoDB persistence backend initialized");
+        # Show subtle message (optional - uncomment to enable)
+        try {
+            import from jaclang.cli.console { console }
+            logger.debug("  ✔ Using MongoDB for persistence", style="muted");
+        } except Exception { }
+    } else {
+        # Fall back to jaclang's SqliteMemory using configured path
+        self.l3 = SqliteMemory(path=_db_config['shelf_db_path']);
+        self._persistence_type = PersistenceType.SQLITE;
+        logger.debug("MongoDB not available, using SqliteMemory for persistence");
+        # Show subtle message
+        try {
+            import from jaclang.cli.console { console }
+            logger.debug("  ✔ Using SQLite for persistence", style="muted");
+        } except Exception { }
+    }
+}
+
+"""Close all backends."""
+impl ScaleTieredMemory.close -> None {
+    # Sync and close L3 persistence
+    if self.l3 {
+        self.l3.sync();
+        self.l3.close();
+    }
+    # Close L2 cache
+    if self.l2 {
+        self.l2.close();
+    }
+    # Clear L1 (inherited from VolatileMemory)
+    self.__mem__.clear();
+    self.__gc__.clear();
+}

jac_scale/impl/memory_hierarchy.mongo.impl.jac

@@ -0,0 +1,239 @@
+"""MongoDB PersistenceBackend Implementation."""
+import logging;
+import from collections.abc { Callable, Generator, Iterable }
+import from pickle { dumps, loads }
+import from typing { Any, cast }
+import from uuid { UUID }
+import from pymongo { MongoClient, UpdateOne }
+import from pymongo.errors { ConnectionFailure }
+import from jaclang.pycore.archetype { Anchor, NodeAnchor, Root }
+import from jaclang.runtimelib.utils { storage_key, to_uuid }
+
+glob logger = logging.getLogger(__name__);
+
+"""Post-initialization: connect to MongoDB."""
+impl MongoBackend.postinit -> None {
+    if self.client is None and self.mongo_url {
+        try {
+            self.client = MongoClient(self.mongo_url);
+            self.db = self.client[self.db_name];
+            self.collection = self.db[self.collection_name];
+        } except Exception as e {
+            logger.debug(f"MongoDB connection failed: {e}");
+            self.client = None;
+        }
+    }
+}
+
+"""Check if MongoDB is available and connected."""
+impl MongoBackend.is_available -> bool {
+    if not self.mongo_url {
+        return False;
+    }
+    client = None;
+    try {
+        client = MongoClient(self.mongo_url);
+        client.admin.command('ping', maxTimeMS=100);
+        return True;
+    } except ConnectionFailure {
+        return False;
+    } except Exception as e {
+        logger.debug(f"MongoDB availability check failed: {e}");
+        return False;
+    } finally {
+        if client {
+            try {
+                client.close();
+            } except Exception { }
+        }
+    }
+}
+
+"""Get anchor by UUID from MongoDB."""
+impl MongoBackend.get(id: UUID) -> (Anchor | None) {
+    if self.client is None {
+        return None;
+    }
+    _id = to_uuid(id);
+    try {
+        db_obj = self.collection.find_one({'_id': str(_id)});
+        if db_obj {
+            return self._load_anchor(db_obj);
+        }
+    } except Exception as e {
+        logger.debug(f"MongoDB get failed: {e}");
+    }
+    return None;
+}
+
+"""Store anchor in MongoDB."""
+impl MongoBackend.put(anchor: Anchor) -> None {
+    if self.client is None or not anchor.persistent {
+        return;
+    }
+    _id = to_uuid(anchor.id);
+    try {
+        data_blob = dumps(anchor);
+        self.collection.update_one(
+            {'_id': str(_id)},
+            {'$set': {'data': data_blob, 'type': type(anchor).__name__}},
+            upsert=True
+        );
+    } except Exception as e {
+        logger.debug(f"MongoDB put failed: {e}");
+    }
+}
+
+"""Delete anchor from MongoDB."""
+impl MongoBackend.delete(id: UUID) -> None {
+    if self.client is None {
+        return;
+    }
+    _id = to_uuid(id);
+    try {
+        self.collection.delete_one({'_id': str(_id)});
+    } except Exception as e {
+        logger.debug(f"MongoDB delete failed: {e}");
+    }
+}
+
+"""Close MongoDB connection."""
+impl MongoBackend.close -> None {
+    if self.client {
+        try {
+            self.client.close();
+        } except Exception as e {
+            logger.warning(f"Error closing MongoDB connection: {e}");
+        }
+        self.client = None;
+    }
+}
+
+"""Check if an anchor exists in MongoDB."""
+impl MongoBackend.has(id: UUID) -> bool {
+    if self.client is None {
+        return False;
+    }
+    _id = to_uuid(id);
+    try {
+        return self.collection.count_documents({'_id': str(_id)}, limit=1) > 0;
+    } except Exception {
+        return False;
+    }
+}
+
+"""Query all anchors with optional filter."""
+impl MongoBackend.query(
+    filter: (Callable[[Anchor], bool] | None) = None
+) -> Generator[Anchor, None, None] {
+    if self.client is None {
+        return;
+    }
+    try {
+        for doc in self.collection.find() {
+            if (anchor := self._load_anchor(doc)) {
+                if filter is None or filter(anchor) {
+                    yield anchor;
+                }
+            }
+        }
+    } except Exception as e {
+        logger.debug(f"MongoDB query failed: {e}");
+    }
+}
+
+"""Get all root anchors."""
+impl MongoBackend.get_roots -> Generator[Root, None, None] {
+    for anchor in self.query() {
+        if isinstance(anchor.archetype, Root) {
+            yield cast(Root, anchor.archetype);
+        }
+    }
+}
+
+"""Find anchors by IDs with optional filter."""
+impl MongoBackend.find(
+    ids: (UUID | Iterable[UUID]), filter: (Callable[[Anchor], Anchor] | None) = None
+) -> Generator[Anchor, None, None] {
+    id_list = [ids] if isinstance(ids, UUID) else list(ids);
+    for id in id_list {
+        if (anchor := self.get(id)) {
+            if filter is None or filter(anchor) {
+                yield anchor;
+            }
+        }
+    }
+}
+
+"""Find one anchor by ID(s) with optional filter."""
+impl MongoBackend.find_one(
+    ids: (UUID | Iterable[UUID]), filter: (Callable[[Anchor], Anchor] | None) = None
+) -> (Anchor | None) {
+    id_list = [ids] if isinstance(ids, UUID) else list(ids);
+    for id in id_list {
+        if (anchor := self.get(id)) {
+            if filter is None or filter(anchor) {
+                return anchor;
+            }
+        }
+    }
+    return None;
+}
+
+"""Commit - no-op for MongoDB (writes are immediate)."""
+impl MongoBackend.commit(anchor: (Anchor | None) = None) -> None {
+# No-op: MongoDB writes are immediate
+}
+
+# PersistentMemory-specific methods
+"""Sync - no-op for MongoDB (writes are immediate)."""
+impl MongoBackend.sync -> None {
+# No-op: MongoDB writes are immediate
+}
+
+"""Bulk store multiple anchors."""
+impl MongoBackend.bulk_put(anchors: Iterable[Anchor]) -> None {
+    if self.client is None {
+        return;
+    }
+    ops: list = [];
+    for anchor in anchors {
+        if not anchor.persistent {
+            continue;
+        }
+        _id = to_uuid(anchor.id);
+        try {
+            data_blob = dumps(anchor);
+            ops.append(
+                UpdateOne(
+                    {'_id': str(_id)},
+                    {'$set': {'data': data_blob, 'type': type(anchor).__name__}},
+                    upsert=True
+                )
+            );
+        } except Exception as e {
+            logger.debug(f"MongoDB bulk_put serialization failed: {e}");
+        }
+    }
+    if ops {
+        try {
+            self.collection.bulk_write(ops);
+        } except Exception as e {
+            logger.debug(f"MongoDB bulk_write failed: {e}");
+        }
+    }
+}
+
+"""Load anchor from raw MongoDB document."""
+impl MongoBackend._load_anchor(raw: dict[(str, Any)]) -> (Anchor | None) {
+    if 'data' not in raw {
+        return None;
+    }
+    try {
+        data: bytes = raw['data'];
+        return loads(data);
+    } except Exception as e {
+        logger.debug(f"MongoDB _load_anchor failed: {e}");
+        return None;
+    }
+}

jac_scale/impl/memory_hierarchy.redis.impl.jac

@@ -0,0 +1,186 @@
+"""Redis CacheBackend Implementation."""
+import redis;
+import logging;
+import from collections.abc { Callable, Generator, Iterable }
+import from pickle { dumps, loads }
+import from uuid { UUID }
+import from jaclang.pycore.archetype { Anchor, Root }
+import from jaclang.runtimelib.utils { storage_key, to_uuid }
+
+glob logger = logging.getLogger(__name__);
+
+"""Post-initialization: connect to Redis."""
+impl RedisBackend.postinit -> None {
+    if self.redis_url and self.redis_client is None {
+        try {
+            self.redis_client = redis.from_url(self.redis_url);
+        } except Exception as e {
+            logger.debug(f"Redis connection failed: {e}");
+            self.redis_client = None;
+        }
+    }
+}
+
+"""Check if Redis is available and connected."""
+impl RedisBackend.is_available -> bool {
+    if not self.redis_url {
+        return False;
+    }
+    client = None;
+    try {
+        client = redis.from_url(self.redis_url);
+        client.ping();
+        return True;
+    } except Exception as e {
+        logger.debug(f"Redis availability check failed: {e}");
+        return False;
+    } finally {
+        if client {
+            try {
+                client.close();
+            } except Exception { }
+        }
+    }
+}
+
+"""Get anchor by UUID from Redis cache."""
+impl RedisBackend.get(id: UUID) -> (Anchor | None) {
+    if self.redis_client is None {
+        return None;
+    }
+    key = storage_key(to_uuid(id));
+    try {
+        raw = self.redis_client.get(key);
+        if not raw {
+            return None;
+        }
+        return loads(raw);
+    } except Exception as e {
+        logger.debug(f"Redis get failed: {e}");
+        return None;
+    }
+}
+
+"""Store anchor in Redis cache."""
+impl RedisBackend.put(anchor: Anchor) -> None {
+    if self.redis_client is None {
+        return;
+    }
+    try {
+        data = dumps(anchor);
+        key = storage_key(anchor.id);
+        self.redis_client.set(key, data);
+    } except Exception as e {
+        logger.debug(f"Redis put failed: {e}");
+    }
+}
+
+"""Delete anchor from Redis cache."""
+impl RedisBackend.delete(id: UUID) -> None {
+    if self.redis_client is None {
+        return;
+    }
+    try {
+        key = storage_key(to_uuid(id));
+        self.redis_client.delete(key);
+    } except Exception as e {
+        logger.debug(f"Redis delete failed: {e}");
+    }
+}
+
+"""Close Redis connection."""
+impl RedisBackend.close -> None {
+    if self.redis_client {
+        try {
+            self.redis_client.close();
+        } except Exception as e {
+            logger.warning(f"Error closing Redis connection: {e}");
+        }
+        self.redis_client = None;
+    }
+}
+
+"""Check if an anchor is in the cache."""
+impl RedisBackend.has(id: UUID) -> bool {
+    return self.exists(id);
+}
+
+"""Query all anchors - not supported for distributed cache."""
+impl RedisBackend.query(
+    filter: (Callable[[Anchor], bool] | None) = None
+) -> Generator[Anchor, None, None] {
+    # Redis doesn't support iteration efficiently
+    return;
+    yield ;
+}
+
+"""Get all root anchors - not supported for distributed cache."""
+impl RedisBackend.get_roots -> Generator[Root, None, None] {
+    return;
+    yield ;
+}
+
+"""Find anchors by IDs with optional filter."""
+impl RedisBackend.find(
+    ids: (UUID | Iterable[UUID]), filter: (Callable[[Anchor], Anchor] | None) = None
+) -> Generator[Anchor, None, None] {
+    id_list = [ids] if isinstance(ids, UUID) else list(ids);
+    for id in id_list {
+        if (anchor := self.get(id)) {
+            if filter is None or filter(anchor) {
+                yield anchor;
+            }
+        }
+    }
+}
+
+"""Find one anchor by ID(s) with optional filter."""
+impl RedisBackend.find_one(
+    ids: (UUID | Iterable[UUID]), filter: (Callable[[Anchor], Anchor] | None) = None
+) -> (Anchor | None) {
+    id_list = [ids] if isinstance(ids, UUID) else list(ids);
+    for id in id_list {
+        if (anchor := self.get(id)) {
+            if filter is None or filter(anchor) {
+                return anchor;
+            }
+        }
+    }
+    return None;
+}
+
+"""Commit - no-op for cache."""
+impl RedisBackend.commit(anchor: (Anchor | None) = None) -> None {
+# No-op: cache doesn't need commit
+}
+
+# CacheMemory-specific methods
+"""Check if key exists in cache."""
+impl RedisBackend.exists(id: UUID) -> bool {
+    if self.redis_client is None {
+        return False;
+    }
+    try {
+        key = storage_key(to_uuid(id));
+        return bool(self.redis_client.exists(key));
+    } except Exception {
+        return False;
+    }
+}
+
+"""Store anchor only if it already exists in cache."""
+impl RedisBackend.put_if_exists(anchor: Anchor) -> bool {
+    if self.redis_client is None {
+        return False;
+    }
+    if not self.exists(anchor.id) {
+        return False;
+    }
+    self.put(anchor);
+    return True;
+}
+
+"""Remove an entry from cache."""
+impl RedisBackend.invalidate(id: UUID) -> None {
+    self.delete(id);
+}