apsw-sqlite3mc 3.53.3.1__tar.gz → 3.53.4.0__tar.gz

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apsw_sqlite3mc
-Version: 3.53.3.1
+Version: 3.53.4.0
 Summary: SQLite3 Multiple Ciphers combined with Another Python SQLite Wrapper
 Home-page: https://github.com/utelle/apsw-sqlite3mc
 Author: Ulrich Telle
@@ -90,7 +90,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.6
+  SQLite3 Multiple Ciphers 2.4.0
   >>> con = apsw.Connection("database.sqlite3")
   >>> con.pragma("key", "my secret passphrase")
   ok

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.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.6
+  SQLite3 Multiple Ciphers 2.4.0
   >>> con = apsw.Connection("database.sqlite3")
   >>> con.pragma("key", "my secret passphrase")
   ok

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.0}/apsw/__init__.pyi

@@ -856,8 +856,8 @@ class Backup:
 @final
 class Blob:
     """This object is created by :meth:`Connection.blob_open` and provides
-    access to a blob in the database.  It behaves like a Python file.
-    It wraps a `sqlite3_blob
+    access to a blob in the database.  It behaves like a Python
+    :class:`file <io.RawIOBase>` in binary mode.  It wraps a `sqlite3_blob
     <https://sqlite.org/c3ref/blob.html>`_.
 
     .. note::
@@ -893,6 +893,9 @@ class Blob:
         Calls: `sqlite3_blob_close <https://sqlite.org/c3ref/blob_close.html>`__"""
         ...
 
+    closed: bool
+    """Indicates if the blob has been closed."""
+
     def __enter__(self) -> Blob:
         """You can use a blob as a `context manager
         <https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers>`_
@@ -913,6 +916,20 @@ class Blob:
         *with* block is raised after closing the blob."""
         ...
 
+    def fileno(self) -> int:
+        """Always raises :exc:`OSError` because there is no
+        underlying file descriptor."""
+        ...
+
+    def flush(self) -> None:
+        """Does nothing.  There is no intermediate buffer, and SQLite's overall
+        transaction/savepoint handling deals with database commits."""
+        ...
+
+    def isatty(self) -> False:
+        """Blobs are never interactive."""
+        ...
+
     def length(self) -> int:
         """Returns the size of the blob in bytes.
 
@@ -951,6 +968,24 @@ class Blob:
 
     readinto = read_into ## OLD-NAME
 
+    def readable(self) -> True:
+        """You can always read from a blob"""
+        ...
+
+    def readall(self) -> bytes:
+        """Read all data until the end of the blob"""
+        ...
+
+    def readline(self, size: int = -1) -> bytes:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You can wrap with :class:`io.BufferedReader`."""
+        ...
+
+    def readlines(self, hint: int = -1) -> list[bytes]:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You can wrap with :class:`io.BufferedReader`."""
+        ...
+
     def reopen(self, rowid: int) -> None:
         """Change this blob object to point to a different row.  It can be
         faster than closing an existing blob an opening a new one.
@@ -968,13 +1003,28 @@ class Blob:
         :raises ValueError: If the resulting offset is before the beginning (less than zero) or beyond the end of the blob."""
         ...
 
+    def seekable(self) -> True:
+        """You can always seek in a blob"""
+        ...
+
     def tell(self) -> int:
         """Returns the current offset."""
         ...
 
-    def write(self, data: Buffer) -> None:
+    def truncate(self, size = None) -> None:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You cannot change the size of a blob."""
+        ...
+
+    def writable(self) -> bool:
+        """Returns True if the blob was open for writing, else False."""
+        ...
+
+    def write(self, data: Buffer) -> int:
         """Writes the data to the blob.
 
+        Returns the number of bytes written, which will be all of them.
+
         :param data: Buffer to write
 
         :raises TypeError: Wrong data type
@@ -987,6 +1037,11 @@ class Blob:
         Calls: `sqlite3_blob_write <https://sqlite.org/c3ref/blob_write.html>`__"""
         ...
 
+    def writelines(self, lines) -> None:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You can wrap with :class:`io.BufferedWriter`."""
+        ...
+
 @final
 class ChangesetBuilder:
     """This object wraps a `sqlite3_changegroup <https://sqlite.org/session/changegroup.html>`__
