remove databases, use SQLAlechemy 2.0 instead
Among the many changes we switch to using SQLAlchemy's connection pool, which means we are no longer required to guard against multiple threads working on the database. All db funcs now receive a connection to use as their first argument, this allows the caller to control transaction & rollback behavior.
This commit is contained in:
parent
c63bee072f
commit
4981de4a04
12 changed files with 876 additions and 765 deletions
129
poetry.lock
generated
129
poetry.lock
generated
|
|
@ -153,31 +153,6 @@ files = [
|
|||
[package.extras]
|
||||
toml = ["tomli"]
|
||||
|
||||
[[package]]
|
||||
name = "databases"
|
||||
version = "0.7.0"
|
||||
description = "Async database support for Python."
|
||||
optional = false
|
||||
python-versions = ">=3.7"
|
||||
files = [
|
||||
{file = "databases-0.7.0-py3-none-any.whl", hash = "sha256:cf5da4b8a3e3cd038c459529725ebb64931cbbb7a091102664f20ef8f6cefd0d"},
|
||||
{file = "databases-0.7.0.tar.gz", hash = "sha256:ea2d419d3d2eb80595b7ceb8f282056f080af62efe2fb9bcd83562f93ec4b674"},
|
||||
]
|
||||
|
||||
[package.dependencies]
|
||||
aiosqlite = {version = "*", optional = true, markers = "extra == \"sqlite\""}
|
||||
sqlalchemy = ">=1.4.42,<1.5"
|
||||
|
||||
[package.extras]
|
||||
aiomysql = ["aiomysql"]
|
||||
aiopg = ["aiopg"]
|
||||
aiosqlite = ["aiosqlite"]
|
||||
asyncmy = ["asyncmy"]
|
||||
asyncpg = ["asyncpg"]
|
||||
mysql = ["aiomysql"]
|
||||
postgresql = ["asyncpg"]
|
||||
sqlite = ["aiosqlite"]
|
||||
|
||||
[[package]]
|
||||
name = "greenlet"
|
||||
version = "3.0.1"
|
||||
|
|
@ -554,62 +529,90 @@ files = [
|
|||
|
||||
[[package]]
|
||||
name = "sqlalchemy"
|
||||
version = "1.4.50"
|
||||
version = "2.0.23"
|
||||
description = "Database Abstraction Library"
|
||||
optional = false
|
||||
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
|
||||
python-versions = ">=3.7"
|
||||
files = [
|
||||
{file = "SQLAlchemy-1.4.50-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d00665725063692c42badfd521d0c4392e83c6c826795d38eb88fb108e5660e5"},
|
||||
{file = "SQLAlchemy-1.4.50-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85292ff52ddf85a39367057c3d7968a12ee1fb84565331a36a8fead346f08796"},
|
||||
{file = "SQLAlchemy-1.4.50-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d0fed0f791d78e7767c2db28d34068649dfeea027b83ed18c45a423f741425cb"},
|
||||
{file = "SQLAlchemy-1.4.50-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db4db3c08ffbb18582f856545f058a7a5e4ab6f17f75795ca90b3c38ee0a8ba4"},
|
||||
{file = "SQLAlchemy-1.4.50-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14b0cacdc8a4759a1e1bd47dc3ee3f5db997129eb091330beda1da5a0e9e5bd7"},
|
||||
{file = "SQLAlchemy-1.4.50-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1fb9cb60e0f33040e4f4681e6658a7eb03b5cb4643284172f91410d8c493dace"},
|
||||
{file = "SQLAlchemy-1.4.50-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4cb501d585aa74a0f86d0ea6263b9c5e1d1463f8f9071392477fd401bd3c7cc"},
|
||||
{file = "SQLAlchemy-1.4.50-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a7a66297e46f85a04d68981917c75723e377d2e0599d15fbe7a56abed5e2d75"},
|
||||
{file = "SQLAlchemy-1.4.50-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1db0221cb26d66294f4ca18c533e427211673ab86c1fbaca8d6d9ff78654293"},
|
||||
{file = "SQLAlchemy-1.4.50-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b7dbe6369677a2bea68fe9812c6e4bbca06ebfa4b5cde257b2b0bf208709131"},
|
||||
{file = "SQLAlchemy-1.4.50-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a9bddb60566dc45c57fd0a5e14dd2d9e5f106d2241e0a2dc0c1da144f9444516"},
|
||||
{file = "SQLAlchemy-1.4.50-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82dd4131d88395df7c318eeeef367ec768c2a6fe5bd69423f7720c4edb79473c"},
|
||||
{file = "SQLAlchemy-1.4.50-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:273505fcad22e58cc67329cefab2e436006fc68e3c5423056ee0513e6523268a"},
|
||||
{file = "SQLAlchemy-1.4.50-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3257a6e09626d32b28a0c5b4f1a97bced585e319cfa90b417f9ab0f6145c33c"},
|
||||
{file = "SQLAlchemy-1.4.50-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d69738d582e3a24125f0c246ed8d712b03bd21e148268421e4a4d09c34f521a5"},
|
||||
{file = "SQLAlchemy-1.4.50-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:34e1c5d9cd3e6bf3d1ce56971c62a40c06bfc02861728f368dcfec8aeedb2814"},
|
||||
{file = "SQLAlchemy-1.4.50-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1fcee5a2c859eecb4ed179edac5ffbc7c84ab09a5420219078ccc6edda45436"},
|
||||
{file = "SQLAlchemy-1.4.50-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fbaf6643a604aa17e7a7afd74f665f9db882df5c297bdd86c38368f2c471f37d"},
|
||||
{file = "SQLAlchemy-1.4.50-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2e70e0673d7d12fa6cd363453a0d22dac0d9978500aa6b46aa96e22690a55eab"},
|
||||
{file = "SQLAlchemy-1.4.50-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b881ac07d15fb3e4f68c5a67aa5cdaf9eb8f09eb5545aaf4b0a5f5f4659be18"},
|
||||
{file = "SQLAlchemy-1.4.50-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f6997da81114daef9203d30aabfa6b218a577fc2bd797c795c9c88c9eb78d49"},
|
||||
{file = "SQLAlchemy-1.4.50-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bdb77e1789e7596b77fd48d99ec1d2108c3349abd20227eea0d48d3f8cf398d9"},
|
||||
{file = "SQLAlchemy-1.4.50-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:128a948bd40780667114b0297e2cc6d657b71effa942e0a368d8cc24293febb3"},
|
||||
{file = "SQLAlchemy-1.4.50-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2d526aeea1bd6a442abc7c9b4b00386fd70253b80d54a0930c0a216230a35be"},
|
||||
{file = "SQLAlchemy-1.4.50.tar.gz", hash = "sha256:3b97ddf509fc21e10b09403b5219b06c5b558b27fc2453150274fa4e70707dbf"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:638c2c0b6b4661a4fd264f6fb804eccd392745c5887f9317feb64bb7cb03b3ea"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e3b5036aa326dc2df50cba3c958e29b291a80f604b1afa4c8ce73e78e1c9f01d"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:787af80107fb691934a01889ca8f82a44adedbf5ef3d6ad7d0f0b9ac557e0c34"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c14eba45983d2f48f7546bb32b47937ee2cafae353646295f0e99f35b14286ab"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0666031df46b9badba9bed00092a1ffa3aa063a5e68fa244acd9f08070e936d3"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:89a01238fcb9a8af118eaad3ffcc5dedaacbd429dc6fdc43fe430d3a941ff965"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-win32.whl", hash = "sha256:cabafc7837b6cec61c0e1e5c6d14ef250b675fa9c3060ed8a7e38653bd732ff8"},
|
||||
{file = "SQLAlchemy-2.0.23-cp310-cp310-win_amd64.whl", hash = "sha256:87a3d6b53c39cd173990de2f5f4b83431d534a74f0e2f88bd16eabb5667e65c6"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d5578e6863eeb998980c212a39106ea139bdc0b3f73291b96e27c929c90cd8e1"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:62d9e964870ea5ade4bc870ac4004c456efe75fb50404c03c5fd61f8bc669a72"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c80c38bd2ea35b97cbf7c21aeb129dcbebbf344ee01a7141016ab7b851464f8e"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75eefe09e98043cff2fb8af9796e20747ae870c903dc61d41b0c2e55128f958d"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd45a5b6c68357578263d74daab6ff9439517f87da63442d244f9f23df56138d"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a86cb7063e2c9fb8e774f77fbf8475516d270a3e989da55fa05d08089d77f8c4"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-win32.whl", hash = "sha256:b41f5d65b54cdf4934ecede2f41b9c60c9f785620416e8e6c48349ab18643855"},
|
||||
{file = "SQLAlchemy-2.0.23-cp311-cp311-win_amd64.whl", hash = "sha256:9ca922f305d67605668e93991aaf2c12239c78207bca3b891cd51a4515c72e22"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d0f7fb0c7527c41fa6fcae2be537ac137f636a41b4c5a4c58914541e2f436b45"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7c424983ab447dab126c39d3ce3be5bee95700783204a72549c3dceffe0fc8f4"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f508ba8f89e0a5ecdfd3761f82dda2a3d7b678a626967608f4273e0dba8f07ac"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6463aa765cf02b9247e38b35853923edbf2f6fd1963df88706bc1d02410a5577"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e599a51acf3cc4d31d1a0cf248d8f8d863b6386d2b6782c5074427ebb7803bda"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fd54601ef9cc455a0c61e5245f690c8a3ad67ddb03d3b91c361d076def0b4c60"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-win32.whl", hash = "sha256:42d0b0290a8fb0165ea2c2781ae66e95cca6e27a2fbe1016ff8db3112ac1e846"},
|
||||
{file = "SQLAlchemy-2.0.23-cp312-cp312-win_amd64.whl", hash = "sha256:227135ef1e48165f37590b8bfc44ed7ff4c074bf04dc8d6f8e7f1c14a94aa6ca"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:14aebfe28b99f24f8a4c1346c48bc3d63705b1f919a24c27471136d2f219f02d"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e983fa42164577d073778d06d2cc5d020322425a509a08119bdcee70ad856bf"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e0dc9031baa46ad0dd5a269cb7a92a73284d1309228be1d5935dac8fb3cae24"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5f94aeb99f43729960638e7468d4688f6efccb837a858b34574e01143cf11f89"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:63bfc3acc970776036f6d1d0e65faa7473be9f3135d37a463c5eba5efcdb24c8"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-win32.whl", hash = "sha256:f48ed89dd11c3c586f45e9eec1e437b355b3b6f6884ea4a4c3111a3358fd0c18"},
|
||||
{file = "SQLAlchemy-2.0.23-cp37-cp37m-win_amd64.whl", hash = "sha256:1e018aba8363adb0599e745af245306cb8c46b9ad0a6fc0a86745b6ff7d940fc"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:64ac935a90bc479fee77f9463f298943b0e60005fe5de2aa654d9cdef46c54df"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c4722f3bc3c1c2fcc3702dbe0016ba31148dd6efcd2a2fd33c1b4897c6a19693"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4af79c06825e2836de21439cb2a6ce22b2ca129bad74f359bddd173f39582bf5"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:683ef58ca8eea4747737a1c35c11372ffeb84578d3aab8f3e10b1d13d66f2bc4"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d4041ad05b35f1f4da481f6b811b4af2f29e83af253bf37c3c4582b2c68934ab"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:aeb397de65a0a62f14c257f36a726945a7f7bb60253462e8602d9b97b5cbe204"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-win32.whl", hash = "sha256:42ede90148b73fe4ab4a089f3126b2cfae8cfefc955c8174d697bb46210c8306"},
|
||||
{file = "SQLAlchemy-2.0.23-cp38-cp38-win_amd64.whl", hash = "sha256:964971b52daab357d2c0875825e36584d58f536e920f2968df8d581054eada4b"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:616fe7bcff0a05098f64b4478b78ec2dfa03225c23734d83d6c169eb41a93e55"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0e680527245895aba86afbd5bef6c316831c02aa988d1aad83c47ffe92655e74"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9585b646ffb048c0250acc7dad92536591ffe35dba624bb8fd9b471e25212a35"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4895a63e2c271ffc7a81ea424b94060f7b3b03b4ea0cd58ab5bb676ed02f4221"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:cc1d21576f958c42d9aec68eba5c1a7d715e5fc07825a629015fe8e3b0657fb0"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:967c0b71156f793e6662dd839da54f884631755275ed71f1539c95bbada9aaab"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-win32.whl", hash = "sha256:0a8c6aa506893e25a04233bc721c6b6cf844bafd7250535abb56cb6cc1368884"},
|
||||
{file = "SQLAlchemy-2.0.23-cp39-cp39-win_amd64.whl", hash = "sha256:f3420d00d2cb42432c1d0e44540ae83185ccbbc67a6054dcc8ab5387add6620b"},
|
||||
{file = "SQLAlchemy-2.0.23-py3-none-any.whl", hash = "sha256:31952bbc527d633b9479f5f81e8b9dfada00b91d6baba021a869095f1a97006d"},
|
||||
{file = "SQLAlchemy-2.0.23.tar.gz", hash = "sha256:c1bda93cbbe4aa2aa0aa8655c5aeda505cd219ff3e8da91d1d329e143e4aff69"},
|
||||
]
|
||||
|
||||
[package.dependencies]
|
||||
aiosqlite = {version = "*", optional = true, markers = "python_version >= \"3\" and extra == \"aiosqlite\""}
|
||||
greenlet = {version = "!=0.4.17", optional = true, markers = "python_version >= \"3\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\" or extra == \"aiosqlite\")"}
|
||||
typing-extensions = {version = "!=3.10.0.1", optional = true, markers = "extra == \"aiosqlite\""}
|
||||
aiosqlite = {version = "*", optional = true, markers = "extra == \"aiosqlite\""}
|
||||
greenlet = {version = "!=0.4.17", optional = true, markers = "platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\" or extra == \"aiosqlite\""}
|
||||
typing-extensions = {version = ">=4.2.0", optional = true, markers = "extra == \"aiosqlite\""}
|
||||
|
||||
[package.extras]
|
||||
aiomysql = ["aiomysql (>=0.2.0)", "greenlet (!=0.4.17)"]
|
||||
aioodbc = ["aioodbc", "greenlet (!=0.4.17)"]
|
||||
aiosqlite = ["aiosqlite", "greenlet (!=0.4.17)", "typing-extensions (!=3.10.0.1)"]
|
||||
asyncio = ["greenlet (!=0.4.17)"]
|
||||
asyncmy = ["asyncmy (>=0.2.3,!=0.2.4)", "greenlet (!=0.4.17)"]
|
||||
mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2)"]
|
||||
asyncmy = ["asyncmy (>=0.2.3,!=0.2.4,!=0.2.6)", "greenlet (!=0.4.17)"]
|
||||
mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2,!=1.1.5)"]
|
||||
mssql = ["pyodbc"]
|
||||
mssql-pymssql = ["pymssql"]
|
||||
mssql-pyodbc = ["pyodbc"]
|
||||
mypy = ["mypy (>=0.910)", "sqlalchemy2-stubs"]
|
||||
mysql = ["mysqlclient (>=1.4.0)", "mysqlclient (>=1.4.0,<2)"]
|
||||
mypy = ["mypy (>=0.910)"]
|
||||
mysql = ["mysqlclient (>=1.4.0)"]
|
||||
mysql-connector = ["mysql-connector-python"]
|
||||
oracle = ["cx-oracle (>=7)", "cx-oracle (>=7,<8)"]
|
||||
oracle = ["cx-oracle (>=8)"]
|
||||
oracle-oracledb = ["oracledb (>=1.0.1)"]
|
||||
postgresql = ["psycopg2 (>=2.7)"]
|
||||
postgresql-asyncpg = ["asyncpg", "greenlet (!=0.4.17)"]
|
||||
postgresql-pg8000 = ["pg8000 (>=1.16.6,!=1.29.0)"]
|
||||
postgresql-pg8000 = ["pg8000 (>=1.29.1)"]
|
||||
postgresql-psycopg = ["psycopg (>=3.0.7)"]
|
||||
postgresql-psycopg2binary = ["psycopg2-binary"]
|
||||
postgresql-psycopg2cffi = ["psycopg2cffi"]
|
||||
pymysql = ["pymysql", "pymysql (<1)"]
|
||||
postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"]
|
||||
pymysql = ["pymysql"]
|
||||
sqlcipher = ["sqlcipher3-binary"]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -683,4 +686,4 @@ files = [
|
|||
[metadata]
|
||||
lock-version = "2.0"
|
||||
python-versions = "^3.12"
|
||||
content-hash = "8d0ddcdcd96f4736bb3608df11678d78776f5cf7c6883474b61b158c99ac4732"
|
||||
content-hash = "fc07028820963701634eb55b42ea12962fd7c6fc25ef76ddadf30f2c74544b5f"
|
||||
|
|
|
|||
|
|
@ -11,10 +11,9 @@ beautifulsoup4 = "^4.9.3"
|
|||
html5lib = "^1.1"
|
||||
starlette = "^0.30"
|
||||
ulid-py = "^1.1.0"
|
||||
databases = {extras = ["sqlite"], version = "^0.7.0"}
|
||||
uvicorn = "^0.23"
|
||||
httpx = "^0.24"
|
||||
sqlalchemy = {version = "^1.4", extras = ["aiosqlite"]}
|
||||
sqlalchemy = {version = "^2.0", extras = ["aiosqlite"]}
|
||||
|
||||
[tool.poetry.group.dev]
|
||||
optional = true
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ dbfile="${UNWIND_DATA:-./data}/tests.sqlite"
|
|||
|
||||
# Rollback in Databases is currently broken, so we have to rebuild the database
|
||||
# each time; see https://github.com/encode/databases/issues/403
|
||||
trap 'rm "$dbfile"' EXIT TERM INT QUIT
|
||||
trap 'rm "$dbfile" "${dbfile}-shm" "${dbfile}-wal"' EXIT TERM INT QUIT
|
||||
|
||||
[ -z "${DEBUG:-}" ] || set -x
|
||||
|
||||
|
|
|
|||
|
|
@ -17,16 +17,19 @@ def event_loop():
|
|||
|
||||
@pytest_asyncio.fixture(scope="session")
|
||||
async def shared_conn():
|
||||
c = db._shared_connection()
|
||||
await c.connect()
|
||||
"""A database connection, ready to use."""
|
||||
await db.open_connection_pool()
|
||||
|
||||
await db.apply_db_patches(c)
|
||||
async with db.new_connection() as c:
|
||||
db._test_connection = c
|
||||
yield c
|
||||
db._test_connection = None
|
||||
|
||||
await c.disconnect()
|
||||
await db.close_connection_pool()
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def conn(shared_conn):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def conn(shared_conn: db.Connection):
|
||||
"""A transacted database connection, will be rolled back after use."""
|
||||
async with db.transacted(shared_conn, force_rollback=True):
|
||||
yield shared_conn
|
||||
|
|
|
|||
207
tests/test_db.py
207
tests/test_db.py
|
|
@ -4,7 +4,7 @@ import pytest
|
|||
|
||||
from unwind import db, models, web_models
|
||||
|
||||
_movie_imdb_id = 1234567
|
||||
_movie_imdb_id = 1230000
|
||||
|
||||
|
||||
def a_movie(**kwds) -> models.Movie:
|
||||
|
|
@ -21,39 +21,39 @@ def a_movie(**kwds) -> models.Movie:
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_current_patch_level(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_current_patch_level(conn: db.Connection):
|
||||
patch_level = "some-patch-level"
|
||||
assert patch_level != await db.current_patch_level(shared_conn)
|
||||
await db.set_current_patch_level(shared_conn, patch_level)
|
||||
assert patch_level == await db.current_patch_level(shared_conn)
|
||||
assert patch_level != await db.current_patch_level(conn)
|
||||
await db.set_current_patch_level(conn, patch_level)
|
||||
assert patch_level == await db.current_patch_level(conn)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_get(conn: db.Connection):
|
||||
m1 = a_movie()
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie(release_year=m1.release_year + 1)
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
assert None is await db.get(models.Movie)
|
||||
assert None is await db.get(models.Movie, id="blerp")
|
||||
assert m1 == await db.get(models.Movie, id=str(m1.id))
|
||||
assert m2 == await db.get(models.Movie, release_year=m2.release_year)
|
||||
assert None is await db.get(conn, models.Movie)
|
||||
assert None is await db.get(conn, models.Movie, id="blerp")
|
||||
assert m1 == await db.get(conn, models.Movie, id=str(m1.id))
|
||||
assert m2 == await db.get(conn, models.Movie, release_year=m2.release_year)
|
||||
assert None is await db.get(
|
||||
models.Movie, id=str(m1.id), release_year=m2.release_year
|
||||
conn, models.Movie, id=str(m1.id), release_year=m2.release_year
|
||||
)
|
||||
assert m2 == await db.get(
|
||||
models.Movie, id=str(m2.id), release_year=m2.release_year
|
||||
conn, models.Movie, id=str(m2.id), release_year=m2.release_year
|
||||
)
|
||||
assert m1 == await db.get(
|
||||
conn,
|
||||
models.Movie,
|
||||
media_type=m1.media_type,
|
||||
order_by=(models.movies.c.release_year, "asc"),
|
||||
)
|
||||
assert m2 == await db.get(
|
||||
conn,
|
||||
models.Movie,
|
||||
media_type=m1.media_type,
|
||||
order_by=(models.movies.c.release_year, "desc"),
|
||||
|
|
@ -61,125 +61,119 @@ async def test_get(shared_conn: db.Database):
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_all(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_get_all(conn: db.Connection):
|
||||
m1 = a_movie()
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie(release_year=m1.release_year)
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
m3 = a_movie(release_year=m1.release_year + 1)
|
||||
await db.add(m3)
|
||||
await db.add(conn, m3)
|
||||
|
||||
assert [] == list(await db.get_all(models.Movie, id="blerp"))
|
||||
assert [m1] == list(await db.get_all(models.Movie, id=str(m1.id)))
|
||||
assert [] == list(await db.get_all(conn, models.Movie, id="blerp"))
|
||||
assert [m1] == list(await db.get_all(conn, models.Movie, id=str(m1.id)))
|
||||
assert [m1, m2] == list(
|
||||
await db.get_all(models.Movie, release_year=m1.release_year)
|
||||
await db.get_all(conn, models.Movie, release_year=m1.release_year)
|
||||
)
|
||||
assert [m1, m2, m3] == list(await db.get_all(models.Movie))
|
||||
assert [m1, m2, m3] == list(await db.get_all(conn, models.Movie))
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_many(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_get_many(conn: db.Connection):
|
||||
m1 = a_movie()
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie(release_year=m1.release_year)
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
m3 = a_movie(release_year=m1.release_year + 1)
|
||||
await db.add(m3)
|
||||
await db.add(conn, m3)
|
||||
|
||||
assert [] == list(await db.get_many(models.Movie)), "selected nothing"
|
||||
assert [m1] == list(await db.get_many(models.Movie, id=[str(m1.id)]))
|
||||
assert [m1] == list(await db.get_many(models.Movie, id={str(m1.id)}))
|
||||
assert [] == list(await db.get_many(conn, models.Movie)), "selected nothing"
|
||||
assert [m1] == list(await db.get_many(conn, models.Movie, id=[str(m1.id)]))
|
||||
assert [m1] == list(await db.get_many(conn, models.Movie, id={str(m1.id)}))
|
||||
assert [m1, m2] == list(
|
||||
await db.get_many(models.Movie, release_year=[m1.release_year])
|
||||
await db.get_many(conn, models.Movie, release_year=[m1.release_year])
|
||||
)
|
||||
assert [m1, m2, m3] == list(
|
||||
await db.get_many(
|
||||
models.Movie, release_year=[m1.release_year, m3.release_year]
|
||||
conn, models.Movie, release_year=[m1.release_year, m3.release_year]
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_add_and_get(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_add_and_get(conn: db.Connection):
|
||||
m1 = a_movie()
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie()
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
assert m1 == await db.get(models.Movie, id=str(m1.id))
|
||||
assert m2 == await db.get(models.Movie, id=str(m2.id))
|
||||
assert m1 == await db.get(conn, models.Movie, id=str(m1.id))
|
||||
assert m2 == await db.get(conn, models.Movie, id=str(m2.id))
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_update(conn: db.Connection):
|
||||
m = a_movie()
|
||||
await db.add(m)
|
||||
await db.add(conn, m)
|
||||
|
||||
assert m == await db.get(models.Movie, id=str(m.id))
|
||||
assert m == await db.get(conn, models.Movie, id=str(m.id))
|
||||
m.title += "something else"
|
||||
assert m != await db.get(models.Movie, id=str(m.id))
|
||||
assert m != await db.get(conn, models.Movie, id=str(m.id))
|
||||
|
||||
await db.update(m)
|
||||
assert m == await db.get(models.Movie, id=str(m.id))
|
||||
await db.update(conn, m)
|
||||
assert m == await db.get(conn, models.Movie, id=str(m.id))
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_remove(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_remove(conn: db.Connection):
|
||||
m1 = a_movie()
|
||||
await db.add(m1)
|
||||
assert m1 == await db.get(models.Movie, id=str(m1.id))
|
||||
await db.add(conn, m1)
|
||||
assert m1 == await db.get(conn, models.Movie, id=str(m1.id))
|
||||
|
||||
await db.remove(m1)
|
||||
assert None is await db.get(models.Movie, id=str(m1.id))
|
||||
await db.remove(conn, m1)
|
||||
assert None is await db.get(conn, models.Movie, id=str(m1.id))
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_find_ratings(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_find_ratings(conn: db.Connection):
|
||||
m1 = a_movie(
|
||||
title="test movie",
|
||||
release_year=2013,
|
||||
genres={"genre-1"},
|
||||
)
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie(
|
||||
title="it's anöther Movie, Part 2",
|
||||
release_year=2015,
|
||||
genres={"genre-2"},
|
||||
)
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
m3 = a_movie(
|
||||
title="movie it's, Part 3",
|
||||
release_year=m2.release_year,
|
||||
genres=m2.genres,
|
||||
)
|
||||
await db.add(m3)
|
||||
await db.add(conn, m3)
|
||||
|
||||
u1 = models.User(
|
||||
imdb_id="u00001",
|
||||
name="User1",
|
||||
secret="secret1",
|
||||
)
|
||||
await db.add(u1)
|
||||
await db.add(conn, u1)
|
||||
|
||||
u2 = models.User(
|
||||
imdb_id="u00002",
|
||||
name="User2",
|
||||
secret="secret2",
|
||||
)
|
||||
await db.add(u2)
|
||||
await db.add(conn, u2)
|
||||
|
||||
r1 = models.Rating(
|
||||
movie_id=m2.id,
|
||||
|
|
@ -189,7 +183,7 @@ async def test_find_ratings(shared_conn: db.Database):
|
|||
score=66,
|
||||
rating_date=datetime.now(),
|
||||
)
|
||||
await db.add(r1)
|
||||
await db.add(conn, r1)
|
||||
|
||||
r2 = models.Rating(
|
||||
movie_id=m2.id,
|
||||
|
|
@ -199,11 +193,12 @@ async def test_find_ratings(shared_conn: db.Database):
|
|||
score=77,
|
||||
rating_date=datetime.now(),
|
||||
)
|
||||
await db.add(r2)
|
||||
await db.add(conn, r2)
|
||||
|
||||
# ---
|
||||
|
||||
rows = await db.find_ratings(
|
||||
conn,
|
||||
title=m1.title,
|
||||
media_type=m1.media_type,
|
||||
exact=True,
|
||||
|
|
@ -218,14 +213,14 @@ async def test_find_ratings(shared_conn: db.Database):
|
|||
web_models.aggregate_ratings(ratings, user_ids=[])
|
||||
)
|
||||
|
||||
rows = await db.find_ratings(title="movie", include_unrated=False)
|
||||
rows = await db.find_ratings(conn, title="movie", include_unrated=False)
|
||||
ratings = tuple(web_models.Rating(**r) for r in rows)
|
||||
assert (
|
||||
web_models.Rating.from_movie(m2, rating=r1),
|
||||
web_models.Rating.from_movie(m2, rating=r2),
|
||||
) == ratings
|
||||
|
||||
rows = await db.find_ratings(title="movie", include_unrated=True)
|
||||
rows = await db.find_ratings(conn, title="movie", include_unrated=True)
|
||||
ratings = tuple(web_models.Rating(**r) for r in rows)
|
||||
assert (
|
||||
web_models.Rating.from_movie(m1),
|
||||
|
|
@ -253,40 +248,39 @@ async def test_find_ratings(shared_conn: db.Database):
|
|||
web_models.RatingAggregate.from_movie(m3),
|
||||
) == tuple(aggr)
|
||||
|
||||
rows = await db.find_ratings(title="movie", include_unrated=True)
|
||||
rows = await db.find_ratings(conn, title="movie", include_unrated=True)
|
||||
ratings = (web_models.Rating(**r) for r in rows)
|
||||
aggr = web_models.aggregate_ratings(ratings, user_ids=[])
|
||||
assert tuple(
|
||||
web_models.RatingAggregate.from_movie(m) for m in [m1, m2, m3]
|
||||
) == tuple(aggr)
|
||||
|
||||
rows = await db.find_ratings(title="test", include_unrated=True)
|
||||
rows = await db.find_ratings(conn, title="test", include_unrated=True)
|
||||
ratings = tuple(web_models.Rating(**r) for r in rows)
|
||||
assert (web_models.Rating.from_movie(m1),) == ratings
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ratings_for_movies(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_ratings_for_movies(conn: db.Connection):
|
||||
m1 = a_movie()
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie()
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
u1 = models.User(
|
||||
imdb_id="u00001",
|
||||
name="User1",
|
||||
secret="secret1",
|
||||
)
|
||||
await db.add(u1)
|
||||
await db.add(conn, u1)
|
||||
|
||||
u2 = models.User(
|
||||
imdb_id="u00002",
|
||||
name="User2",
|
||||
secret="secret2",
|
||||
)
|
||||
await db.add(u2)
|
||||
await db.add(conn, u2)
|
||||
|
||||
r1 = models.Rating(
|
||||
movie_id=m2.id,
|
||||
|
|
@ -296,63 +290,62 @@ async def test_ratings_for_movies(shared_conn: db.Database):
|
|||
score=66,
|
||||
rating_date=datetime.now(),
|
||||
)
|
||||
await db.add(r1)
|
||||
await db.add(conn, r1)
|
||||
|
||||
# ---
|
||||
|
||||
movie_ids = [m1.id]
|
||||
user_ids = []
|
||||
assert tuple() == tuple(
|
||||
await db.ratings_for_movies(movie_ids=movie_ids, user_ids=user_ids)
|
||||
await db.ratings_for_movies(conn, movie_ids=movie_ids, user_ids=user_ids)
|
||||
)
|
||||
|
||||
movie_ids = [m2.id]
|
||||
user_ids = []
|
||||
assert (r1,) == tuple(
|
||||
await db.ratings_for_movies(movie_ids=movie_ids, user_ids=user_ids)
|
||||
await db.ratings_for_movies(conn, movie_ids=movie_ids, user_ids=user_ids)
|
||||
)
|
||||
|
||||
movie_ids = [m2.id]
|
||||
user_ids = [u2.id]
|
||||
assert tuple() == tuple(
|
||||
await db.ratings_for_movies(movie_ids=movie_ids, user_ids=user_ids)
|
||||
await db.ratings_for_movies(conn, movie_ids=movie_ids, user_ids=user_ids)
|
||||
)
|
||||
|
||||
movie_ids = [m2.id]
|
||||
user_ids = [u1.id]
|
||||
assert (r1,) == tuple(
|
||||
await db.ratings_for_movies(movie_ids=movie_ids, user_ids=user_ids)
|
||||
await db.ratings_for_movies(conn, movie_ids=movie_ids, user_ids=user_ids)
|
||||
)
|
||||
|
||||
movie_ids = [m1.id, m2.id]
|
||||
user_ids = [u1.id, u2.id]
|
||||
assert (r1,) == tuple(
|
||||
await db.ratings_for_movies(movie_ids=movie_ids, user_ids=user_ids)
|
||||
await db.ratings_for_movies(conn, movie_ids=movie_ids, user_ids=user_ids)
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_find_movies(shared_conn: db.Database):
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
async def test_find_movies(conn: db.Connection):
|
||||
m1 = a_movie(title="movie one")
|
||||
await db.add(m1)
|
||||
await db.add(conn, m1)
|
||||
|
||||
m2 = a_movie(title="movie two", imdb_score=33, release_year=m1.release_year + 1)
|
||||
await db.add(m2)
|
||||
await db.add(conn, m2)
|
||||
|
||||
u1 = models.User(
|
||||
imdb_id="u00001",
|
||||
name="User1",
|
||||
secret="secret1",
|
||||
)
|
||||
await db.add(u1)
|
||||
await db.add(conn, u1)
|
||||
|
||||
u2 = models.User(
|
||||
imdb_id="u00002",
|
||||
name="User2",
|
||||
secret="secret2",
|
||||
)
|
||||
await db.add(u2)
|
||||
await db.add(conn, u2)
|
||||
|
||||
r1 = models.Rating(
|
||||
movie_id=m2.id,
|
||||
|
|
@ -362,53 +355,65 @@ async def test_find_movies(shared_conn: db.Database):
|
|||
score=66,
|
||||
rating_date=datetime.now(),
|
||||
)
|
||||
await db.add(r1)
|
||||
await db.add(conn, r1)
|
||||
|
||||
# ---
|
||||
|
||||
assert () == tuple(await db.find_movies(title=m1.title, include_unrated=False))
|
||||
assert () == tuple(
|
||||
await db.find_movies(conn, title=m1.title, include_unrated=False)
|
||||
)
|
||||
assert ((m1, []),) == tuple(
|
||||
await db.find_movies(title=m1.title, include_unrated=True)
|
||||
await db.find_movies(conn, title=m1.title, include_unrated=True)
|
||||
)
|
||||
|
||||
assert ((m1, []),) == tuple(
|
||||
await db.find_movies(title="mo on", exact=False, include_unrated=True)
|
||||
await db.find_movies(conn, title="mo on", exact=False, include_unrated=True)
|
||||
)
|
||||
assert ((m1, []),) == tuple(
|
||||
await db.find_movies(title="movie one", exact=True, include_unrated=True)
|
||||
await db.find_movies(conn, title="movie one", exact=True, include_unrated=True)
|
||||
)
|
||||
assert () == tuple(
|
||||
await db.find_movies(title="mo on", exact=True, include_unrated=True)
|
||||
await db.find_movies(conn, title="mo on", exact=True, include_unrated=True)
|
||||
)
|
||||
|
||||
assert ((m2, []),) == tuple(
|
||||
await db.find_movies(title="movie", exact=False, include_unrated=False)
|
||||
await db.find_movies(conn, title="movie", exact=False, include_unrated=False)
|
||||
)
|
||||
assert ((m2, []), (m1, [])) == tuple(
|
||||
await db.find_movies(title="movie", exact=False, include_unrated=True)
|
||||
await db.find_movies(conn, title="movie", exact=False, include_unrated=True)
|
||||
)
|
||||
|
||||
assert ((m1, []),) == tuple(
|
||||
await db.find_movies(include_unrated=True, yearcomp=("=", m1.release_year))
|
||||
await db.find_movies(
|
||||
conn, include_unrated=True, yearcomp=("=", m1.release_year)
|
||||
)
|
||||
)
|
||||
assert ((m2, []),) == tuple(
|
||||
await db.find_movies(include_unrated=True, yearcomp=("=", m2.release_year))
|
||||
await db.find_movies(
|
||||
conn, include_unrated=True, yearcomp=("=", m2.release_year)
|
||||
)
|
||||
)
|
||||
assert ((m1, []),) == tuple(
|
||||
await db.find_movies(include_unrated=True, yearcomp=("<", m2.release_year))
|
||||
await db.find_movies(
|
||||
conn, include_unrated=True, yearcomp=("<", m2.release_year)
|
||||
)
|
||||
)
|
||||
assert ((m2, []),) == tuple(
|
||||
await db.find_movies(include_unrated=True, yearcomp=(">", m1.release_year))
|
||||
await db.find_movies(
|
||||
conn, include_unrated=True, yearcomp=(">", m1.release_year)
|
||||
)
|
||||
)
|
||||
|
||||
assert ((m2, []), (m1, [])) == tuple(await db.find_movies(include_unrated=True))
|
||||
assert ((m2, []), (m1, [])) == tuple(
|
||||
await db.find_movies(conn, include_unrated=True)
|
||||
)
|
||||
assert ((m2, []),) == tuple(
|
||||
await db.find_movies(include_unrated=True, limit_rows=1)
|
||||
await db.find_movies(conn, include_unrated=True, limit_rows=1)
|
||||
)
|
||||
assert ((m1, []),) == tuple(
|
||||
await db.find_movies(include_unrated=True, skip_rows=1)
|
||||
await db.find_movies(conn, include_unrated=True, skip_rows=1)
|
||||
)
|
||||
|
||||
assert ((m2, [r1]), (m1, [])) == tuple(
|
||||
await db.find_movies(include_unrated=True, user_ids=[u1.id, u2.id])
|
||||
await db.find_movies(conn, include_unrated=True, user_ids=[u1.id, u2.id])
|
||||
)
|
||||
|
|
|
|||
11
tests/test_models.py
Normal file
11
tests/test_models.py
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
import pytest
|
||||
|
||||
from unwind import models
|
||||
|
||||
|
||||
@pytest.mark.parametrize("mapper", models.mapper_registry.mappers)
|
||||
def test_fields(mapper):
|
||||
"""Test that models.fields() matches exactly all table columns."""
|
||||
dcfields = {f.name for f in models.fields(mapper.class_)}
|
||||
mfields = {c.name for c in mapper.columns}
|
||||
assert dcfields == mfields
|
||||
|
|
@ -34,7 +34,7 @@ def admin_client() -> TestClient:
|
|||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_ratings_for_group(
|
||||
shared_conn: db.Database, unauthorized_client: TestClient
|
||||
conn: db.Connection, unauthorized_client: TestClient
|
||||
):
|
||||
user = models.User(
|
||||
imdb_id="ur12345678",
|
||||
|
|
@ -48,12 +48,12 @@ async def test_get_ratings_for_group(
|
|||
)
|
||||
user.groups = [models.UserGroup(id=str(group.id), access="r")]
|
||||
path = app.url_path_for("get_ratings_for_group", group_id=str(group.id))
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
|
||||
resp = unauthorized_client.get(path)
|
||||
assert resp.status_code == 404, "Group does not exist (yet)"
|
||||
|
||||
await db.add(user)
|
||||
await db.add(group)
|
||||
await db.add(conn, user)
|
||||
await db.add(conn, group)
|
||||
|
||||
resp = unauthorized_client.get(path)
|
||||
assert resp.status_code == 200
|
||||
|
|
@ -66,12 +66,12 @@ async def test_get_ratings_for_group(
|
|||
imdb_id="tt12345678",
|
||||
genres={"genre-1"},
|
||||
)
|
||||
await db.add(movie)
|
||||
await db.add(conn, movie)
|
||||
|
||||
rating = models.Rating(
|
||||
movie_id=movie.id, user_id=user.id, score=66, rating_date=datetime.now()
|
||||
)
|
||||
await db.add(rating)
|
||||
await db.add(conn, rating)
|
||||
|
||||
rating_aggregate = {
|
||||
"canonical_title": movie.title,
|
||||
|
|
@ -110,9 +110,7 @@ async def test_get_ratings_for_group(
|
|||
)
|
||||
assert resp.status_code == 200
|
||||
assert resp.json() == [rating_aggregate]
|
||||
resp = unauthorized_client.get(
|
||||
path, params={"title": "te mo", "exact": "false"}
|
||||
)
|
||||
resp = unauthorized_client.get(path, params={"title": "te mo", "exact": "false"})
|
||||
assert resp.status_code == 200
|
||||
assert resp.json() == [rating_aggregate]
|
||||
resp = unauthorized_client.get(path, params={"title": "te mo", "exact": "true"})
|
||||
|
|
@ -126,12 +124,11 @@ async def test_get_ratings_for_group(
|
|||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_movies(
|
||||
shared_conn: db.Database,
|
||||
conn: db.Connection,
|
||||
unauthorized_client: TestClient,
|
||||
authorized_client: TestClient,
|
||||
):
|
||||
path = app.url_path_for("list_movies")
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
response = unauthorized_client.get(path)
|
||||
assert response.status_code == 403
|
||||
|
||||
|
|
@ -146,7 +143,7 @@ async def test_list_movies(
|
|||
imdb_id="tt12345678",
|
||||
genres={"genre-1"},
|
||||
)
|
||||
await db.add(m)
|
||||
await db.add(conn, m)
|
||||
|
||||
response = authorized_client.get(path, params={"include_unrated": 1})
|
||||
assert response.status_code == 200
|
||||
|
|
@ -174,13 +171,12 @@ async def test_list_movies(
|
|||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_users(
|
||||
shared_conn: db.Database,
|
||||
conn: db.Connection,
|
||||
unauthorized_client: TestClient,
|
||||
authorized_client: TestClient,
|
||||
admin_client: TestClient,
|
||||
):
|
||||
path = app.url_path_for("list_users")
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
response = unauthorized_client.get(path)
|
||||
assert response.status_code == 403
|
||||
|
||||
|
|
@ -197,7 +193,7 @@ async def test_list_users(
|
|||
secret="secret-1",
|
||||
groups=[],
|
||||
)
|
||||
await db.add(m)
|
||||
await db.add(conn, m)
|
||||
|
||||
m_plain = {
|
||||
"groups": m.groups,
|
||||
|
|
@ -214,13 +210,12 @@ async def test_list_users(
|
|||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_groups(
|
||||
shared_conn: db.Database,
|
||||
conn: db.Connection,
|
||||
unauthorized_client: TestClient,
|
||||
authorized_client: TestClient,
|
||||
admin_client: TestClient,
|
||||
):
|
||||
path = app.url_path_for("list_groups")
|
||||
async with shared_conn.transaction(force_rollback=True):
|
||||
response = unauthorized_client.get(path)
|
||||
assert response.status_code == 403
|
||||
|
||||
|
|
@ -235,7 +230,7 @@ async def test_list_groups(
|
|||
name="group-1",
|
||||
users=[models.GroupUser(id="123", name="itsa-me")],
|
||||
)
|
||||
await db.add(m)
|
||||
await db.add(conn, m)
|
||||
|
||||
m_plain = {
|
||||
"users": m.users,
|
||||
|
|
|
|||
301
unwind/db.py
301
unwind/db.py
|
|
@ -1,13 +1,11 @@
|
|||
import asyncio
|
||||
import contextlib
|
||||
import logging
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from typing import Any, AsyncGenerator, Iterable, Literal, Type, TypeVar
|
||||
from typing import Any, AsyncGenerator, Iterable, Literal, Sequence, Type, TypeVar
|
||||
|
||||
import sqlalchemy as sa
|
||||
from databases import Database
|
||||
from sqlalchemy.dialects.sqlite import insert
|
||||
from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, create_async_engine
|
||||
|
||||
from . import config
|
||||
from .models import (
|
||||
|
|
@ -31,7 +29,9 @@ from .types import ULID
|
|||
log = logging.getLogger(__name__)
|
||||
T = TypeVar("T")
|
||||
|
||||
_database: Database | None = None
|
||||
_engine: AsyncEngine | None = None
|
||||
|
||||
type Connection = AsyncConnection
|
||||
|
||||
|
||||
async def open_connection_pool() -> None:
|
||||
|
|
@ -39,12 +39,13 @@ async def open_connection_pool() -> None:
|
|||
|
||||
This function needs to be called before any access to the database can happen.
|
||||
"""
|
||||
db = _shared_connection()
|
||||
await db.connect()
|
||||
async with transaction() as conn:
|
||||
await conn.execute(sa.text("PRAGMA journal_mode=WAL"))
|
||||
|
||||
await db.execute(sa.text("PRAGMA journal_mode=WAL"))
|
||||
await conn.run_sync(metadata.create_all, tables=[db_patches])
|
||||
|
||||
await apply_db_patches(db)
|
||||
async with new_connection() as conn:
|
||||
await apply_db_patches(conn)
|
||||
|
||||
|
||||
async def close_connection_pool() -> None:
|
||||
|
|
@ -53,32 +54,33 @@ async def close_connection_pool() -> None:
|
|||
This function should be called before the app shuts down to ensure all data
|
||||
has been flushed to the database.
|
||||
"""
|
||||
db = _shared_connection()
|
||||
engine = _shared_engine()
|
||||
|
||||
async with engine.begin() as conn:
|
||||
# Run automatic ANALYZE prior to closing the db,
|
||||
# see https://sqlite.com/lang_analyze.html.
|
||||
await db.execute(sa.text("PRAGMA analysis_limit=400"))
|
||||
await db.execute(sa.text("PRAGMA optimize"))
|
||||
await conn.execute(sa.text("PRAGMA analysis_limit=400"))
|
||||
await conn.execute(sa.text("PRAGMA optimize"))
|
||||
|
||||
await db.disconnect()
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
async def current_patch_level(db: Database) -> str:
|
||||
async def current_patch_level(conn: Connection, /) -> str:
|
||||
query = sa.select(db_patches.c.current)
|
||||
current = await db.fetch_val(query)
|
||||
current = await conn.scalar(query)
|
||||
return current or ""
|
||||
|
||||
|
||||
async def set_current_patch_level(db: Database, current: str) -> None:
|
||||
async def set_current_patch_level(conn: Connection, /, current: str) -> None:
|
||||
stmt = insert(db_patches).values(id=1, current=current)
|
||||
stmt = stmt.on_conflict_do_update(set_={"current": stmt.excluded.current})
|
||||
await db.execute(stmt)
|
||||
await conn.execute(stmt)
|
||||
|
||||
|
||||
db_patches_dir = Path(__file__).parent / "sql"
|
||||
|
||||
|
||||
async def apply_db_patches(db: Database) -> None:
|
||||
async def apply_db_patches(conn: Connection, /) -> None:
|
||||
"""Apply all remaining patches to the database.
|
||||
|
||||
Beware that patches will be applied in lexicographical order,
|
||||
|
|
@ -90,7 +92,7 @@ async def apply_db_patches(db: Database) -> None:
|
|||
using two consecutive semi-colons (;).
|
||||
Failing to do so will result in an error.
|
||||
"""
|
||||
applied_lvl = await current_patch_level(db)
|
||||
applied_lvl = await current_patch_level(conn)
|
||||
|
||||
did_patch = False
|
||||
|
||||
|
|
@ -109,31 +111,52 @@ async def apply_db_patches(db: Database) -> None:
|
|||
)
|
||||
raise RuntimeError("No statement found.")
|
||||
|
||||
async with db.transaction():
|
||||
async with transacted(conn):
|
||||
for query in queries:
|
||||
await db.execute(sa.text(query))
|
||||
await conn.execute(sa.text(query))
|
||||
|
||||
await set_current_patch_level(db, patch_lvl)
|
||||
await set_current_patch_level(conn, patch_lvl)
|
||||
|
||||
did_patch = True
|
||||
|
||||
if did_patch:
|
||||
await db.execute(sa.text("vacuum"))
|
||||
await _vacuum(conn)
|
||||
|
||||
|
||||
async def get_import_progress() -> Progress | None:
|
||||
async def _vacuum(conn: Connection, /) -> None:
|
||||
"""Vacuum the database.
|
||||
|
||||
This function cannot be run on a connection with an open transaction.
|
||||
"""
|
||||
# With SQLAlchemy's "autobegin" behavior we need to switch the connection
|
||||
# to "autocommit" first to keep it from automatically starting a transaction,
|
||||
# as VACUUM cannot be run inside a transaction for most databases.
|
||||
await conn.commit()
|
||||
isolation_level = await conn.get_isolation_level()
|
||||
log.debug("Previous isolation_level: %a", isolation_level)
|
||||
await conn.execution_options(isolation_level="AUTOCOMMIT")
|
||||
try:
|
||||
await conn.execute(sa.text("vacuum"))
|
||||
await conn.commit()
|
||||
finally:
|
||||
await conn.execution_options(isolation_level=isolation_level)
|
||||
|
||||
|
||||
async def get_import_progress(conn: Connection, /) -> Progress | None:
|
||||
"""Return the latest import progress."""
|
||||
return await get(
|
||||
Progress, type="import-imdb-movies", order_by=(progress.c.started, "desc")
|
||||
conn, Progress, type="import-imdb-movies", order_by=(progress.c.started, "desc")
|
||||
)
|
||||
|
||||
|
||||
async def stop_import_progress(*, error: BaseException | None = None) -> None:
|
||||
async def stop_import_progress(
|
||||
conn: Connection, /, *, error: BaseException | None = None
|
||||
) -> None:
|
||||
"""Stop the current import.
|
||||
|
||||
If an error is given, it will be logged to the progress state.
|
||||
"""
|
||||
current = await get_import_progress()
|
||||
current = await get_import_progress(conn)
|
||||
is_running = current and current.stopped is None
|
||||
|
||||
if not is_running:
|
||||
|
|
@ -144,17 +167,17 @@ async def stop_import_progress(*, error: BaseException | None = None) -> None:
|
|||
current.error = repr(error)
|
||||
current.stopped = utcnow().isoformat()
|
||||
|
||||
await update(current)
|
||||
await update(conn, current)
|
||||
|
||||
|
||||
async def set_import_progress(progress: float) -> Progress:
|
||||
async def set_import_progress(conn: Connection, /, progress: float) -> Progress:
|
||||
"""Set the current import progress percentage.
|
||||
|
||||
If no import is currently running, this will create a new one.
|
||||
"""
|
||||
progress = min(max(0.0, progress), 100.0) # clamp to 0 <= progress <= 100
|
||||
|
||||
current = await get_import_progress()
|
||||
current = await get_import_progress(conn)
|
||||
is_running = current and current.stopped is None
|
||||
|
||||
if not is_running:
|
||||
|
|
@ -164,71 +187,88 @@ async def set_import_progress(progress: float) -> Progress:
|
|||
current.percent = progress
|
||||
|
||||
if is_running:
|
||||
await update(current)
|
||||
await update(conn, current)
|
||||
else:
|
||||
await add(current)
|
||||
await add(conn, current)
|
||||
|
||||
return current
|
||||
|
||||
|
||||
_lock = threading.Lock()
|
||||
_prelock = threading.Lock()
|
||||
def _new_engine() -> AsyncEngine:
|
||||
uri = f"sqlite+aiosqlite:///{config.storage_path}"
|
||||
|
||||
return create_async_engine(
|
||||
uri,
|
||||
isolation_level="SERIALIZABLE",
|
||||
)
|
||||
|
||||
|
||||
def _shared_engine() -> AsyncEngine:
|
||||
global _engine
|
||||
|
||||
if _engine is None:
|
||||
_engine = _new_engine()
|
||||
|
||||
return _engine
|
||||
|
||||
|
||||
def _new_connection() -> Connection:
|
||||
return _shared_engine().connect()
|
||||
|
||||
|
||||
@contextlib.asynccontextmanager
|
||||
async def single_threaded():
|
||||
"""Ensure the nested code is run only by a single thread at a time."""
|
||||
wait = 1e-5 # XXX not sure if there's a better magic value here
|
||||
async def transaction(
|
||||
*, force_rollback: bool = False
|
||||
) -> AsyncGenerator[Connection, None]:
|
||||
async with new_connection() as conn:
|
||||
yield conn
|
||||
|
||||
# The pre-lock (a lock for the lock) allows for multiple threads to hand of
|
||||
# the main lock.
|
||||
# With only a single lock the contending thread will spend most of its time
|
||||
# in the asyncio.sleep and the reigning thread will have time to finish
|
||||
# whatever it's doing and simply acquire the lock again before the other
|
||||
# thread has had a change to try.
|
||||
# By having another lock (and the same sleep time!) the contending thread
|
||||
# will always have a chance to acquire the main lock.
|
||||
while not _prelock.acquire(blocking=False):
|
||||
await asyncio.sleep(wait)
|
||||
if not force_rollback:
|
||||
await conn.commit()
|
||||
|
||||
try:
|
||||
while not _lock.acquire(blocking=False):
|
||||
await asyncio.sleep(wait)
|
||||
finally:
|
||||
_prelock.release()
|
||||
|
||||
# The _test_connection allows pinning a connection that will be shared across the app.
|
||||
# This can (and should only) be used when running tests, NOT IN PRODUCTION!
|
||||
_test_connection: Connection | None = None
|
||||
|
||||
|
||||
@contextlib.asynccontextmanager
|
||||
async def new_connection() -> AsyncGenerator[Connection, None]:
|
||||
"""Return a new connection.
|
||||
|
||||
Any changes will be rolled back, unless `.commit()` is called on the
|
||||
connection.
|
||||
|
||||
If you want to commit changes, consider using `transaction()` instead.
|
||||
"""
|
||||
conn = _test_connection or _new_connection()
|
||||
|
||||
# Support reusing the same connection for _test_connection.
|
||||
is_started = conn.sync_connection is not None
|
||||
if is_started:
|
||||
yield conn
|
||||
return
|
||||
|
||||
async with conn:
|
||||
yield conn
|
||||
|
||||
|
||||
@contextlib.asynccontextmanager
|
||||
async def transacted(
|
||||
conn: Connection, /, *, force_rollback: bool = False
|
||||
) -> AsyncGenerator[None, None]:
|
||||
transaction = contextlib.nullcontext() if conn.in_transaction() else conn.begin()
|
||||
|
||||
async with transaction:
|
||||
try:
|
||||
yield
|
||||
|
||||
finally:
|
||||
_lock.release()
|
||||
if force_rollback:
|
||||
await conn.rollback()
|
||||
|
||||
|
||||
@contextlib.asynccontextmanager
|
||||
async def _locked_connection():
|
||||
async with single_threaded():
|
||||
yield _shared_connection()
|
||||
|
||||
|
||||
def _shared_connection() -> Database:
|
||||
global _database
|
||||
|
||||
if _database is None:
|
||||
uri = f"sqlite:///{config.storage_path}"
|
||||
# uri = f"sqlite+aiosqlite:///{config.storage_path}"
|
||||
_database = Database(uri)
|
||||
|
||||
engine = sa.create_engine(uri, future=True)
|
||||
metadata.create_all(engine, tables=[db_patches])
|
||||
|
||||
return _database
|
||||
|
||||
|
||||
def transaction():
|
||||
return _shared_connection().transaction()
|
||||
|
||||
|
||||
async def add(item: Model) -> None:
|
||||
async def add(conn: Connection, /, item: Model) -> None:
|
||||
# Support late initializing - used for optimization.
|
||||
if getattr(item, "_is_lazy", False):
|
||||
assert hasattr(item, "_lazy_init")
|
||||
|
|
@ -237,14 +277,29 @@ async def add(item: Model) -> None:
|
|||
table: sa.Table = item.__table__
|
||||
values = asplain(item, serialize=True)
|
||||
stmt = table.insert().values(values)
|
||||
async with _locked_connection() as conn:
|
||||
await conn.execute(stmt)
|
||||
|
||||
|
||||
async def fetch_all(
|
||||
conn: Connection, /, query: sa.Executable, values: "dict | None" = None
|
||||
) -> Sequence[sa.Row]:
|
||||
result = await conn.execute(query, values)
|
||||
return result.all()
|
||||
|
||||
|
||||
async def fetch_one(
|
||||
conn: Connection, /, query: sa.Executable, values: "dict | None" = None
|
||||
) -> sa.Row | None:
|
||||
result = await conn.execute(query, values)
|
||||
return result.first()
|
||||
|
||||
|
||||
ModelType = TypeVar("ModelType", bound=Model)
|
||||
|
||||
|
||||
async def get(
|
||||
conn: Connection,
|
||||
/,
|
||||
model: Type[ModelType],
|
||||
*,
|
||||
order_by: tuple[sa.Column, Literal["asc", "desc"]] | None = None,
|
||||
|
|
@ -268,13 +323,12 @@ async def get(
|
|||
query = query.order_by(
|
||||
order_col.asc() if order_dir == "asc" else order_col.desc()
|
||||
)
|
||||
async with _locked_connection() as conn:
|
||||
row = await conn.fetch_one(query)
|
||||
row = await fetch_one(conn, query)
|
||||
return fromplain(model, row._mapping, serialized=True) if row else None
|
||||
|
||||
|
||||
async def get_many(
|
||||
model: Type[ModelType], **field_sets: set | list
|
||||
conn: Connection, /, model: Type[ModelType], **field_sets: set | list
|
||||
) -> Iterable[ModelType]:
|
||||
"""Return the items with any values matching all given field sets.
|
||||
|
||||
|
|
@ -288,12 +342,13 @@ async def get_many(
|
|||
|
||||
table: sa.Table = model.__table__
|
||||
query = sa.select(model).where(*(table.c[k].in_(v) for k, v in field_sets.items()))
|
||||
async with _locked_connection() as conn:
|
||||
rows = await conn.fetch_all(query)
|
||||
rows = await fetch_all(conn, query)
|
||||
return (fromplain(model, row._mapping, serialized=True) for row in rows)
|
||||
|
||||
|
||||
async def get_all(model: Type[ModelType], **field_values) -> Iterable[ModelType]:
|
||||
async def get_all(
|
||||
conn: Connection, /, model: Type[ModelType], **field_values
|
||||
) -> Iterable[ModelType]:
|
||||
"""Filter all items by comparing all given field values.
|
||||
|
||||
If no filters are given, all items will be returned.
|
||||
|
|
@ -302,12 +357,11 @@ async def get_all(model: Type[ModelType], **field_values) -> Iterable[ModelType]
|
|||
query = sa.select(model).where(
|
||||
*(table.c[k] == v for k, v in field_values.items() if v is not None)
|
||||
)
|
||||
async with _locked_connection() as conn:
|
||||
rows = await conn.fetch_all(query)
|
||||
rows = await fetch_all(conn, query)
|
||||
return (fromplain(model, row._mapping, serialized=True) for row in rows)
|
||||
|
||||
|
||||
async def update(item: Model) -> None:
|
||||
async def update(conn: Connection, /, item: Model) -> None:
|
||||
# Support late initializing - used for optimization.
|
||||
if getattr(item, "_is_lazy", False):
|
||||
assert hasattr(item, "_lazy_init")
|
||||
|
|
@ -316,30 +370,28 @@ async def update(item: Model) -> None:
|
|||
table: sa.Table = item.__table__
|
||||
values = asplain(item, serialize=True)
|
||||
stmt = table.update().where(table.c.id == values["id"]).values(values)
|
||||
async with _locked_connection() as conn:
|
||||
await conn.execute(stmt)
|
||||
|
||||
|
||||
async def remove(item: Model) -> None:
|
||||
async def remove(conn: Connection, /, item: Model) -> None:
|
||||
table: sa.Table = item.__table__
|
||||
values = asplain(item, filter_fields={"id"}, serialize=True)
|
||||
stmt = table.delete().where(table.c.id == values["id"])
|
||||
async with _locked_connection() as conn:
|
||||
await conn.execute(stmt)
|
||||
|
||||
|
||||
async def add_or_update_user(user: User) -> None:
|
||||
db_user = await get(User, imdb_id=user.imdb_id)
|
||||
async def add_or_update_user(conn: Connection, /, user: User) -> None:
|
||||
db_user = await get(conn, User, imdb_id=user.imdb_id)
|
||||
if not db_user:
|
||||
await add(user)
|
||||
await add(conn, user)
|
||||
else:
|
||||
user.id = db_user.id
|
||||
|
||||
if user != db_user:
|
||||
await update(user)
|
||||
await update(conn, user)
|
||||
|
||||
|
||||
async def add_or_update_many_movies(movies: list[Movie]) -> None:
|
||||
async def add_or_update_many_movies(conn: Connection, /, movies: list[Movie]) -> None:
|
||||
"""Add or update Movies in the database.
|
||||
|
||||
This is an optimized version of `add_or_update_movie` for the purpose
|
||||
|
|
@ -348,12 +400,13 @@ async def add_or_update_many_movies(movies: list[Movie]) -> None:
|
|||
# for movie in movies:
|
||||
# await add_or_update_movie(movie)
|
||||
db_movies = {
|
||||
m.imdb_id: m for m in await get_many(Movie, imdb_id=[m.imdb_id for m in movies])
|
||||
m.imdb_id: m
|
||||
for m in await get_many(conn, Movie, imdb_id=[m.imdb_id for m in movies])
|
||||
}
|
||||
for movie in movies:
|
||||
# XXX optimize bulk add & update as well
|
||||
if movie.imdb_id not in db_movies:
|
||||
await add(movie)
|
||||
await add(conn, movie)
|
||||
else:
|
||||
db_movie = db_movies[movie.imdb_id]
|
||||
movie.id = db_movie.id
|
||||
|
|
@ -366,10 +419,10 @@ async def add_or_update_many_movies(movies: list[Movie]) -> None:
|
|||
if movie.updated <= db_movie.updated:
|
||||
return
|
||||
|
||||
await update(movie)
|
||||
await update(conn, movie)
|
||||
|
||||
|
||||
async def add_or_update_movie(movie: Movie) -> None:
|
||||
async def add_or_update_movie(conn: Connection, /, movie: Movie) -> None:
|
||||
"""Add or update a Movie in the database.
|
||||
|
||||
This is an upsert operation, but it will also update the Movie you pass
|
||||
|
|
@ -377,9 +430,9 @@ async def add_or_update_movie(movie: Movie) -> None:
|
|||
set all optional values on your Movie that might be unset but exist in the
|
||||
database. It's a bidirectional sync.
|
||||
"""
|
||||
db_movie = await get(Movie, imdb_id=movie.imdb_id)
|
||||
db_movie = await get(conn, Movie, imdb_id=movie.imdb_id)
|
||||
if not db_movie:
|
||||
await add(movie)
|
||||
await add(conn, movie)
|
||||
else:
|
||||
movie.id = db_movie.id
|
||||
|
||||
|
|
@ -391,23 +444,23 @@ async def add_or_update_movie(movie: Movie) -> None:
|
|||
if movie.updated <= db_movie.updated:
|
||||
return
|
||||
|
||||
await update(movie)
|
||||
await update(conn, movie)
|
||||
|
||||
|
||||
async def add_or_update_rating(rating: Rating) -> bool:
|
||||
async def add_or_update_rating(conn: Connection, /, rating: Rating) -> bool:
|
||||
db_rating = await get(
|
||||
Rating, movie_id=str(rating.movie_id), user_id=str(rating.user_id)
|
||||
conn, Rating, movie_id=str(rating.movie_id), user_id=str(rating.user_id)
|
||||
)
|
||||
|
||||
if not db_rating:
|
||||
await add(rating)
|
||||
await add(conn, rating)
|
||||
return True
|
||||
|
||||
else:
|
||||
rating.id = db_rating.id
|
||||
|
||||
if rating != db_rating:
|
||||
await update(rating)
|
||||
await update(conn, rating)
|
||||
return True
|
||||
|
||||
return False
|
||||
|
|
@ -418,6 +471,8 @@ def sql_escape(s: str, char: str = "#") -> str:
|
|||
|
||||
|
||||
async def find_ratings(
|
||||
conn: Connection,
|
||||
/,
|
||||
*,
|
||||
title: str | None = None,
|
||||
media_type: str | None = None,
|
||||
|
|
@ -475,9 +530,8 @@ async def find_ratings(
|
|||
)
|
||||
.limit(limit_rows)
|
||||
)
|
||||
async with _locked_connection() as conn:
|
||||
rating_rows: AsyncGenerator[Rating, None] = conn.iterate(query) # type: ignore
|
||||
movie_ids = [r.movie_id async for r in rating_rows]
|
||||
rating_rows: sa.CursorResult[Rating] = await conn.execute(query)
|
||||
movie_ids = [r.movie_id for r in rating_rows]
|
||||
|
||||
if include_unrated and len(movie_ids) < limit_rows:
|
||||
query = (
|
||||
|
|
@ -491,15 +545,17 @@ async def find_ratings(
|
|||
)
|
||||
.limit(limit_rows - len(movie_ids))
|
||||
)
|
||||
async with _locked_connection() as conn:
|
||||
movie_rows: AsyncGenerator[Movie, None] = conn.iterate(query) # type: ignore
|
||||
movie_ids += [r.id async for r in movie_rows]
|
||||
movie_rows: sa.CursorResult[Movie] = await conn.execute(query)
|
||||
movie_ids += [r.id for r in movie_rows]
|
||||
|
||||
return await ratings_for_movie_ids(ids=movie_ids)
|
||||
return await ratings_for_movie_ids(conn, ids=movie_ids)
|
||||
|
||||
|
||||
async def ratings_for_movie_ids(
|
||||
ids: Iterable[ULID | str] = [], imdb_ids: Iterable[str] = []
|
||||
conn: Connection,
|
||||
/,
|
||||
ids: Iterable[ULID | str] = [],
|
||||
imdb_ids: Iterable[str] = [],
|
||||
) -> Iterable[dict[str, Any]]:
|
||||
conds = []
|
||||
|
||||
|
|
@ -527,13 +583,12 @@ async def ratings_for_movie_ids(
|
|||
.outerjoin_from(movies, ratings, movies.c.id == ratings.c.movie_id)
|
||||
.where(sa.or_(*conds))
|
||||
)
|
||||
async with _locked_connection() as conn:
|
||||
rows = await conn.fetch_all(query)
|
||||
rows = await fetch_all(conn, query)
|
||||
return tuple(dict(r._mapping) for r in rows)
|
||||
|
||||
|
||||
async def ratings_for_movies(
|
||||
movie_ids: Iterable[ULID], user_ids: Iterable[ULID] = []
|
||||
conn: Connection, /, movie_ids: Iterable[ULID], user_ids: Iterable[ULID] = []
|
||||
) -> Iterable[Rating]:
|
||||
conditions = [ratings.c.movie_id.in_(str(x) for x in movie_ids)]
|
||||
|
||||
|
|
@ -542,13 +597,14 @@ async def ratings_for_movies(
|
|||
|
||||
query = sa.select(ratings).where(*conditions)
|
||||
|
||||
async with _locked_connection() as conn:
|
||||
rows = await conn.fetch_all(query)
|
||||
rows = await fetch_all(conn, query)
|
||||
|
||||
return (fromplain(Rating, row._mapping, serialized=True) for row in rows)
|
||||
|
||||
|
||||
async def find_movies(
|
||||
conn: Connection,
|
||||
/,
|
||||
*,
|
||||
title: str | None = None,
|
||||
media_type: str | None = None,
|
||||
|
|
@ -606,15 +662,14 @@ async def find_movies(
|
|||
.offset(skip_rows)
|
||||
)
|
||||
|
||||
async with _locked_connection() as conn:
|
||||
rows = await conn.fetch_all(query)
|
||||
rows = await fetch_all(conn, query)
|
||||
|
||||
movies_ = [fromplain(Movie, row._mapping, serialized=True) for row in rows]
|
||||
|
||||
if not user_ids:
|
||||
return ((m, []) for m in movies_)
|
||||
|
||||
ratings = await ratings_for_movies((m.id for m in movies_), user_ids)
|
||||
ratings = await ratings_for_movies(conn, (m.id for m in movies_), user_ids)
|
||||
|
||||
aggreg: dict[ULID, tuple[Movie, list[Rating]]] = {m.id: (m, []) for m in movies_}
|
||||
for rating in ratings:
|
||||
|
|
|
|||
|
|
@ -40,7 +40,9 @@ async def refresh_user_ratings_from_imdb(stop_on_dupe: bool = True):
|
|||
async with asession() as s:
|
||||
s.headers["Accept-Language"] = "en-US, en;q=0.5"
|
||||
|
||||
for user in await db.get_all(User):
|
||||
async with db.new_connection() as conn:
|
||||
users = list(await db.get_all(conn, User))
|
||||
for user in users:
|
||||
log.info("⚡️ Loading data for %s ...", user.name)
|
||||
|
||||
try:
|
||||
|
|
@ -96,7 +98,7 @@ find_year = re.compile(
|
|||
find_movie_id = re.compile(r"/title/(?P<id>tt\d+)/").search
|
||||
|
||||
|
||||
def movie_and_rating_from_item(item) -> tuple[Movie, Rating]:
|
||||
def movie_and_rating_from_item(item: bs4.Tag) -> tuple[Movie, Rating]:
|
||||
genres = (genre := item.find("span", "genre")) and genre.string or ""
|
||||
movie = Movie(
|
||||
title=item.h3.a.string.strip(),
|
||||
|
|
@ -161,7 +163,8 @@ async def parse_page(url: str) -> tuple[list[Rating], str | None]:
|
|||
assert isinstance(meta, bs4.Tag)
|
||||
imdb_id = meta["content"]
|
||||
assert isinstance(imdb_id, str)
|
||||
user = await db.get(User, imdb_id=imdb_id) or User(
|
||||
async with db.new_connection() as conn:
|
||||
user = await db.get(conn, User, imdb_id=imdb_id) or User(
|
||||
imdb_id=imdb_id, name="", secret=""
|
||||
)
|
||||
|
||||
|
|
@ -213,14 +216,15 @@ async def load_ratings(user_id: str):
|
|||
for i, rating in enumerate(ratings):
|
||||
assert rating.user and rating.movie
|
||||
|
||||
async with db.transaction() as conn:
|
||||
if i == 0:
|
||||
# All rating objects share the same user.
|
||||
await db.add_or_update_user(rating.user)
|
||||
await db.add_or_update_user(conn, rating.user)
|
||||
rating.user_id = rating.user.id
|
||||
|
||||
await db.add_or_update_movie(rating.movie)
|
||||
await db.add_or_update_movie(conn, rating.movie)
|
||||
rating.movie_id = rating.movie.id
|
||||
|
||||
is_updated = await db.add_or_update_rating(rating)
|
||||
is_updated = await db.add_or_update_rating(conn, rating)
|
||||
|
||||
yield rating, is_updated
|
||||
|
|
|
|||
|
|
@ -209,7 +209,8 @@ async def import_from_file(*, basics_path: Path, ratings_path: Path):
|
|||
for i, m in enumerate(read_basics(basics_path)):
|
||||
perc = 100 * i / total
|
||||
if perc >= perc_next_report:
|
||||
await db.set_import_progress(perc)
|
||||
async with db.transaction() as conn:
|
||||
await db.set_import_progress(conn, perc)
|
||||
log.info("⏳ Imported %s%%", round(perc, 1))
|
||||
perc_next_report += perc_step
|
||||
|
||||
|
|
@ -233,15 +234,18 @@ async def import_from_file(*, basics_path: Path, ratings_path: Path):
|
|||
chunk.append(m)
|
||||
|
||||
if len(chunk) > 1000:
|
||||
await add_or_update_many_movies(chunk)
|
||||
async with db.transaction() as conn:
|
||||
await add_or_update_many_movies(conn, chunk)
|
||||
chunk = []
|
||||
|
||||
if chunk:
|
||||
await add_or_update_many_movies(chunk)
|
||||
async with db.transaction() as conn:
|
||||
await add_or_update_many_movies(conn, chunk)
|
||||
chunk = []
|
||||
|
||||
log.info("👍 Imported 100%")
|
||||
await db.set_import_progress(100)
|
||||
async with db.transaction() as conn:
|
||||
await db.set_import_progress(conn, 100)
|
||||
|
||||
|
||||
async def download_datasets(*, basics_path: Path, ratings_path: Path) -> None:
|
||||
|
|
@ -270,7 +274,8 @@ async def load_from_web(*, force: bool = False) -> None:
|
|||
See https://www.imdb.com/interfaces/ and https://datasets.imdbws.com/ for
|
||||
more information on the IMDb database dumps.
|
||||
"""
|
||||
await db.set_import_progress(0)
|
||||
async with db.transaction() as conn:
|
||||
await db.set_import_progress(conn, 0)
|
||||
|
||||
try:
|
||||
ratings_file = config.datadir / "imdb/title.ratings.tsv.gz"
|
||||
|
|
@ -290,8 +295,10 @@ async def load_from_web(*, force: bool = False) -> None:
|
|||
await import_from_file(basics_path=basics_file, ratings_path=ratings_file)
|
||||
|
||||
except BaseException as err:
|
||||
await db.stop_import_progress(error=err)
|
||||
async with db.transaction() as conn:
|
||||
await db.stop_import_progress(conn, error=err)
|
||||
raise
|
||||
|
||||
else:
|
||||
await db.stop_import_progress()
|
||||
async with db.transaction() as conn:
|
||||
await db.stop_import_progress(conn)
|
||||
|
|
|
|||
|
|
@ -354,49 +354,6 @@ The contents of the Relation are ignored or discarded when using
|
|||
Relation = Annotated[T | None, _RelationSentinel]
|
||||
|
||||
|
||||
@mapper_registry.mapped
|
||||
@dataclass
|
||||
class Rating:
|
||||
__table__: ClassVar[Table] = Table(
|
||||
"ratings",
|
||||
metadata,
|
||||
Column("id", String, primary_key=True), # ULID
|
||||
Column("movie_id", ForeignKey("movies.id"), nullable=False), # ULID
|
||||
Column("user_id", ForeignKey("users.id"), nullable=False), # ULID
|
||||
Column("score", Integer, nullable=False),
|
||||
Column("rating_date", String, nullable=False), # datetime
|
||||
Column("favorite", Integer), # bool
|
||||
Column("finished", Integer), # bool
|
||||
)
|
||||
|
||||
id: ULID = field(default_factory=ULID)
|
||||
|
||||
movie_id: ULID = None
|
||||
movie: Relation[Movie] = None
|
||||
|
||||
user_id: ULID = None
|
||||
user: Relation["User"] = None
|
||||
|
||||
score: int = None # range: [0,100]
|
||||
rating_date: datetime = None
|
||||
favorite: bool | None = None
|
||||
finished: bool | None = None
|
||||
|
||||
def __eq__(self, other):
|
||||
"""Return wether two Ratings are equal.
|
||||
|
||||
This operation compares all fields as expected, except that it
|
||||
ignores any field marked as Relation.
|
||||
"""
|
||||
if type(other) is not type(self):
|
||||
return False
|
||||
return all(
|
||||
getattr(self, f.name) == getattr(other, f.name) for f in fields(self)
|
||||
)
|
||||
|
||||
|
||||
ratings = Rating.__table__
|
||||
|
||||
Access = Literal[
|
||||
"r", # read
|
||||
"i", # index
|
||||
|
|
@ -442,6 +399,50 @@ class User:
|
|||
self.groups.append({"id": group_id, "access": access})
|
||||
|
||||
|
||||
@mapper_registry.mapped
|
||||
@dataclass
|
||||
class Rating:
|
||||
__table__: ClassVar[Table] = Table(
|
||||
"ratings",
|
||||
metadata,
|
||||
Column("id", String, primary_key=True), # ULID
|
||||
Column("movie_id", ForeignKey("movies.id"), nullable=False), # ULID
|
||||
Column("user_id", ForeignKey("users.id"), nullable=False), # ULID
|
||||
Column("score", Integer, nullable=False),
|
||||
Column("rating_date", String, nullable=False), # datetime
|
||||
Column("favorite", Integer), # bool
|
||||
Column("finished", Integer), # bool
|
||||
)
|
||||
|
||||
id: ULID = field(default_factory=ULID)
|
||||
|
||||
movie_id: ULID = None
|
||||
movie: Relation[Movie] = None
|
||||
|
||||
user_id: ULID = None
|
||||
user: Relation[User] = None
|
||||
|
||||
score: int = None # range: [0,100]
|
||||
rating_date: datetime = None
|
||||
favorite: bool | None = None
|
||||
finished: bool | None = None
|
||||
|
||||
def __eq__(self, other):
|
||||
"""Return wether two Ratings are equal.
|
||||
|
||||
This operation compares all fields as expected, except that it
|
||||
ignores any field marked as Relation.
|
||||
"""
|
||||
if type(other) is not type(self):
|
||||
return False
|
||||
return all(
|
||||
getattr(self, f.name) == getattr(other, f.name) for f in fields(self)
|
||||
)
|
||||
|
||||
|
||||
ratings = Rating.__table__
|
||||
|
||||
|
||||
class GroupUser(TypedDict):
|
||||
id: str
|
||||
name: str
|
||||
|
|
|
|||
|
|
@ -168,7 +168,8 @@ async def auth_user(request) -> User | None:
|
|||
if not isinstance(request.user, AuthedUser):
|
||||
return
|
||||
|
||||
user = await db.get(User, id=request.user.user_id)
|
||||
async with db.new_connection() as conn:
|
||||
user = await db.get(conn, User, id=request.user.user_id)
|
||||
if not user:
|
||||
return
|
||||
|
||||
|
|
@ -195,7 +196,8 @@ def route(path: str, *, methods: list[str] | None = None, **kwds):
|
|||
async def get_ratings_for_group(request):
|
||||
group_id = as_ulid(request.path_params["group_id"])
|
||||
|
||||
if (group := await db.get(Group, id=str(group_id))) is None:
|
||||
async with db.new_connection() as conn:
|
||||
if (group := await db.get(conn, Group, id=str(group_id))) is None:
|
||||
return not_found()
|
||||
|
||||
user_ids = {u["id"] for u in group.users}
|
||||
|
|
@ -207,13 +209,17 @@ async def get_ratings_for_group(request):
|
|||
|
||||
# if (imdb_id or unwind_id) and (movie := await db.get(Movie, id=unwind_id, imdb_id=imdb_id)):
|
||||
if unwind_id:
|
||||
rows = await db.ratings_for_movie_ids(ids=[unwind_id])
|
||||
async with db.new_connection() as conn:
|
||||
rows = await db.ratings_for_movie_ids(conn, ids=[unwind_id])
|
||||
|
||||
elif imdb_id:
|
||||
rows = await db.ratings_for_movie_ids(imdb_ids=[imdb_id])
|
||||
async with db.new_connection() as conn:
|
||||
rows = await db.ratings_for_movie_ids(conn, imdb_ids=[imdb_id])
|
||||
|
||||
else:
|
||||
async with db.new_connection() as conn:
|
||||
rows = await find_ratings(
|
||||
conn,
|
||||
title=params.get("title"),
|
||||
media_type=params.get("media_type"),
|
||||
exact=truthy(params.get("exact")),
|
||||
|
|
@ -261,7 +267,8 @@ async def list_movies(request):
|
|||
if group_id := params.get("group_id"):
|
||||
group_id = as_ulid(group_id)
|
||||
|
||||
group = await db.get(Group, id=str(group_id))
|
||||
async with db.new_connection() as conn:
|
||||
group = await db.get(conn, Group, id=str(group_id))
|
||||
if not group:
|
||||
return not_found("Group not found.")
|
||||
|
||||
|
|
@ -286,8 +293,11 @@ async def list_movies(request):
|
|||
|
||||
if imdb_id or unwind_id:
|
||||
# XXX missing support for user_ids and user_scores
|
||||
async with db.new_connection() as conn:
|
||||
movies = (
|
||||
[m] if (m := await db.get(Movie, id=unwind_id, imdb_id=imdb_id)) else []
|
||||
[m]
|
||||
if (m := await db.get(conn, Movie, id=unwind_id, imdb_id=imdb_id))
|
||||
else []
|
||||
)
|
||||
|
||||
resp = [asplain(web_models.RatingAggregate.from_movie(m)) for m in movies]
|
||||
|
|
@ -295,7 +305,9 @@ async def list_movies(request):
|
|||
else:
|
||||
per_page = as_int(params.get("per_page"), max=1000, default=5)
|
||||
page = as_int(params.get("page"), min=1, default=1)
|
||||
async with db.new_connection() as conn:
|
||||
movieratings = await find_movies(
|
||||
conn,
|
||||
title=params.get("title"),
|
||||
media_type=params.get("media_type"),
|
||||
exact=truthy(params.get("exact")),
|
||||
|
|
@ -325,7 +337,8 @@ async def add_movie(request):
|
|||
@route("/movies/_reload_imdb", methods=["GET"])
|
||||
@requires(["authenticated", "admin"])
|
||||
async def progress_for_load_imdb_movies(request):
|
||||
progress = await db.get_import_progress()
|
||||
async with db.new_connection() as conn:
|
||||
progress = await db.get_import_progress(conn)
|
||||
if not progress:
|
||||
return JSONResponse({"status": "No import exists."}, status_code=404)
|
||||
|
||||
|
|
@ -364,14 +377,16 @@ async def load_imdb_movies(request):
|
|||
force = truthy(params.get("force"))
|
||||
|
||||
async with _import_lock:
|
||||
progress = await db.get_import_progress()
|
||||
async with db.new_connection() as conn:
|
||||
progress = await db.get_import_progress(conn)
|
||||
if progress and not progress.stopped:
|
||||
return JSONResponse(
|
||||
{"status": "Import is running.", "progress": progress.percent},
|
||||
status_code=409,
|
||||
)
|
||||
|
||||
await db.set_import_progress(0)
|
||||
async with db.transaction() as conn:
|
||||
await db.set_import_progress(conn, 0)
|
||||
|
||||
task = BackgroundTask(imdb_import.load_from_web, force=force)
|
||||
return JSONResponse(
|
||||
|
|
@ -382,7 +397,8 @@ async def load_imdb_movies(request):
|
|||
@route("/users")
|
||||
@requires(["authenticated", "admin"])
|
||||
async def list_users(request):
|
||||
users = await db.get_all(User)
|
||||
async with db.new_connection() as conn:
|
||||
users = await db.get_all(conn, User)
|
||||
|
||||
return JSONResponse([asplain(u) for u in users])
|
||||
|
||||
|
|
@ -398,7 +414,8 @@ async def add_user(request):
|
|||
secret = secrets.token_bytes()
|
||||
|
||||
user = User(name=name, imdb_id=imdb_id, secret=phc_scrypt(secret))
|
||||
await db.add(user)
|
||||
async with db.transaction() as conn:
|
||||
await db.add(conn, user)
|
||||
|
||||
return JSONResponse(
|
||||
{
|
||||
|
|
@ -414,7 +431,8 @@ async def show_user(request):
|
|||
user_id = as_ulid(request.path_params["user_id"])
|
||||
|
||||
if is_admin(request):
|
||||
user = await db.get(User, id=str(user_id))
|
||||
async with db.new_connection() as conn:
|
||||
user = await db.get(conn, User, id=str(user_id))
|
||||
|
||||
else:
|
||||
user = await auth_user(request)
|
||||
|
|
@ -441,14 +459,15 @@ async def show_user(request):
|
|||
async def remove_user(request):
|
||||
user_id = as_ulid(request.path_params["user_id"])
|
||||
|
||||
user = await db.get(User, id=str(user_id))
|
||||
async with db.new_connection() as conn:
|
||||
user = await db.get(conn, User, id=str(user_id))
|
||||
if not user:
|
||||
return not_found()
|
||||
|
||||
async with db.transaction():
|
||||
async with db.transaction() as conn:
|
||||
# XXX remove user refs from groups and ratings
|
||||
|
||||
await db.remove(user)
|
||||
await db.remove(conn, user)
|
||||
|
||||
return JSONResponse(asplain(user))
|
||||
|
||||
|
|
@ -459,7 +478,8 @@ async def modify_user(request):
|
|||
user_id = as_ulid(request.path_params["user_id"])
|
||||
|
||||
if is_admin(request):
|
||||
user = await db.get(User, id=str(user_id))
|
||||
async with db.new_connection() as conn:
|
||||
user = await db.get(conn, User, id=str(user_id))
|
||||
|
||||
else:
|
||||
user = await auth_user(request)
|
||||
|
|
@ -495,7 +515,8 @@ async def modify_user(request):
|
|||
|
||||
user.secret = phc_scrypt(secret)
|
||||
|
||||
await db.update(user)
|
||||
async with db.transaction() as conn:
|
||||
await db.update(conn, user)
|
||||
|
||||
return JSONResponse(asplain(user))
|
||||
|
||||
|
|
@ -505,13 +526,15 @@ async def modify_user(request):
|
|||
async def add_group_to_user(request):
|
||||
user_id = as_ulid(request.path_params["user_id"])
|
||||
|
||||
user = await db.get(User, id=str(user_id))
|
||||
async with db.new_connection() as conn:
|
||||
user = await db.get(conn, User, id=str(user_id))
|
||||
if not user:
|
||||
return not_found("User not found")
|
||||
|
||||
(group_id, access) = await json_from_body(request, ["group", "access"])
|
||||
|
||||
group = await db.get(Group, id=str(group_id))
|
||||
async with db.new_connection() as conn:
|
||||
group = await db.get(conn, Group, id=str(group_id))
|
||||
if not group:
|
||||
return not_found("Group not found")
|
||||
|
||||
|
|
@ -519,7 +542,8 @@ async def add_group_to_user(request):
|
|||
raise HTTPException(422, f"Invalid access level.")
|
||||
|
||||
user.set_access(group_id, access)
|
||||
await db.update(user)
|
||||
async with db.transaction() as conn:
|
||||
await db.update(conn, user)
|
||||
|
||||
return JSONResponse(asplain(user))
|
||||
|
||||
|
|
@ -547,7 +571,8 @@ async def load_imdb_user_ratings(request):
|
|||
@route("/groups")
|
||||
@requires(["authenticated", "admin"])
|
||||
async def list_groups(request):
|
||||
groups = await db.get_all(Group)
|
||||
async with db.new_connection() as conn:
|
||||
groups = await db.get_all(conn, Group)
|
||||
|
||||
return JSONResponse([asplain(g) for g in groups])
|
||||
|
||||
|
|
@ -560,7 +585,8 @@ async def add_group(request):
|
|||
# XXX restrict name
|
||||
|
||||
group = Group(name=name)
|
||||
await db.add(group)
|
||||
async with db.transaction() as conn:
|
||||
await db.add(conn, group)
|
||||
|
||||
return JSONResponse(asplain(group))
|
||||
|
||||
|
|
@ -569,7 +595,8 @@ async def add_group(request):
|
|||
@requires(["authenticated"])
|
||||
async def add_user_to_group(request):
|
||||
group_id = as_ulid(request.path_params["group_id"])
|
||||
group = await db.get(Group, id=str(group_id))
|
||||
async with db.new_connection() as conn:
|
||||
group = await db.get(conn, Group, id=str(group_id))
|
||||
|
||||
if not group:
|
||||
return not_found()
|
||||
|
|
@ -596,7 +623,8 @@ async def add_user_to_group(request):
|
|||
else:
|
||||
group.users.append({"name": name, "id": user_id})
|
||||
|
||||
await db.update(group)
|
||||
async with db.transaction() as conn:
|
||||
await db.update(conn, group)
|
||||
|
||||
return JSONResponse(asplain(group))
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue