marc/folkugat-web
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use basedpyright refactor

Browse Source
This commit is contained in:
marc
2025-03-22 23:06:34 +01:00
parent ac54453b7f
commit 2f7c7c2429
41 changed files with 480 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
folkugat_web/dal/sql/__init__.py
View File

@@ -1 +1,3 @@
from ._connection import get_connection, Connection
from ._connection import Connection, get_connection
__all__ = ["get_connection", "Connection"]

2
folkugat_web/dal/sql/_connection.py
View File

@@ -8,7 +8,7 @@ Connection = sqlite3.Connection
@contextmanager
def get_connection(con: Optional[Connection] = None) -> Iterator[Connection]:
def get_connection(con: Connection | None = None) -> Iterator[Connection]:
if con:
yield con
else:

5
folkugat_web/dal/sql/ddl.py
View File

@@ -1,10 +1,11 @@
from folkugat_web.dal.sql import get_connection, sessions
from folkugat_web.dal.sql import get_connection
from folkugat_web.dal.sql.playlists import ddl as playlists_ddl
from folkugat_web.dal.sql.sessions import ddl as sessions_ddl
from folkugat_web.dal.sql.temes import ddl as temes_ddl
def create_db():
with get_connection() as con:
sessions.create_db(con)
sessions_ddl.create_db(con)
temes_ddl.create_db(con)
playlists_ddl.create_db(con)

15
folkugat_web/dal/sql/playlists/_conversion.py → folkugat_web/dal/sql/playlists/conversion.py
View File

