From 4baea47f1176166fe46f1ffc1ce1e85ee950d760 Mon Sep 17 00:00:00 2001
From: Christian Heller <c.heller@plomlompom.de>
Date: Wed, 27 Nov 2024 05:53:51 +0100
Subject: [PATCH] Some variable renamings for better clarity.

---
 src/sync.py                                   |  11 +-
 src/templates/{video.tmpl => file_data.tmpl}  |   0
 src/templates/{videos.tmpl => files.tmpl}     |   0
 .../{queries.tmpl => yt_queries.tmpl}         |   0
 .../{yt_video.tmpl => yt_result.tmpl}         |   0
 .../{results.tmpl => yt_results.tmpl}         |   0
 src/ytplom/misc.py                            | 103 +++++++++---------
 7 files changed, 55 insertions(+), 59 deletions(-)
 rename src/templates/{video.tmpl => file_data.tmpl} (100%)
 rename src/templates/{videos.tmpl => files.tmpl} (100%)
 rename src/templates/{queries.tmpl => yt_queries.tmpl} (100%)
 rename src/templates/{yt_video.tmpl => yt_result.tmpl} (100%)
 rename src/templates/{results.tmpl => yt_results.tmpl} (100%)

diff --git a/src/sync.py b/src/sync.py
index fdeced8..98bdfcb 100755
--- a/src/sync.py
+++ b/src/sync.py
@@ -12,7 +12,7 @@ from paramiko import SSHClient  # type: ignore
 from scp import SCPClient  # type: ignore
 from ytplom.misc import (
         PAGE_NAMES, PATH_DB, PATH_DOWNLOADS, PATH_TEMP,
-        Config, DatabaseConnection, PathStr, QuotaLog, VideoFile,
+        Config, DbConnection, PathStr, QuotaLog, VideoFile,
         YoutubeQuery, YoutubeVideo)
 
 
@@ -21,7 +21,7 @@ ATTR_NAME_LAST_UPDATE = 'last_update'
 
 
 def back_and_forth(sync_func: Callable,
-                   dbs: tuple[DatabaseConnection, DatabaseConnection],
+                   dbs: tuple[DbConnection, DbConnection],
                    shared: YoutubeVideo | tuple[Any, str]
                    ) -> None:
     """Run sync_func on arg pairs + shared, and again with pairs switched."""
