Added support for logging (#19)

* Added logging feature

* Reformatted code slightly

* Added logging to various utility methods

* Added debugs

* Added a series of sources to existing queries

* Added a few more resources

* Added a few more resources

Author: jrg94

pymon.py

@@ -1,4 +1,7 @@
+import logging
 import os
+import pathlib
+from logging.handlers import RotatingFileHandler
 
 import discord
 from discord import Message
@@ -8,9 +11,27 @@
 
 import pymon_utils as utils
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 
 
+# Setup logging
+logs_path = pathlib.Path(
+    os.path.abspath(os.path.dirname(__file__)),
+    "logs"
+)
+logs_path.mkdir(parents=True, exist_ok=True)
+logging.basicConfig(
+    handlers=[RotatingFileHandler(
+        logs_path / "bot.log",
+        backupCount=10,
+        maxBytes=1000000
+    )],
+    level=logging.DEBUG,
+    format='%(asctime)s,%(msecs)d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',
+    datefmt='%Y-%m-%d:%H:%M:%S',
+)
+log = logging.getLogger(__name__)
+
 # Global variables
 client = commands.Bot(
     command_prefix=commands.when_mentioned_or("!"),
@@ -168,4 +189,5 @@ async def _refresh(ctx):
     await ctx.send(f"{len(diff)} queries modified and/or added.")
 
 
-client.run(os.environ.get("DISCORD_TOKEN"))
+if __name__ == '__main__':
+    client.run(os.environ.get("DISCORD_TOKEN"))

pymon_utils.py

@@ -1,10 +1,13 @@
 import json
+import logging
 import os
 import string
 from urllib.request import urlopen
 
 from dotenv import load_dotenv
 
+log = logging.getLogger(__name__)
+
 
 def generate_keyword_mapping(queries: list) -> dict:
     """
@@ -13,6 +16,7 @@ def generate_keyword_mapping(queries: list) -> dict:
     :param queries: a list of queries with responses
     :return: a dictionary of keywords to query indices
     """
+    log.debug(f"Generating keyword mapping from following list: {queries}")
     keyword_to_queries = dict()
     for i, question in enumerate(queries):
         if question.get('query'):
@@ -26,6 +30,7 @@ def generate_keyword_mapping(queries: list) -> dict:
                 keyword_to_queries.setdefault(keyword, {})
                 keyword_to_queries[keyword].setdefault(i, 0)
                 keyword_to_queries[keyword][i] += 1
+    log.debug(f"Generated keyword mapping as follows: {keyword_to_queries}")
     return keyword_to_queries
 
 
@@ -36,14 +41,16 @@ def generate_keywords(query: string) -> list:
     :param query: a search query
     :return: the list of keywords from that query
     """
+    log.debug(f"Generating keywords from following query: {query}")
     stop_words = ["", "is", "a", "the", "can",
                   "i", "to", "in", "by", "from", "be", "of",
-                  "what", "where", "when", "why", "how", "which"]
+                  "what", "where", "when", "why", "how", "which", "and"]
     keywords = query \
         .translate(str.maketrans('', '', string.punctuation)) \
         .lower() \
         .split(" ")
     keywords = [word for word in keywords if word not in stop_words]
+    log.debug(f"Generated list of keywords as follows: {keywords}")
     return keywords
 
 
@@ -55,14 +62,18 @@ def search(keyword_to_queries: dict, keywords: list) -> list:
     :param keywords: a list of keywords to lookup
     :return: a list of query indices
     """
+    log.debug(f"Searching for matching queries from the following list of keywords: {keywords}")
     query_count = dict()
     for keyword in keywords:
         query_indices = keyword_to_queries.get(keyword, {})
         for i, weight in query_indices.items():
             query_count.setdefault(i, 0)
             query_count[i] += weight
-    best_matches = list(
-        dict(sorted(query_count.items(), key=lambda item: item[1], reverse=True)).keys())
+    log.debug(f"Generated dictionary of query counts: {query_count}")
+    best_matches = list(dict(
+        sorted(query_count.items(), key=lambda item: item[1], reverse=True)
+    ).keys())
+    log.debug(f"Found closest matches as follows: {best_matches}")
     return best_matches
 
 
@@ -73,12 +84,14 @@ def generate_similar_queries(queries: list, keyword_to_queries: dict) -> None:
     :param queries: a list of queries
     :param keyword_to_queries: a mapping of keywords to query indices
     """
+    log.debug("Adding similar_queries field to queries list")
     for i, query in enumerate(queries):
         if i > 0:
             keywords = generate_keywords(query["query"])
             top_ids = search(keyword_to_queries, keywords)
             top_ids.remove(i)
             query["similar_queries"] = top_ids
+            log.debug(f"Updated query to include similar queries: {query}")
 
 
 def create_md_link(url: string, text: string) -> string:
@@ -89,6 +102,7 @@ def create_md_link(url: string, text: string) -> string:
     :param text: the text to display
     :return: the markdown link
     """
+    log.debug(f"Creating markdown link from url ({url}) and text ({text}).")
     if url:
         return f"[{text}]({url})"
     return text
@@ -104,6 +118,7 @@ def load_knowledge() -> tuple[int, list]:
     :return: a tuple of the type of knowledge database and the
         knowledge database (0 for remote, 1 for local, 2 for default)
     """
+    log.debug("Loading Pymon's brain from knowledge path.")
     if path := os.environ.get("KNOWLEDGE_PATH"):
         try:
             data = urlopen(path).read().decode("utf-8")
@@ -123,6 +138,7 @@ def refresh_knowledge() -> tuple[list, dict]:
     :return: a tuple of the knowledge database and a mapping of
         keywords to query indices
     """
+    log.debug("Refreshes Pymon's brain assuming new data exists.")
     load_dotenv()
     _, queries = load_knowledge()
     keyword_mapping = generate_keyword_mapping(queries)
@@ -138,10 +154,12 @@ def generate_tags_set(queries: list) -> set:
     :param queries: the list of queries from Pymon's brain
     :return: a set of tags represented in Pymon's brain
     """
+    log.debug(f"Generating the unique set of tags from following list of queries: {queries}")
     tags = set()
     for query in queries:
         query_tags = query.get("tags", [])
         tags |= set(query_tags)
+    log.debug(f"Generated list of unique tags as follows: {tags}")
     return tags
 
 
@@ -154,8 +172,10 @@ def get_queries_from_tag(queries: list, tag: str) -> list[tuple[int, dict]]:
     :param tag: a tag to lookup
     :return: a list of tuples in the form (query ID, query)
     """
+    log.debug(f"Getting set of queries that include the following tag: {tag}")
     matches = list()
     for i, query in enumerate(queries):
         if tag in query.get("tags", []):
             matches.append((i, query))
+    log.debug(f"Found queries that match tag as follows: {matches}")
     return matches

queries.json

@@ -27,6 +27,7 @@
     {
         "query": "What is testing?",
         "response": "Testing is the process of evaluating a program for bugs. It cannot be used to determine correctness of a program. It is used in conjuction with debugging to resolve bugs.",
+        "resource": "https://therenegadecoder.com/code/junit-testing-in-java/",
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
@@ -52,6 +53,7 @@
     {
         "query": "What is unit testing?",
         "response": "Unit testing is a specific form of program testing where the focus is on a small unit of the program, usually a single method. A common unit testing framework in Java is JUnit.",
+        "resource": "https://therenegadecoder.com/code/junit-testing-in-java/",
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
@@ -63,6 +65,7 @@
     {
         "query": "What is confidence building?",
         "response": "Confidence building is an approach to reasoning about a recursive algorithm. Confidence building begins by testing the recursive algorithm with the smallest problem. It then tests the recursive algorithm with the next smallest problem, and so on. By subbing in correct answers to smaller problems, we can build confidence in the recursive algorithm.",
+        "resource": "https://therenegadecoder.com/code/5-tips-for-making-sense-of-recursion/",
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
@@ -72,6 +75,12 @@
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
+    {
+        "query": "What is the static type of a variable?",
+        "response": "Sometimes called the declared type or the compile-time type, the static type is the type of a variable that the compiler uses to perform type checking. The static type is often called the declared type because it is the type of the variable when it is declared.",
+        "credit": ["Jeremy Grifski"],
+        "tags": ["Exam 2"]
+    },
     {
         "query": "What is method overriding?",
         "response": "Method overriding occurs when a method from a parent class is reimplemented in the child class. An overridden method can appear in multiple classes, each with the same name and parameters.",
@@ -81,6 +90,7 @@
     {
         "query": "What is method overloading?",
         "response": "Method overloading occurs when multiple methods with the same name have different parameters.",
+        "resource": "https://therenegadecoder.com/code/explain-like-im-five-method-overloading/",
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
@@ -111,12 +121,14 @@
     {
         "query": "What is a parameter mode?",
         "response": "A parameter mode is a way to specify what will happen to a parameter when the method is called. In our course, there are four main parameter modes: restores, clears, updates, and replaces.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
     {
         "query": "What is restores mode?",
         "response": "Restores mode is the default parameter mode. If a parameter is in restores mode, the method promises that the parameter will not be modified from the perspective of the client. It is okay for a method to modify the parameter, but they must always restore it before the method returns.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Jeremy Grifski"],
         "tags": ["Exam 2"]
     },
@@ -167,12 +179,14 @@
     {
         "query": "What is replaces mode?",
         "response": "Replaces mode is a parameter mode that indicates that a parameter will change regardless of its initial value. In this course, we indicate replaces mode using the JavaDoc annotation @replaces.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Shaan Patel"],
         "tags": ["Exam 2"]
     },
     {
         "query": "What is updates mode?",
         "response": "Updates mode is a parameter mode which describes a parameter that is to be changed to some other value. Under this mode, the initial value of the parameter matters. In this course, we indicate updates mode using the JavaDoc annotation @updates.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Colin Russel"],
         "tags": ["Exam 2"]
     },
@@ -191,12 +205,14 @@
     {
         "query": "What is clears mode?",
         "response": "Clears mode is a parameter mode where the method resets the value of the parameter to a predetermined initial value. Clears mode is indicated through the @clears JavaDoc annotation.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Ethan Chilton"],
         "tags": ["Exam 2"]
     },
     {
         "query": "What is the default parameter mode when none is specified in the method contract?",
         "response": "When no parameter mode is specified in the method contract, the default parameter mode is Restores. This means that the variable should be restored to its original value/state after the method is called.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Dan Brace"],
         "tags": ["Exam 2"]
     },
@@ -255,7 +271,7 @@
         "tags": ["Exam 2"]
     },
     {
-        "query": "What is object-oriented-programming?",
+        "query": "What is object-oriented programming (OOP)?",
         "response": "Object-oriented programming is programming with objects that contain both data and methods, which we can re-use. It allows us to implement and conceptualize real-world entities such as cars, animals, and beverages. We can use techniques such as polymorphism to use the same method to perform different tasks, hence the idea of 'many form'.",
         "credit": ["Felix Ji"],
         "tags": ["Exam 2"]
@@ -365,18 +381,19 @@
     {
         "query": "What are the four parameter modes?",
         "response": "The four parameter modes are: Restores, Clears, Replaces, and Updates.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Darrel Jobin"],
         "tags": ["Exam 2"]
     },
     {
-        "query": "What are NaturalNumberKernal's three methods?",
-        "response": "NaturalNumberKernal's three methods are multiplyBy10, divideBy10, and isZero.",
+        "query": "What are NaturalNumberKernel's three methods?",
+        "response": "NaturalNumberKernel's three methods are multiplyBy10, divideBy10, and isZero.",
         "credit": ["Alyssa Wiegman", "Catherine Wu"],
         "tags": ["Exam 2"]
     },
     {
         "query": "What is a procedure?",
-        "response": "A procedure (statement) is a method that has side effects and does not have a return value typically (void return type).",
+        "response": "A procedure is a method that has side effects and does not have a return value typically (void return type).",
         "credit": ["Amit Bharathan"],
         "tags": ["Exam 1"]
     },
@@ -401,6 +418,7 @@
     {
         "query": "Is restores mode a default parameter mode?",
         "response": "Yes, restores mode is the default parameter mode.",
+        "resource": "https://therenegadecoder.com/code/improve-code-readability-by-using-parameter-modes/",
         "credit": ["Allen Zhang"],
         "tags": ["Exam 2"]
     },