Added 1 module, 1 class, 3 constants, 31 functions, and 5 kwargs

Author: netromdk

README.md

@@ -7,7 +7,7 @@ Everything is contained within "minpy.py" - no other file is necessary.
 
 Since the code is vanilla Python, and it doesn't have any external dependencies, it works with v2.7+ and v3+.
 
-It functions by parsing Python code into an abstract syntax tree (AST), which it traverses and matches against internal dictionaries of 39 modules, 88 classes/functions/constants members of modules, and 16 kwargs of functions. Including looking for v2/v3 `print expr` and `print(expr)`, `"..".format(..)`, imports (`import X`, `from X import Y`, `from X import *`), and function calls wrt. name and kwargs.
+It functions by parsing Python code into an abstract syntax tree (AST), which it traverses and matches against internal dictionaries with 184 rules divided into 40 modules, 123 classes/functions/constants members of modules, and 21 kwargs of functions. Including looking for v2/v3 `print expr` and `print(expr)`, `"..".format(..)`, imports (`import X`, `from X import Y`, `from X import *`), and function calls wrt. name and kwargs.
 
 ## Usage
 It is fairly straightforward to use Minpy:
@@ -30,6 +30,7 @@ Options:
   -v..    Verbosity level 1 to 2. -v shows less than -vv but more than no verbosity.
   -i      Ignore incompatible version warnings.
   -p=X    Use X concurrent processes to analyze files (defaults to all cores = 8).
+  -d      Dump AST node visits.
 
 % ./minpy.py -q minpy.py
 Minimum required versions: 2.7, 3.0

class_tests.py

@@ -12,3 +12,6 @@ def test_terminal_size_of_os(self):
 
   def test_Barrier_of_multiprocessing(self):
     self.assertOnlyIn(3.3, detect("from multiprocessing import Barrier"))
+
+  def test_TextTestResult_of_unittest(self):
+    self.assertOnlyIn((2.7, 3.0), detect("from unittest import TextTestResult"))

constants_tests.py

@@ -93,3 +93,15 @@ def test_version_info_of_sys(self):
 
   def test_sentinel_of_multiprocessing_Process(self):
     self.assertOnlyIn(3.3, detect("from multiprocessing import Process\np = Process()\np.sentinel"))