@@ -1,7 +1,18 @@
from typing import TypedDict
from folkugat_web.model import playlists as model
PlaylistRowTuple = tuple[int, int, int, int | None]
def playlist_entry_to_row(tema_in_set: model.PlaylistEntry) -> dict:
class PlaylistRowDict(TypedDict):
id: int | None
session_id: int
set_id: int
tema_id: int | None
def playlist_entry_to_row(tema_in_set: model.PlaylistEntry) -> PlaylistRowDict:
return {
'id': tema_in_set.id,
'session_id': tema_in_set.session_id,
@@ -10,7 +21,7 @@ def playlist_entry_to_row(tema_in_set: model.PlaylistEntry) -> dict:
}
def row_to_playlist_entry(row: tuple) -> model.PlaylistEntry:
def row_to_playlist_entry(row: PlaylistRowTuple) -> model.PlaylistEntry:
return model.PlaylistEntry(
id=row[0],
session_id=row[1],

8
folkugat_web/dal/sql/playlists/ddl.py
View File

@@ -1,9 +1,7 @@
from typing import Optional
from folkugat_web.dal.sql import Connection, get_connection
def create_db(con: Optional[Connection] = None):
def create_db(con: Connection | None = None):
with get_connection(con) as con:
create_playlists_table(con)
@@ -11,7 +9,7 @@ def create_db(con: Optional[Connection] = None):
def drop_playlists_table(con: Connection):
query = "DROP TABLE IF EXISTS playlists"
cur = con.cursor()
cur.execute(query)
_ = cur.execute(query)
def create_playlists_table(con: Connection):
@@ -24,4 +22,4 @@ def create_playlists_table(con: Connection):
)
"""
cur = con.cursor()
cur.execute(query)
_ = cur.execute(query)

49
folkugat_web/dal/sql/playlists/query.py
View File

@@ -1,19 +1,27 @@
from collections.abc import Iterator
from typing import Optional
from typing import TypedDict
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.dal.sql.sessions import conversion as sessions_conversion
from folkugat_web.model import playlists as model
from folkugat_web.model.sessions import Session
from ._conversion import row_to_playlist_entry
from . import conversion
class QueryData(TypedDict, total=False):
id: int
set_id: int
session_id: int
def _filter_clause(
entry_id: Optional[int] = None,
set_id: Optional[int] = None,
session_id: Optional[int] = None,
) -> tuple[str, dict]:
filter_clauses = []
query_data = {}
entry_id: int | None = None,
set_id: int | None = None,
session_id: int | None = None,
) -> tuple[str, QueryData]:
filter_clauses: list[str] = []
query_data: QueryData = {}
if entry_id is not None:
filter_clauses.append("id = :id")
@@ -29,10 +37,10 @@ def _filter_clause(
def get_playlist_entries(
entry_id: Optional[int] = None,
set_id: Optional[int] = None,
session_id: Optional[int] = None,
con: Optional[Connection] = None,
entry_id: int | None = None,
set_id: int | None = None,
session_id: int | None = None,
con: Connection | None = None,
) -> Iterator[model.PlaylistEntry]:
filter_clause, data = _filter_clause(entry_id=entry_id, set_id=set_id, session_id=session_id)
query = f"""
@@ -43,5 +51,18 @@ def get_playlist_entries(
"""
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
return map(row_to_playlist_entry, cur.fetchall())
_ = cur.execute(query, data)
return map(conversion.row_to_playlist_entry, cur.fetchall())
def get_tune_sessions(tema_ids: list[int], con: Connection | None = None) -> Iterator[Session]:
query = """
SELECT p.tema_id, s.id, s.date, s.start_time, s.end_time, s.venue_name, s.venue_url, s.is_live
FROM playlists p JOIN sessions s ON p.session_id = s.id
WHERE p.tema_id IN :tema_ids
"""
data = dict(tema_ids=tuple(tema_ids))
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
return map(sessions_conversion.row_to_session, cur.fetchall())

28
folkugat_web/dal/sql/playlists/write.py
View File

@@ -1,12 +1,10 @@
from typing import Optional
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.model import playlists as model
from ._conversion import playlist_entry_to_row, row_to_playlist_entry
from . import conversion
def insert_playlist_entry(pl_entry: model.PlaylistEntry, con: Optional[Connection] = None) -> model.PlaylistEntry:
def insert_playlist_entry(pl_entry: model.PlaylistEntry, con: Connection | None = None) -> model.PlaylistEntry:
query = """
INSERT INTO playlists
(id, session_id, set_id, tema_id)
@@ -14,15 +12,15 @@ def insert_playlist_entry(pl_entry: model.PlaylistEntry, con: Optional[Connectio
(:id, :session_id, :set_id, :tema_id)
RETURNING *
"""
data = playlist_entry_to_row(pl_entry)
data = conversion.playlist_entry_to_row(pl_entry)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
row = cur.fetchone()
return row_to_playlist_entry(row)
_ = cur.execute(query, data)
row: conversion.PlaylistRowTuple = cur.fetchone()
return conversion.row_to_playlist_entry(row)
def update_playlist_entry(entry: model.PlaylistEntry, con: Optional[Connection] = None):
def update_playlist_entry(entry: model.PlaylistEntry, con: Connection | None = None):
query = """
UPDATE playlists
SET
@@ -30,14 +28,14 @@ def update_playlist_entry(entry: model.PlaylistEntry, con: Optional[Connection]
WHERE
id = :id
"""
data = playlist_entry_to_row(entry)
data = conversion.playlist_entry_to_row(entry)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
_ = cur.execute(query, data)
return
def delete_playlist_entry(entry_id: int, con: Optional[Connection] = None):
def delete_playlist_entry(entry_id: int, con: Connection | None = None):
query = """
DELETE FROM playlists
WHERE id = :id
@@ -45,11 +43,11 @@ def delete_playlist_entry(entry_id: int, con: Optional[Connection] = None):
data = dict(id=entry_id)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
_ = cur.execute(query, data)
return
def delete_playlist_set(session_id: int, set_id: int, con: Optional[Connection] = None):
def delete_playlist_set(session_id: int, set_id: int, con: Connection | None = None):
query = """
DELETE FROM playlists
WHERE session_id = :session_id AND set_id = :set_id
@@ -57,5 +55,5 @@ def delete_playlist_set(session_id: int, set_id: int, con: Optional[Connection]
data = dict(session_id=session_id, set_id=set_id)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
_ = cur.execute(query, data)
return

194
folkugat_web/dal/sql/sessions.py
View File

@@ -1,194 +0,0 @@
import datetime
from typing import Optional
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.model import sessions as model
from folkugat_web.model.sql import OrderCol, Range
from folkugat_web.typing import OptionalListOrValue as OLV
def create_db(con: Optional[Connection] = None):
with get_connection(con) as con:
create_sessions_table(con)
def drop_sessions_table(con: Connection):
query = "DROP TABLE IF EXISTS sessions"
cur = con.cursor()
cur.execute(query)
def create_sessions_table(con: Connection):
query = """
CREATE TABLE IF NOT EXISTS sessions (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
start_time TEXT NOT NULL,
end_time TEXT NOT NULL,
venue_name TEXT,
venue_url TEXT,
is_live BOOLEAN DEFAULT false
)
"""
cur = con.cursor()
cur.execute(query)
def _session_to_row(sessio: model.Session) -> dict:
return {
'id': sessio.id,
'date': sessio.date,
'start_time': sessio.start_time.isoformat(),
'end_time': sessio.end_time.isoformat(),
'venue_name': sessio.venue.name,
'venue_url': sessio.venue.url,
'is_live': sessio.is_live,
}
def _row_to_session(row: tuple) -> model.Session:
return model.Session(
id=row[0],
date=datetime.date.fromisoformat(row[1]),
start_time=datetime.time.fromisoformat(row[2]),
end_time=datetime.time.fromisoformat(row[3]),
venue=model.SessionVenue(
name=row[4],
url=row[5],
),
is_live=row[6],
)
def insert_session(session: model.Session, con: Optional[Connection] = None):
query = """
INSERT INTO sessions
(id, date, start_time, end_time, venue_name, venue_url, is_live)
VALUES
(:id, :date, :start_time, :end_time, :venue_name, :venue_url, :is_live)
RETURNING *
"""
data = _session_to_row(session)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
row = cur.fetchone()
return _row_to_session(row)
def update_session(session: model.Session, con: Optional[Connection] = None):
query = """
UPDATE sessions SET
date = :date, start_time = :start_time, end_time = :end_time,
venue_name = :venue_name, venue_url = :venue_url, is_live = :is_live
WHERE id = :id
"""
data = _session_to_row(session)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
def _filter_clause(session_id: Optional[int] = None,
date_range: Optional[Range[datetime.date]] = None,
is_live: Optional[bool] = None) -> tuple[str, dict]:
filter_clauses = []
filter_data = {}
if session_id is not None:
filter_clauses.append(f"id = :session_id")
filter_data["session_id"] = session_id
if date_range:
if ub := date_range.upper_bound():
operator = "<=" if ub[1] else "<"
filter_clauses.append(f"date {operator} :date_ub")
filter_data["date_ub"] = ub[0]
if lb := date_range.lower_bound():
operator = ">=" if lb[1] else ">"
filter_clauses.append(f"date {operator} :date_lb")
filter_data["date_lb"] = lb[0]
if is_live is not None:
filter_clauses.append(f"is_live = :is_live")
filter_data["is_live"] = is_live
if filter_clauses:
filter_clause_str = " AND ".join(filter_clauses)
filter_clause = f"WHERE {filter_clause_str}"
return filter_clause, filter_data
else:
return "", {}
def _order_clause(order_by: OLV[OrderCol[model.SessionCols]]) -> str:
if not order_by:
return ""
if not isinstance(order_by, list):
order_by = [order_by]
order_clauses = [f"{ocol.column.value} {ocol.order.value}" for ocol in order_by]
order_clauses_str = " ".join(order_clauses)
return f"ORDER BY {order_clauses_str}"
def get_sessions(session_id: Optional[int] = None,
date_range: Optional[Range[datetime.date]] = None,
is_live: Optional[bool] = None,
order_by: OLV[OrderCol[model.SessionCols]] = None,
limit: Optional[int] = None, offset: Optional[int] = None,
con: Optional[Connection] = None) -> list[model.Session]:
clauses = []
filter_clause, data = _filter_clause(session_id=session_id, date_range=date_range, is_live=is_live)
if filter_clause:
clauses.append(filter_clause)
if order_clause := _order_clause(order_by=order_by):
clauses.append(order_clause)
if limit is not None:
clauses.append("LIMIT :limit")
data["limit"] = limit
if offset is not None:
clauses.append("OFFSET :offset")
data["offset"] = offset
clauses_str = " ".join(clauses)
query = f"""
SELECT id, date, start_time, end_time, venue_name, venue_url, is_live
FROM sessions
{clauses_str}
"""
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
return list(map(_row_to_session, cur.fetchall()))
def delete_session_by_id(session_id: int, con: Optional[Connection] = None):
query = """
DELETE FROM sessions
WHERE id = :id
"""
data = dict(id=session_id)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
def stop_live_sessions(con: Optional[Connection] = None):
query = """
UPDATE sessions SET is_live = false WHERE is_live = true
"""
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query)
def set_live_session(session_id: int, con: Optional[Connection] = None):
query = """
UPDATE sessions SET is_live = true WHERE id = :id
"""
data = dict(id=session_id)
with get_connection(con) as con:
stop_live_sessions(con=con)
cur = con.cursor()
cur.execute(query, data)

0
folkugat_web/dal/sql/sessions/__init__.py Normal file
View File

42
folkugat_web/dal/sql/sessions/conversion.py Normal file
View File

@@ -0,0 +1,42 @@
import datetime
from typing import TypedDict
from folkugat_web.model import sessions as model
SessionRowTuple = tuple[int, str, str, str, str | None, str | None, bool]
class SessionRowDict(TypedDict):
id: int | None
date: str
start_time: str
end_time: str
venue_name: str | None
venue_url: str | None
is_live: bool
def session_to_row(sessio: model.Session) -> SessionRowDict:
return {
'id': sessio.id,
'date': sessio.date.isoformat(),
'start_time': sessio.start_time.isoformat(),
'end_time': sessio.end_time.isoformat(),
'venue_name': sessio.venue.name,
'venue_url': sessio.venue.url,
'is_live': sessio.is_live,
}
def row_to_session(row: SessionRowTuple) -> model.Session:
return model.Session(
id=row[0],
date=datetime.date.fromisoformat(row[1]),
start_time=datetime.time.fromisoformat(row[2]),
end_time=datetime.time.fromisoformat(row[3]),
venue=model.SessionVenue(
name=row[4],
url=row[5],
),
is_live=row[6],
)

28
folkugat_web/dal/sql/sessions/ddl.py Normal file
View File

@@ -0,0 +1,28 @@
from folkugat_web.dal.sql import Connection, get_connection
def create_db(con: Connection | None = None):
with get_connection(con) as con:
create_sessions_table(con)
def drop_sessions_table(con: Connection):
query = "DROP TABLE IF EXISTS sessions"
cur = con.cursor()
_ = cur.execute(query)
def create_sessions_table(con: Connection):
query = """
CREATE TABLE IF NOT EXISTS sessions (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL,
start_time TEXT NOT NULL,
end_time TEXT NOT NULL,
venue_name TEXT,
venue_url TEXT,
is_live BOOLEAN DEFAULT false
)
"""
cur = con.cursor()
_ = cur.execute(query)

92
folkugat_web/dal/sql/sessions/query.py Normal file
View File

@@ -0,0 +1,92 @@
import datetime
from typing import TypedDict
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.model import sessions as model
from folkugat_web.model.sql import OrderCol, Range
from folkugat_web.typing import OptionalListOrValue as OLV
from . import conversion
class QueryData(TypedDict, total=False):
session_id: int | None
date_ub: datetime.date
date_lb: datetime.date
is_live: bool
limit: int
offset: int
def _filter_clause(session_id: int | None = None,
date_range: Range[datetime.date] | None = None,
is_live: bool | None = None) -> tuple[str, QueryData]:
filter_clauses: list[str] = []
filter_data: QueryData = {}
if session_id is not None:
filter_clauses.append(f"id = :session_id")
filter_data["session_id"] = session_id
if date_range:
if ub := date_range.upper_bound():
operator = "<=" if ub[1] else "<"
filter_clauses.append(f"date {operator} :date_ub")
filter_data["date_ub"] = ub[0]
if lb := date_range.lower_bound():
operator = ">=" if lb[1] else ">"
filter_clauses.append(f"date {operator} :date_lb")
filter_data["date_lb"] = lb[0]
if is_live is not None:
filter_clauses.append(f"is_live = :is_live")
filter_data["is_live"] = is_live
if filter_clauses:
filter_clause_str = " AND ".join(filter_clauses)
filter_clause = f"WHERE {filter_clause_str}"
return filter_clause, filter_data
else:
return "", {}
def _order_clause(order_by: OLV[OrderCol[model.SessionCols]]) -> str:
if not order_by:
return ""
if not isinstance(order_by, list):
order_by = [order_by]
order_clauses = [f"{ocol.column.value} {ocol.order.value}" for ocol in order_by]
order_clauses_str = " ".join(order_clauses)
return f"ORDER BY {order_clauses_str}"
def get_sessions(session_id: int | None = None,
date_range: Range[datetime.date] | None = None,
is_live: bool | None = None,
order_by: OLV[OrderCol[model.SessionCols]] = None,
limit: int | None = None, offset: int | None = None,
con: Connection | None = None) -> list[model.Session]:
clauses: list[str] = []
filter_clause, data = _filter_clause(session_id=session_id, date_range=date_range, is_live=is_live)
if filter_clause:
clauses.append(filter_clause)
if order_clause := _order_clause(order_by=order_by):
clauses.append(order_clause)
if limit is not None:
clauses.append("LIMIT :limit")
data["limit"] = limit
if offset is not None:
clauses.append("OFFSET :offset")
data["offset"] = offset
clauses_str = " ".join(clauses)
query = f"""
SELECT id, date, start_time, end_time, venue_name, venue_url, is_live
FROM sessions
{clauses_str}
"""
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
return list(map(conversion.row_to_session, cur.fetchall()))

64
folkugat_web/dal/sql/sessions/write.py Normal file
View File

@@ -0,0 +1,64 @@
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.model import sessions as model
from . import conversion
def insert_session(session: model.Session, con: Connection | None = None):
query = """
INSERT INTO sessions
(id, date, start_time, end_time, venue_name, venue_url, is_live)
VALUES
(:id, :date, :start_time, :end_time, :venue_name, :venue_url, :is_live)
RETURNING *
"""
data = conversion.session_to_row(session)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
row: conversion.SessionRowTuple = cur.fetchone()
return conversion.row_to_session(row)
def update_session(session: model.Session, con: Connection | None = None):
query = """
UPDATE sessions SET
date = :date, start_time = :start_time, end_time = :end_time,
venue_name = :venue_name, venue_url = :venue_url, is_live = :is_live
WHERE id = :id
"""
data = conversion.session_to_row(session)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
def delete_session_by_id(session_id: int, con: Connection | None = None):
query = """
DELETE FROM sessions
WHERE id = :id
"""
data = dict(id=session_id)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
def stop_live_sessions(con: Connection | None = None):
query = """
UPDATE sessions SET is_live = false WHERE is_live = true
"""
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query)
def set_live_session(session_id: int, con: Connection | None = None):
query = """
UPDATE sessions SET is_live = true WHERE id = :id
"""
data = dict(id=session_id)
with get_connection(con) as con:
stop_live_sessions(con=con)
cur = con.cursor()
_ = cur.execute(query, data)

23
folkugat_web/dal/sql/temes/_conversion.py → folkugat_web/dal/sql/temes/conversion.py
View File

@@ -1,11 +1,28 @@
import datetime
import json
from typing import TypedDict
from folkugat_web.model import IndexedList
from folkugat_web.model import search as search_model
from folkugat_web.model import temes as model
TemaRowTuple = tuple[int, str, str, str, str, str, str, str, str, int]
def tema_to_row(tema: model.Tema) -> dict:
class TemaRowDict(TypedDict):
id: int | None
title: str
properties: str
links: str
lyrics: str
alternatives: str
ngrams: str
modification_date: str
creation_date: str
hidden: int
def tema_to_row(tema: model.Tema) -> TemaRowDict:
return {
'id': tema.id,
'title': tema.title,
@@ -20,11 +37,11 @@ def tema_to_row(tema: model.Tema) -> dict:
}
def cell_to_ngrams(cell: str) -> model.NGrams:
def cell_to_ngrams(cell: str) -> search_model.NGrams:
return {int(n): ngrams_ for n, ngrams_ in json.loads(cell).items()}
def row_to_tema(row: tuple) -> model.Tema:
def row_to_tema(row: TemaRowTuple) -> model.Tema:
return model.Tema(
id=row[0],
title=row[1],

14
folkugat_web/dal/sql/temes/ddl.py
View File

@@ -1,23 +1,15 @@
from typing import Optional
from folkugat_web import data
from folkugat_web.dal.sql import Connection, get_connection
from .write import insert_tema
def create_db(con: Optional[Connection] = None):
def create_db(con: Connection | None = None):
with get_connection(con) as con:
create_temes_table(con)
# for tema in data.TEMES:
# insert_tema(tema, con)
def drop_temes_table(con: Connection):
query = "DROP TABLE IF EXISTS temes"
cur = con.cursor()
cur.execute(query)
_ = cur.execute(query)
def create_temes_table(con: Connection):
@@ -36,4 +28,4 @@ def create_temes_table(con: Connection):
)
"""
cur = con.cursor()
cur.execute(query)
_ = cur.execute(query)

37
folkugat_web/dal/sql/temes/query.py
View File

@@ -1,14 +1,13 @@
from typing import Optional
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.model import search as search_model
from folkugat_web.model import temes as model
from ._conversion import cell_to_ngrams, row_to_tema
from . import conversion
TEMA_ID_TO_NGRAMS_CACHE = None
_tema_id_to_ngrams_cache: dict[int, search_model.NGrams] | None = None
def get_tema_by_id(tema_id: int, con: Optional[Connection] = None) -> Optional[model.Tema]:
def get_tema_by_id(tema_id: int, con: Connection | None = None) -> model.Tema | None:
query = """
SELECT
id, title, properties, links, lyrics, alternatives, ngrams,
@@ -19,30 +18,30 @@ def get_tema_by_id(tema_id: int, con: Optional[Connection] = None) -> Optional[m
data = dict(id=tema_id)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
row = cur.fetchone()
return row_to_tema(row) if row else None
_ = cur.execute(query, data)
row: conversion.TemaRowTuple = cur.fetchone()
return conversion.row_to_tema(row) if row else None
def evict_tema_id_to_ngrams_cache():
global TEMA_ID_TO_NGRAMS_CACHE
TEMA_ID_TO_NGRAMS_CACHE = None
global _tema_id_to_ngrams_cache
_tema_id_to_ngrams_cache = None
def get_tema_id_to_ngrams(con: Optional[Connection] = None) -> dict[int, model.NGrams]:
global TEMA_ID_TO_NGRAMS_CACHE
if TEMA_ID_TO_NGRAMS_CACHE is None:
TEMA_ID_TO_NGRAMS_CACHE = _get_tema_id_to_ngrams(con)
return TEMA_ID_TO_NGRAMS_CACHE
def get_tema_id_to_ngrams(con: Connection | None = None) -> dict[int, search_model.NGrams]:
global _tema_id_to_ngrams_cache
if _tema_id_to_ngrams_cache is None:
_tema_id_to_ngrams_cache = _get_tema_id_to_ngrams(con)
return _tema_id_to_ngrams_cache
def _get_tema_id_to_ngrams(con: Optional[Connection] = None) -> dict[int, model.NGrams]:
def _get_tema_id_to_ngrams(con: Connection | None = None) -> dict[int, search_model.NGrams]:
query = """
SELECT id, ngrams
FROM temes
"""
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query)
rows = cur.fetchall()
return {id_: cell_to_ngrams(ng) for id_, ng in rows}
_ = cur.execute(query)
rows: list[tuple[int, str]] = cur.fetchall()
return {id_: conversion.cell_to_ngrams(ng) for id_, ng in rows}

24
folkugat_web/dal/sql/temes/write.py
View File

@@ -1,13 +1,11 @@
from typing import Optional
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.model import temes as model
from ._conversion import row_to_tema, tema_to_row
from . import conversion
from .query import evict_tema_id_to_ngrams_cache
def insert_tema(tema: model.Tema, con: Optional[Connection] = None) -> model.Tema:
def insert_tema(tema: model.Tema, con: Connection | None = None) -> model.Tema:
query = """
INSERT INTO temes
(id, title, properties, links, lyrics, alternatives, ngrams,
@@ -17,16 +15,16 @@ def insert_tema(tema: model.Tema, con: Optional[Connection] = None) -> model.Tem
:creation_date, :modification_date, :hidden)
RETURNING *
"""
data = tema_to_row(tema)
data = conversion.tema_to_row(tema)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
row = cur.fetchone()
_ = cur.execute(query, data)
row: conversion.TemaRowTuple = cur.fetchone()
evict_tema_id_to_ngrams_cache()
return row_to_tema(row)
return conversion.row_to_tema(row)
def update_tema(tema: model.Tema, con: Optional[Connection] = None):
def update_tema(tema: model.Tema, con: Connection | None = None):
query = """
UPDATE temes
SET
@@ -36,15 +34,15 @@ def update_tema(tema: model.Tema, con: Optional[Connection] = None):
WHERE
id = :id
"""
data = tema_to_row(tema)
data = conversion.tema_to_row(tema)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
_ = cur.execute(query, data)
evict_tema_id_to_ngrams_cache()
return
def delete_tema(tema_id: int, con: Optional[Connection] = None):
def delete_tema(tema_id: int, con: Connection | None = None):
query = """
DELETE FROM temes
WHERE id = :id
@@ -52,6 +50,6 @@ def delete_tema(tema_id: int, con: Optional[Connection] = None):
data = dict(id=tema_id)
with get_connection(con) as con:
cur = con.cursor()
cur.execute(query, data)
_ = cur.execute(query, data)
evict_tema_id_to_ngrams_cache()
return