avoid using sessions

Author: Kareem Zidane

setup.py

@@ -10,7 +10,7 @@
         "Topic :: Software Development :: Libraries :: Python Modules"
     ],
     description="CS50 library for Python",
-    install_requires=["Flask>=1.0", "SQLAlchemy", "sqlparse", "termcolor"],
+    install_requires=["Flask>=1.0", "SQLAlchemy<2", "sqlparse", "termcolor"],
     keywords="cs50",
     name="cs50",
     package_dir={"": "src"},

src/cs50/_engine.py

@@ -0,0 +1,66 @@
+import threading
+
+from ._engine_util import create_engine
+
+
+thread_local_data = threading.local()
+
+
+class Engine:
+    """Wraps a SQLAlchemy engine.
+    """
+
+    def __init__(self, url):
+        self._engine = create_engine(url)
+
+    def get_transaction_connection(self):
+        """
+        :returns: A new connection with autocommit disabled (to be used for transactions).
+        """
+
+        _thread_local_connections()[self] = self._engine.connect().execution_options(
+            autocommit=False)
+        return self.get_existing_transaction_connection()
+
+    def get_connection(self):
+        """
+        :returns: A new connection with autocommit enabled
+        """
+
+        return self._engine.connect().execution_options(autocommit=True)
+
+    def get_existing_transaction_connection(self):
+        """
+        :returns: The transaction connection bound to this Engine instance, if one exists, or None.
+        """
+
+        return _thread_local_connections().get(self)
+
+    def close_transaction_connection(self):
+        """Closes the transaction connection bound to this Engine instance, if one exists and
+        removes it.
+        """
+
+        connection = self.get_existing_transaction_connection()
+        if connection:
+            connection.close()
+            del _thread_local_connections()[self]
+
+    def is_postgres(self):
+        return self._engine.dialect.name in {"postgres", "postgresql"}
+
+    def __getattr__(self, attr):
+        return getattr(self._engine, attr)
+
+def _thread_local_connections():
+    """
+    :returns: A thread local dict to keep track of transaction connection. If one does not exist,
+    creates one.
+    """
+
+    try:
+        connections = thread_local_data.connections
+    except AttributeError:
+        connections = thread_local_data.connections = {}
+
+    return connections

src/cs50/_engine_util.py

@@ -0,0 +1,43 @@
+"""Utility functions used by _session.py.
+"""
+
+import os
+import sqlite3
+
+import sqlalchemy
+
+sqlite_url_prefix = "sqlite:///"
+
+
+def create_engine(url, **kwargs):
+    """Creates a new SQLAlchemy engine. If ``url`` is a URL for a SQLite database, makes sure that
+    the SQLite file exits and enables foreign key constraints.
+    """
+
+    try:
+        engine = sqlalchemy.create_engine(url, **kwargs)
+    except sqlalchemy.exc.ArgumentError:
+        raise RuntimeError(f"invalid URL: {url}") from None
+
+    if _is_sqlite_url(url):
+        _assert_sqlite_file_exists(url)
+        sqlalchemy.event.listen(engine, "connect", _enable_sqlite_foreign_key_constraints)
+
+    return engine
+
+def _is_sqlite_url(url):
+    return url.startswith(sqlite_url_prefix)
+
+
+def _assert_sqlite_file_exists(url):
+    path = url[len(sqlite_url_prefix):]
+    if not os.path.exists(path):
+        raise RuntimeError(f"does not exist: {path}")
+    if not os.path.isfile(path):
+        raise RuntimeError(f"not a file: {path}")
+
+
+def _enable_sqlite_foreign_key_constraints(dbapi_connection, _):
+    cursor = dbapi_connection.cursor()
+    cursor.execute("PRAGMA foreign_keys=ON")
+    cursor.close()

src/cs50/_session.py

@@ -5,6 +5,8 @@
 import decimal
 import warnings
 
+import sqlalchemy
+
 
 def process_select_result(result):
     """Converts a SQLAlchemy result to a ``list`` of ``dict`` objects, each of which represents a
@@ -36,3 +38,14 @@ def raise_errors_for_warnings():
     with warnings.catch_warnings():
         warnings.simplefilter("error")
         yield
+
+
+def postgres_lastval(connection):
+    """
+    :returns: The ID of the last inserted row, if defined in this session, or None
+    """
+
+    try:
+        return connection.execute("SELECT LASTVAL()").first()[0]
+    except sqlalchemy.exc.OperationalError:
+        return None

src/cs50/_session_util.py

@@ -64,7 +64,7 @@ def __init__(self, sql_sanitizer, sql, *args, **kwargs):
         self._paramstyle = self._get_paramstyle()
         self._placeholders = self._get_placeholders()
         self._substitute_markers_with_escaped_params()
-        self._escape_verbatim_colons()
+        # self._escape_verbatim_colons()
 
     def _get_escaped_args(self, args):
         return [self._sql_sanitizer.escape(arg) for arg in args]