@@ -31,7 +31,7 @@ def back_and_forth(sync_func: Callable,
 
 
 def sync_objects(host_names: tuple[str, str],
-                 dbs: tuple[DatabaseConnection, DatabaseConnection],
+                 dbs: tuple[DbConnection, DbConnection],
                  shared: tuple[Any, str]
                  ) -> None:
     """Equalize both DB's object collections; prefer newer states to older."""
@@ -58,7 +58,7 @@ def sync_objects(host_names: tuple[str, str],
 
 
 def sync_relations(host_names: tuple[str, str],
-                   dbs: tuple[DatabaseConnection, DatabaseConnection],
+                   dbs: tuple[DbConnection, DbConnection],
                    yt_result: YoutubeVideo
                    ) -> None:
     """To dbs[1] add YT yt_video->yt_q_colls[0] mapping not in yt_q_colls[1]"""
@@ -78,8 +78,7 @@ def main():
     ssh.connect(config.remote)
     scp = SCPClient(ssh.get_transport())
     scp.get(PATH_DB, PATH_DB_REMOTE)
-    local_db = DatabaseConnection(PATH_DB)
-    remote_db = DatabaseConnection(PATH_DB_REMOTE)
+    local_db, remote_db = DbConnection(PATH_DB), DbConnection(PATH_DB_REMOTE)
     for cls in (QuotaLog, YoutubeQuery, YoutubeVideo, VideoFile):
         back_and_forth(sync_objects, (local_db, remote_db),
                        (cls, 'rel_path' if cls is VideoFile else 'id_'))
diff --git a/src/templates/video.tmpl b/src/templates/file_data.tmpl
similarity index 100%
rename from src/templates/video.tmpl
rename to src/templates/file_data.tmpl
diff --git a/src/templates/videos.tmpl b/src/templates/files.tmpl
similarity index 100%
rename from src/templates/videos.tmpl
rename to src/templates/files.tmpl
diff --git a/src/templates/queries.tmpl b/src/templates/yt_queries.tmpl
similarity index 100%
rename from src/templates/queries.tmpl
rename to src/templates/yt_queries.tmpl
diff --git a/src/templates/yt_video.tmpl b/src/templates/yt_result.tmpl
similarity index 100%
rename from src/templates/yt_video.tmpl
rename to src/templates/yt_result.tmpl
diff --git a/src/templates/results.tmpl b/src/templates/yt_results.tmpl
similarity index 100%
rename from src/templates/results.tmpl
rename to src/templates/yt_results.tmpl
diff --git a/src/ytplom/misc.py b/src/ytplom/misc.py
index f654657..cd86352 100644
--- a/src/ytplom/misc.py
+++ b/src/ytplom/misc.py
@@ -65,11 +65,11 @@ PATH_CONFFILE = PathStr(path_join(PATH_HOME, '.config/ytplom/config.json'))
 
 # template paths
 PATH_TEMPLATES = PathStr(path_join(PATH_APP_DATA, 'templates'))
-NAME_TEMPLATE_QUERIES = PathStr('queries.tmpl')
-NAME_TEMPLATE_RESULTS = PathStr('results.tmpl')
-NAME_TEMPLATE_VIDEOS = PathStr('videos.tmpl')
-NAME_TEMPLATE_VIDEO = PathStr('video.tmpl')
-NAME_TEMPLATE_YT_VIDEO = PathStr('yt_video.tmpl')
+NAME_TEMPLATE_QUERIES = PathStr('yt_queries.tmpl')
+NAME_TEMPLATE_RESULTS = PathStr('yt_results.tmpl')
+NAME_TEMPLATE_FILES = PathStr('files.tmpl')
+NAME_TEMPLATE_FILE_DATA = PathStr('file_data.tmpl')
+NAME_TEMPLATE_YT_VIDEO = PathStr('yt_result.tmpl')
 NAME_TEMPLATE_PLAYLIST = PathStr('playlist.tmpl')
 
 # page names
@@ -81,7 +81,7 @@ PAGE_NAMES: PageNames = {
     'missing': PathStr('missing.json'),
     'playlist': PathStr('playlist'),
     'thumbnails': PathStr('thumbnails'),
-    'yt_result': PathStr('yt_video'),
+    'yt_result': PathStr('yt_result'),
     'yt_query': PathStr('yt_query'),
     'yt_queries': PathStr('yt_queries')
 }
@@ -112,7 +112,7 @@ ENVIRON_PREFIX = 'YTPLOM_'
 TIMESTAMP_FMT = '%Y-%m-%d %H:%M:%S.%f'
 LEGAL_EXTENSIONS = {'webm', 'mp4', 'mkv'}
 NAME_INSTALLER = PathStr('install.sh')
-VIDEO_FLAGS: dict[FlagName, FlagsInt] = {
+FILE_FLAGS: dict[FlagName, FlagsInt] = {
   FlagName('delete'): FlagsInt(1 << 62)
 }
 
@@ -165,7 +165,7 @@ class Config:
                              if k.isupper() and k.startswith(ENVIRON_PREFIX)})
 
 
-class DatabaseConnection:
+class DbConnection:
     """Wrapped sqlite3.Connection."""
 
     def __init__(self, path: PathStr = PATH_DB) -> None:
@@ -221,7 +221,7 @@ class DbData:
         return cls(**kwargs)
 
     @classmethod
-    def get_one(cls, conn: DatabaseConnection, id_: str) -> Self:
+    def get_one(cls, conn: DbConnection, id_: str) -> Self:
         """Return single entry of id_ from DB."""
         sql = SqlText(f'SELECT * FROM {cls._table_name} WHERE id = ?')
         row = conn.exec(sql, (id_,)).fetchone()
@@ -231,13 +231,13 @@ class DbData:
         return cls._from_table_row(row)
 
     @classmethod
-    def get_all(cls, conn: DatabaseConnection) -> list[Self]:
+    def get_all(cls, conn: DbConnection) -> list[Self]:
         """Return all entries from DB."""
         sql = SqlText(f'SELECT * FROM {cls._table_name}')
         rows = conn.exec(sql).fetchall()
         return [cls._from_table_row(row) for row in rows]
 
-    def save(self, conn: DatabaseConnection) -> Cursor:
+    def save(self, conn: DbConnection) -> Cursor:
         """Save entry to DB."""
         vals = [getattr(self, col_name) for col_name in self._cols]
         q_marks = '(' + ','.join(['?'] * len(vals)) + ')'
@@ -261,7 +261,7 @@ class YoutubeQuery(DbData):
 
     @classmethod
     def get_all_for_video(cls,
-                          conn: DatabaseConnection,
+                          conn: DbConnection,
                           video_id: YoutubeId
                           ) -> list[Self]:
         """Return YoutubeQueries containing YoutubeVideo's ID in results."""
@@ -318,7 +318,7 @@ class YoutubeVideo(DbData):
 
     @classmethod
     def get_all_for_query(cls,
-                          conn: DatabaseConnection,
+                          conn: DbConnection,
                           query_id: QueryId
                           ) -> list[Self]:
         """Return all videos for query of query_id."""
@@ -328,10 +328,7 @@ class YoutubeVideo(DbData):
         return [cls.get_one(conn, video_id_tup[0])
                 for video_id_tup in video_ids]
 
-    def save_to_query(self,
-                      conn: DatabaseConnection,
-                      query_id: QueryId
-                      ) -> None:
+    def save_to_query(self, conn: DbConnection, query_id: QueryId) -> None:
         """Save inclusion of self in results to query of query_id."""
         conn.exec(SqlText('REPLACE INTO yt_query_results VALUES (?, ?)'),
                   (query_id, self.id_))
@@ -361,7 +358,7 @@ class VideoFile(DbData):
         self.last_update = DatetimeStr(datetime.now().strftime(TIMESTAMP_FMT))
 
     @classmethod
-    def get_by_yt_id(cls, conn: DatabaseConnection, yt_id: YoutubeId) -> Self:
+    def get_by_yt_id(cls, conn: DbConnection, yt_id: YoutubeId) -> Self:
         """Return VideoFile of .yt_id."""
         sql = SqlText(f'SELECT * FROM {cls._table_name} WHERE yt_id = ?')
         row = conn.exec(sql, (yt_id,)).fetchone()
@@ -396,7 +393,7 @@ class VideoFile(DbData):
 
     def is_flag_set(self, flag_name: FlagName) -> bool:
         """Return if flag of flag_name is set in flags field."""
-        return bool(self._flags & VIDEO_FLAGS[flag_name])
+        return bool(self._flags & FILE_FLAGS[flag_name])
 
     def ensure_absence_if_deleted(self) -> None:
         """If 'delete' flag set, ensure no actual file in filesystem."""
@@ -422,7 +419,7 @@ class QuotaLog(DbData):
         self.cost = cost
 
     @classmethod
-    def update(cls, conn: DatabaseConnection, cost: QuotaCost) -> None:
+    def update(cls, conn: DbConnection, cost: QuotaCost) -> None:
         """Adds cost mapped to current datetime."""
         cls._remove_old(conn)
         new = cls(None,
@@ -431,14 +428,14 @@ class QuotaLog(DbData):
         new.save(conn)
 
     @classmethod
-    def current(cls, conn: DatabaseConnection) -> QuotaCost:
+    def current(cls, conn: DbConnection) -> QuotaCost:
         """Returns quota cost total for last 24 hours, purges old data."""
         cls._remove_old(conn)
         quota_costs = cls.get_all(conn)
         return QuotaCost(sum(c.cost for c in quota_costs))
 
     @classmethod
-    def _remove_old(cls, conn: DatabaseConnection) -> None:
+    def _remove_old(cls, conn: DbConnection) -> None:
         cutoff = datetime.now() - timedelta(days=1)
         sql = SqlText(f'DELETE FROM {cls._table_name} WHERE timestamp < ?')
         conn.exec(SqlText(sql), (cutoff.strftime(TIMESTAMP_FMT),))
@@ -582,7 +579,7 @@ class DownloadsManager:
         self._sync_db()
 
     def _sync_db(self):
-        conn = DatabaseConnection()
+        conn = DbConnection()
         files_via_db = VideoFile.get_all(conn)
         old_cwd = getcwd()
         chdir(PATH_DOWNLOADS)
@@ -696,14 +693,14 @@ class TaskHandler(BaseHTTPRequestHandler):
         body_length = int(self.headers['content-length'])
         postvars = parse_qs(self.rfile.read(body_length).decode())
         if PAGE_NAMES['playlist'] == page_name:
-            self._post_player_command(list(postvars.keys())[0])
+            self._receive_player_command(list(postvars.keys())[0])
         elif PAGE_NAMES['file'] == page_name:
-            self._post_video_flag(YoutubeId(toks_url[2]),
-                                  [FlagName(k) for k in postvars])
+            self._receive_video_flag(YoutubeId(toks_url[2]),
+                                     [FlagName(k) for k in postvars])
         elif PAGE_NAMES['yt_queries'] == page_name:
-            self._post_query(QueryText(postvars['query'][0]))
+            self._receive_yt_query(QueryText(postvars['query'][0]))
 
-    def _post_player_command(self, command: str) -> None:
+    def _receive_player_command(self, command: str) -> None:
         if 'pause' == command:
             self.server.player.toggle_pause()
         elif 'prev' == command:
@@ -717,15 +714,15 @@ class TaskHandler(BaseHTTPRequestHandler):
         sleep(0.5)  # avoid redir happening before current_file update
         self._send_http(headers=[('Location', '/')], code=302)
 
-    def _post_video_flag(self,
-                         yt_id: YoutubeId,
-                         flag_names: list[FlagName]
-                         ) -> None:
-        conn = DatabaseConnection()
+    def _receive_video_flag(self,
+                            yt_id: YoutubeId,
+                            flag_names: list[FlagName]
+                            ) -> None:
+        conn = DbConnection()
         file = VideoFile.get_by_yt_id(conn, yt_id)
         flags = FlagsInt(0)
         for flag_name in flag_names:
-            flags = FlagsInt(file.flags | VIDEO_FLAGS[flag_name])
+            flags = FlagsInt(file.flags | FILE_FLAGS[flag_name])
         file.flags = flags
         file.save(conn)
         conn.commit_close()
@@ -734,8 +731,8 @@ class TaskHandler(BaseHTTPRequestHandler):
                                   f'/{PAGE_NAMES["file"]}/{yt_id}')],
                         code=302)
 
