hivemind-sqlite-database 0.0.3a1__tar.gz → 0.2.1__tar.gz

hivemind_sqlite_database-0.2.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: hivemind-sqlite-database
+Version: 0.2.1
+Summary: sqlite database plugin for hivemind-core
+Author-email: jarbasAi <jarbasai@mailfence.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/JarbasHiveMind/hivemind-sqlite-database
+Requires-Python: >=3.9
+License-File: LICENSE.md
+Requires-Dist: hivemind-plugin-manager<1.0.0,>=0.1.0
+Requires-Dist: hivemind-bus-client
+Requires-Dist: ovos-utils
+Dynamic: license-file

{hivemind-sqlite-database-0.0.3a1 → hivemind_sqlite_database-0.2.1}/hivemind_sqlite_database/__init__.py

@@ -1,6 +1,7 @@
 import json
 import os.path
 import sqlite3
+import threading
 from typing import List, Union, Iterable
 
 from ovos_utils.log import LOG
@@ -10,6 +11,13 @@ from hivemind_plugin_manager.database import Client, AbstractDB
 
 from dataclasses import dataclass
 
+_VALID_COLUMNS = frozenset({
+    "client_id", "api_key", "name", "description", "is_admin",
+    "last_seen", "intent_blacklist", "skill_blacklist", "message_blacklist",
+    "allowed_types", "crypto_key", "password",
+    "can_broadcast", "can_escalate", "can_propagate",
+})
+
 
 @dataclass
 class SQLiteDB(AbstractDB):
@@ -25,8 +33,10 @@ class SQLiteDB(AbstractDB):
         LOG.debug(f"sqlite database path: {db_path}")
         os.makedirs(os.path.dirname(db_path), exist_ok=True)
 
-        self.conn = sqlite3.connect(db_path)
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
         self.conn.row_factory = sqlite3.Row
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self._write_lock = threading.Lock()
         self._initialize_database()
 
     def _initialize_database(self):
@@ -65,7 +75,7 @@ class SQLiteDB(AbstractDB):
             True if the addition was successful, False otherwise.
         """
         try:
-            with self.conn:
+            with self._write_lock, self.conn:
                 self.conn.execute("""
                     INSERT OR REPLACE INTO clients (
                         client_id, api_key, name, description, is_admin,
@@ -99,6 +109,9 @@ class SQLiteDB(AbstractDB):
         Returns:
             A list of clients that match the search criteria.
         """
+        if key not in _VALID_COLUMNS:
+            LOG.error(f"Invalid search key: {key!r}")
+            return []
         try:
             with self.conn:
                 cur = self.conn.execute(f"SELECT * FROM clients WHERE {key} = ?", (val,))
@@ -110,8 +123,12 @@ class SQLiteDB(AbstractDB):
 
     def __len__(self) -> int:
         """Get the number of clients in the database."""
-        cur = self.conn.execute("SELECT COUNT(*) FROM clients")
-        return cur.fetchone()[0]
+        try:
+            cur = self.conn.execute("SELECT COUNT(*) FROM clients")
+            return cur.fetchone()[0]
+        except sqlite3.Error as e:
+            LOG.error(f"Failed to count clients in SQLite: {e}")
+            return 0
 
     def __iter__(self) -> Iterable['Client']:
         """
@@ -127,7 +144,8 @@ class SQLiteDB(AbstractDB):
     def commit(self) -> bool:
         """Commit changes to the SQLite database."""
         try:
-            self.conn.commit()
+            with self._write_lock:
+                self.conn.commit()
             return True
         except sqlite3.Error as e:
             LOG.error(f"Failed to commit SQLite database: {e}")
@@ -141,7 +159,7 @@ class SQLiteDB(AbstractDB):
             api_key=row["api_key"],
             name=row["name"],
             description=row["description"],
-            is_admin=row["is_admin"] or False,
+            is_admin=bool(row["is_admin"]),
             last_seen=row["last_seen"],
             intent_blacklist=json.loads(row["intent_blacklist"] or "[]"),
             skill_blacklist=json.loads(row["skill_blacklist"] or "[]"),
@@ -149,7 +167,7 @@ class SQLiteDB(AbstractDB):
             allowed_types=json.loads(row["allowed_types"] or "[]"),
             crypto_key=row["crypto_key"],
             password=row["password"],
-            can_broadcast=row["can_broadcast"],
-            can_escalate=row["can_escalate"],
-            can_propagate=row["can_propagate"]
+            can_broadcast=bool(row["can_broadcast"]),
+            can_escalate=bool(row["can_escalate"]),
+            can_propagate=bool(row["can_propagate"])
         )

