apsw-sqlite3mc 3.53.0.0__tar.gz → 3.53.1.0__tar.gz

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apsw_sqlite3mc
-Version: 3.53.0.0
+Version: 3.53.1.0
 Summary: SQLite3 Multiple Ciphers combined with Another Python SQLite Wrapper
 Home-page: https://github.com/utelle/apsw-sqlite3mc
 Author: Ulrich Telle
@@ -89,7 +89,7 @@ Setting the key on a new database is the only change needed to your code.
 
   >>> import apsw
   >>> print(apsw.mc_version)
-  SQLite3 Multiple Ciphers 2.3.3
+  SQLite3 Multiple Ciphers 2.3.4
   >>> con = apsw.Connection("database.sqlite3")
   >>> con.pragma("key", "my secret passphrase")
   ok

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/README.rst

@@ -59,7 +59,7 @@ Setting the key on a new database is the only change needed to your code.
 
   >>> import apsw
   >>> print(apsw.mc_version)
-  SQLite3 Multiple Ciphers 2.3.3
+  SQLite3 Multiple Ciphers 2.3.4
   >>> con = apsw.Connection("database.sqlite3")
   >>> con.pragma("key", "my secret passphrase")
   ok

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/__init__.pyi

@@ -7500,13 +7500,13 @@ class AsyncCursor:
       * :attr:`Cursor.description_full`
       * :attr:`Cursor.description`"""
 
-    description: Awaitable[tuple[tuple[str, str, None, None, None, None, None], ...]]
+    description: tuple[tuple[str, str, None, None, None, None, None], ...]
     """Based on the `DB-API cursor property
     <https://www.python.org/dev/peps/pep-0249/>`__, this returns the
     same as :meth:`get_description` but with 5 Nones appended because
     SQLite does not have the information."""
 
-    description_full: Awaitable[tuple[tuple[str, str, str, str, str], ...]]
+    description_full: tuple[tuple[str, str, str, str, str], ...]
     """Only present if SQLITE_ENABLE_COLUMN_METADATA was defined at
     compile time.
 
@@ -7634,7 +7634,7 @@ class AsyncCursor:
         """Returns the :attr:`connection` this cursor is part of"""
         ...
 