-    def _post_query(self, query_txt: QueryText) -> None:
-        conn = DatabaseConnection()
+    def _receive_yt_query(self, query_txt: QueryText) -> None:
+        conn = DbConnection()
 
         def collect_results(query_txt: QueryText) -> list[YoutubeVideo]:
             _ensure_expected_dirs([PATH_THUMBNAILS])
@@ -800,17 +797,17 @@ class TaskHandler(BaseHTTPRequestHandler):
             elif PAGE_NAMES['download'] == page_name:
                 self._send_or_download_video(YoutubeId(toks_url[2]))
             elif PAGE_NAMES['files'] == page_name:
-                self._send_videos_index()
+                self._send_files_index()
             elif PAGE_NAMES['file'] == page_name:
-                self._send_video_data(YoutubeId(toks_url[2]))
+                self._send_file_data(YoutubeId(toks_url[2]))
             elif PAGE_NAMES['yt_result'] == page_name:
-                self._send_yt_video_data(YoutubeId(toks_url[2]))
+                self._send_yt_result(YoutubeId(toks_url[2]))
             elif PAGE_NAMES['missing'] == page_name:
                 self._send_missing_json()
             elif PAGE_NAMES['yt_query'] == page_name:
-                self._send_query_page(QueryId(toks_url[2]))
+                self._send_yt_query_page(QueryId(toks_url[2]))
             elif PAGE_NAMES['yt_queries'] == page_name:
-                self._send_queries_index_and_search()
+                self._send_yt_queries_index_and_search()
             elif PAGE_NAMES['last_update'] == page_name:
                 self._send_last_playlist_update()
             else:  # e.g. for /
@@ -855,8 +852,8 @@ class TaskHandler(BaseHTTPRequestHandler):
                                   f'/{PAGE_NAMES["yt_result"]}/{video_id}')],
                         code=302)
 
-    def _send_query_page(self, query_id: QueryId) -> None:
-        conn = DatabaseConnection()
+    def _send_yt_query_page(self, query_id: QueryId) -> None:
+        conn = DbConnection()
         query = YoutubeQuery.get_one(conn, str(query_id))
         results = YoutubeVideo.get_all_for_query(conn, query_id)
         conn.commit_close()
@@ -864,8 +861,8 @@ class TaskHandler(BaseHTTPRequestHandler):
                 NAME_TEMPLATE_RESULTS,
                 {'query': query.text, 'videos': results})
 
-    def _send_queries_index_and_search(self) -> None:
-        conn = DatabaseConnection()
+    def _send_yt_queries_index_and_search(self) -> None:
+        conn = DbConnection()
         quota_count = QuotaLog.current(conn)
         queries_data = YoutubeQuery.get_all(conn)
         conn.commit_close()