hivemind_sqlite_database-0.2.1/hivemind_sqlite_database/version.py

@@ -0,0 +1,8 @@
+# START_VERSION_BLOCK
+VERSION_MAJOR = 0
+VERSION_MINOR = 2
+VERSION_BUILD = 1
+VERSION_ALPHA = 0
+# END_VERSION_BLOCK
+
+__version__ = f"{VERSION_MAJOR}.{VERSION_MINOR}.{VERSION_BUILD}" + (f"a{VERSION_ALPHA}" if VERSION_ALPHA else "")

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

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: hivemind-sqlite-database
+Version: 0.2.1
+Summary: sqlite database plugin for hivemind-core
+Author-email: jarbasAi <jarbasai@mailfence.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/JarbasHiveMind/hivemind-sqlite-database
+Requires-Python: >=3.9
+License-File: LICENSE.md
+Requires-Dist: hivemind-plugin-manager<1.0.0,>=0.1.0
+Requires-Dist: hivemind-bus-client
+Requires-Dist: ovos-utils
+Dynamic: license-file

{hivemind-sqlite-database-0.0.3a1 → hivemind_sqlite_database-0.2.1}/hivemind_sqlite_database.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE.md
 README.md
-setup.py
+pyproject.toml
 hivemind_sqlite_database/__init__.py
 hivemind_sqlite_database/version.py
 hivemind_sqlite_database.egg-info/PKG-INFO
@@ -8,4 +8,5 @@ hivemind_sqlite_database.egg-info/SOURCES.txt
 hivemind_sqlite_database.egg-info/dependency_links.txt
 hivemind_sqlite_database.egg-info/entry_points.txt
 hivemind_sqlite_database.egg-info/requires.txt
-hivemind_sqlite_database.egg-info/top_level.txt
+hivemind_sqlite_database.egg-info/top_level.txt
+tests/test_sqlitedb.py

hivemind_sqlite_database-0.2.1/hivemind_sqlite_database.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hivemind.database]
+hivemind-sqlite-db-plugin = hivemind_sqlite_database:SQLiteDB

{hivemind-sqlite-database-0.0.3a1 → hivemind_sqlite_database-0.2.1}/hivemind_sqlite_database.egg-info/requires.txt

@@ -1 +1,3 @@
 hivemind-plugin-manager<1.0.0,>=0.1.0
+hivemind-bus-client
+ovos-utils

