Fixed logger stuff, some pylint changes

Author: dave3d

comment_spell_check/comment_spell_check.py

@@ -167,27 +167,28 @@ def spell_check_words(spell_checker: SpellChecker, words: list[str]):
     return True
 
 
-def find_misspellings(
-    spell: SpellChecker, line: str, logger: logging.Logger
-) -> list[str]:
+def find_misspellings(spell: SpellChecker, line: str) -> list[str]:
     """Find misspellings in a line of text."""
 
+    logger = logging.getLogger("comment_spell_check")
     words = filter_string(line)
 
     mistakes = []
 
     for word in words:
         if not (word.lower() in spell or word in spell):
-            logger.info(f"Misspelled word: {word}")
+            logger.info("Misspelled word: %s", word)
             mistakes.append(word)
     return mistakes
 
 
-def remove_contractions(word: str, logger: logging.Logger):
+def remove_contractions(word: str):
     """Remove contractions from the word."""
+
+    logger = logging.getLogger("comment_spell_check")
     for contraction in CONTRACTIONS:
         if word.endswith(contraction):
-            logger.info(f"Contraction: {word} -> {word[: -len(contraction)]}")
+            logger.info("Contraction: %s -> %s", word, word[: -len(contraction)])
             return word[: -len(contraction)]
     return word
 
@@ -203,25 +204,25 @@ def remove_prefix(word: str, prefixes: list[str]):
 def spell_check_comment(
     spell: SpellChecker,
     c: comment_parser.common.Comment,
-    logger: logging.Logger,
     prefixes: list[str] = None,
 ) -> list[str]:
     """Check comment and return list of identified issues if any."""
 
-    logger.info(f"Line {c.line_number()}: {c}")
+    logger = logging.getLogger("comment_spell_check")
+    logger.info("Line #%d: %s", c.line_number(), c.text())
 
     line = c.text()
     if "https://" in line or "http://" in line:
         line = url_remove.remove_urls(line)
-        logger.debug(f"    Removed URLs: {line}")
+        logger.debug("    Removed URLs: %s", line)
 
-    bad_words = find_misspellings(spell, line, logger)
+    bad_words = find_misspellings(spell, line)
 
     mistakes = []
     for error_word in bad_words:
-        logger.debug(f"    Error: {error_word}")
+        logger.debug("    Error: %s", error_word)
 
-        error_word = remove_contractions(error_word, logger)
+        error_word = remove_contractions(error_word)
 
         prefixes = prefixes or []
         error_word = remove_prefix(error_word, prefixes)