@@ -6057,8 +6112,8 @@ class AsyncBlob:
     """This represents a :class:`Blob` when in async mode.
 
     This object is created by :meth:`Connection.blob_open` and provides
-    access to a blob in the database.  It behaves like a Python file.
-    It wraps a `sqlite3_blob
+    access to a blob in the database.  It behaves like a Python
+    :class:`file <io.RawIOBase>` in binary mode.  It wraps a `sqlite3_blob
     <https://sqlite.org/c3ref/blob.html>`_.
 
     .. note::
@@ -6103,8 +6158,25 @@ class AsyncBlob:
         Calls: `sqlite3_blob_close <https://sqlite.org/c3ref/blob_close.html>`__"""
         ...
 
+    closed: bool
+    """Indicates if the blob has been closed."""
 
 
+
+    def fileno(self) -> int:
+        """Always raises :exc:`OSError` because there is no
+        underlying file descriptor."""
+        ...
+
+    async def flush(self) -> None:
+        """Does nothing.  There is no intermediate buffer, and SQLite's overall
+        transaction/savepoint handling deals with database commits."""
+        ...
+
+    def isatty(self) -> False:
+        """Blobs are never interactive."""
+        ...
+
     def length(self) -> int:
         """Returns the size of the blob in bytes.
 
@@ -6141,6 +6213,24 @@ class AsyncBlob:
         Calls: `sqlite3_blob_read <https://sqlite.org/c3ref/blob_read.html>`__"""
         ...
 
+    def readable(self) -> True:
+        """You can always read from a blob"""
+        ...
+
+    async def readall(self) -> bytes:
+        """Read all data until the end of the blob"""
+        ...
+
+    async def readline(self, size: int = -1) -> bytes:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You can wrap with :class:`io.BufferedReader`."""
+        ...
+
+    async def readlines(self, hint: int = -1) -> list[bytes]:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You can wrap with :class:`io.BufferedReader`."""
+        ...
+
     async def reopen(self, rowid: int) -> None:
         """Change this blob object to point to a different row.  It can be
         faster than closing an existing blob an opening a new one.
@@ -6158,13 +6248,28 @@ class AsyncBlob:
         :raises ValueError: If the resulting offset is before the beginning (less than zero) or beyond the end of the blob."""
         ...
 
+    def seekable(self) -> True:
+        """You can always seek in a blob"""
+        ...
+
     def tell(self) -> int:
         """Returns the current offset."""
         ...
 
-    async def write(self, data: Buffer) -> None:
+    async def truncate(self, size = None) -> None:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You cannot change the size of a blob."""
+        ...
+
+    def writable(self) -> bool:
+        """Returns True if the blob was open for writing, else False."""
+        ...
+
+    async def write(self, data: Buffer) -> int:
         """Writes the data to the blob.
 
+        Returns the number of bytes written, which will be all of them.
+
         :param data: Buffer to write
 
         :raises TypeError: Wrong data type
@@ -6177,6 +6282,11 @@ class AsyncBlob:
         Calls: `sqlite3_blob_write <https://sqlite.org/c3ref/blob_write.html>`__"""
         ...
 
+    async def writelines(self, lines) -> None:
+        """Always raises :exc:`io.UnsupportedOperation`.
+        You can wrap with :class:`io.BufferedWriter`."""
+        ...
+
 class AsyncConnection:
     """This represents a :class:`Connection` when in async mode.
 

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.0}/apsw/tests/__main__.py

@@ -379,24 +379,20 @@ class APSW(unittest.TestCase):
             if name in apsw.vfs_names():
                 apsw.unregister_vfs(name)
 
-    def check_db_mutex(self):
+    def check_db_mutex(self, db):
         # verify a db mutex is not being held by doing work in another
         # thread
-        try:
-            self.db.readonly("main")
-        except apsw.ConnectionClosedError:
-            return
 
-        self.db.set_progress_handler(None)
-        self.db.exec_trace = None
-        self.db.row_trace = None
+        db.set_progress_handler(None)
+        db.exec_trace = None
+        db.row_trace = None
 
         val = Exception("The database mutex is still held and should not be")
 
         def thread():
             nonlocal val
             try:
-                val = self.db.execute("select 3").get
+                val = db.execute("select 3").get
             except BaseException as exc:
                 val = exc
 