hivemind_sqlite_database-0.2.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hivemind-sqlite-database"
+dynamic = ["version"]
+description = "sqlite database plugin for hivemind-core"
+license = { text = "Apache-2.0" }
+authors = [{ name = "jarbasAi", email = "jarbasai@mailfence.com" }]
+requires-python = ">=3.9"
+dependencies = [
+    "hivemind-plugin-manager>=0.1.0,<1.0.0",
+    "hivemind-bus-client",
+    "ovos-utils",
+]
+
+
+[project.urls]
+Homepage = "https://github.com/JarbasHiveMind/hivemind-sqlite-database"
+
+[project.entry-points."hivemind.database"]
+"hivemind-sqlite-db-plugin" = "hivemind_sqlite_database:SQLiteDB"
+
+[tool.setuptools.dynamic]
+version = {attr = "hivemind_sqlite_database.version.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hivemind_sqlite_database*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

hivemind_sqlite_database-0.2.1/tests/test_sqlitedb.py

@@ -0,0 +1,306 @@
+"""
+Tests for SQLiteDB using an in-memory database.
+No external services required.
+"""
+import sqlite3
+import tempfile
+import threading
+import os
+import unittest
+
+from hivemind_plugin_manager.database import Client
+from hivemind_sqlite_database import SQLiteDB
+
+
+def make_db() -> SQLiteDB:
+    """Return a fresh in-memory SQLiteDB instance."""
+    db = object.__new__(SQLiteDB)
+    db.name = "clients"
+    db.subfolder = "hivemind-core"
+    db.conn = sqlite3.connect(":memory:", check_same_thread=False)
+    db.conn.row_factory = sqlite3.Row
+    db.conn.execute("PRAGMA journal_mode=WAL")
+    db._write_lock = threading.Lock()
+    db._initialize_database()
+    return db
+
+
+def make_client(client_id: int = 1, api_key: str = "key-abc", **kwargs) -> Client:
+    return Client(client_id=client_id, api_key=api_key, **kwargs)
+
+
+class TestSQLiteDBWAL(unittest.TestCase):
+    def test_wal_mode_pragma_in_source(self):
+        """WAL pragma must be present in __post_init__ source code."""
+        import inspect
+        from hivemind_sqlite_database import SQLiteDB as _DB
+        src = inspect.getsource(_DB.__post_init__)
+        self.assertIn("journal_mode=WAL", src)
+
+    def test_wal_mode_active_on_file_db(self):
+        """WAL mode is confirmed active on a real file-based SQLite DB."""
+        with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+            path = f.name
+        try:
+            conn = sqlite3.connect(path, check_same_thread=False)
+            conn.row_factory = sqlite3.Row
+            conn.execute("PRAGMA journal_mode=WAL")
+            cur = conn.execute("PRAGMA journal_mode")
+            mode = cur.fetchone()[0]
+            conn.close()
+            self.assertEqual(mode, "wal")
+        finally:
+            os.unlink(path)
+
+
+class TestSQLiteDBLen(unittest.TestCase):
+    def test_empty_db_has_len_zero(self):
+        db = make_db()
+        self.assertEqual(len(db), 0)
+
+    def test_len_increments_after_add(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1"))
+        db.add_item(make_client(2, "k2"))
+        self.assertEqual(len(db), 2)
+
+    def test_len_includes_revoked_entries(self):
+        db = make_db()
+        c = make_client(1, "k1")
+        db.add_item(c)
+        db.delete_item(c)
+        self.assertEqual(len(db), 1)
+
+    def test_len_returns_zero_on_error(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1"))
+        db.conn.close()
+        self.assertEqual(len(db), 0)
+
+
+class TestSQLiteDBAddItem(unittest.TestCase):
+    def test_add_returns_true_on_success(self):
+        db = make_db()
+        result = db.add_item(make_client(1, "key"))
+        self.assertTrue(result)
+
+    def test_add_upserts_existing_client_id(self):
+        db = make_db()
+        db.add_item(make_client(1, "original"))
+        db.add_item(make_client(1, "updated"))
+        results = db.search_by_value("api_key", "updated")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].api_key, "updated")
+        # original key is gone
+        self.assertEqual(db.search_by_value("api_key", "original"), [])
+
+    def test_add_returns_false_on_error(self):
+        db = make_db()
+        db.conn.close()  # closing the connection causes sqlite3.Error on next operation
+        result = db.add_item(make_client(1, "key"))
+        self.assertFalse(result)
+
+
+class TestSQLiteDBDeleteItem(unittest.TestCase):
+    def test_delete_sets_api_key_to_revoked(self):
+        db = make_db()
+        c = make_client(1, "live-key")
+        db.add_item(c)
+        db.delete_item(c)
+        results = db.search_by_value("api_key", "revoked")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].client_id, 1)
+
+    def test_delete_does_not_remove_row(self):
+        db = make_db()
+        c = make_client(1, "live-key")
+        db.add_item(c)
+        db.delete_item(c)
+        self.assertEqual(len(db), 1)
+
+    def test_original_key_no_longer_searchable_after_delete(self):
+        db = make_db()
+        c = make_client(1, "live-key")
+        db.add_item(c)
+        db.delete_item(c)
+        self.assertEqual(db.search_by_value("api_key", "live-key"), [])
+
+
+class TestSQLiteDBSearchByValue(unittest.TestCase):
+    def test_search_by_api_key_returns_client(self):
+        db = make_db()
+        db.add_item(make_client(1, "my-key"))
+        results = db.search_by_value("api_key", "my-key")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].api_key, "my-key")
+
+    def test_search_returns_empty_list_on_no_match(self):
+        db = make_db()
+        db.add_item(make_client(1, "real-key"))
+        self.assertEqual(db.search_by_value("api_key", "ghost"), [])
+
+    def test_search_by_is_admin_true(self):
+        db = make_db()
+        db.add_item(make_client(1, "admin-key", is_admin=True))
+        db.add_item(make_client(2, "user-key", is_admin=False))
+        results = db.search_by_value("is_admin", True)
+        self.assertEqual(len(results), 1)
+        self.assertTrue(results[0].is_admin)
+
+    def test_search_by_is_admin_false(self):
+        db = make_db()
+        db.add_item(make_client(1, "admin-key", is_admin=True))
+        db.add_item(make_client(2, "user-key", is_admin=False))
+        results = db.search_by_value("is_admin", False)
+        self.assertEqual(len(results), 1)
+        self.assertFalse(results[0].is_admin)
+
+    def test_search_by_name(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1", name="alice"))
+        db.add_item(make_client(2, "k2", name="bob"))
+        results = db.search_by_value("name", "alice")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].name, "alice")
+
+    def test_search_by_nonexistent_name_returns_empty(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1", name="alice"))
+        self.assertEqual(db.search_by_value("name", "ghost"), [])
+
+    def test_search_returns_empty_on_sqlite_error(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1"))
+        db.conn.close()
+        results = db.search_by_value("api_key", "k1")
+        self.assertEqual(results, [])
+
+    def test_search_rejects_invalid_column_name(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1"))
+        results = db.search_by_value("1=1; DROP TABLE clients; --", "x")
+        self.assertEqual(results, [])
+        # table must still exist
+        self.assertEqual(len(db), 1)
+
+    def test_search_rejects_unknown_column(self):
+        db = make_db()
+        results = db.search_by_value("nonexistent_column", "value")
+        self.assertEqual(results, [])
+
+
+class TestSQLiteDBIter(unittest.TestCase):
+    def test_iter_yields_all_rows(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1"))
+        db.add_item(make_client(2, "k2"))
+        all_clients = list(db)
+        self.assertEqual(len(all_clients), 2)
+
+    def test_iter_includes_revoked_entries(self):
+        db = make_db()
+        c = make_client(1, "k1")
+        db.add_item(c)
+        db.delete_item(c)
+        all_clients = list(db)
+        self.assertEqual(len(all_clients), 1)
+        self.assertEqual(all_clients[0].api_key, "revoked")
+
+    def test_iter_yields_client_instances(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1"))
+        for client in db:
+            self.assertIsInstance(client, Client)
+
+
+class TestSQLiteDBRoundTrip(unittest.TestCase):
+    def test_list_fields_survive_round_trip(self):
+        db = make_db()
+        intent_bl = ["skill:action1", "skill:action2"]
+        allowed = ["recognizer_loop:utterance", "speak:b64_audio"]
+        c = make_client(1, "k1",
+                        intent_blacklist=intent_bl,
+                        allowed_types=allowed)
+        db.add_item(c)
+        results = db.search_by_value("api_key", "k1")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].intent_blacklist, intent_bl)
+        self.assertEqual(results[0].allowed_types, allowed)
+
+    def test_boolean_fields_remain_bool_after_round_trip(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1", is_admin=True, can_broadcast=False))
+        results = db.search_by_value("api_key", "k1")
+        self.assertIs(type(results[0].is_admin), bool)
+        self.assertTrue(results[0].is_admin)
+        self.assertIs(type(results[0].can_broadcast), bool)
+        self.assertFalse(results[0].can_broadcast)
+
+    def test_full_client_fields_preserved(self):
+        db = make_db()
+        c = Client(
+            client_id=42,
+            api_key="full-key",
+            name="test-client",
+            description="a test",
+            is_admin=False,
+            last_seen=1234567890.0,
+            intent_blacklist=["a:b"],
+            skill_blacklist=["c:d"],
+            message_blacklist=["e:f"],
+            allowed_types=["recognizer_loop:utterance"],
+            crypto_key="1234567890123456",
+            password="secret",
+            can_broadcast=True,
+            can_escalate=False,
+            can_propagate=True,
+        )
+        db.add_item(c)
+        results = db.search_by_value("api_key", "full-key")
+        self.assertEqual(len(results), 1)
+        r = results[0]
+        self.assertEqual(r.client_id, 42)
+        self.assertEqual(r.name, "test-client")
+        self.assertEqual(r.description, "a test")
+        self.assertFalse(r.is_admin)
+        self.assertEqual(r.last_seen, 1234567890.0)
+        self.assertEqual(r.crypto_key, "1234567890123456")
+        self.assertEqual(r.password, "secret")
+        self.assertFalse(r.can_escalate)
+
+
+class TestSQLiteDBCommit(unittest.TestCase):
+    def test_commit_returns_true(self):
+        db = make_db()
+        self.assertTrue(db.commit())
+
+    def test_commit_returns_false_on_error(self):
+        db = make_db()
+        db.conn.close()
+        result = db.commit()
+        self.assertFalse(result)
+
+
+class TestSQLiteDBUpdateAndReplace(unittest.TestCase):
+    def test_update_item_changes_fields(self):
+        db = make_db()
+        db.add_item(make_client(1, "k1", name="old"))
+        updated = make_client(1, "k1", name="new")
+        db.update_item(updated)
+        results = db.search_by_value("name", "new")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].name, "new")
+
+    def test_replace_item(self):
+        db = make_db()
+        old = make_client(1, "old-key")
+        new = make_client(2, "new-key")
+        db.add_item(old)
+        db.replace_item(old, new)
+        self.assertEqual(db.search_by_value("api_key", "new-key")[0].client_id, 2)
+        # old entry is revoked, not gone
+        self.assertEqual(db.search_by_value("api_key", "revoked")[0].client_id, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

hivemind-sqlite-database-0.0.3a1/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 1.0
-Name: hivemind-sqlite-database
-Version: 0.0.3a1
-Summary: sqlite database plugin for hivemind-core
-Home-page: https://github.com/JarbasHiveMind/hivemind-sqlite-database
-Author: jarbasAi
-Author-email: jarbasai@mailfence.com
-License: Apache-2.0
-Description: UNKNOWN
-Platform: UNKNOWN

hivemind-sqlite-database-0.0.3a1/hivemind_sqlite_database/version.py

@@ -1,6 +0,0 @@
-# START_VERSION_BLOCK
-VERSION_MAJOR = 0
-VERSION_MINOR = 0
-VERSION_BUILD = 3
-VERSION_ALPHA = 1
-# END_VERSION_BLOCK

hivemind-sqlite-database-0.0.3a1/hivemind_sqlite_database.egg-info/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 1.0
-Name: hivemind-sqlite-database
-Version: 0.0.3a1
-Summary: sqlite database plugin for hivemind-core
-Home-page: https://github.com/JarbasHiveMind/hivemind-sqlite-database
-Author: jarbasAi
-Author-email: jarbasai@mailfence.com
-License: Apache-2.0
-Description: UNKNOWN
-Platform: UNKNOWN

hivemind-sqlite-database-0.0.3a1/hivemind_sqlite_database.egg-info/entry_points.txt

@@ -1,3 +0,0 @@
-[hivemind.database]
-hivemind-sqlite-db-plugin=hivemind_sqlite_database:SQLiteDB
-

hivemind-sqlite-database-0.0.3a1/setup.py

@@ -1,55 +0,0 @@
-import os
-from setuptools import setup
-
-BASEDIR = os.path.abspath(os.path.dirname(__file__))
-
-
-def get_version():
-    """ Find the version of the package"""
-    version_file = os.path.join(BASEDIR, 'hivemind_sqlite_database', 'version.py')
-    major, minor, build, alpha = (None, None, None, None)
-    with open(version_file) as f:
-        for line in f:
-            if 'VERSION_MAJOR' in line:
-                major = line.split('=')[1].strip()
-            elif 'VERSION_MINOR' in line:
-                minor = line.split('=')[1].strip()
-            elif 'VERSION_BUILD' in line:
-                build = line.split('=')[1].strip()
-            elif 'VERSION_ALPHA' in line:
-                alpha = line.split('=')[1].strip()
-
-            if ((major and minor and build and alpha) or
-                    '# END_VERSION_BLOCK' in line):
-                break
-    version = f"{major}.{minor}.{build}"
-    if int(alpha) > 0:
-        version += f"a{alpha}"
-    return version
-
-
-def required(requirements_file):
-    """ Read requirements file and remove comments and empty lines. """
-    with open(os.path.join(BASEDIR, requirements_file), 'r') as f:
-        requirements = f.read().splitlines()
-        if 'MYCROFT_LOOSE_REQUIREMENTS' in os.environ:
-            print('USING LOOSE REQUIREMENTS!')
-            requirements = [r.replace('==', '>=').replace('~=', '>=') for r in requirements]
-        return [pkg for pkg in requirements
-                if pkg.strip() and not pkg.startswith("#")]
-
-
-PLUGIN_ENTRY_POINT = 'hivemind-sqlite-db-plugin=hivemind_sqlite_database:SQLiteDB'
-
-setup(
-    name='hivemind-sqlite-database',
-    version=get_version(),
-    packages=['hivemind_sqlite_database'],
-    url='https://github.com/JarbasHiveMind/hivemind-sqlite-database',
-    license='Apache-2.0',
-    author='jarbasAi',
-    install_requires=required("requirements.txt"),
-    entry_points={'hivemind.database': PLUGIN_ENTRY_POINT},
-    author_email='jarbasai@mailfence.com',
-    description='sqlite database plugin for hivemind-core'
-)