Remove apsw alias from utils

Author: pydanny

apswutils/db.py

@@ -1,14 +1,15 @@
 # This file is from sqlite-utils and copyright and license is the same as that project
 __all__ = ['Database', 'Queryable', 'Table', 'View']
 
-from .utils import ( chunks, hash_record, sqlite3, OperationalError, suggest_column_types, types_for_column_types, column_affinity, find_spatialite,)
+from .utils import ( chunks, hash_record, OperationalError, suggest_column_types, types_for_column_types, column_affinity, find_spatialite,)
 import binascii
 from collections import namedtuple
 from collections.abc import Mapping
 import contextlib, datetime, decimal, inspect, itertools, json, os, pathlib, re, secrets, textwrap
 from typing import ( cast, Any, Callable, Dict, Generator, Iterable, Union, Optional, List, Tuple,Iterator)
 from functools import cache
 import uuid
+import apsw
 import apsw.ext
 import apsw.bestpractice
 
@@ -219,7 +220,7 @@ class Database:
         dB = Database(memory=True)
 
     :param filename_or_conn: String path to a file, or a ``pathlib.Path`` object, or a
-      ``sqlite3`` connection
+      ``apsw`` connection
     :param memory: set to ``True`` to create an in-memory database
     :param memory_name: creates a named in-memory database that can be shared across multiple connections
     :param recreate: set to ``True`` to delete and recreate a file database (**dangerous**)
