Precommit hooks, list_banned_words, more tests

Raymo111 · Raymo111 · commit 6b03744a9daf · 2023-04-15T22:26:06.000-07:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -0,0 +1,62 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-ast
+      - id: check-case-conflict
+      - id: check-docstring-first
+      - id: check-executables-have-shebangs
+      - id: check-shebang-scripts-are-executable
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-toml
+      - id: check-yaml
+      - id: debug-statements
+      - id: destroyed-symlinks
+      - id: detect-private-key
+      - id: end-of-file-fixer
+      - id: forbid-submodules
+      - id: mixed-line-ending
+      - id: name-tests-test
+        args:
+          - --pytest-test-first
+      - id: trailing-whitespace
+  - repo: https://github.com/pre-commit/pygrep-hooks
+    rev: v1.10.0
+    hooks:
+      - id: python-check-blanket-noqa
+      - id: python-check-blanket-type-ignore
+      - id: python-check-mock-methods
+      - id: python-no-eval
+      - id: python-no-log-warn
+      - id: python-use-type-annotations
+      - id: text-unicode-replacement-char
+  - repo: local
+    hooks:
+      - id: flakes
+        name: flake8
+        entry: flake8
+        language: python
+        types: [python]
+        pass_filenames: false
+        args:
+          - --count
+          - --show-source
+          - --statistics
+          - --max-line-length=120
+          - --per-file-ignores=src/nexus/Freqlog/backends/__init__.py:F401
+          - --exclude=venv
+        additional_dependencies: [flake8]
+      - id: pytest
+        name: pytest
+        entry: pytest
+        language: python
+        types: [python]
+        pass_filenames: false
+        stages:
+          - push
+        args:
+          - --cov=nexus
+          - --cov-report=html
+        additional_dependencies: [., pytest, pytest-cov]
diff --git a/dist.py b/dist.py
@@ -58,3 +58,7 @@
     os.system("cp README.md LICENSE dist")
 
 print("Done! Built executable is in dist/")
+
+# Setup git hooks
+print("Setting up git hooks...")
+os.system("pre-commit install")
diff --git a/src/nexus/Freqlog/Definitions.py b/src/nexus/Freqlog/Definitions.py
@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta
 from enum import Enum
+from typing import Any, Self
 
 from pynput.keyboard import Key
 
