update to pyramid 2.0 (#6969)

* update to pyramid 2.0
sqlalchemy 1.4 optimisation

* python 3.10

* randint -> sample for generating unique sequences

* force mark `obj.randomNumber` as modified

Author: slav0nic

frameworks/Python/pyramid/README.md

@@ -8,7 +8,7 @@ review the [documentation](https://github.com/TechEmpower/FrameworkBenchmarks/wi
 Also note that there is additional information that's provided in 
 the [Python README](../).
 
-[Pyramid](http://www.pylonsproject.org/) is a flexible Python 2/3 framework.
+[Pyramid](http://www.pylonsproject.org/) is a flexible Python 3 framework.
 This test uses [SQLAlchemy](http://www.sqlalchemy.org/) as its ORM, the default
 [Chameleon](http://www.pylonsproject.org/) for its templating, and
 [Gunicorn](https://github.com/benoitc/gunicorn) for the application server.
@@ -28,5 +28,5 @@ This test uses [SQLAlchemy](http://www.sqlalchemy.org/) as its ORM, the default
 
 ### Community
 
-* `#pyramid` IRC Channel ([irc.freenode.net](https://freenode.net/))
+* `#pyramid` IRC Channel ([irc.libera.chat](https://libera.chat))
 * [Pyramid (pylons-discuss) Google Group](https://groups.google.com/forum/#!forum/pylons-discuss)

frameworks/Python/pyramid/benchmark_config.json

@@ -23,29 +23,6 @@
       "display_name": "Pyramid",
       "notes": "",
       "versus": "wsgi"
-    },
-    "py2": {
-      "json_url": "/json",
-      "db_url": "/db",
-      "query_url": "/queries?queries=",
-      "fortune_url": "/fortunes",
-      "update_url": "/updates?queries=",
-      "plaintext_url": "/plaintext",
-      "port": 8080,
-      "approach": "Realistic",
-      "classification": "Fullstack",
-      "database": "Postgres",
-      "framework": "pyramid",
-      "language": "Python",
-      "flavor": "Python2",
-      "orm": "Full",
-      "platform": "None",
-      "webserver": "Meinheld",
-      "os": "Linux",
-      "database_os": "Linux",
-      "display_name": "Pyramid",
-      "notes": "",
-      "versus": "wsgi"
     }
   }]
 }

frameworks/Python/pyramid/config.toml

@@ -17,20 +17,3 @@ orm = "Full"
 platform = "None"
 webserver = "Meinheld"
 versus = "wsgi"
-
-[py2]
-urls.plaintext = "/plaintext"
-urls.json = "/json"
-urls.db = "/db"
-urls.query = "/queries?queries="
-urls.update = "/updates?queries="
-urls.fortune = "/fortunes"
-approach = "Realistic"
-classification = "Fullstack"
-database = "Postgres"
-database_os = "Linux"
-os = "Linux"
-orm = "Full"
-platform = "None"
-webserver = "Meinheld"
-versus = "wsgi"

frameworks/Python/pyramid/create_database.py

@@ -11,15 +11,18 @@ pyramid.debug_authorization = false
 pyramid.debug_notfound = false
 pyramid.debug_routematch = false
 pyramid.default_locale_name = en
+pyramid.includes = pyramid_debugtoolbar
+debugtoolbar.active_panels = performance
+sqlalchemy.url = postgresql:///frameworkbenchmarks
 
 ###
 # wsgi server configuration
 ###
 
 [server:main]
-use = egg:gunicorn#main
+use = egg:waitress#main
 host = 0.0.0.0
-port = 6543
+port = 8080
 
 ###
 # logging configuration

frameworks/Python/pyramid/development.ini

@@ -2,19 +2,39 @@
 App config and initialization.
 """
 
+import orjson
 from pyramid.config import Configurator
+from pyramid.renderers import JSON
+from .models import get_engine, get_session_factory
+
+
+def dbsession(request):
+    sess = request.registry.dbsession_factory()
+
+    def cleanup(request):
+        sess.close()
+
+    request.add_finished_callback(cleanup)
+    return sess
 
 
 def main(global_config, **settings):
-    """ This function returns a Pyramid WSGI application.
-    """
-    config = Configurator(settings=settings)
-    config.include('pyramid_chameleon')
-    config.add_route('test_1', '/json')
-    config.add_route('test_2', '/db')
-    config.add_route('test_3', '/queries')
-    config.add_route('test_4', '/fortunes')
-    config.add_route('test_5', '/updates')
-    config.add_route('test_6', '/plaintext')
-    config.scan()
+    """This function returns a Pyramid WSGI application."""
+    json_renderer = JSON(serializer=orjson.dumps)
+    with Configurator(settings=settings) as config:
+        config.include("pyramid_chameleon")
+        config.add_renderer("json", json_renderer)
+        config.add_route("test_1", "/json")
+        config.add_route("test_2", "/db")
+        config.add_route("test_3", "/queries")
+        config.add_route("test_4", "/fortunes")
+        config.add_route("test_5", "/updates")
+        config.add_route("test_6", "/plaintext")
+        config.set_default_csrf_options(require_csrf=False)
+
+        engine = get_engine(settings)
+        config.registry.dbsession_factory = get_session_factory(engine)
+        config.add_request_method(dbsession, reify=True)
+
+        config.scan()
     return config.make_wsgi_app()

frameworks/Python/pyramid/frameworkbenchmarks/__init__.py

@@ -2,50 +2,48 @@
 Benchmark models.
 """
 
-import json
-import os
-import psycopg2
-from collections import Iterable
-from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String
-from sqlalchemy.orm import sessionmaker
+
+from sqlalchemy import Column, Integer, MetaData, String, create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
 from sqlalchemy.pool import QueuePool
-from sqlalchemy.ext.declarative import declarative_base, DeclarativeMeta
 
 
-def get_conn():
-    return psycopg2.connect(
-        user='benchmarkdbuser',
-        password='benchmarkdbpass',
-        host='tfb-database',
-        port='5432',
-        database='hello_world')
+def get_engine(settings):
+    return create_engine(
+        settings["sqlalchemy.url"],
+        poolclass=QueuePool,
+        pool_size=100,
+        max_overflow=25,
+        enable_from_linting=False,
+        future=True,
+    )
+
 
+def get_session_factory(engine):
+    Session = sessionmaker(bind=engine, autoflush=False, future=True)
+    return Session
 
-conn_pool = QueuePool(get_conn, pool_size=100, max_overflow=25, echo=False)
 
-pg = create_engine('postgresql://', pool=conn_pool)
-DBSession = sessionmaker(bind=pg)()
 metadata = MetaData()
 
-DatabaseBase = declarative_base()
+Base = declarative_base()
 
 
-class World(DatabaseBase):
-    __tablename__ = 'world'
+class World(Base):
+    __tablename__ = "world"
 
-    id = Column('id', Integer, primary_key=True)
-    randomNumber = Column(
-        'randomnumber', Integer, nullable=False, server_default='0')
+    id = Column("id", Integer, primary_key=True)
+    randomNumber = Column("randomnumber", Integer, nullable=False, server_default="0")
 
     def __json__(self, request=None):
-        return {'id': self.id, 'randomNumber': self.randomNumber}
+        return {"id": self.id, "randomNumber": self.randomNumber}
 
 
-class Fortune(DatabaseBase):
-    __tablename__ = 'fortune'
+class Fortune(Base):
+    __tablename__ = "fortune"
 
-    id = Column('id', Integer, primary_key=True)
-    message = Column('message', String, nullable=False)
+    id = Column("id", Integer, primary_key=True)
+    message = Column("message", String, nullable=False)
 
     def __json__(self):
-        return {'id': self.id, 'message': self.message}
+        return {"id": self.id, "message": self.message}

frameworks/Python/pyramid/frameworkbenchmarks/models.py

@@ -1,83 +1,77 @@
-# encoding: utf-8
-
 import unittest
 import json
-import sys
+
 
 class FunctionalTests(unittest.TestCase):
     def setUp(self):
         from frameworkbenchmarks import main
-        app = main({})
         from webtest import TestApp
+
+        app = main({}, **{"sqlalchemy.url": "postgresql:///frameworkbenchmarks"})
+
         self.testapp = TestApp(app)
-        self.py3k = sys.version_info >= (3, 0)
 
-    def _get(self, url, content_type='application/json'):
+    def _get(self, url, content_type="application/json"):
         res = self.testapp.get(url, status=200)
-        self.assertTrue('Content-Length' in res.headers)
+        self.assertTrue("Content-Length" in res.headers)
         return res
 
-    def _str_compat(self, obj):
-        if self.py3k:
-            return obj.decode('utf-8')
-        return obj
-
     def _test_obj(self, obj):
-        self.assertTrue('id' in obj)
-        self.assertTrue('randomNumber' in obj)
-        self.assertTrue(1 <= obj['randomNumber'] <= 10000)
+        self.assertTrue("id" in obj)
+        self.assertTrue("randomNumber" in obj)
+        self.assertTrue(1 <= obj["randomNumber"] <= 10000)
 
     def test_json(self):
         """
         /json
         """
-        res = self._get('/json')
-        self.assertEqual(self._str_compat(res.body), """{"message": "Hello, World!"}""")
+        res = self._get("/json")
+        self.assertEqual(res.body, b"""{"message":"Hello, World!"}""")
 
     def test_db(self):
         """
         /db
         """
-        res = self._get('/db')
-        obj = json.loads(self._str_compat(res.body))
+        res = self._get("/db")
+        obj = json.loads(res.body)
         self._test_obj(obj)
 
     def test_queries_0(self):
         """
         /queries?queries=0
         """
-        res = self._get('/queries?queries=0')
-        self.assertEqual(len(json.loads(self._str_compat(res.body))), 1)
+        res = self._get("/queries?queries=0")
+        self.assertEqual(len(json.loads(res.body)), 1)
 
     def test_queries_999(self):
         """
         /queries?queries=999
         """
-        res = self._get('/queries?queries=999')
-        self.assertEqual(len(json.loads(self._str_compat(res.body))), 500)
+        res = self._get("/queries?queries=999")
+        self.assertEqual(len(json.loads(res.body)), 500)
 
     def test_queries_10(self):
         """
         /queries?queries=10 objects
         """
-        res = self._get('/queries?queries=10')
-        objset = json.loads(self._str_compat(res.body))
+        res = self._get("/queries?queries=10")
+        objset = json.loads(res.body)
         for obj in objset:
             self._test_obj(obj)
 
     def test_fortunes(self):
         """
         /fortunes
         """
-        res = self._get('/fortunes')
-        self.assertEqual(self._str_compat(res.body).strip(), fortunes.strip())
+        res = self._get("/fortunes")
+        self.assertEqual(res.body.decode('utf-8').strip(), fortunes.strip())
 
     def test_updates(self):
         """
         /updates?queries=10
         """
-        res = self._get('/updates?queries=10')
-        objset = json.loads(self._str_compat(res.body))
+        res = self._get("/updates?queries=10")
+        objset = json.loads(res.body)
         # don't bother with more...
         for obj in objset:
             self._test_obj(obj)
@@ -86,8 +80,8 @@ def test_plaintext(self):
         """
         /plaintext
         """
-        res = self._get('/plaintext', content_type='text/plain')
-        self.assertEqual(self._str_compat(res.body), "Hello, World!")
+        res = self._get("/plaintext", content_type="text/plain")
+        self.assertEqual(res.body, b"Hello, World!")
 
 
 fortunes = """