nonebot-plugin-onebot-luckperms 0.1.0__py3-none-any.whl

nonebot_plugin_onebot_luckperms/storage/memory.py

@@ -0,0 +1,46 @@
+from typing import Optional, List, Dict
+
+from ..core.models import User, Group, PermissionNode
+
+
+class MemoryStore:
+    def __init__(self):
+        self._users: Dict[str, User] = {}
+        self._groups: Dict[str, Group] = {}
+        self._registered_nodes: Dict[str, PermissionNode] = {}
+
+    async def get_user(self, user_id: str) -> Optional[User]:
+        return self._users.get(user_id)
+
+    async def save_user(self, user: User) -> None:
+        self._users[user.user_id] = user
+
+    async def delete_user(self, user_id: str) -> None:
+        self._users.pop(user_id, None)
+
+    async def list_users(self) -> List[str]:
+        return list(self._users.keys())
+
+    async def get_group(self, name: str) -> Optional[Group]:
+        return self._groups.get(name)
+
+    async def save_group(self, group: Group) -> None:
+        self._groups[group.name] = group
+
+    async def delete_group(self, name: str) -> None:
+        self._groups.pop(name, None)
+
+    async def list_groups(self) -> List[str]:
+        return list(self._groups.keys())
+
+    async def get_registered_nodes(self) -> List[PermissionNode]:
+        return list(self._registered_nodes.values())
+
+    async def save_registered_node(self, node: PermissionNode) -> None:
+        self._registered_nodes[node.key] = node
+
+    async def load_all(self) -> None:
+        pass
+
+    async def save_all(self) -> None:
+        pass

nonebot_plugin_onebot_luckperms/storage/protocol.py

@@ -0,0 +1,21 @@
+from typing import Protocol, Optional, List, Dict, Any
+
+from ..core.models import User, Group, PermissionNode
+
+
+class PermissionStore(Protocol):
+    async def get_user(self, user_id: str) -> Optional[User]: ...
+    async def save_user(self, user: User) -> None: ...
+    async def delete_user(self, user_id: str) -> None: ...
+    async def list_users(self) -> List[str]: ...
+
+    async def get_group(self, name: str) -> Optional[Group]: ...
+    async def save_group(self, group: Group) -> None: ...
+    async def delete_group(self, name: str) -> None: ...
+    async def list_groups(self) -> List[str]: ...
+
+    async def get_registered_nodes(self) -> List[PermissionNode]: ...
+    async def save_registered_node(self, node: PermissionNode) -> None: ...
+
+    async def load_all(self) -> None: ...
+    async def save_all(self) -> None: ...

nonebot_plugin_onebot_luckperms/storage/redis.py