@@ -412,14 +408,10 @@ class APSW(unittest.TestCase):
 
     def tearDown(self):
         apsw.config(apsw.SQLITE_CONFIG_LOG, None)
-        if self.db is not None:
-            try:
-                self.check_db_mutex()
-            finally:
-                self.db.close(True)
-        del self.db
         for c in apsw.connections():
-            c.close()
+            self.check_db_mutex(c)
+            c.close(True)
+        del self.db
         gc.collect()
         deltempfiles()
         if hasattr(apsw, "leak_check"):
@@ -4875,6 +4867,8 @@ class APSW(unittest.TestCase):
 
     def testClosingChecks(self):
         "Check closed connection/blob/cursor is correctly detected"
+        if sys.platform == "emscripten":
+            self.skipTest("pyodide crashes")
         cur = self.db.cursor()
         rowid = curnext(
             cur.execute("create table foo(x blob); insert into foo values(zeroblob(98765)); select rowid from foo")
@@ -4882,7 +4876,7 @@ class APSW(unittest.TestCase):
         blob = self.db.blob_open("main", "foo", "x", rowid, True)
         blob.close()
         nargs = self.blob_nargs
-        for func in [x for x in dir(blob) if not x.startswith("__") and x not in ("close", "aclose")]:
+        for func in [x for x in dir(blob) if not x.startswith("__") and x not in ("close", "aclose", "closed")]:
             args = ("one", "two", "three")[: nargs.get(func, 0)]
             try:
                 getattr(blob, func)(*args)
@@ -6150,7 +6144,7 @@ class APSW(unittest.TestCase):
                 "order": ("closed",),
             },
             "APSWBlob": {
-                "skip": ("dealloc", "dealloc_mutex", "init", "close", "close_internal", "tp_repr", "bool", "aclose"),
+                "skip": ("dealloc", "dealloc_mutex", "init", "close", "close_internal", "tp_repr", "bool", "aclose", "closed"),
                 "req": {"closed": "CHECK_BLOB_CLOSED"},
                 "order": ("use", "closed"),
             },
@@ -6967,6 +6961,12 @@ class APSW(unittest.TestCase):
         self.assertEqual(blobro.read(), b"\x00" * 98765)
         blobro.seek(-3, 2)
         self.assertEqual(blobro.read(), b"\x00" * 3)
+        blobro.seek(0)
+        x=blobro.read()
+        blobro.seek(0)
+        self.assertEqual(blobro.readall(), x)
+        self.assertEqual(b"", blobro.read())
+        self.assertEqual(b"", blobro.readall())
         # check types
         self.assertRaises(TypeError, blobro.read, "foo")
         self.assertRaises(TypeError, blobro.tell, "foo")
@@ -6989,6 +6989,7 @@ class APSW(unittest.TestCase):
         self.assertRaises(apsw.ReadOnlyError, blobro.close)
         # check can't work on closed blob
         self.assertRaises(ValueError, blobro.read)
+        self.assertRaises(ValueError, blobro.readall)
         self.assertRaises(ValueError, blobro.read_into, b"ab")
         self.assertRaises(ValueError, blobro.seek, 0, 0)
         self.assertRaises(ValueError, blobro.tell)
@@ -7063,7 +7064,7 @@ class APSW(unittest.TestCase):
         blobrw.seek(0, 0)
         self.assertEqual(blobrw.read(7), b"abcdefg")
         blobrw.seek(50, 0)
-        blobrw.write(b"hijkl")
+        self.assertEqual(5, blobrw.write(b"hijkl"))
         blobrw.seek(-98765, 2)
         self.assertEqual(blobrw.read(55), b"abcdefg" + b"\x00" * 43 + b"hijkl")
         self.assertRaises(TypeError, blobrw.write, 12)
@@ -7090,21 +7091,93 @@ class APSW(unittest.TestCase):
         self.assertRaises(apsw.SQLError, blobro.reopen, 0x1FFFFFFFF)
         blobro.close()
 