+
+  def test_skipped_of_unittest_TestResult(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestResult\np = TestResult()\np.skipped"))
+
+  def test_buffer_of_unittest_TestResult(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestResult\np = TestResult()\np.buffer"))
+
+  def test_failfast_of_unittest_TestResult(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestResult\np = TestResult()\np.failfast"))

function_tests.py

@@ -164,3 +164,122 @@ def test_set_start_method_of_multiprocessing(self):
 
   def test_get_context_of_multiprocessing(self):
     self.assertOnlyIn(3.4, detect("import multiprocessing\nget_context()"))
+
+  def test_assertIs_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0), detect("from unittest import TestCase\nTestCase.assertIs()"))
+
+  def test_assertIsNot_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0), detect("from unittest import TestCase\nTestCase.assertIsNot()"))
+
+  def test_assertIsNone_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0), detect("from unittest import TestCase\nTestCase.assertIsNone()"))
+
+  def test_assertIsNotNone_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertIsNotNone()"))
+
+  def test_assertIn_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0), detect("from unittest import TestCase\nTestCase.assertIn()"))
+
+  def test_assertNotIn_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0), detect("from unittest import TestCase\nTestCase.assertNotIn()"))
+
+  def test_assertIsInstance_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertIsInstance()"))
+
+  def test_assertNotIsInstance_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertNotIsInstance()"))
+
+  def test_assertRaisesRegexp_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertRaisesRegexp()"))
+
+  def test_assertGreater_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertGreater()"))
+
+  def test_assertGreaterEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertGreaterEqual()"))
+
+  def test_assertLess_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertLess()"))
+
+  def test_assertLessEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertLessEqual()"))
+
+  def test_assertRegexpMatches_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertRegexpMatches()"))
+
+  def test_assertNotRegexpMatches_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertNotRegexpMatches()"))
+
+  def test_assertItemsEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertItemsEqual()"))
+
+  def test_assertDictContainsSubset_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertDictContainsSubset()"))
+
+  def test_addTypeEqualityFunc_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.addTypeEqualityFunc()"))
+
+  def test_assertMultilineEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertMultilineEqual()"))
+
+  def test_assertSequenceEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertSequenceEqual()"))
+
+  def test_assertListEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertListEqual()"))
+
+  def test_assertTupleEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertTupleEqual()"))
+
+  def test_assertSetEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertSetEqual()"))
+
+  def test_assertDictEqual_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertDictEqual()"))
+
+  def test_longMessage_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.longMessage()"))
+
+  def test_maxDiff_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.maxDiff()"))
+
+  def test_addCleanup_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.addCleanup()"))
+
+  def test_doCleanup_of_unittest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.doCleanup()"))
+
+  def test_discover_of_unittest_TestLoader(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestLoader\nTestLoader.discover()"))
+
+  def test_startTestRun_of_unittest_TestResult(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestResult\nTestResult.startTestRun()"))
+
+  def test_stopTestRun_of_unittest_TestResult(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestResult\nTestResult.stopTestRun()"))

kwargs_tests.py

@@ -49,3 +49,21 @@ def test_context_of_Pool_from_multiprocessing(self):
 
   def test_daemon_of_Process_from_multiprocessing(self):
     self.assertOnlyIn(3.3, detect("import multiprocessing\nProcess(daemon=None)"))
+
+  def test_compact_of_PrettyPrinter_from_pprint(self):
+    self.assertOnlyIn(3.4, detect("import pprint\npprint.PrettyPrinter(compact=True)"))
+
+  def test_compact_of_pformat_from_pprint(self):
+    self.assertOnlyIn(3.4, detect("import pprint\npprint.pformat(compact=True)"))
+
+  def test_compact_of_pprint_from_pprint(self):
+    self.assertOnlyIn(3.4, detect("import pprint\npprint.pprint(compact=True)"))
+
+  def test_delta_of_assertAlmostEqual_from_unitest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\nTestCase.assertAlmostEqual(delta=1)"))
+
+  def test_delta_of_assertNotAlmostEqual_from_unitest_TestCase(self):
+    self.assertOnlyIn((2.7, 3.0),
+                      detect("from unittest import TestCase\n"
+                             "TestCase.assertNotAlmostEqual(delta=1)"))

minpy.py

@@ -44,6 +44,7 @@
   "string.lowercase": (2.0, None),
   "string.uppercase": (2.0, None),
   "tkinter": (None, 3.0),
+  "unittest": (2.1, 3.0),
   "urllib2": (2.0, None),
   "winreg": (None, 3.0),
   "xmlrpc": (None, 3.0),
@@ -55,10 +56,38 @@
   "ABC": ("abc", (None, 3.4)),
   "Barrier": ("multiprocessing", (None, 3.3)),
   "PathLike": ("os", (None, 3.6)),
+  "TextTestResult": ("unittest", (2.7, 3.0)),
   "terminal_size": ("os", (None, 3.3)),
 
   # Functions
+  "addCleanup": ("unittest.TestCase", (2.7, 3.0)),
+  "addTypeEqualityFunc": ("unittest.TestCase", (2.7, 3.0)),
+  "assertDictContainsSubset": ("unittest.TestCase", (2.7, 3.0)),
+  "assertDictEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertGreater": ("unittest.TestCase", (2.7, 3.0)),
+  "assertGreaterEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertIn": ("unittest.TestCase", (2.7, 3.0)),
+  "assertIs": ("unittest.TestCase", (2.7, 3.0)),
+  "assertIsInstance": ("unittest.TestCase", (2.7, 3.0)),
+  "assertIsNone": ("unittest.TestCase", (2.7, 3.0)),
+  "assertIsNot": ("unittest.TestCase", (2.7, 3.0)),
+  "assertIsNotNone": ("unittest.TestCase", (2.7, 3.0)),
+  "assertItemsEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertLess": ("unittest.TestCase", (2.7, 3.0)),
+  "assertLessEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertListEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertMultilineEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertNotIn": ("unittest.TestCase", (2.7, 3.0)),
+  "assertNotIsInstance": ("unittest.TestCase", (2.7, 3.0)),
+  "assertNotRegexpMatches": ("unittest.TestCase", (2.7, 3.0)),
+  "assertRaisesRegexp": ("unittest.TestCase", (2.7, 3.0)),
+  "assertRegexpMatches": ("unittest.TestCase", (2.7, 3.0)),
+  "assertSequenceEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertSetEqual": ("unittest.TestCase", (2.7, 3.0)),
+  "assertTupleEqual": ("unittest.TestCase", (2.7, 3.0)),
   "commonpath": ("os.path", (None, 3.5)),
+  "discover": ("unittest.TestLoader", (2.7, 3.0)),
+  "doCleanup": ("unittest.TestCase", (2.7, 3.0)),
   "exc_clear": ("sys", (2.3, None)),
   "fsdecode": ("os", (None, 3.2)),
   "fsencode": ("os", (None, 3.2)),
@@ -91,6 +120,8 @@
   "ismount": ("os.path", (None, 3.4)),
   "lexists": ("os.path", (2.4, 3.0)),
   "lockf": ("os", (None, 3.3)),
+  "longMessage": ("unittest.TestCase", (2.7, 3.0)),
+  "maxDiff": ("unittest.TestCase", (2.7, 3.0)),
   "pipe2": ("os", (None, 3.3)),
   "posix_fadvise": ("os", (None, 3.3)),
   "posix_fallocate": ("os", (None, 3.3)),
@@ -109,6 +140,8 @@
   "setresuid": ("os", (2.7, 3.2)),
   "starmap": ("multiprocessing.Pool", (None, 3.3)),
   "starmap_async": ("multiprocessing.Pool", (None, 3.3)),
+  "startTestRun": ("unittest.TestResult", (2.7, 3.0)),
+  "stopTestRun": ("unittest.TestResult", (2.7, 3.0)),
   "wait": ("multiprocessing.connection", (None, 3.3)),
   "writev": ("os", (None, 3.3)),
 
@@ -133,13 +166,16 @@
   "SF_NODISKIO": ("os", (None, 3.3)),
   "SF_SYNC": ("os", (None, 3.3)),
   "api_version": ("sys", (2.3, 3.0)),
+  "buffer": ("unittest.TestResult", (2.7, 3.0)),
   "environb": ("os", (None, 3.2)),
+  "failfast": ("unittest.TestResult", (2.7, 3.0)),
   "flags": ("sys", (2.6, 3.0)),
   "float_info": ("sys", (2.6, 3.0)),
   "float_repr_style": ("sys", (2.7, 3.0)),
   "long_info": ("sys", (2.7, None)),
   "py3kwarning": ("sys", (2.6, None)),
   "sentinel": ("multiprocessing.Process", (None, 3.3)),
+  "skipped": ("unittest.TestResult", (2.7, 3.0)),
   "subversion": ("sys", (2.5, None)),
   "supports_bytes_environ": ("os", (None, 3.2)),
   "supports_unicode_filenames": ("os.path", (2.3, 3.0)),
@@ -150,10 +186,13 @@
 KWARGS_REQS = {
   ("Pool", "context"): (None, 3.4),  # multiprocessing
   ("Pool", "maxtasksperchild"): (None, 3.2),  # multiprocessing
+  ("PrettyPrinter", "compact"): (None, 3.4),  # pprint
   ("Process", "daemon"): (None, 3.3),  # multiprocessing
   ("access", "dir_fd"): (None, 3.3),  # os
   ("access", "effective_ids"): (None, 3.3),  # os
   ("access", "follow_symlinks"): (None, 3.3),  # os
+  ("assertAlmostEqual", "delta"): (2.7, 3.0),  # unittest.TestCase
+  ("assertNotAlmostEqual", "delta"): (2.7, 3.0),  # unittest.TestCase
   ("chflags", "follow_symlinks"): (None, 3.3),  # os
   ("chmod", "dir_fd"): (None, 3.3),  # os
   ("chmod", "follow_symlinks"): (None, 3.3),  # os
@@ -164,6 +203,8 @@
   ("link", "follow_symlinks"): (None, 3.3),  # os
   ("link", "src_dir_fd"): (None, 3.3),  # os
   ("open", "dir_fd"): (None, 3.3),  # os
+  ("pformat", "compact"): (None, 3.4),  # pprint
+  ("pprint", "compact"): (None, 3.4),  # pprint
 }
 
 QUIET = False

module_tests.py

@@ -118,3 +118,6 @@ def test_string_uppercase(self):
 
   def test_ast(self):
     self.assertOnlyIn((2.6, 3.0), detect("import ast"))
+
+  def test_unittest(self):
+    self.assertOnlyIn((2.1, 3.0), detect("import unittest"))