porting thread-local storage to v6

Author: dmalan

.gitignore

@@ -1,10 +1,6 @@
 .*
-!.github
+!/.github/
 !.gitignore
-!.travis.yml
 *.db
 *.egg-info/
 *.pyc
-build/
-dist/
-test.db

setup.py

@@ -10,11 +10,11 @@
         "Topic :: Software Development :: Libraries :: Python Modules"
     ],
     description="CS50 library for Python",
-    install_requires=["Flask>=1.0", "SQLAlchemy<2", "sqlparse", "termcolor"],
+    install_requires=["Flask>=1.0", "SQLAlchemy", "sqlparse", "termcolor"],
     keywords="cs50",
     name="cs50",
     package_dir={"": "src"},
     packages=["cs50"],
     url="https://github.com/cs50/python-cs50",
-    version="7.0.2"
+    version="7.1.0"
 )

src/cs50/__init__.py

@@ -1,5 +1,20 @@
-from .cs50 import get_float, get_int, get_string
-from .sql import SQL
-from ._logger import _setup_logger
+import logging
+import os
+import sys
+
+
+# Disable cs50 logger by default
+logging.getLogger("cs50").disabled = True
 
-_setup_logger()
+# Import cs50_*
+from .cs50 import get_char, get_float, get_int, get_string
+try:
+    from .cs50 import get_long
+except ImportError:
+    pass
+
+# Hook into flask importing
+from . import flask
+
+# Wrap SQLAlchemy
+from .sql import SQL

src/cs50/_engine.py

@@ -1,104 +1,143 @@
-"""Exposes simple API for getting and validating user input"""
+from __future__ import print_function
 
+import inspect
+import logging
+import os
 import re
 import sys
 
+from distutils.sysconfig import get_python_lib
+from os.path import abspath, join
+from termcolor import colored
+from traceback import format_exception
 
-def get_float(prompt):
-    """Reads a line of text from standard input and returns the equivalent float as precisely as
-    possible; if text does not represent a float, user is prompted to retry. If line can't be read,
-    returns None.
 
-    :type prompt: str
+# Configure default logging handler and formatter
+# Prevent flask, werkzeug, etc from adding default handler
+logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG)
 
-    """
+try:
+    # Patch formatException
+    logging.root.handlers[0].formatter.formatException = lambda exc_info: _formatException(*exc_info)
+except IndexError:
+    pass
 
-    while True:
-        try:
-            return _get_float(prompt)
-        except (OverflowError, ValueError):
-            pass
+# Configure cs50 logger
+_logger = logging.getLogger("cs50")
+_logger.setLevel(logging.DEBUG)
 
+# Log messages once
+_logger.propagate = False
 
-def _get_float(prompt):
-    user_input = get_string(prompt)
-    if user_input is None:
-        return None
-
-    if len(user_input) > 0 and re.search(r"^[+-]?\d*(?:\.\d*)?$", user_input):
-        return float(user_input)
+handler = logging.StreamHandler()
+handler.setLevel(logging.DEBUG)
 
-    raise ValueError(f"invalid float literal: {user_input}")
+formatter = logging.Formatter("%(levelname)s: %(message)s")
+formatter.formatException = lambda exc_info: _formatException(*exc_info)
+handler.setFormatter(formatter)
+_logger.addHandler(handler)
 
 
-def get_int(prompt):
-    """Reads a line of text from standard input and return the equivalent int; if text does not
-    represent an int, user is prompted to retry. If line can't be read, returns None.
+class _flushfile():
+    """
+    Disable buffering for standard output and standard error.
 