@@ -0,0 +1,162 @@
+import json
+import logging
+import time
+from typing import Optional, List
+
+import redis.asyncio as aioredis
+
+from ..core.models import User, Group, PermissionNode, ContextSet
+
+logger = logging.getLogger("oblp")
+
+
+class RedisStore:
+    def __init__(self, url: str = "redis://localhost:6379/0"):
+        self.url = url
+        self._redis: Optional[aioredis.Redis] = None
+        self._prefix = "oblp"
+
+    async def _get_redis(self) -> aioredis.Redis:
+        if self._redis is None:
+            self._redis = aioredis.from_url(self.url, decode_responses=True)
+        return self._redis
+
+    async def _set_ttl(self, key: str, node: PermissionNode):
+        if node.expiry is not None:
+            ttl = int(node.expiry - time.time())
+            if ttl > 0:
+                r = await self._get_redis()
+                await r.expire(key, ttl)
+
+    async def get_user(self, user_id: str) -> Optional[User]:
+        r = await self._get_redis()
+        data = await r.hgetall(f"{self._prefix}:user:{user_id}")
+        if not data:
+            return None
+        return User(
+            user_id=data.get("user_id", user_id),
+            username=data.get("username"),
+            primary_group=data.get("primary_group"),
+            groups=json.loads(data.get("groups", "[]")),
+            nodes=[self._node_from_dict(n) for n in json.loads(data.get("nodes", "[]"))],
+        )
+
+    async def save_user(self, user: User) -> None:
+        r = await self._get_redis()
+        key = f"{self._prefix}:user:{user.user_id}"
+        await r.hset(
+            key,
+            mapping={
+                "user_id": user.user_id,
+                "username": user.username or "",
+                "primary_group": user.primary_group or "",
+                "groups": json.dumps(user.groups),
+                "nodes": json.dumps([self._node_to_dict(n) for n in user.nodes]),
+            },
+        )
+        max_expiry = min((n.expiry for n in user.nodes if n.expiry), default=None)
+        if max_expiry:
+            await r.expire(key, int(max_expiry - time.time()))
+
+    async def delete_user(self, user_id: str) -> None:
+        r = await self._get_redis()
+        await r.delete(f"{self._prefix}:user:{user_id}")
+
+    async def list_users(self) -> List[str]:
+        r = await self._get_redis()
+        cursor = "0"
+        keys = []
+        while cursor != 0:
+            cursor, batch = await r.scan(cursor=cursor, match=f"{self._prefix}:user:*")
+            keys.extend([k.split(":", 2)[2] for k in batch])
+            cursor = int(cursor)
+        return keys
+
+    async def get_group(self, name: str) -> Optional[Group]:
+        r = await self._get_redis()
+        data = await r.hgetall(f"{self._prefix}:group:{name}")
+        if not data:
+            return None
+        return Group(
+            name=name,
+            display_name=data.get("display_name"),
+            weight=int(data.get("weight", 0)),
+            parents=json.loads(data.get("parents", "[]")),
+            nodes=[self._node_from_dict(n) for n in json.loads(data.get("nodes", "[]"))],
+        )
+
+    async def save_group(self, group: Group) -> None:
+        r = await self._get_redis()
+        key = f"{self._prefix}:group:{group.name}"
+        await r.hset(
+            key,
+            mapping={
+                "display_name": group.display_name or "",
+                "weight": str(group.weight),
+                "parents": json.dumps(group.parents),
+                "nodes": json.dumps([self._node_to_dict(n) for n in group.nodes]),
+            },
+        )
+        max_expiry = min((n.expiry for n in group.nodes if n.expiry), default=None)
+        if max_expiry:
+            await r.expire(key, int(max_expiry - time.time()))
+
+    async def delete_group(self, name: str) -> None:
+        r = await self._get_redis()
+        await r.delete(f"{self._prefix}:group:{name}")
+
+    async def list_groups(self) -> List[str]:
+        r = await self._get_redis()
+        cursor = "0"
+        keys = []
+        while cursor != 0:
+            cursor, batch = await r.scan(cursor=cursor, match=f"{self._prefix}:group:*")
+            keys.extend([k.split(":", 2)[2] for k in batch])
+            cursor = int(cursor)
+        return keys
+
+    async def get_registered_nodes(self) -> List[PermissionNode]:
+        r = await self._get_redis()
+        raw = await r.get(f"{self._prefix}:registry")
+        if not raw:
+            return []
+        return [self._node_from_dict(n) for n in json.loads(raw)]
+
+    async def save_registered_node(self, node: PermissionNode) -> None:
+        existing = await self.get_registered_nodes()
+        existing_dict = {n.key: n for n in existing}
+        existing_dict[node.key] = node
+        r = await self._get_redis()
+        await r.set(
+            f"{self._prefix}:registry",
+            json.dumps([self._node_to_dict(n) for n in existing_dict.values()]),
+        )
+
+    async def load_all(self) -> None:
+        pass
+
+    async def save_all(self) -> None:
+        pass
+
+    async def close(self):
+        if self._redis is not None:
+            await self._redis.close()
+            self._redis = None
+
+    @staticmethod
+    def _node_to_dict(node: PermissionNode) -> dict:
+        return {
+            "key": node.key,
+            "value": node.value,
+            "expiry": node.expiry,
+            "contexts": node.contexts.to_dict(),
+        }
+
+    @staticmethod
+    def _node_from_dict(d: dict) -> PermissionNode:
+        return PermissionNode(
+            key=d["key"],
+            value=d.get("value", True),
+            expiry=d.get("expiry"),
+            contexts=ContextSet.from_dict(d.get("contexts", {})),
+        )

nonebot_plugin_onebot_luckperms/storage/sqlite.py