@@ -231,10 +232,8 @@ def spell_check_comment(
 
         # Try splitting camel case words and checking each sub-word
         sub_words = split_camel_case(error_word)
-        logger.debug(
-            f"    Trying splitting camel case word: {error_word}\n"
-            + f"    Sub-words: {sub_words}\n"
-        )
+        logger.debug( "    Trying splitting camel case word: %s", error_word)
+        logger.debug( "    Sub-words: %s", sub_words)
 
         if len(sub_words) > 1 and spell_check_words(spell, sub_words):
             continue
@@ -248,7 +247,6 @@ def spell_check_comment(
 def spell_check_file(
     filename: str,
     spell_checker: SpellChecker,
-    logger: logging.Logger,
     mime_type: str = "",
     prefixes=None,
 ):
@@ -257,7 +255,8 @@ def spell_check_file(
     if len(mime_type) == 0:
         mime_type = get_mime_type(filename)
 
-    logger.info(f"spell_check_file: {filename}, {mime_type}")
+    logger = logging.getLogger("comment_spell_check")
+    logger.info("spell_check_file: %s, %s", filename, mime_type)
 
     # Returns a list of comment_parser.parsers.common.Comments
     if mime_type == "text/plain":
@@ -266,19 +265,19 @@ def spell_check_file(
         try:
             clist = comment_parser.extract_comments(filename, mime=mime_type)
         except TypeError:
-            logger.error(f"Parser failed, skipping file {filename}")
+            logger.error("Parser failed, skipping file %s", filename)
             return []
 
     bad_words = []
     line_count = 0
 
     for c in clist:
-        mistakes = spell_check_comment(spell_checker, c, logger, prefixes=prefixes)
+        mistakes = spell_check_comment(spell_checker, c, prefixes=prefixes)
         if len(mistakes) > 0:
-            logger.info(f"\nLine number {c.line_number()}")
+            logger.info("\nLine number %s", c.line_number())
             logger.info(c.text())
             for m in mistakes:
-                logger.info(f"    {m}")
+                logger.info("    %s", m)
                 bad_words.append([m, filename, c.line_number()])
         line_count = line_count + 1
 
@@ -437,15 +436,16 @@ def parse_args():
     return args
 
 
-def build_dictionary_list(args, logger):
+def build_dictionary_list(args):
     """build a list of dictionaries to use for spell checking."""
     dict_list = []
     initial_dct = Path(__file__).parent / "additional_dictionary.txt"
 
+    logger = logging.getLogger("comment_spell_check")
     if initial_dct.exists():
         dict_list.append(initial_dct)
     else:
-        logger.warning(f"Initial dictionary not found: {initial_dct}")
+        logger.warning("Initial dictionary not found: %s", initial_dct)
 
     if not isinstance(args.dict, list):
         return dict_list
@@ -458,17 +458,17 @@ def build_dictionary_list(args, logger):
     return dict_list
 
 
-def add_bibtex_words(
-    spell: SpellChecker, bibtex_files: list = None, logger: logging.Logger = None
-):
+def add_bibtex_words(spell: SpellChecker, bibtex_files: list[str]):
     """Add words from bibtex files to the spell checker."""
 
     if list is None:
         return
 
+    logger = logging.getLogger("comment_spell_check")
+
     for bibtex_file in bibtex_files:
-        logger.info(f"Loading bibtex file: {bibtex_file}")
-        bibtex_loader.add_bibtex(spell, bibtex_file, logger)
+        logger.info("Loading bibtex file: %s", bibtex_file)
+        bibtex_loader.add_bibtex(spell, bibtex_file)
 
 
 def output_results(args, bad_words):
@@ -499,7 +499,7 @@ def output_results(args, bad_words):
     print(f"\n{len(bad_words)} misspellings found")
 
 
-def setup_logger(name, args):
+def setup_logger(args):
     """Sets up a logger that outputs to the console."""
 
     level = logging.INFO
@@ -510,7 +510,7 @@ def setup_logger(name, args):
     if args.brief:
         level = logging.WARNING
 
-    logger = logging.getLogger(name)
+    logger = logging.getLogger("comment_spell_check")
     logger.setLevel(level)
 
     # Create a console handler
@@ -534,14 +534,14 @@ def setup_logger(name, args):
 def main():
     """comment_spell_check main function."""
     args = parse_args()
-    logger = setup_logger("comment_spell_check", args)
+    logger = setup_logger(args)
 
-    dict_list = build_dictionary_list(args, logger)
+    dict_list = build_dictionary_list(args)
 
-    spell = create_checker.create_checker(dict_list, logger)
+    spell = create_checker.create_checker(dict_list)
 
     if args.bibtex:
-        add_bibtex_words(spell, args.bibtex, logger)
+        add_bibtex_words(spell, args.bibtex)
 
     file_list = []
     if len(args.filenames):
@@ -583,7 +583,6 @@ def main():
                 result, lc = spell_check_file(
                     x,
                     spell,
-                    logger,
                     args.mime_type,
                     prefixes=prefixes,
                 )
@@ -601,7 +600,6 @@ def main():
             result, lc = spell_check_file(
                 f,
                 spell,
-                logger,
                 args.mime_type,
                 prefixes=prefixes,
             )

comment_spell_check/utils/bibtex_loader.py

@@ -19,11 +19,12 @@ def split_bibtex_name(name: str):
     return words
 
 
-def add_bibtex(spell: spellchecker.SpellChecker, filename: str, logger: logging.Logger):
+def add_bibtex(spell: spellchecker.SpellChecker, filename: str):
     """Update ``spell`` spell checking dictionary with names
     from ``filename``, a Bibtex file."""
 
-    logger.info(f"Bibtex file: {filename}")
+    logger = logging.getLogger("comment_spell_check.bibtex_loader")
+    logger.info("Bibtex file: %s", filename)
 
     word_list = []
 
@@ -34,5 +35,5 @@ def add_bibtex(spell: spellchecker.SpellChecker, filename: str, logger: logging.
             words = split_bibtex_name(k)
             word_list.extend(words)
 
-        logger.info(f"Words: {word_list}")
+        logger.info("Words: %s", word_list)
         spell.word_frequency.load_words(word_list)

comment_spell_check/utils/create_checker.py

@@ -2,75 +2,33 @@
 additional dictionaries if provided.
 """
 
-import sys
 import logging
 import importlib.resources
 import spellchecker
 
 
-def create_checker(dict_list: list[str] = None, logger: logging.Logger = None):
+def create_checker(dict_list: list[str] = None) -> spellchecker.SpellChecker:
     """Create a case sensitive spell checker with the English dictionary and
     additional dictionaries if provided."""
 
+    logger = logging.getLogger("comment_spell_check.create_checker")
+
     # create an empty SpellChecker object, because we want a case
     # sensitive checker
     checker = spellchecker.SpellChecker(language=None, case_sensitive=True)
 
     # load the English dictionary
     lib_path = importlib.resources.files(spellchecker)
     english_dict = str(lib_path) + "/resources/en.json.gz"
-    logger.info(f"Loading English dictionary from: {english_dict}")
+    logger.info("Loading English dictionary from: %s", english_dict)
     checker.word_frequency.load_dictionary(english_dict)
 
     # load the additional dictionaries
     if not isinstance(dict_list, list):
         return checker
     if len(dict_list) > 0:
         for d in dict_list:
-            logger.info(f"Loading additional dictionary from: {d}")
+            logger.info("Loading additional dictionary from: %s", d)
             checker.word_frequency.load_text_file(d)
 
     return checker
-
-
-if __name__ == "__main__":
-
-    # set up logging
-    lg = logging.getLogger(__name__)
-    lg.setLevel(logging.INFO)
-    ch = logging.StreamHandler()
-    ch.setLevel(logging.INFO)
-    lg.addHandler(ch)
-
-    lg.info("\nStarting spell checker")
-    if len(sys.argv) > 1:
-        lg.info("Arguments: %s", sys.argv[1:])
-
-    # create the spell checker
-    spell = create_checker(sys.argv[1:], lg)
-
-    # find those words that may be misspelled
-    misspelled = spell.unknown(["something", "is", "hapenning", "here"])
-
-    for word in misspelled:
-        lg.warning("\nMisspelled: %s", word)
-        # Get the one `most likely` answer
-        lg.warning("Most likely word: %s", spell.correction(word))
-
-        # Get a list of `likely` options
-        lg.warning("Candidate words: %s", spell.candidates(word))
-
-    # test if case sensitive checking from the additional dictionaries works
-    my_words = [
-        "Zsize",
-        "Zuerich",
-        "accesor",
-        "accessor",
-        "zsize",
-        "zuerich",
-        "sdfasdfas",
-    ]
-
-    lg.info("\nTesting case sensitive checking from the additional dictionaries")
-    for w in my_words:
-        lg.info("Checking word: %s, %s", w, w in spell)