-    :type prompt: str
+    http://stackoverflow.com/a/231216
     """
 
-    while True:
-        try:
-            return _get_int(prompt)
-        except (MemoryError, ValueError):
-            pass
+    def __init__(self, f):
+        self.f = f
 
+    def __getattr__(self, name):
+        return object.__getattribute__(self.f, name)
 
-def _get_int(prompt):
-    user_input = get_string(prompt)
-    if user_input is None:
-        return None
+    def write(self, x):
+        self.f.write(x)
+        self.f.flush()
 
-    if re.search(r"^[+-]?\d+$", user_input):
-        return int(user_input, 10)
 
-    raise ValueError(f"invalid int literal for base 10: {user_input}")
+sys.stderr = _flushfile(sys.stderr)
+sys.stdout = _flushfile(sys.stdout)
 
 
-def get_string(prompt):
-    """Reads a line of text from standard input and returns it as a string, sans trailing line
-    ending. Supports CR (\r), LF (\n), and CRLF (\r\n) as line endings. If user inputs only a line
-    ending, returns "", not None.  Returns None upon error or no input whatsoever (i.e., just EOF).
+def _formatException(type, value, tb):
+    """
+    Format traceback, darkening entries from global site-packages directories
+    and user-specific site-packages directory.
 
-    :type prompt: str
+    https://stackoverflow.com/a/46071447/5156190
     """
 
-    if not isinstance(prompt, str):
-        raise TypeError("prompt must be of type str")
+    # Absolute paths to site-packages
+    packages = tuple(join(abspath(p), "") for p in sys.path[1:])
 
-    try:
-        return _get_input(prompt)
-    except EOFError:
-        return None
+    # Highlight lines not referring to files in site-packages
+    lines = []
+    for line in format_exception(type, value, tb):
+        matches = re.search(r"^  File \"([^\"]+)\", line \d+, in .+", line)
+        if matches and matches.group(1).startswith(packages):
+            lines += line
+        else:
+            matches = re.search(r"^(\s*)(.*?)(\s*)$", line, re.DOTALL)
+            lines.append(matches.group(1) + colored(matches.group(2), "yellow") + matches.group(3))
+    return "".join(lines).rstrip()
 
 
-def _get_input(prompt):
-    return input(prompt)
+sys.excepthook = lambda type, value, tb: print(_formatException(type, value, tb), file=sys.stderr)
 
 
-class _flushfile():
-    """ Disable buffering for standard output and standard error.
-    http://stackoverflow.com/a/231216
-    """
+def eprint(*args, **kwargs):
+    raise RuntimeError("The CS50 Library for Python no longer supports eprint, but you can use print instead!")
 
-    def __init__(self, stream):
-        self.stream = stream
 
-    def __getattr__(self, name):
-        return object.__getattribute__(self.stream, name)
+def get_char(prompt):
+    raise RuntimeError("The CS50 Library for Python no longer supports get_char, but you can use get_string instead!")
 
-    def write(self, data):
-        """Writes data to stream"""
-        self.stream.write(data)
-        self.stream.flush()
 
+def get_float(prompt):
+    """
+    Read a line of text from standard input and return the equivalent float
+    as precisely as possible; if text does not represent a double, user is
+    prompted to retry. If line can't be read, return None.
+    """
+    while True:
+        s = get_string(prompt)
+        if s is None:
+            return None
+        if len(s) > 0 and re.search(r"^[+-]?\d*(?:\.\d*)?$", s):
+            try:
+                return float(s)
+            except (OverflowError, ValueError):
+                pass
 
-def disable_output_buffering():
-    """Disables output buffering to prevent prompts from being buffered.
+
+def get_int(prompt):
     """