-    def testBlobReadError(self):
-        "Ensure blob read errors are handled well"
-        cur = self.db.cursor()
-        cur.execute("create table ioerror (x, blob)")
-        cur.execute("insert into ioerror (rowid,x,blob) values (2,3,x'deadbeef')")
-        blob = self.db.blob_open("main", "ioerror", "blob", 2, False)
-        blob.read(1)
-        # Do a write which cause blob to become invalid
-        cur.execute("update ioerror set blob='fsdfdsfasd' where x=3")
-        try:
-            blob.read(1)
-            1 / 0
-        except:
-            klass, value = sys.exc_info()[:2]
-            self.assertTrue(klass is apsw.AbortError)
+    def testBlobExpiredError(self):
+        "Ensure blob errors are handled well"
+        self.db.execute("""
+            create table ioerror (x, blob);
+            insert into ioerror (rowid,x,blob)
+                    values (2,3,x'deadbeefbaadf00d'), (3,3,x'deadbeefbaadf00d');""")
+        blobro = self.db.blob_open("main", "ioerror", "blob", 2, False)
+        blobrw = self.db.blob_open("main", "ioerror", "blob", 3, True)
+        self.assertEqual(blobro.length(), 8)
+        self.assertEqual(blobrw.length(), 8)
+        blobro.read(4)
+        blobrw.read(4)
+        blobrw.write(b"X")
+        self.assertEqual(blobro.tell(), 4)
+        self.assertEqual(blobrw.tell(), 5)
+        # Do a SQL write which cause blobs to become invalid
+        self.db.execute("update ioerror set blob='fsdfdsfasd' where x=3")
+        self.assertRaises(apsw.AbortError, blobro.read)
+        self.assertRaises(apsw.AbortError, blobro.readinto, bytearray(10))
+        self.assertRaises(apsw.AbortError, blobrw.write, b"Y")
+        self.assertRaises(apsw.AbortError, blobrw.write, b"Z")
+        self.assertRaises(apsw.AbortError, blobro.readall)
+        self.assertRaises(apsw.AbortError, blobrw.readall)
+        self.assertRaises(apsw.AbortError, blobro.read, 1)
+
+    def testBlobIOBase(self):
+        "blob conformance with io.RawIOBase"
+
+        rowids=self.db.execute("""
+            CREATE TABLE victim(x);
+            INSERT INTO victim VALUES (randomblob(16383)) RETURNING rowid;
+            INSERT INTO victim VALUES (randomblob(16383)) RETURNING rowid;
+        """).get
+
+        blobro = self.db.blob_open("main", "victim", "x", rowids[0], False)
+        blobrw = self.db.blob_open("main", "victim", "x", rowids[1], True)
+
+        for name in dir(io.RawIOBase):
+            match name:
+                case "close" | "read" | "write" | "seek" | "tell" | "readall" | "readinto":
+                    # covered in tests above
+                    pass
+                case _ if name.startswith("_"):
+                    pass
+                case "closed":
+                    self.assertFalse(blobro.closed)
+                    self.assertFalse(blobrw.closed)
+                case "fileno":
+                    self.assertRaises(OSError, blobro.fileno)
+                    self.assertRaises(OSError, blobrw.fileno)
+                case "flush":
+                    self.assertIsNone(blobro.flush())
+                    self.assertIsNone(blobrw.flush())
+                case "isatty":
+                    self.assertFalse(blobro.isatty())
+                    self.assertFalse(blobrw.isatty())
+                case "readable" | "seekable":
+                    self.assertTrue(blobro.readable())
+                    self.assertTrue(blobrw.readable())
+                    self.assertTrue(blobro.seekable())
+                    self.assertTrue(blobrw.seekable())
+                case "readline" | "readlines" | "writelines" | "truncate":
+                    # pyodide gets a fatal internal error on these
+                    if sys.platform == "emscripten":
+                        self.skipTest("pyodide crashes")
+                    self.assertRaises(io.UnsupportedOperation, blobro.readline)
+                    self.assertRaises(io.UnsupportedOperation, blobrw.readline)
+                    self.assertRaises(io.UnsupportedOperation, blobro.readlines)
+                    self.assertRaises(io.UnsupportedOperation, blobrw.readlines)
+                    self.assertRaises(io.UnsupportedOperation, blobro.writelines)
+                    self.assertRaises(io.UnsupportedOperation, blobrw.writelines)
+                    self.assertRaises(io.UnsupportedOperation, blobro.truncate)
+                    self.assertRaises(io.UnsupportedOperation, blobrw.truncate)
+                case "writable":
+                    self.assertFalse(blobro.writable())
+                    self.assertTrue(blobrw.writable())
+                case _:
+                    raise NotImplementedError
+
+        blobro.close()
+        blobrw.close()
+        self.assertTrue(blobro.closed)
+        self.assertTrue(blobrw.closed)
+
+        self.assertIsInstance(blobro, io.RawIOBase)
+        self.assertIsInstance(blobrw, io.RawIOBase)
+
 
     def testAutovacuumPages(self):
         self.assertRaises(TypeError, self.db.autovacuum_pages)

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.0}/apsw/tests/async_meta.py