@@ -0,0 +1,189 @@
+import json
+import logging
+from pathlib import Path
+from typing import Optional, List, Dict
+
+import aiosqlite
+
+from ..core.models import User, Group, PermissionNode, ContextSet
+
+logger = logging.getLogger("oblp")
+
+
+class SQLiteStore:
+    def __init__(self, db_path: str = "./data/oblp/permissions.db"):
+        self.db_path = db_path
+        self._conn: Optional[aiosqlite.Connection] = None
+
+    async def _ensure_dir(self):
+        p = Path(self.db_path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+
+    async def _get_conn(self) -> aiosqlite.Connection:
+        if self._conn is None:
+            await self._ensure_dir()
+            self._conn = await aiosqlite.connect(self.db_path)
+            self._conn.row_factory = aiosqlite.Row
+        return self._conn
+
+    async def _init_tables(self):
+        conn = await self._get_conn()
+        await conn.executescript("""
+            CREATE TABLE IF NOT EXISTS users (
+                user_id TEXT PRIMARY KEY,
+                username TEXT,
+                primary_group TEXT,
+                groups_json TEXT NOT NULL DEFAULT '[]',
+                nodes_json TEXT NOT NULL DEFAULT '[]'
+            );
+            CREATE TABLE IF NOT EXISTS groups (
+                name TEXT PRIMARY KEY,
+                display_name TEXT,
+                weight INTEGER NOT NULL DEFAULT 0,
+                parents_json TEXT NOT NULL DEFAULT '[]',
+                nodes_json TEXT NOT NULL DEFAULT '[]'
+            );
+            CREATE TABLE IF NOT EXISTS meta (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL
+            );
+        """)
+        await conn.commit()
+
+    async def get_user(self, user_id: str) -> Optional[User]:
+        await self._init_tables()
+        conn = await self._get_conn()
+        cursor = await conn.execute("SELECT * FROM users WHERE user_id = ?", (user_id,))
+        row = await cursor.fetchone()
+        if row is None:
+            return None
+        return User(
+            user_id=row["user_id"],
+            username=row["username"],
+            primary_group=row["primary_group"],
+            groups=json.loads(row["groups_json"]),
+            nodes=[self._node_from_dict(n) for n in json.loads(row["nodes_json"])],
+        )
+
+    async def save_user(self, user: User) -> None:
+        await self._init_tables()
+        conn = await self._get_conn()
+        await conn.execute(
+            """INSERT OR REPLACE INTO users (user_id, username, primary_group, groups_json, nodes_json)
+               VALUES (?, ?, ?, ?, ?)""",
+            (
+                user.user_id,
+                user.username,
+                user.primary_group,
+                json.dumps(user.groups),
+                json.dumps([self._node_to_dict(n) for n in user.nodes]),
+            ),
+        )
+        await conn.commit()
+
+    async def delete_user(self, user_id: str) -> None:
+        await self._init_tables()
+        conn = await self._get_conn()
+        await conn.execute("DELETE FROM users WHERE user_id = ?", (user_id,))
+        await conn.commit()
+
+    async def list_users(self) -> List[str]:
+        await self._init_tables()
+        conn = await self._get_conn()
+        cursor = await conn.execute("SELECT user_id FROM users")
+        rows = await cursor.fetchall()
+        return [row["user_id"] for row in rows]
+
+    async def get_group(self, name: str) -> Optional[Group]:
+        await self._init_tables()
+        conn = await self._get_conn()
+        cursor = await conn.execute("SELECT * FROM groups WHERE name = ?", (name,))
+        row = await cursor.fetchone()
+        if row is None:
+            return None
+        return Group(
+            name=row["name"],
+            display_name=row["display_name"],
+            weight=row["weight"],
+            parents=json.loads(row["parents_json"]),
+            nodes=[self._node_from_dict(n) for n in json.loads(row["nodes_json"])],
+        )
+
+    async def save_group(self, group: Group) -> None:
+        await self._init_tables()
+        conn = await self._get_conn()
+        await conn.execute(
+            """INSERT OR REPLACE INTO groups (name, display_name, weight, parents_json, nodes_json)
+               VALUES (?, ?, ?, ?, ?)""",
+            (
+                group.name,
+                group.display_name,
+                group.weight,
+                json.dumps(group.parents),
+                json.dumps([self._node_to_dict(n) for n in group.nodes]),
+            ),
+        )
+        await conn.commit()
+
+    async def delete_group(self, name: str) -> None:
+        await self._init_tables()
+        conn = await self._get_conn()
+        await conn.execute("DELETE FROM groups WHERE name = ?", (name,))
+        await conn.commit()
+
+    async def list_groups(self) -> List[str]:
+        await self._init_tables()
+        conn = await self._get_conn()
+        cursor = await conn.execute("SELECT name FROM groups")
+        rows = await cursor.fetchall()
+        return [row["name"] for row in rows]
+
+    async def get_registered_nodes(self) -> List[PermissionNode]:
+        await self._init_tables()
+        conn = await self._get_conn()
+        cursor = await conn.execute("SELECT value FROM meta WHERE key = 'registered_nodes'")
+        row = await cursor.fetchone()
+        if row is None:
+            return []
+        return [self._node_from_dict(n) for n in json.loads(row["value"])]
+
+    async def save_registered_node(self, node: PermissionNode) -> None:
+        await self._init_tables()
+        existing = await self.get_registered_nodes()
+        existing_dict = {n.key: n for n in existing}
+        existing_dict[node.key] = node
+        conn = await self._get_conn()
+        await conn.execute(
+            "INSERT OR REPLACE INTO meta (key, value) VALUES ('registered_nodes', ?)",
+            (json.dumps([self._node_to_dict(n) for n in existing_dict.values()]),),
+        )
+        await conn.commit()
+
+    async def load_all(self) -> None:
+        await self._init_tables()
+
+    async def save_all(self) -> None:
+        await self._init_tables()
+
+    async def close(self):
+        if self._conn is not None:
+            await self._conn.close()
+            self._conn = None
+
+    @staticmethod
+    def _node_to_dict(node: PermissionNode) -> dict:
+        return {
+            "key": node.key,
+            "value": node.value,
+            "expiry": node.expiry,
+            "contexts": node.contexts.to_dict(),
+        }
+
+    @staticmethod
+    def _node_from_dict(d: dict) -> PermissionNode:
+        return PermissionNode(
+            key=d["key"],
+            value=d.get("value", True),
+            expiry=d.get("expiry"),
+            contexts=ContextSet.from_dict(d.get("contexts", {})),
+        )

nonebot_plugin_onebot_luckperms/webeditor/__init__.py

@@ -0,0 +1,9 @@
+from .bytebin import BytebinClient
+from .websocket import BytesocksClient
+from .session import WebEditorSession
+
+__all__ = [
+    "BytebinClient",
+    "BytesocksClient",
+    "WebEditorSession",
+]

nonebot_plugin_onebot_luckperms/webeditor/bytebin.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import gzip
+import json
+import logging
+from typing import Any
+
+import aiohttp
+
+log = logging.getLogger("oblp.webeditor")
+
+DEFAULT_BYTEBIN_URL = "https://usercontent.luckperms.net"
+
+
+class BytebinClient:
+    def __init__(self, base_url: str = DEFAULT_BYTEBIN_URL):
+        self.base_url = base_url.rstrip("/")
+
+    async def upload(self, payload: dict[str, Any]) -> str:
+        json_bytes = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        compressed = gzip.compress(json_bytes)
+
+        headers = {
+            "Content-Type": "application/json",
+            "Content-Encoding": "gzip",
+            "User-Agent": "LuckPerms/5.4.0/editor",
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/post",
+                data=compressed,
+                headers=headers,
+            ) as resp:
+                if resp.status not in (200, 201):
+                    text = await resp.text()
+                    raise RuntimeError(
+                        f"Bytebin upload failed: HTTP {resp.status} - {text}"
+                    )
+
+                key: str | None = None
+                location = resp.headers.get("Location")
+                if location:
+                    key = location.rstrip("/").split("/")[-1]
+
+                if not key:
+                    result = await resp.json()
+                    key = result.get("key") or result.get("code") or result.get("id")
+
+                if not key:
+                    raise RuntimeError(f"Bytebin invalid response: {await resp.text()}")
+                log.info("Bytebin upload OK, key=%s", key)
+                return key
+
+    async def download(self, code: str) -> dict[str, Any]:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{self.base_url}/{code}",
+                headers={"User-Agent": "LuckPerms/5.4.0/editor"},
+            ) as resp:
+                if resp.status != 200:
+                    text = await resp.text()
+                    raise RuntimeError(
+                        f"Bytebin download failed: HTTP {resp.status} - {text}"
+                    )
+                raw = await resp.read()
+                try:
+                    decompressed = gzip.decompress(raw)
+                except Exception:
+                    decompressed = raw
+                return json.loads(decompressed.decode("utf-8"))