@@ -43,7 +44,7 @@ def __init__(self, word: str, frequency: int, last_used: datetime, average_speed
         self.last_used = last_used
         self.average_speed = average_speed
 
-    def __or__(self, other):
+    def __or__(self, other: Any) -> Self:
         """Merge two WordMetadata objects"""
         if other is not None and not isinstance(other, WordMetadata):
             raise TypeError(f"unsupported operand type(s) for |: '{type(self).__name__}' and '{type(other).__name__}'")
@@ -91,7 +92,7 @@ class ChordMetadataAttr(Enum):
     last_used = "lastused"
 
 
-class Banlist:
+class BanlistEntry:
     """Banlist entry"""
 
     def __init__(self, word: str, date_added: datetime) -> None:
diff --git a/src/nexus/Freqlog/Freqlog.py b/src/nexus/Freqlog/Freqlog.py
@@ -5,7 +5,7 @@
 from pynput import keyboard as kbd, mouse
 
 from .backends import Backend, SQLiteBackend
-from .Definitions import ActionType, Banlist, BanlistAttr, CaseSensitivity, ChordMetadata, ChordMetadataAttr, \
+from .Definitions import ActionType, BanlistAttr, BanlistEntry, CaseSensitivity, ChordMetadata, ChordMetadataAttr, \
     Defaults, WordMetadata, WordMetadataAttr
 
 
@@ -115,7 +115,7 @@ def _log_and_reset_word(min_length: int = 1) -> None:
                 if action == ActionType.PRESS and key in self.modifier_keys:
                     active_modifier_keys.add(key)
                 elif action == ActionType.RELEASE:
-                    active_modifier_keys.remove(key)
+                    active_modifier_keys.discard(key)
 
                 # On backspace, remove last char from word if word is not empty
                 if key == kbd.Key.backspace and word:
@@ -186,10 +186,10 @@ def check_banned(self, word: str, case: CaseSensitivity) -> bool:
         logging.info(f"Checking if {word} is banned, case {case}")
         return self.backend.check_banned(word, case)
 
-    def ban_word(self, word: str, case: CaseSensitivity) -> None:
+    def ban_word(self, word: str, case: CaseSensitivity, time: datetime) -> None:
         """Ban a word from being logged"""
-        logging.info(f"Banning {word}, case {case}")
-        self.backend.ban_word(word, case)
+        logging.info(f"Banning {word}, case {case} - {time}")
+        self.backend.ban_word(word, case, time)
         logging.warning(f"Banned {word}, case {case}")
 
     def unban_word(self, word: str, case: CaseSensitivity) -> None:
@@ -222,12 +222,14 @@ def list_chords(self, limit: int, sort_by: ChordMetadataAttr,
         logging.info(f"Listing chords, limit {limit}, sort_by {sort_by}, reverse {reverse}, case {case}")
         return self.backend.list_chords(limit, sort_by, reverse, case)
 
-    def list_banned_words(self, limit: int, sort_by: BanlistAttr, reverse: bool) -> list[Banlist]:
+    def list_banned_words(self, limit: int, sort_by: BanlistAttr, reverse: bool) \
+            -> tuple[list[BanlistEntry], list[BanlistEntry]]:
         """
         List banned words
         :param limit: Maximum number of banned words to return
         :param sort_by: Attribute to sort by: word
         :param reverse: Reverse sort order
+        :returns: Tuple of (banned words with case, banned words without case)
         """
         logging.info(f"Listing banned words, limit {limit}, sort_by {sort_by}, reverse {reverse}")
         return self.backend.list_banned_words(limit, sort_by, reverse)
diff --git a/src/nexus/Freqlog/backends/Backend.py b/src/nexus/Freqlog/backends/Backend.py
@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 
-from nexus.Freqlog.Definitions import Banlist, BanlistAttr, CaseSensitivity, ChordMetadata, ChordMetadataAttr, \
+from nexus.Freqlog.Definitions import BanlistAttr, BanlistEntry, CaseSensitivity, ChordMetadata, ChordMetadataAttr, \
     WordMetadata, WordMetadataAttr
 
 
@@ -40,7 +40,7 @@ def check_banned(self, word: str, case: CaseSensitivity) -> bool:
     # TODO: Support banning chords
 
     @abstractmethod
-    def ban_word(self, word: str, case: CaseSensitivity) -> None:
+    def ban_word(self, word: str, case: CaseSensitivity, time: datetime) -> None:
         """Delete a word entry and add it to the ban list"""
 
     @abstractmethod
@@ -70,13 +70,15 @@ def list_chords(self, limit: int, sort_by: ChordMetadataAttr,
         """
 
     @abstractmethod
-    def list_banned_words(self, limit: int, sort_by: BanlistAttr, reverse: bool) -> list[Banlist]:
+    def list_banned_words(self, limit: int, sort_by: BanlistAttr, reverse: bool) \
+            -> tuple[list[BanlistEntry], list[BanlistEntry]]:
         """
         List banned words
         :param limit: Maximum number of banned words to return
         :param sort_by: Attribute to sort by: word
         :param reverse: Reverse sort order
+        :returns: Tuple of (banned words with case, banned words without case)
         """
 
-    def close(self):
+    def close(self) -> None:
         """Close the backend"""
diff --git a/src/nexus/Freqlog/backends/SQLite/SQLiteBackend.py b/src/nexus/Freqlog/backends/SQLite/SQLiteBackend.py
@@ -3,7 +3,7 @@
 
 from nexus import __version__
 from nexus.Freqlog.backends.Backend import Backend
-from nexus.Freqlog.Definitions import Banlist, BanlistAttr, CaseSensitivity, ChordMetadata, ChordMetadataAttr, \
+from nexus.Freqlog.Definitions import BanlistAttr, BanlistEntry, CaseSensitivity, ChordMetadata, ChordMetadataAttr, \
     WordMetadata, WordMetadataAttr
 
 # WARNING: Loaded into SQL query, do not use unsanitized user input
@@ -35,8 +35,9 @@ def __init__(self, db_path: str) -> None:
         # Banlist table
         self._execute(
             "CREATE TABLE IF NOT EXISTS banlist (word TEXT PRIMARY KEY, dateadded timestamp NOT NULL) WITHOUT ROWID")
-        self._execute("CREATE INDEX IF NOT EXISTS banlist_lower ON banlist(word COLLATE NOCASE)")
-        self._execute("CREATE UNIQUE INDEX IF NOT EXISTS banlist_dateadded ON banlist(dateadded)")
+        self._execute("CREATE INDEX IF NOT EXISTS banlist_dateadded ON banlist(dateadded)")
+        self._execute("CREATE TABLE IF NOT EXISTS banlist_lower (word TEXT PRIMARY KEY COLLATE NOCASE,"
+                      "dateadded timestamp NOT NULL) WITHOUT ROWID")
 
     def _execute(self, query: str, params=None) -> None:
         if params:
@@ -83,9 +84,11 @@ def get_word_metadata(self, word: str, case: CaseSensitivity) -> WordMetadata |
                 res_u = self._fetchone(f"{SQL_SELECT_STAR_FROM_FREQLOG} WHERE word=?", (word_u,))
                 res_l = self._fetchone(f"{SQL_SELECT_STAR_FROM_FREQLOG} WHERE word=?", (word_l,))
                 word_meta_u = WordMetadata(word, res_u[1], datetime.fromtimestamp(res_u[2]),
-                                           timedelta(seconds=res_u[3]))
+                                           timedelta(seconds=res_u[3])) if res_u else None
                 word_meta_l = WordMetadata(word, res_l[1], datetime.fromtimestamp(res_l[2]),
-                                           timedelta(seconds=res_l[3]))
+                                           timedelta(seconds=res_l[3])) if res_l else None
+                if not word_meta_u:
+                    return word_meta_l
                 return word_meta_u | word_meta_l
             case CaseSensitivity.SENSITIVE:
                 res = self._fetchone(f"{SQL_SELECT_STAR_FROM_FREQLOG} WHERE word=?", (word,))
@@ -134,30 +137,32 @@ def check_banned(self, word: str, case: CaseSensitivity) -> bool:
                 res = self._fetchone("SELECT word FROM banlist WHERE word=?", (word,))
                 return res is not None
 
-    def ban_word(self, word: str, case: CaseSensitivity) -> None:
+    def ban_word(self, word: str, case: CaseSensitivity, time: datetime) -> None:
         """Delete a word entry and add it to the ban list"""
         match case:
             case CaseSensitivity.INSENSITIVE:
                 word = word.lower()
                 self._execute("DELETE FROM freqlog WHERE word = ? COLLATE NOCASE", (word,))
-                self._execute("INSERT INTO banlist VALUES (?)", (word,))
+                self._execute("INSERT INTO banlist VALUES (?, ?)", (word, time.timestamp()))
+                self._execute("INSERT INTO banlist_lower VALUES (?, ?)", (word, time.timestamp()))
             case CaseSensitivity.FIRST_CHAR:
                 word_u = word[0].upper() + word[1:]
                 word_l = word[0].lower() + word[1:]
                 self._execute("DELETE FROM freqlog WHERE word=?", (word_u,))
                 self._execute("DELETE FROM freqlog WHERE word=?", (word_l,))
-                self._execute("INSERT INTO banlist VALUES (?)", (word_u,))
-                self._execute("INSERT INTO banlist VALUES (?)", (word_l,))
+                self._execute("INSERT INTO banlist VALUES (?, ?)", (word_u, time.timestamp()))
+                self._execute("INSERT INTO banlist VALUES (?, ?)", (word_l, time.timestamp()))
             case CaseSensitivity.SENSITIVE:
                 self._execute("DELETE FROM freqlog WHERE word=?", (word,))
-                self._execute("INSERT INTO banlist VALUES (?)", (word,))
+                self._execute("INSERT INTO banlist VALUES (?, ?)", (word, time.timestamp()))
 
     def unban_word(self, word: str, case: CaseSensitivity) -> None:
         """Remove a word from the ban list"""
         match case:
             case CaseSensitivity.INSENSITIVE:
                 word = word.lower()
                 self._execute("DELETE FROM banlist WHERE word = ? COLLATE NOCASE", (word,))
+                self._execute("DELETE FROM banlist_lower WHERE word = ? COLLATE NOCASE", (word,))
             case CaseSensitivity.FIRST_CHAR:
                 word_u = word[0].upper() + word[1:]
                 word_l = word[0].lower() + word[1:]
@@ -208,16 +213,27 @@ def list_chords(self, limit: int, sort_by: ChordMetadataAttr,
         """
         raise NotImplementedError  # TODO: implement
 
-    def list_banned_words(self, limit: int, sort_by: BanlistAttr, reverse: bool) -> list[Banlist]:
+    def list_banned_words(self, limit: int, sort_by: BanlistAttr, reverse: bool) \
+            -> tuple[list[BanlistEntry], list[BanlistEntry]]:
         """
         List banned words
         :param limit: Maximum number of banned words to return
         :param sort_by: Attribute to sort by: word
         :param reverse: Reverse sort order
+        :returns: Tuple of (banned words with case, banned words without case)
         """
-        raise NotImplementedError  # TODO: implement
-
-    def close(self):
+        if reverse:
+            sql_sort_limit = f"{sort_by.value} DESC"
+        else:
+            sql_sort_limit = sort_by.value
+        if limit > 0:
+            sql_sort_limit += f" LIMIT {limit}"
+        res = self._fetchall(f"SELECT * FROM banlist ORDER BY {sql_sort_limit}")
+        res_lower = self._fetchall(f"SELECT * FROM banlist_lower ORDER BY {sql_sort_limit}")
+        return [BanlistEntry(row[0], datetime.fromtimestamp(row[1])) for row in res], \
+            [BanlistEntry(row[0], datetime.fromtimestamp(row[1])) for row in res_lower]
+
+    def close(self) -> None:
         """Close the database connection"""
         self.cursor.close()
         self.conn.close()
diff --git a/src/nexus/__main__.py b/src/nexus/__main__.py
@@ -236,13 +236,17 @@ def main():
                                             reverse=(args.order == Order.DESCENDING)):
                             print(chord)
             case "banlist":  # get banned words
-                res = freqlog.list_banned_words(args.num, BanlistAttr[args.sort_by], args.order == Order.DESCENDING)
-                if len(res) == 0:
+                res, res1 = freqlog.list_banned_words(args.num, BanlistAttr[args.sort_by],
+                                                      args.order == Order.DESCENDING)
+                if len(res) == 0 and len(res1) == 0:
                     print("No banned words")
                 else:
-                    for word in sorted(res, key=lambda x: getattr(x, args.sort_by),
-                                       reverse=(args.order == Order.DESCENDING)):
-                        print(word)
+                    for entry in res1:
+                        entry.word += "*"
+                    print("Banned words (* denotes case-insensitive entries):")
+                    for entry in sorted(res + res1, key=lambda x: getattr(x, args.sort_by),
+                                        reverse=(args.order == Order.DESCENDING)):
+                        print(entry)
     except NotImplementedError:
         print(f"Error: The '{args.command}' command has not been implemented yet")
         exit_code = 100
diff --git a/tests/Freqlog/backends/SQLite/test_SQLiteBackend.py b/tests/Freqlog/backends/SQLite/test_SQLiteBackend.py