@@ -237,7 +238,7 @@ class Database:
 
     def __init__(
         self,
-        filename_or_conn: Optional[Union[str, pathlib.Path, sqlite3.Connection]] = None,
+        filename_or_conn: Optional[Union[str, pathlib.Path, apsw.Connection]] = None,
         memory: bool = False,
         memory_name: Optional[str] = None,
         recreate: bool = False,
@@ -253,21 +254,21 @@ def __init__(
             uri = "file:{}?mode=memory&cache=shared".format(memory_name)
             # The flags being set allow apswutils to maintain the same behavior here
             # as sqlite-minutils
-            self.conn = sqlite3.Connection(
+            self.conn = apsw.Connection(
                 uri, flags=apsw.SQLITE_OPEN_URI|apsw.SQLITE_OPEN_READWRITE
             )
         elif memory or filename_or_conn == ":memory:":
-            self.conn = sqlite3.Connection(":memory:")
+            self.conn = apsw.Connection(":memory:")
         elif isinstance(filename_or_conn, (str, pathlib.Path)):
             if recreate and os.path.exists(filename_or_conn):
                 try:
                     os.remove(filename_or_conn)
                 except OSError:
                     # Avoid mypy and __repr__ errors, see:
                     # https://github.com/simonw/sqlite-utils/issues/503
-                    self.conn = sqlite3.Connection(":memory:")
+                    self.conn = apsw.Connection(":memory:")
                     raise
-            self.conn = sqlite3.Connection(str(filename_or_conn))
+            self.conn = apsw.Connection(str(filename_or_conn))
         else:
             assert not recreate, "recreate cannot be used with connections, only paths"
             self.conn = filename_or_conn
@@ -368,7 +369,7 @@ def register(fn):
                         fn_name, fn, arity,  **dict(kwargs, deterministic=True)
                     )
                     registered = True
-                except sqlite3.Error:  # Remember, sqlite3 here is actually apsw
+                except apsw.Error:
                     # TODO Find the precise error, sqlite-minutils used sqlite3.NotSupportedError
                     # but as this isn't defined in APSW we fall back to apsw.Error
                     pass
@@ -422,9 +423,9 @@ def query(
 
     def execute(
         self, sql: str, parameters: Optional[Union[Iterable, dict]] = None
-    ) -> sqlite3.Cursor:
+    ) -> apsw.Cursor:
         """
-        Execute SQL query and return a ``sqlite3.Cursor``.
+        Execute SQL query and return a ``apsw.Cursor``.
 
         :param sql: SQL query to execute
         :param parameters: Parameters to use in that query - an iterable for ``where id = ?``
@@ -435,9 +436,9 @@ def execute(
         if parameters: return self.conn.execute(sql, parameters)
         else: return self.conn.execute(sql)
 
-    def executescript(self, sql: str) -> sqlite3.Cursor:
+    def executescript(self, sql: str) -> apsw.Cursor:
         """
-        Execute multiple SQL statements separated by ; and return the ``sqlite3.Cursor``.
+        Execute multiple SQL statements separated by ; and return the ``apsw.Cursor``.
 
         :param sql: SQL to execute
         """
@@ -1353,7 +1354,7 @@ def schema(self) -> str:
 
 class Table(Queryable):
     """
-    A Table class instance represents a sqlite3 table that may or may not exist
+    A Table class instance represents a table that may or may not exist
     in the database. The Table class instance may or may not represent some of
     the rows of the database table. After some mutations (INSERT/UPDATE/UPSERT)
     the changed records the Table class instance can be iterated over, returning

apswutils/utils.py

@@ -11,13 +11,11 @@
 import sys
 import json
 from typing import Dict, cast, BinaryIO, Iterable, Optional, Tuple, Type
+import apsw
 
-# TODO: Change use of apsw as a shim for sqlite3 more explicit
-#       In order to keep this PR minimal, we use sqlite3  as a shim for APSW
-import apsw as sqlite3
 # TODO: Replace use of OperationalError with more explicit apsw errors
 #       In order to keep this PR minimal, we use OperationalError  as a shim for apsw.Error
-OperationalError = sqlite3.Error
+OperationalError = apsw.Error
 
 SPATIALITE_PATHS = (
     "/usr/lib/x86_64-linux-gnu/mod_spatialite.so",

tests/conftest.py

@@ -1,5 +1,5 @@
 from apswutils import Database
-from apswutils.utils import sqlite3
+import apsw
 import pytest
 
 CREATE_TABLES = """
@@ -36,6 +36,6 @@ def existing_db():
 @pytest.fixture
 def db_path(tmpdir):
     path = str(tmpdir / "test.db")
-    db = sqlite3.connect(path)
+    db = Database(path)
     db.executescript(CREATE_TABLES)
     return path

tests/test_create.py

@@ -9,7 +9,7 @@
     Table,
     View,
 )
-from apswutils.utils import hash_record, sqlite3
+from apswutils.utils import hash_record
 import collections
 import datetime
 import decimal
@@ -717,7 +717,7 @@ def test_columns_not_in_first_record_should_not_cause_batch_to_be_too_large(fres
         fresh_db["too_many_columns"].insert_all(
             records, alter=True, batch_size=batch_size
         )
-    except sqlite3.OperationalError:
+    except OperationalError:
         raise
 
 
@@ -1312,7 +1312,7 @@ def test_rename_table(fresh_db):
     assert ["renamed"] == fresh_db.table_names()
     assert [{"foo": "bar"}] == list(fresh_db["renamed"].rows)
     # Should error if table does not exist:
-    with pytest.raises(sqlite3.SQLError):
+    with pytest.raises(apsw.SQLError):
         fresh_db.rename_table("does_not_exist", "renamed")
 
 

tests/test_recreate.py

@@ -1,5 +1,5 @@
+import apsw
 from apswutils import Database
-import sqlite3
 import pathlib
 import pytest
 
@@ -13,7 +13,7 @@ def test_recreate_ignored_for_in_memory():
 
 
 def test_recreate_not_allowed_for_connection():
-    conn = sqlite3.connect(":memory:")
+    conn = apsw.Connection(":memory:")
     with pytest.raises(AssertionError):
         Database(conn, recreate=True)
 

tests/test_register_function.py

@@ -2,7 +2,7 @@
 import pytest
 import sys
 from unittest.mock import MagicMock, call
-from apswutils.utils import sqlite3
+import apsw
 
 
 def test_register_function(fresh_db):
@@ -60,9 +60,9 @@ def side_effect(*args, **kwargs):
         nonlocal first
         if first:
             first = False
-            raise sqlite3.Error()
+            raise apsw.Error()
 
-    # But if sqlite3.NotSupportedError is raised, it tries again
+    # But if apsw.NotSupportedError is raised, it tries again
     fresh_db.conn.create_scalar_function.reset_mock()
     fresh_db.conn.create_scalar_function.side_effect = side_effect
 

tests/test_transform.py

@@ -1,6 +1,5 @@
 from apswutils.db import ForeignKey
 from apswutils.utils import OperationalError
-from sqlite3 import IntegrityError
 import pytest
 import apsw
 from collections.abc import Mapping
@@ -391,14 +390,14 @@ def test_transform_verify_foreign_keys(fresh_db):
     fresh_db["books"].insert(
         {"id": 1, "title": "Book", "author_id": 3}, pk="id", foreign_keys={"author_id"}
     )
-    # Renaming the id column on authors should break everything with an IntegrityError
+    # Renaming the id column on authors should break everything with an SQLError
     # The old error didn't match the Sqlite docs.
     # We use a transaction to constrain and rollback the error.
     fresh_db.begin()
     try:
         fresh_db["authors"].transform(rename={"id": "id2"})
         fresh_db.commit()
-    except apsw.ConstraintError:
+    except apsw.SQLError:
         fresh_db.rollback()
 
     # This should have rolled us back