-    async def get_description(self) -> tuple[tuple[str, str], ...]:
+    def get_description(self) -> tuple[tuple[str, str], ...]:
         """If you are trying to get information about a table or view,
         then `pragma table_info <https://sqlite.org/pragma.html#pragma_table_info>`__
         is better.  If you want to know up front what columns and other

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/aio.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import contextlib
 import contextvars
 import logging
@@ -368,9 +369,6 @@ class AsyncIO:
                 return await task
 
     def __init__(self, *, thread_name: str = "asyncio apsw background worker"):
-        global asyncio
-        import asyncio
-
         self.queue: queue.SimpleQueue[_CallTracker | None] = queue.SimpleQueue()
         self.loop = asyncio.get_running_loop()
         threading.Thread(name=thread_name, target=self.worker_thread_run).start()
@@ -651,8 +649,6 @@ def Auto() -> Trio | AsyncIO | AnyIO:
 
     if found is None and "asyncio" in sys.modules:
         try:
-            import asyncio
-
             asyncio.get_running_loop()
             found = AsyncIO
         except:

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/ext.py

@@ -180,7 +180,7 @@ class TypesConverterCursorFactory:
         """Registers a callable that converts from a SQLite value"""
         self.converters[name] = callable
 
-    def __call__(self, connection: apsw.Connection) -> TypeConverterCursor:
+    def __call__(self, connection: apsw.Connection) -> TypesConverterCursorFactory.TypeConverterCursor:
         "Returns a new convertor :class:`cursor <apsw.Cursor>` for the `connection`"
         return TypesConverterCursorFactory.TypeConverterCursor(connection, self)
 
@@ -2224,7 +2224,7 @@ def get_column_names(row: Any) -> tuple[Sequence[str], VTColumnAccess]:
         * - Type
           - Access
           - Column names From
-        * - :external:func:`dataclasses.is_dataclass`
+        * - :func:`dataclasses.is_dataclass`
           - :attr:`VTColumnAccess.By_Attr`
           - :func:`dataclasses.fields`
         * - :func:`isinstance <isinstance>`\(:class:`tuple`) and :func:`hasattr <hasattr>`\(:code:`"_fields"`) - eg :func:`~collections.namedtuple`

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/tests/__main__.py

@@ -6058,6 +6058,7 @@ class APSW(unittest.TestCase):
                     "get_description_full",
                     "getdescription_dbapi",
                     "bool",
+                    "next",
                 ),
                 "req": {
                     "closed": "CHECK_CURSOR_CLOSED",

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/tests/aiotest.py

@@ -10,6 +10,7 @@ import functools
 import threading
 import unittest
 import tempfile
+import random
 import sys
 import math
 import inspect
@@ -539,6 +540,209 @@ class Async(unittest.TestCase):
 
                 self.assertEqual(values, list(range(min(NUM_ENTRIES, error))))
 
+    async def atestCursorStatementAttributes(self, fw):
+
+        # This is to verify #613 needing to keep iteration, prefetch,
+        # and description in sync with each other, not to mention all
+        # the other cursor statement related attributes.  Multiple
+        # tables with varying number of columns and content are
+        # selected from in a single SQL string and async iteration
+        # compared to sync
+
+        # used to name the tables, columns, and types with languages
+        # from wikipedia.org front page
+        names = """one two three four five six seven eight nine ten
+        eleven twelve thirteen fourteen fifteen sixteen seventeen
+        eighteen nineteen twenty العربية Deutsch English Español فارسی
+        Français Italiano مصرى Nederlands日本語Polski Português
+        Sinugboanong Binisaya Svenska Українська Tiếng Việt Winaray中
+        文Русский  articles Afrikaans Shqip Asturianu Azərbaycanca
+        Български閩南語  Bân-lâm-gú বাংলা Беларуская Català Čeština
+        Cymraeg Dansk Eesti Ελληνικά Esperanto Euskara Galego 한국어
+        Հայերեն हिन्दी Hrvatski Bahasa Indonesia עברית ქართული Ladin
+        Latina Latviešu Lietuvių Magyar Македонски Malagasy मराठी
+        Bahasa Melayu Bahaso Minangkabau မြန်မာဘာသာ Norskbokmålnynorsk
+        Нохчийн Oʻzbekcha  Ўзбекча Қазақша Qazaqşa قازاقشا Română
+        Simple English Slovenčina Slovenščina Српски Srpski
+        Srpskohrvatski  Српскохрватски Suomi Kiswahili தமிழ் Татарча
+        Tatarça తెలుగు ภาษาไทย Тоҷикӣ تۆرکجه Türkçe اردو粵語Bahsa Acèh
+        Alemannisch አማርኛ Aragonés Արեւմտահայերէն Bahasa Hulontalo Basa
+        Bali Bahasa Banjar Basa Banyumasan Башҡортса Беларуская
+        тарашкевіца Bikol Central বিষ্ণুপ্রিয়া মণিপুরী Boarisch
+        Bosanski Brezhoneg Чӑвашла Dagbanli الدارجة Diné Bizaad
+        Emigliàn–Rumagnòl Fiji Hindi Føroyskt Frysk Fulfulde Gaeilge
+        Gàidhlig گیلکی ગુજરાતી Hak-kâ-ngî  客家語Hausa Hornjoserbsce
+        Ido Igbo Ilokano Interlingua Interlingue Ирон Íslenska Jawa
+        ಕನ್ನಡ Kapampangan ភាសាខ្មែរ Kotava Kreyòl Ayisyen Kurdî كوردی
+        کوردیی ناوەندی Кыргызча Кырык мары Lëtzebuergesch Lìgure
+        Limburgs Lombard मैथिली മലയാളം მარგალური مازِرونی
+        Mìng-dĕ̤ng-ngṳ̄  閩東語Монгол Napulitano नेपाल भाषा Nordfriisk
+        Occitan Олык марий ଓଡି଼ଆ অসমীযা় ਪੰਜਾਬੀ پنجابی شاہ مکھی پښتو
+        Piemontèis Plattdüütsch Qaraqalpaqsha Qırımtatarca Runa Simi
+        Русиньскый संस्कृतम् ᱥᱟᱱᱛᱟᱲᱤ سرائیکی Саха Тыла Scots ChiShona
+        Sicilianu සිංහල سنڌي Ślůnski Soomaaliga Basa Sunda Taclḥit
+        Tagalog ၽႃႇသႃႇတႆး ⵜⴰⵎⴰⵣⵉⵖⵜ ⵜⴰⵏⴰⵡⴰⵢⵜ tolışi chiTumbuka Basa Ugi
+        Vèneto Volapük Walon文言吴语ייִדיש """.split()
+
+        con = apsw.Connection("")
+        acon = await apsw.Connection.as_async("")
+
+        has_full = hasattr(apsw.Cursor, "description_full")
+
+        try:
+            apsw.allow_missing_dict_bindings(True)
+
+            tables = []
+
+            table_columns = {}
+
+            for table in random.choices(names, k=6):
+                # choices can return duplicates
+                if table in tables:
+                    continue
+                tables.append(table)
+                sql = ""
+                sql += f'create table "{table}"('
+                columns = list(set(random.choices(names, k=random.randint(1, 10))))
+                table_columns[table] = columns
+
+                sql += ",".join(
+                    f'"{name}" "{coltype}"' for (name, coltype) in zip(columns, random.choices(names, k=len(columns)))
+                )
+                sql += ");"
+
+                con.execute(sql)
+                await acon.execute(sql)
+
+                insert = f'insert into "{table}" values(' + ",".join("?" * len(columns)) + ")"
+
+                async with acon:
+                    with con:
+                        for row in range(random.randint(0, 100)):
+                            con.execute(insert, [row] * len(columns))
+                            await acon.execute(insert, [row] * len(columns))
+
+            sql = []
+            emsql = []
+            emvalues = []
+
+            stuff = "abcdefghijklmnopqrstuvwxyz"
+
+            for i in range(12):
+                sql.append(f'SELECT * FROM "{random.choice(tables)}" LIMIT {random.randint(0, 10)};')
+                table = random.choice(tables)
+                one = "".join(random.choices(stuff, k=10))
+                two = "".join(random.choices(stuff, k=10))
+                emsql.append(f'SELECT * FROM "{table}" WHERE coalesce(${one},:{two}, 3) is not null LIMIT :limit ;')
+                emvalues.append({"limit": random.randint(0, 10), one: 77, two: 94})
+                if i in {1, 3, 7, 11, 17}:
+                    for q in (
+                        "/* no vdbe for this */ ;",
+                        "explain query plan select * from sqlite_schema;",
+                        "create table if not exists orange(a,c);",
+                    ):
+                        sql.append(q)
+                        emsql.append(q)
+
+            embindings = emvalues[:]
+            random.shuffle(embindings)
+
+            async_attrs = "bindings_names expanded_sql sql".split()
+            sync_attrs = "bindings_count has_vdbe is_explain is_readonly description".split() + (
+                ["description_full"] if has_full else []
+            )
+
+            sync_cur = con.cursor()
+            async_cur = acon.cursor()
+            self.assertRaises(apsw.ExecutionCompleteError, sync_cur.get_description)
+            self.assertRaises(apsw.ExecutionCompleteError, async_cur.get_description)
+            for a in async_attrs:
+                self.assertRaises(apsw.ExecutionCompleteError, getattr, sync_cur, a)
+                with self.assertRaises(apsw.ExecutionCompleteError):
+                    await getattr(async_cur, a)
+            for a in sync_attrs:
+                self.assertRaises(apsw.ExecutionCompleteError, getattr, sync_cur, a)
+                self.assertRaises(apsw.ExecutionCompleteError, getattr, async_cur, a)
+
+            for prefetch in (1, 3, 11, 64):
+                apsw.async_cursor_prefetch.set(prefetch)
+                random.shuffle(sql)
+                # regular execute mode
+                sync_cur = con.execute("".join(sql))
+                async_cur = await acon.execute("".join(sql))
+
+                async for row in async_cur:
+                    self.assertEqual(row, next(sync_cur))
+                    self.assertEqual(sync_cur.get_description(), async_cur.get_description())
+                    for a in async_attrs:
+                        self.assertEqual(getattr(sync_cur, a), await getattr(async_cur, a))
+                    for a in sync_attrs:
+                        self.assertEqual(getattr(sync_cur, a), getattr(async_cur, a))
+
+                # check raises complete
+                self.assertRaises(StopIteration, next, sync_cur)
+                with self.assertRaises(StopAsyncIteration):
+                    await anext(async_cur)
+
+                self.assertRaises(apsw.ExecutionCompleteError, sync_cur.get_description)
+                self.assertRaises(apsw.ExecutionCompleteError, async_cur.get_description)
+                for a in async_attrs:
+                    self.assertRaises(apsw.ExecutionCompleteError, getattr, sync_cur, a)
+                    with self.assertRaises(apsw.ExecutionCompleteError):
+                        await getattr(async_cur, a)
+                for a in sync_attrs:
+                    self.assertRaises(apsw.ExecutionCompleteError, getattr, sync_cur, a)
+                    self.assertRaises(apsw.ExecutionCompleteError, getattr, async_cur, a)
+
+                # errors
+                error_sql = "select 3; select syntax error"
+                sync_cur = con.execute(error_sql)
+                async_cur = aiter(await acon.execute(error_sql))
+
+                next(sync_cur)
+                await anext(async_cur)
+
+                self.assertRaises(apsw.SQLError, next, sync_cur)
+                with self.assertRaises(apsw.SQLError):
+                    await anext(async_cur)
+
+                self.assertRaises(StopIteration, next, sync_cur)
+                with self.assertRaises(StopAsyncIteration):
+                    await anext(async_cur)
+
+                # executemany mode
+                random.shuffle(emsql)
+
+                sync_cur = con.executemany("".join(emsql), embindings)
+                async_cur = await acon.executemany("".join(emsql), embindings)
+                async for row in async_cur:
+                    self.assertEqual(row, next(sync_cur))
+                    self.assertEqual(sync_cur.get_description(), async_cur.get_description())
+                    for a in async_attrs:
+                        self.assertEqual(getattr(sync_cur, a), await getattr(async_cur, a))
+                    for a in sync_attrs:
+                        self.assertEqual(getattr(sync_cur, a), getattr(async_cur, a))
+
+                # check raises complete
+                self.assertRaises(StopIteration, next, sync_cur)
+                with self.assertRaises(StopAsyncIteration):
+                    await anext(async_cur)
+
+                self.assertRaises(apsw.ExecutionCompleteError, sync_cur.get_description)
+                self.assertRaises(apsw.ExecutionCompleteError, async_cur.get_description)
+                for a in async_attrs:
+                    self.assertRaises(apsw.ExecutionCompleteError, getattr, sync_cur, a)
+                    with self.assertRaises(apsw.ExecutionCompleteError):
+                        await getattr(async_cur, a)
+                for a in sync_attrs:
+                    self.assertRaises(apsw.ExecutionCompleteError, getattr, sync_cur, a)
+                    self.assertRaises(apsw.ExecutionCompleteError, getattr, async_cur, a)
+
+        finally:
+            apsw.allow_missing_dict_bindings(False)
+            con.close(True)
+            acon.close(True)
+
     async def atestConfigure(self, fw):
         auto = apsw.aio.Auto()
         auto.close()

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/tests/jsonb.py

@@ -1109,12 +1109,12 @@ class JSONB(unittest.TestCase):
 
     def testRandomJSON(self):
         "sqlite randomjson extension if present"
-        if not os.path.exists("randomjson.so"):
+        import apsw.sqlite_extra
+        try:
+            apsw.sqlite_extra.load(self.db, "randomjson")
+        except apsw.sqlite_extra.NotAvailable:
             return
 
-        self.db.enable_load_extension(True)
-        self.db.load_extension("./randomjson")
-
         for seed in range(2000, 3000):
             # we round trip the json through as many combinations of SQLite, Python and APSW
             # encoders / decoders as possible

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw/tests/mctests.py

@@ -141,6 +141,7 @@ class MultipleCiphers(unittest.TestCase):
         for config in (
             {
                 "plaintext_header_size": 64,
+                "cipher_salt": "B1349F791FE98DDD1648406C5554BD1F",
                 "cipher": "sqlcipher",
                 "key": "one",
             },
@@ -286,6 +287,9 @@ def apply_encryption(db, **kwargs):
         # then anything with legacy in the name
         if "legacy" in pragma:
             return 3
+        # explicit cipher salt
+        if pragma == "cipher_salt":
+            return 99
         # all except keys
         if pragma not in {"key", "hexkey", "rekey", "hexrekey"}:
             return 3
@@ -299,7 +303,7 @@ def apply_encryption(db, **kwargs):
     for pragma, value in sorted(kwargs.items(), key=pragma_order):
         # if the pragma was understood and in range we get the value
         # back, while key related ones return 'ok'
-        expected = "ok" if pragma_order((pragma, value)) == 100 else str(value)
+        expected = "ok" if pragma_order((pragma, value)) >= 99 else str(value)
         if db.pragma(pragma, value) != expected:
             raise ValueError(f"Failed to configure {pragma=}")
 

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/apsw_sqlite3mc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apsw-sqlite3mc
-Version: 3.53.0.0
+Version: 3.53.1.0
 Summary: SQLite3 Multiple Ciphers combined with Another Python SQLite Wrapper
 Home-page: https://github.com/utelle/apsw-sqlite3mc
 Author: Ulrich Telle
@@ -89,7 +89,7 @@ Setting the key on a new database is the only change needed to your code.
 
   >>> import apsw
   >>> print(apsw.mc_version)
-  SQLite3 Multiple Ciphers 2.3.3
+  SQLite3 Multiple Ciphers 2.3.4
   >>> con = apsw.Connection("database.sqlite3")
   >>> con.pragma("key", "my secret passphrase")
   ok

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/checksums

@@ -9,7 +9,7 @@
 # way.
 
 # These are used too compile sqlite extra
-
+https://sqlite.org/vec1/zip/vec1-20260505104119-eb38e10fef.zip 149803 b37509b229a393a387f3f4f352529dcf10cc3ebdbb2c75fa062763d4fdd0953b ceb3aa3699c378872e88b06b237e94eec9e545ffc1abe7388f521a107ec50699
 https://sqlite.org/vec1/zip/vec1-20260409204746-4b73767df0.zip 119674 952af14601531b527a497df81d038a2693c1a39dba2d76ed798c3e5ba3dd7c22 55e2d7e05da20b7eb4abbe77688bdff4662a6f4f248f6710e7d2b605d3c90107
 https://sqlite.org/vec1/zip/vec1-20260330201854-5b7c141049.zip 107146 099acc5f1eee719cae16d4843e904bba432cda9ce43d1cefb756f6566462d9f5 1c3e4264a416d68209ea37139c7e0ad42fcee4f66c021c8f495cce9882bc71e3
 https://sqlite.org/vec1/zip/vec1-20260306155250-d070184523.zip 75980 6a58eebbe1e4679645c80084fdfc44f2902e19cde95da5af932bb51bfdc7d02d 77785c8f4e0a9672dded6794861a2ca9d5a5a8dda43300b183690cd84149bf35
@@ -20,6 +20,8 @@ https://sqlite.org/sqlar/zip/sqlar-src-20180107193712-4824e73896.zip 1980460 63b
 https://www.zlib.net/zlib132.zip 1616754 e8bf55f3017aa181690990cb58a994e77885da140609fc8f94abe9b65d2cae28 6b35b981f73425dc5f142cbee457f078d42240c022c804982849b962f1d1e2c6
 
 # SQLite releases
+https://sqlite.org/2026/sqlite-autoconf-3530100.tar.gz 3275272 83e6b2020a034e9a7ad4a72feea59e1ad52f162e09cbd26735a3ffb98359fc4f 36ca143645cf76997d07b66e9244c636b8ccdec64a1d50558259c4e415e6558b
+https://sqlite.org/2026/sqlite-src-3530100.zip 14515734 1b2b5755d9064c4d5d1b0bf5307b48b089963e291c40cc7351318aa1b61c460e 27cfc9264b2188fd17f811a8c03424eb65391c2ef9874cbfc860ea25f4322363
 https://sqlite.org/2026/sqlite-autoconf-3530000.tar.gz 3274709 851e9b38192fe2ceaa65e0baa665e7fa06230c3d9bd1a6a9662d02380d73365a 60c4b08c6729761e488d185e0d52411da10b14c72b53ada6936dc5eea225cefe
 https://sqlite.org/2026/sqlite-src-3530000.zip 14513779 fbc30cdbfcfa42c78fe7bddd3fd37ab8995369a31d39097a5d0633296c0b6e65 4ffbd00ba8db1e1172dbc69a5203a2c185556a32543e58585ba3713abf676fe5
 

{apsw_sqlite3mc-3.53.0.0 → apsw_sqlite3mc-3.53.1.0}/setup.py

@@ -306,7 +306,7 @@ class fetch(Command):
             for desc, url, replace in (
                 (
                     "experimental vec1 extension source",
-                    "https://sqlite.org/vec1/zip/vec1-20260409204746-4b73767df0.zip",
+                    "https://sqlite.org/vec1/zip/vec1-20260505104119-eb38e10fef.zip",
                     "sqlite3/vec1",
                 ),
                 (