-    sys.stderr = _flushfile(sys.stderr)
-    sys.stdout = _flushfile(sys.stdout)
+    Read a line of text from standard input and return the equivalent int;
+    if text does not represent an int, user is prompted to retry. If line
+    can't be read, return None.
+    """
+    while True:
+        s = get_string(prompt)
+        if s is None:
+            return None
+        if re.search(r"^[+-]?\d+$", s):
+            try:
+                return int(s, 10)
+            except ValueError:
+                pass
 
 
-disable_output_buffering()
+def get_string(prompt):
+    """
+    Read a line of text from standard input and return it as a string,
+    sans trailing line ending. Supports CR (\r), LF (\n), and CRLF (\r\n)
+    as line endings. If user inputs only a line ending, returns "", not None.
+    Returns None upon error or no input whatsoever (i.e., just EOF).
+    """
+    if type(prompt) is not str:
+        raise TypeError("prompt must be of type str")
+    try:
+        return input(prompt)
+    except EOFError:
+        return None

src/cs50/_engine_util.py

@@ -0,0 +1,38 @@
+import os
+import pkgutil
+import sys
+
+def _wrap_flask(f):
+    if f is None:
+        return
+
+    from distutils.version import StrictVersion
+    from .cs50 import _formatException
+
+    if f.__version__ < StrictVersion("1.0"):
+        return
+
+    if os.getenv("CS50_IDE_TYPE") == "online":
+        from werkzeug.middleware.proxy_fix import ProxyFix
+        _flask_init_before = f.Flask.__init__
+        def _flask_init_after(self, *args, **kwargs):
+            _flask_init_before(self, *args, **kwargs)
+            self.wsgi_app = ProxyFix(self.wsgi_app, x_proto=1)  # For HTTPS-to-HTTP proxy
+        f.Flask.__init__ = _flask_init_after
+
+
+# If Flask was imported before cs50
+if "flask" in sys.modules:
+    _wrap_flask(sys.modules["flask"])
+
+# If Flask wasn't imported
+else:
+    flask_loader = pkgutil.get_loader('flask')
+    if flask_loader:
+        _exec_module_before = flask_loader.exec_module
+
+        def _exec_module_after(*args, **kwargs):
+            _exec_module_before(*args, **kwargs)
+            _wrap_flask(sys.modules["flask"])
+
+        flask_loader.exec_module = _exec_module_after

src/cs50/_logger.py

@@ -0,0 +1,22 @@
+import requests
+import sys
+from flask import Flask, render_template
+
+sys.path.insert(0, "../../src")
+
+import cs50
+import cs50.flask
+
+app = Flask(__name__)
+
+db = cs50.SQL("sqlite:///../sqlite.db")
+
+@app.route("/")
+def index():
+    db.execute("SELECT 1")
+    """
+    def f():
+        res = requests.get("cs50.harvard.edu")
+    f()
+    """
+    return render_template("index.html")

src/cs50/_sql_sanitizer.py

@@ -0,0 +1,2 @@
+cs50
+Flask

src/cs50/_sql_util.py

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+
+<html>
+    <head>
+        <title>error</title>
+    </head>
+    <body>
+        error
+    </body>
+</html>

src/cs50/_statement.py

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+
+<html>
+    <head>
+        <title>flask</title>
+    </head>
+    <body>
+        flask
+    </body>
+</html>

src/cs50/_statement_util.py

@@ -0,0 +1,48 @@
+import logging
+import sys
+
+sys.path.insert(0, "../src")
+
+import cs50
+
+"""
+db = cs50.SQL("sqlite:///foo.db")
+
+logging.getLogger("cs50").disabled = False
+
+#db.execute("SELECT ? FROM ? ORDER BY ?", "a", "tbl", "c")
+db.execute("CREATE TABLE IF NOT EXISTS bar (firstname STRING)")
+
+db.execute("INSERT INTO bar VALUES (?)", "baz")
+db.execute("INSERT INTO bar VALUES (?)", "qux")
+db.execute("SELECT * FROM bar WHERE firstname IN (?)", ("baz", "qux"))
+db.execute("DELETE FROM bar")
+"""
+
+db = cs50.SQL("postgresql://postgres@localhost/test")
+
+"""
+print(db.execute("DROP TABLE IF EXISTS cs50"))
+print(db.execute("CREATE TABLE cs50 (id SERIAL PRIMARY KEY, val VARCHAR(16), bin BYTEA)"))
+print(db.execute("INSERT INTO cs50 (val) VALUES('foo')"))
+print(db.execute("SELECT * FROM cs50"))
+
+print(db.execute("DROP TABLE IF EXISTS cs50"))
+print(db.execute("CREATE TABLE cs50 (val VARCHAR(16), bin BYTEA)"))
+print(db.execute("INSERT INTO cs50 (val) VALUES('foo')"))
+print(db.execute("SELECT * FROM cs50"))
+"""
+
+print(db.execute("DROP TABLE IF EXISTS cs50"))
+print(db.execute("CREATE TABLE cs50 (id SERIAL PRIMARY KEY, val VARCHAR(16), bin BYTEA)"))
+print(db.execute("INSERT INTO cs50 (val) VALUES('foo')"))
+print(db.execute("INSERT INTO cs50 (val) VALUES('bar')"))
+print(db.execute("INSERT INTO cs50 (val) VALUES('baz')"))
+print(db.execute("SELECT * FROM cs50"))
+try:
+    print(db.execute("INSERT INTO cs50 (id, val) VALUES(1, 'bar')"))
+except Exception as e:
+    print(e)
+    pass
+print(db.execute("INSERT INTO cs50 (val) VALUES('qux')"))
+#print(db.execute("DELETE FROM cs50"))

src/cs50/cs50.py

@@ -0,0 +1,8 @@
+import sys
+
+sys.path.insert(0, "../src")
+
+from cs50 import SQL
+
+db = SQL("mysql://root@localhost/test")
+db.execute("SELECT 1")

src/cs50/flask.py

@@ -0,0 +1,8 @@
+import sys
+
+sys.path.insert(0, "../src")
+
+import cs50
+
+i = cs50.get_int("Input:  ")
+print(f"Output: {i}")

src/cs50/sql.py

@@ -0,0 +1,12 @@
+import cs50
+from flask import Flask, redirect, render_template
+
+app = Flask(__name__)
+
+@app.route("/")
+def index():
+    return redirect("/foo")
+
+@app.route("/foo")
+def foo():
+    return render_template("foo.html")

tests/flask/application.py

@@ -0,0 +1 @@
+foo

tests/flask/requirements.txt

@@ -9,6 +9,7 @@
 
 
 class SQLTests(unittest.TestCase):
+
     def test_multiple_statements(self):
         self.assertRaises(RuntimeError, self.db.execute, "INSERT INTO cs50(val) VALUES('baz'); INSERT INTO cs50(val) VALUES('qux')")
 
@@ -27,7 +28,6 @@ def test_delete_returns_affected_rows(self):
     def test_insert_returns_last_row_id(self):
         self.assertEqual(self.db.execute("INSERT INTO cs50(val) VALUES('foo')"), 1)
         self.assertEqual(self.db.execute("INSERT INTO cs50(val) VALUES('bar')"), 2)
-        self.assertEqual(self.db.execute("INSERT INTO cs50(val) VALUES('qux')"), 3)
 
     def test_select_all(self):
         self.assertEqual(self.db.execute("SELECT * FROM cs50"), [])
@@ -132,13 +132,64 @@ def test_rollback(self):
     def test_identifier_case(self):
         self.assertIn("count", self.db.execute("SELECT 1 AS count")[0])
 
-    def test_none(self):
-        self.db.execute("CREATE TABLE foo (val INTEGER)")
-        self.db.execute("SELECT * FROM foo WHERE val = ?", None)
+    def tearDown(self):
+        self.db.execute("DROP TABLE cs50")
+        self.db.execute("DROP TABLE IF EXISTS foo")
+        self.db.execute("DROP TABLE IF EXISTS bar")
+
+    @classmethod
+    def tearDownClass(self):
+        try:
+            self.db.execute("DROP TABLE IF EXISTS cs50")
+        except Warning as e:
+            # suppress "unknown table"
+            if not str(e).startswith("(1051"):
+                raise e
+
+
+class MySQLTests(SQLTests):
+    @classmethod
+    def setUpClass(self):
+        self.db = SQL("mysql://root@localhost/test")
+
+    def setUp(self):
+        self.db.execute("CREATE TABLE IF NOT EXISTS cs50 (id INTEGER NOT NULL AUTO_INCREMENT, val VARCHAR(16), bin BLOB, PRIMARY KEY (id))")
+        self.db.execute("DELETE FROM cs50")
+
+
+class PostgresTests(SQLTests):
+    @classmethod
+    def setUpClass(self):
+        self.db = SQL("postgresql://postgres@localhost/test")
+
+    def setUp(self):
+        self.db.execute("CREATE TABLE IF NOT EXISTS cs50 (id SERIAL PRIMARY KEY, val VARCHAR(16), bin BYTEA)")
+        self.db.execute("DELETE FROM cs50")
+
+    def test_cte(self):
+        self.assertEqual(self.db.execute("WITH foo AS ( SELECT 1 AS bar ) SELECT bar FROM foo"), [{"bar": 1}])
+
+
+class SQLiteTests(SQLTests):
+
+    @classmethod
+    def setUpClass(self):
+        open("test.db", "w").close()
+        self.db = SQL("sqlite:///test.db")
+
+    def setUp(self):
+        self.db.execute("CREATE TABLE IF NOT EXISTS cs50 (id INTEGER PRIMARY KEY, val TEXT, bin BLOB)")
+        self.db.execute("DELETE FROM cs50")
+
+    def test_lastrowid(self):
+        self.db.execute("CREATE TABLE foo(id INTEGER PRIMARY KEY AUTOINCREMENT, firstname TEXT, lastname TEXT)")
+        self.assertEqual(self.db.execute("INSERT INTO foo (firstname, lastname) VALUES('firstname', 'lastname')"), 1)
+        self.assertRaises(ValueError, self.db.execute, "INSERT INTO foo (id, firstname, lastname) VALUES(1, 'firstname', 'lastname')")
+        self.assertEqual(self.db.execute("INSERT OR IGNORE INTO foo (id, firstname, lastname) VALUES(1, 'firstname', 'lastname')"), None)
 
     def test_integrity_constraints(self):
         self.db.execute("CREATE TABLE foo(id INTEGER PRIMARY KEY)")
-        self.db.execute("INSERT INTO foo VALUES(1)")
+        self.assertEqual(self.db.execute("INSERT INTO foo VALUES(1)"), 1)
         self.assertRaises(ValueError, self.db.execute, "INSERT INTO foo VALUES(1)")
 
     def test_foreign_key_support(self):
@@ -147,7 +198,7 @@ def test_foreign_key_support(self):
         self.assertRaises(ValueError, self.db.execute, "INSERT INTO bar VALUES(50)")
 
     def test_qmark(self):
-        self.db.execute("CREATE TABLE foo (firstname VARCHAR(255), lastname VARCHAR(255))")
+        self.db.execute("CREATE TABLE foo (firstname STRING, lastname STRING)")
 
         self.db.execute("INSERT INTO foo VALUES (?, 'bar')", "baz")
         self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "baz", "lastname": "bar"}])
@@ -177,7 +228,7 @@ def test_qmark(self):
         self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "bar", "lastname": "baz"}])
         self.db.execute("DELETE FROM foo")
 
-        self.db.execute("CREATE TABLE bar (firstname VARCHAR(255))")
+        self.db.execute("CREATE TABLE bar (firstname STRING)")
 
         self.db.execute("INSERT INTO bar VALUES (?)", "baz")
         self.assertEqual(self.db.execute("SELECT * FROM bar"), [{"firstname": "baz"}])
@@ -201,7 +252,7 @@ def test_qmark(self):
         self.assertRaises(RuntimeError, self.db.execute, "INSERT INTO foo VALUES (?, ?)", 'bar', baz='baz')
 
     def test_named(self):
-        self.db.execute("CREATE TABLE foo (firstname VARCHAR(255), lastname VARCHAR(255))")
+        self.db.execute("CREATE TABLE foo (firstname STRING, lastname STRING)")
 
         self.db.execute("INSERT INTO foo VALUES (:baz, 'bar')", baz="baz")
         self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "baz", "lastname": "bar"}])
@@ -223,11 +274,7 @@ def test_named(self):
         self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "bar", "lastname": "baz"}])
         self.db.execute("DELETE FROM foo")
 
-        self.db.execute("INSERT INTO foo VALUES (:baz, :baz)", baz="baz")
-        self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "baz", "lastname": "baz"}])
-        self.db.execute("DELETE FROM foo")
-
-        self.db.execute("CREATE TABLE bar (firstname VARCHAR(255))")
+        self.db.execute("CREATE TABLE bar (firstname STRING)")
         self.db.execute("INSERT INTO bar VALUES (:baz)", baz="baz")
         self.assertEqual(self.db.execute("SELECT * FROM bar"), [{"firstname": "baz"}])
 
@@ -236,8 +283,9 @@ def test_named(self):
         self.assertRaises(RuntimeError, self.db.execute, "INSERT INTO foo VALUES (:bar, :baz)", bar='bar', baz='baz', qux='qux')
         self.assertRaises(RuntimeError, self.db.execute, "INSERT INTO foo VALUES (:bar, :baz)", 'baz', bar='bar')
 
+
     def test_numeric(self):
-        self.db.execute("CREATE TABLE foo (firstname VARCHAR(255), lastname VARCHAR(255))")
+        self.db.execute("CREATE TABLE foo (firstname STRING, lastname STRING)")
 
         self.db.execute("INSERT INTO foo VALUES (:1, 'bar')", "baz")
         self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "baz", "lastname": "bar"}])
@@ -259,7 +307,7 @@ def test_numeric(self):
         self.assertEqual(self.db.execute("SELECT * FROM foo"), [{"firstname": "bar", "lastname": "baz"}])
         self.db.execute("DELETE FROM foo")
 
-        self.db.execute("CREATE TABLE bar (firstname VARCHAR(255))")
+        self.db.execute("CREATE TABLE bar (firstname STRING)")
         self.db.execute("INSERT INTO bar VALUES (:1)", "baz")
         self.assertEqual(self.db.execute("SELECT * FROM bar"), [{"firstname": "baz"}])
 
@@ -271,51 +319,6 @@ def test_numeric(self):
     def test_cte(self):
         self.assertEqual(self.db.execute("WITH foo AS ( SELECT 1 AS bar ) SELECT bar FROM foo"), [{"bar": 1}])
 
-    def tearDown(self):
-        self.db.execute("DROP TABLE IF EXISTS cs50")
-        self.db.execute("DROP TABLE IF EXISTS bar")
-        self.db.execute("DROP TABLE IF EXISTS foo")
-
-class MySQLTests(SQLTests):
-    @classmethod
-    def setUpClass(self):
-        self.db = SQL("mysql://root@127.0.0.1/test")
-
-    def setUp(self):
-        self.db.execute("CREATE TABLE IF NOT EXISTS cs50 (id INTEGER NOT NULL AUTO_INCREMENT, val VARCHAR(16), bin BLOB, PRIMARY KEY (id))")
-        self.db.execute("DELETE FROM cs50")
-
-class PostgresTests(SQLTests):
-    @classmethod
-    def setUpClass(self):
-        self.db = SQL("postgresql://postgres:postgres@127.0.0.1/test")
-
-    def setUp(self):
-        self.db.execute("CREATE TABLE IF NOT EXISTS cs50 (id SERIAL PRIMARY KEY, val VARCHAR(16), bin BYTEA)")
-        self.db.execute("DELETE FROM cs50")
-
-    def test_cte(self):
-        self.assertEqual(self.db.execute("WITH foo AS ( SELECT 1 AS bar ) SELECT bar FROM foo"), [{"bar": 1}])
-
-    def test_postgres_scheme(self):
-        db = SQL("postgres://postgres:postgres@127.0.0.1/test")
-        db.execute("SELECT 1")
-
-class SQLiteTests(SQLTests):
-    @classmethod
-    def setUpClass(self):
-        open("test.db", "w").close()
-        self.db = SQL("sqlite:///test.db")
-
-    def setUp(self):
-        self.db.execute("CREATE TABLE IF NOT EXISTS cs50 (id INTEGER PRIMARY KEY, val TEXT, bin BLOB)")
-        self.db.execute("DELETE FROM cs50")
-
-    def test_lastrowid(self):
-        self.db.execute("CREATE TABLE foo(id INTEGER PRIMARY KEY AUTOINCREMENT, firstname TEXT, lastname TEXT)")
-        self.assertEqual(self.db.execute("INSERT INTO foo (firstname, lastname) VALUES('firstname', 'lastname')"), 1)
-        self.assertRaises(ValueError, self.db.execute, "INSERT INTO foo (id, firstname, lastname) VALUES(1, 'firstname', 'lastname')")
-        self.assertEqual(self.db.execute("INSERT OR IGNORE INTO foo (id, firstname, lastname) VALUES(1, 'firstname', 'lastname')"), None)
 
 if __name__ == "__main__":
     suite = unittest.TestSuite([

tests/flask/templates/error.html

@@ -0,0 +1,44 @@
+import logging
+import sys
+
+sys.path.insert(0, "../src")
+
+from cs50 import SQL
+
+logging.getLogger("cs50").disabled = False
+
+db = SQL("sqlite:///sqlite.db")
+db.execute("SELECT 1")
+
+# TODO
+#db.execute("SELECT * FROM Employee WHERE FirstName = ?", b'\x00')
+
+db.execute("SELECT * FROM Employee WHERE FirstName = ?", "' OR 1 = 1")
+
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", "Andrew")
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", ["Andrew"])
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", ("Andrew",))
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", ["Andrew", "Nancy"])
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", ("Andrew", "Nancy"))
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", [])
+db.execute("SELECT * FROM Employee WHERE FirstName IN (?)", ())
+
+db.execute("SELECT * FROM Employee WHERE FirstName = ? AND LastName = ?", "Andrew", "Adams")
+db.execute("SELECT * FROM Employee WHERE FirstName = ? AND LastName = ?", ["Andrew", "Adams"])
+db.execute("SELECT * FROM Employee WHERE FirstName = ? AND LastName = ?", ("Andrew", "Adams"))
+
+db.execute("SELECT * FROM Employee WHERE FirstName = :1 AND LastName = :2", "Andrew", "Adams")
+db.execute("SELECT * FROM Employee WHERE FirstName = :1 AND LastName = :2", ["Andrew", "Adams"])
+db.execute("SELECT * FROM Employee WHERE FirstName = :1 AND LastName = :2", ("Andrew", "Adams"))
+
+db.execute("SELECT * FROM Employee WHERE FirstName = ':Andrew :Adams'")
+
+db.execute("SELECT * FROM Employee WHERE FirstName = :first AND LastName = :last", first="Andrew", last="Adams")
+db.execute("SELECT * FROM Employee WHERE FirstName = :first AND LastName = :last", {"first": "Andrew", "last": "Adams"})
+
+db.execute("SELECT * FROM Employee WHERE FirstName = %s AND LastName = %s", "Andrew", "Adams")
+db.execute("SELECT * FROM Employee WHERE FirstName = %s AND LastName = %s", ["Andrew", "Adams"])
+db.execute("SELECT * FROM Employee WHERE FirstName = %s AND LastName = %s", ("Andrew", "Adams"))
+
+db.execute("SELECT * FROM Employee WHERE FirstName = %(first)s AND LastName = %(last)s", first="Andrew", last="Adams")
+db.execute("SELECT * FROM Employee WHERE FirstName = %(first)s AND LastName = %(last)s", {"first": "Andrew", "last": "Adams"})

tests/flask/templates/index.html

@@ -0,0 +1,10 @@
+import sys
+
+sys.path.insert(0, "../src")
+
+import cs50
+import requests
+
+def f():
+    res = requests.get("cs50.harvard.edu")
+f()