@@ -874,8 +871,8 @@ class TaskHandler(BaseHTTPRequestHandler):
                 NAME_TEMPLATE_QUERIES, {'queries': queries_data,
                                         'quota_count': quota_count})
 
-    def _send_yt_video_data(self, video_id: YoutubeId) -> None:
-        conn = DatabaseConnection()
+    def _send_yt_result(self, video_id: YoutubeId) -> None:
+        conn = DbConnection()
         linked_queries = YoutubeQuery.get_all_for_video(conn, video_id)
         try:
             video_data = YoutubeVideo.get_one(conn, video_id)
@@ -891,19 +888,19 @@ class TaskHandler(BaseHTTPRequestHandler):
                  'youtube_prefix': YOUTUBE_URL_PREFIX,
                  'queries': linked_queries})
 
-    def _send_video_data(self, yt_id: YoutubeId) -> None:
-        conn = DatabaseConnection()
+    def _send_file_data(self, yt_id: YoutubeId) -> None:
+        conn = DbConnection()
         file = VideoFile.get_by_yt_id(conn, yt_id)
         conn.commit_close()
         self._send_rendered_template(
-                NAME_TEMPLATE_VIDEO,
-                {'file': file, 'flag_names': list(VIDEO_FLAGS)})
+                NAME_TEMPLATE_FILE_DATA,
+                {'file': file, 'flag_names': list(FILE_FLAGS)})
 
-    def _send_videos_index(self) -> None:
+    def _send_files_index(self) -> None:
         videos = [(id_, PathStr(basename(path)))
                   for id_, path in self.server.downloads.ids_to_paths.items()]
         videos.sort(key=lambda t: t[1])
-        self._send_rendered_template(NAME_TEMPLATE_VIDEOS, {'videos': videos})
+        self._send_rendered_template(NAME_TEMPLATE_FILES, {'videos': videos})
 
     def _send_missing_json(self) -> None:
         self._send_http(
-- 
2.30.2