@@ -10,14 +10,14 @@
 # stubs and documentation.
 
 import functools
-import inspect
-import threading
-import unittest
 import importlib.resources
+import inspect
+import io
 import json
-
 import queue
-from typing import Literal, Callable, Any
+import threading
+import unittest
+from typing import Any, Callable, Literal
 
 import apsw
 import apsw.aio
@@ -245,6 +245,14 @@ class AsyncMeta(unittest.TestCase):
             if klass == "Connection" and member in {"vtab_config", "vtab_on_conflict"}:
                 return "value"
             raise
+        except io.UnsupportedOperation:
+            if klass == "Blob" and member in {"readline", "readlines", "truncate", "writelines"}:
+                return "value" if send else "async"
+            raise
+        except OSError:
+            if (klass, member) == ("Blob", "fileno"):
+                return "value"
+            raise
 
     def testMetaJson(self):
         apsw.async_controller.set(SimpleController)
@@ -335,7 +343,6 @@ class AsyncMeta(unittest.TestCase):
             "aclose",
             "__exit__",
             "__aexit__",
-            "finish",
         }
 
         pre = {"__aexit__": "__aenter__", "__exit__": "__enter__", "__next__": "__iter__", "__anext__": "__aiter__"}

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.0}/apsw_sqlite3mc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apsw-sqlite3mc
-Version: 3.53.3.1
+Version: 3.53.4.0
 Summary: SQLite3 Multiple Ciphers combined with Another Python SQLite Wrapper
 Home-page: https://github.com/utelle/apsw-sqlite3mc
 Author: Ulrich Telle
@@ -90,7 +90,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.6
+  SQLite3 Multiple Ciphers 2.4.0
   >>> con = apsw.Connection("database.sqlite3")
   >>> con.pragma("key", "my secret passphrase")
   ok

{apsw_sqlite3mc-3.53.3.1 → apsw_sqlite3mc-3.53.4.0}/checksums

@@ -21,6 +21,8 @@ https://sqlite.org/sqlar/zip/sqlar-src-20180107193712-4824e73896.zip 1980460 63b
 https://github.com/madler/zlib/releases/download/v1.3.2/zlib132.zip 1616754 e8bf55f3017aa181690990cb58a994e77885da140609fc8f94abe9b65d2cae28 6b35b981f73425dc5f142cbee457f078d42240c022c804982849b962f1d1e2c6
 
 # SQLite releases
+https://sqlite.org/2026/sqlite-autoconf-3530400.tar.gz 3283177 0e9483900e92cd5de8fd48d16bf9200145a61f7fd5be542a5ac81d8a9516eb9c 454e45f61c6bd75b7420e7190732dea03ce6639c63ada47bbc592f67fc340338
+https://sqlite.org/2026/sqlite-src-3530400.zip 14557315 d18fa15aec74d8c17e1463f861095adc01b5ad190256acb4f91d22f0368d232b b834d474b9b393d85a9e3ee4cc11f1329e007e9376a424ee740796f5c4bda3a8
 https://sqlite.org/2026/sqlite-autoconf-3530300.tar.gz 3282443 c917d7db16648ec95f714974ace5e5dcf46b7dc70e26600a0a102a3141125db0 98f2b3f3c11be6a03ea32346937b032c2472ebbd7a716bed36ca2f5693e7ce8b
 https://sqlite.org/2026/sqlite-src-3530300.zip 14537772 bb80bf8a3bffc19241ce8aba5a4bc74e9c3980013cb0b5f0f0976a99516942af 2daecfa16e3b19e058dc2e2cb717b80ade361e0315aa5376c3619f66aa81e181
 https://sqlite.org/2026/sqlite-autoconf-3530200.tar.gz 3279926 588ad51949419a56ebe81fe56193d510c559eb94c9a57748387860b5d3069316 025328da165109f48abccc6e7478508060804412bed2bd81d47e98ba1b72983b