Replacing "print" with "logging" Module

python_ta/__init__.py

@@ -35,6 +35,7 @@
     pass
 
 import importlib.util
+import logging
 import os
 import sys
 import tokenize
@@ -53,11 +54,14 @@
 from .reporters import REPORTERS
 from .upload import upload_to_server
 
+# Configuring logger
+logging.basicConfig(format="[%(levelname)s] %(message)s", level=logging.NOTSET)
+
 HELP_URL = "http://www.cs.toronto.edu/~david/pyta/checkers/index.html"
 
 # check the python version
 if sys.version_info < (3, 7, 0):
-    print("[WARNING] You need Python 3.7 or later to run PythonTA.")
+    logging.warning("You need Python 3.7 or later to run PythonTA.")
 
 
 # Flag to determine if we've previously patched pylint
@@ -174,17 +178,15 @@ def _check(
                 current_reporter.print_messages(level)
                 if linter.config.pyta_file_permission:
                     f_paths.append(file_py)  # Appending paths for upload
-                print(
-                    "[INFO] File: {} was checked using the configuration file: {}".format(
+                logging.info(
+                    "File: {} was checked using the configuration file: {}".format(
                         file_py, linter.config_file
-                    ),
-                    file=sys.stderr,
+                    )
                 )
-                print(
-                    "[INFO] File: {} was checked using the messages-config file: {}".format(
+                logging.info(
+                    "File: {} was checked using the messages-config file: {}".format(
                         file_py, messages_config_path
-                    ),
-                    file=sys.stderr,
+                    )
                 )
             if linter.config.pyta_error_permission:
                 errs = list(current_reporter.messages.values())
@@ -206,10 +208,10 @@ def _check(
             linter.generate_reports()
         return current_reporter
     except Exception as e:
-        print(
-            "[ERROR] Unexpected error encountered! Please report this to your instructor (and attach the code that caused the error)."
+        logging.error(
+            "Unexpected error encountered! Please report this to your instructor (and attach the code that caused the error)."
         )
-        print('[ERROR] Error message: "{}"'.format(e))
+        logging.error('Error message: "{}"'.format(e))
         raise e
 
 
@@ -386,32 +388,32 @@ def _verify_pre_check(filepath: AnyStr, allow_pylint_comments: bool) -> bool:
                     continue
                 match = OPTION_PO.search(content)
                 if match is not None:
-                    print(
-                        '[ERROR] String "pylint:" found in comment. '
+                    logging.error(
+                        'String "pylint:" found in comment. '
                         + "No check run on file `{}.`\n".format(filepath)
                     )
                     return False
     except IndentationError as e:
-        print(
-            "[ERROR] python_ta could not check your code due to an "
+        logging.error(
+            "python_ta could not check your code due to an "
             + "indentation error at line {}.".format(e.lineno)
         )
         return False
     except tokenize.TokenError as e:
-        print(
-            "[ERROR] python_ta could not check your code due to a " + "syntax error in your file."
+        logging.error(
+            "python_ta could not check your code due to a " + "syntax error in your file."
         )
         return False
     except UnicodeDecodeError:
-        print(
-            "[ERROR] python_ta could not check your code due to an "
+        logging.error(
+            "python_ta could not check your code due to an "
             + "invalid character. Please check the following lines "
             "in your file and all characters that are marked with a �."
         )
         with open(os.path.expanduser(filepath), encoding="utf-8", errors="replace") as f:
             for i, line in enumerate(f):
                 if "�" in line:
-                    print(f"  Line {i}: {line}", end="")
+                    logging.error(f"  Line {i + 1}: {line}")
         return False
     return True
 
@@ -428,7 +430,7 @@ def _get_valid_files_to_check(module_name: Union[List[str], str]) -> Generator[A
         module_name = [module_name]
     # Otherwise, enforce API to expect `module_name` type as list
     elif not isinstance(module_name, list):
-        print(
+        logging.error(
             "No checks run. Input to check, `{}`, has invalid type, must be a list of strings.".format(
                 module_name
             )
@@ -438,7 +440,9 @@ def _get_valid_files_to_check(module_name: Union[List[str], str]) -> Generator[A
     # Filter valid files to check
     for item in module_name:
         if not isinstance(item, str):  # Issue errors for invalid types
-            print("No check run on file `{}`, with invalid type. Must be type: str.\n".format(item))
+            logging.error(
+                "No check run on file `{}`, with invalid type. Must be type: str.\n".format(item)
+            )
         elif os.path.isdir(item):
             yield item
         elif not os.path.exists(os.path.expanduser(item)):
@@ -448,15 +452,15 @@ def _get_valid_files_to_check(module_name: Union[List[str], str]) -> Generator[A
                 if os.path.exists(filepath):
                     yield filepath
                 else:
-                    print("Could not find the file called, `{}`\n".format(item))
+                    logging.error("Could not find the file called, `{}`\n".format(item))
             except ImportError:
-                print("Could not find the file called, `{}`\n".format(item))
+                logging.error("Could not find the file called, `{}`\n".format(item))
         else:
             yield item  # Check other valid files.
 
 
 def doc(msg_id: str) -> None:
     """Open a webpage explaining the error for the given message."""
     msg_url = HELP_URL + "#" + msg_id.lower()
-    print("Opening {} in a browser.".format(msg_url))
+    logging.info("Opening {} in a browser.".format(msg_url))
     webbrowser.open(msg_url)

python_ta/config/__init__.py

@@ -2,7 +2,7 @@
 Within the config submodule, this .py file encompasses functions responsible
  for managing all configuration-related tasks.
 """
-
+import logging
 import os
 import sys
 from pathlib import Path
@@ -48,7 +48,7 @@ def override_config(linter: PyLinter, config_location: AnyStr) -> None:
     try:
         _, config_args = config_file_parser.parse_config_file(file_path=config_location)
     except OSError as ex:
-        print(ex, file=sys.stderr)
+        logging.error(ex)
         sys.exit(32)
 
     # Override the config options by parsing the provided file.
@@ -76,7 +76,7 @@ def load_messages_config(path: str, default_path: str, use_pyta_error_messages:
         try:
             merge_from = toml.load(path)
         except FileNotFoundError:
-            print(f"[WARNING] Could not find messages config file at {str(Path(path).resolve())}.")
+            logging.warning(f"Could not find messages config file at {str(Path(path).resolve())}. ")
             merge_from = {}
 
     if not use_pyta_error_messages:

python_ta/contracts/__init__.py

@@ -10,6 +10,7 @@
     [(assertion, compiled, return_val_var_name)].
 """
 import inspect
+import logging
 import sys
 import typing
 from types import CodeType, FunctionType, ModuleType
@@ -613,8 +614,7 @@ def _debug(msg: str) -> None:
     """
     if not DEBUG_CONTRACTS:
         return
-
-    print("[PyTA]", msg, file=sys.stderr)
+    logging.debug(msg)
 
 
 def _set_invariants(klass: type) -> None:

tests/fixtures/pylint_comment.py

@@ -0,0 +1 @@
+# pylint: disable=unbalanced-tuple-unpacking

tests/fixtures/unicode_decode_error.py

@@ -0,0 +1,5 @@
+"�"
+"�"
+"foo"
+"foo"
+"�"

tests/test_config/test_config.py

@@ -2,12 +2,16 @@
 Test suite for checking whether configuration worked correctly with user-inputted configurations.
 """
 import json
+import logging
 import os
 from unittest.mock import mock_open, patch
 
+import pylint.lint
 import pytest
+from pylint import lint
 
 import python_ta
+from python_ta.config import load_messages_config, override_config
 
 TEST_CONFIG = {
     "pyta-number-of-messages": 10,
@@ -229,6 +233,26 @@ def test_config_parse_error_has_no_snippet() -> None:
     assert snippet == ""
 
 
+def test_override_config_logging(caplog) -> None:
+    """Testing that the OSError in override_config is logged correctly"""
+    path = "C:\\foo\\tests\\file_fixtures\\test_f0011.pylintrc"
+    linter = lint.PyLinter()
+
+    with pytest.raises(SystemExit):
+        override_config(linter, path)
+    assert caplog.records[0].levelname == "ERROR"
+    assert f"The config file {path} doesn't exist!" in caplog.text
+
+
+@patch("python_ta.config.toml.load", side_effect=FileNotFoundError)
+def test_load_messages_config_logging(_, caplog):
+    try:
+        load_messages_config("non_existent_file.toml", "default_file.toml", True)
+    except FileNotFoundError:
+        assert "Could not find messages config file at" in caplog.text
+        assert "WARNING" in [record.levelname for record in caplog.records]
+
+
 def test_allow_pylint_comments() -> None:
     """Test that checks whether the allow-pylint-comments configuration option works as expected when it is
     set to True

tests/test_contracts/test_contracts_debug.py

@@ -0,0 +1,26 @@
+from python_ta import contracts
+
+contracts.DEBUG_CONTRACTS = True
+from python_ta.contracts import check_contracts
+
+
+def test_contracts_debug(caplog) -> None:
+    """Test to see if _debug method is logging messages correctly"""
+
+    @check_contracts
+    def divide(x: int, y: int) -> int:
+        """Return x // y.
+
+        Preconditions:
+            - invalid precondition
+        """
+        return x // y
+
+    divide(6, 2)
+
+    for record in caplog.records:
+        assert record.levelname == "DEBUG"
+    assert (
+        "Warning: precondition invalid precondition could not be parsed as a valid Python expression"
+        in caplog.text
+    )

tests/test_init_logging.py

@@ -0,0 +1,108 @@
+"""Tests for top level __init__.py logging functionality in pyta"""
+import os
+import tokenize
+from unittest.mock import patch
+
+import python_ta
+from python_ta import _get_valid_files_to_check, _verify_pre_check
+
+
+def test_check_log(caplog) -> None:
+    """Testing logging in _check function when no exception is thrown"""
+    expected_messages = [
+        "was checked using the configuration file:",
+        "was checked using the messages-config file:",
+    ]
+
+    python_ta._check()
+    for i in range(2):
+        assert caplog.records[i].levelname == "INFO"
+        assert expected_messages[i] in caplog.records[i].msg
+
+
+@patch("python_ta._get_valid_files_to_check", side_effect=Exception("Testing"))
+def test_check_exception_log(_, caplog) -> None:
+    """Testing logging in _check function when exception is thrown"""
+    try:
+        python_ta._check()
+    except Exception:
+        expected_logs = [
+            "Unexpected error encountered! Please report this to your instructor (and attach the code that caused the error).",
+            'Error message: "Testing"',
+        ]
+
+        for i in range(2):
+            assert caplog.records[i].levelname == "ERROR"
+            assert expected_logs[i] in caplog.records[i].msg
+
+
+def test_pre_check_log_pylint_comment(caplog) -> None:
+    """Testing logging in _verify_pre_check function when checking for pyling comment"""
+    path = os.path.join(os.path.dirname(__file__), "fixtures", "pylint_comment.py")
+    _verify_pre_check(path, False)
+    assert f'String "pylint:" found in comment. No check run on file `{path}' in caplog.text
+    assert "ERROR" == caplog.records[0].levelname
+
+
+@patch("python_ta.tokenize.open", side_effect=IndentationError)
+def test_pre_check_log_indentation_error(_, caplog) -> None:
+    """Testing logging in _verify_pre_check function IndentationError catch block"""
+    # Don't need a valid file path since patching error into open function
+    _verify_pre_check("", False)
+    assert "python_ta could not check your code due to an indentation error at line" in caplog.text
+    assert "ERROR" == caplog.records[0].levelname
+
+
+@patch("python_ta.tokenize.open", side_effect=tokenize.TokenError)
+def test_pre_check_log_token_error(_, caplog) -> None:
+    """Testing logging in _verify_pre_check function TokenError catch block"""
+    # Don't need a valid file path since patching error into open function
+    _verify_pre_check("", False)
+    assert "python_ta could not check your code due to a syntax error in your file." in caplog.text
+    assert "ERROR" == caplog.records[0].levelname
+
+
+@patch("python_ta.tokenize.open", side_effect=UnicodeDecodeError("", b"", 0, 0, ""))
+def test_pre_check_log_pylint_unicode_error(_, caplog) -> None:
+    """Testing logging in _verify_pre_check function UnicodeDecodeError catch block"""
+    expected_logs = [
+        "python_ta could not check your code due to an invalid character. Please check the following lines in your file and all characters that are marked with a �.",
+        '  Line 1: "�"\n',
+        '  Line 2: "�"\n',
+        '  Line 5: "�"',
+    ]
+
+    path = os.path.join(os.path.dirname(__file__), "fixtures", "unicode_decode_error.py")
+    _verify_pre_check(path, False)
+
+    for i in range(len(expected_logs)):
+        assert expected_logs[i] == caplog.records[i].msg
+        assert "ERROR" == caplog.records[i].levelname
+
+
+def test_get_valid_files_to_check(caplog) -> None:
+    """Testing logging in _get_valid_files_to_check function"""
+    expected_logs = [
+        "No checks run. Input to check, `{'examples/nodes/assign'}`, has invalid type, must be a list of strings.",
+        "No check run on file `0`, with invalid type. Must be type: str.",
+        "Could not find the file called, `foo`",
+    ]
+
+    # Iterating through generators to produce errors
+    [_ for _ in _get_valid_files_to_check(module_name={"examples/nodes/assign"})]
+    [_ for _ in _get_valid_files_to_check(module_name=[0])]
+    [_ for _ in _get_valid_files_to_check(module_name="foo")]
+
+    for i in range(len(expected_logs)):
+        assert caplog.records[i].levelname == "ERROR"
+        assert expected_logs[i] in caplog.records[i].msg
+
+
+def test_doc_log(caplog) -> None:
+    """Testing logging in doc function"""
+    python_ta.doc("E0602")
+    assert caplog.records[0].levelname == "INFO"
+    assert (
+        "Opening http://www.cs.toronto.edu/~david/pyta/checkers/index.html#e0602 in a browser."
+        in caplog.text
+    )

tests/test_init_version.py

@@ -0,0 +1,14 @@
+"""Test for __init__.py system version check"""
+import importlib
+import sys
+
+import python_ta
+
+
+def test_sys_version_log(caplog, monkeypatch) -> None:
+    """Testing if message logged when system version is too low is correct"""
+    monkeypatch.setattr(sys, "version_info", (2, 6, 0))
+    importlib.reload(python_ta)  # Necessary due to python's import not actually reimporting package
+
+    assert caplog.records[0].levelname == "WARNING"
+    assert "You need Python 3.7 or later to run PythonTA." in caplog.text