Merge pull request #59 from pylint-dev/58-update-test-environment

Update test

Author: PeterHamfelt

pylint_ml/checkers/matplotlib/__init__.py

@@ -0,0 +1,76 @@
+# Licensed under the MIT: https://mit-license.org/
+# For details: https://github.com/pylint-dev/pylint-ml/LICENSE
+# Copyright (c) https://github.com/pylint-dev/pylint-ml/CONTRIBUTORS.txt
+
+"""Check for proper usage of Matplotlib functions with required parameters."""
+
+from astroid import nodes
+from pylint.checkers.utils import only_required_for_messages
+from pylint.interfaces import HIGH
+
+from pylint_ml.util.library_handler import LibraryHandler
+
+
+class MatplotlibParameterChecker(LibraryHandler):
+    name = "matplotlib-parameter"
+    msgs = {
+        "W8111": (
+            "Ensure that required parameters %s are explicitly specified in matplotlib method %s.",
+            "matplotlib-parameter",
+            "Explicitly specifying required parameters improves model performance and prevents unintended behavior.",
+        ),
+    }
+
+    # Define required parameters for specific matplotlib classes and methods
+    REQUIRED_PARAMS = {
+        # Plotting Functions
+        "plot": ["x", "y"],  # x and y data points are required for basic line plots
+        "scatter": ["x", "y"],  # x and y data points are required for scatter plots
+        "bar": ["x", "height"],  # x positions and heights are required for bar plots
+        "hist": ["x"],  # Data points (x) are required for histogram plots
+        "pie": ["x"],  # x data is required for pie chart slices
+        "imshow": ["X"],  # Input array (X) is required for displaying images
+        "contour": ["X", "Y", "Z"],  # X, Y, and Z data points are required for contour plots
+        "contourf": ["X", "Y", "Z"],  # X, Y, and Z data points for filled contour plots
+        "pcolormesh": ["X", "Y", "C"],  # X, Y grid and C color values are required for pseudo color plot
+        # Axes Functions
+        "set_xlabel": ["xlabel"],  # xlabel is required for setting the x-axis label
+        "set_ylabel": ["ylabel"],  # ylabel is required for setting the y-axis label
+        "set_xlim": ["left", "right"],  # Left and right bounds for x-axis limit
+        "set_ylim": ["bottom", "top"],  # Bottom and top bounds for y-axis limit
+        # Figures and Subplots
+        "subplots": ["nrows", "ncols"],  # Number of rows and columns are required for creating a subplot grid
+        "subplot": ["nrows", "ncols", "index"],  # Number of rows, columns, and index for specific subplot
+        # Miscellaneous Functions
+        "savefig": ["fname"],  # Filename or file object is required to save a figure
+    }
+
+    @only_required_for_messages("matplotlib-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        # TODO Update
+        # if not self.is_library_imported('matplotlib') and self.is_library_version_valid(lib_version=):
+        #     return
+
+        method_name = self._get_full_method_name(node)
+        if method_name in self.REQUIRED_PARAMS:
+            provided_keywords = {kw.arg for kw in node.keywords if kw.arg is not None}
+            missing_params = [param for param in self.REQUIRED_PARAMS[method_name] if param not in provided_keywords]
+            if missing_params:
+                self.add_message(
+                    "matplotlib-parameter",
+                    node=node,
+                    confidence=HIGH,
+                    args=(", ".join(missing_params), method_name),
+                )
+
+    def _get_full_method_name(self, node: nodes.Call) -> str:
+        func = node.func
+        method_chain = []
+
+        while isinstance(func, nodes.Attribute):
+            method_chain.insert(0, func.attrname)
+            func = func.expr
+        if isinstance(func, nodes.Name):
+            method_chain.insert(0, func.name)
+
+        return ".".join(method_chain)

pylint_ml/checkers/matplotlib/matplotlib_parameter.py

@@ -7,12 +7,13 @@
 from __future__ import annotations
 
 from astroid import nodes
-from pylint.checkers import BaseChecker
 from pylint.checkers.utils import only_required_for_messages
 from pylint.interfaces import HIGH
 
+from pylint_ml.util.library_handler import LibraryHandler
 
-class NumpyDotChecker(BaseChecker):
+
+class NumpyDotChecker(LibraryHandler):
     name = "numpy-dot-checker"
     msgs = {
         "W8122": (
@@ -23,8 +24,14 @@ class NumpyDotChecker(BaseChecker):
         ),
     }
 
+    def visit_import(self, node: nodes.Import):
+        super().visit_import(node=node)
+
     @only_required_for_messages("numpy-dot-usage")
     def visit_call(self, node: nodes.Call) -> None:
+        if not self.is_library_imported("numpy"):
+            return
+
         # Check if the function being called is np.dot
         if isinstance(node.func, nodes.Attribute):
             func_name = node.func.attrname

pylint_ml/checkers/numpy/numpy_dot.py

@@ -0,0 +1,34 @@
+from pylint.checkers import BaseChecker
+
+
+class LibraryHandler(BaseChecker):
+
+    def __init__(self, linter):
+        super().__init__(linter)
+        self.imports = {}
+
+    def visit_import(self, node):
+        for name, alias in node.names:
+            self.imports[alias or name] = name
+
+    def visit_importfrom(
+        self,
+        node,
+    ):
+        # TODO Update method to handle either:
+        #   1. Check of specific method-name imported?
+        #   2. Store all method names importfrom libname?
+
+        module = node.modname
+        for name, alias in node.names:
+            full_name = f"{module}.{name}"
+            self.imports[alias or name] = full_name
+
+    def is_library_imported(self, library_name):
+        return any(mod.startswith(library_name) for mod in self.imports.values())
+
+    # def is_library_version_valid(self, lib_version):
+    #     # TODO update solution
+    #     if lib_version is None:
+    #         pass
+    #     return

pylint_ml/util/library_handler.py

@@ -9,23 +9,22 @@ class TestNumpyDotChecker(pylint.testutils.CheckerTestCase):
     CHECKER_CLASS = NumpyDotChecker
 
     def test_warning_for_dot(self):
-        node = astroid.extract_node(
-            """
-            import numpy as np
-            a = np.array([1, 2])
-            b = np.array([3, 4])
-            result = np.dot(a, b)  # [numpy-dot-usage]
+        import_np, node = astroid.extract_node(
             """
+        import numpy as np #@
+        a = np.array([1, 2])
+        b = np.array([3, 4])
+        np.dot(a, b) #@
+        """
         )
 
-        dot_call = node.value
-
         with self.assertAddsMessages(
             pylint.testutils.MessageTest(
                 msg_id="numpy-dot-usage",
+                node=node,
                 confidence=HIGH,
-                node=dot_call,
             ),
             ignore_position=True,
         ):
-            self.checker.visit_call(dot_call)
+            self.checker.visit_import(import_np)
+            self.checker.visit_call(node)

tests/checkers/test_numpy/test_numpy_dot.py

@@ -9,45 +9,45 @@ class TestNumpyImport(pylint.testutils.CheckerTestCase):
     CHECKER_CLASS = NumpyImportChecker
 
     def test_correct_numpy_import(self):
-        numpy_import_node = astroid.extract_node(
+        import_node = astroid.extract_node(
             """
-        import numpy as np
+        import numpy as np #@
         """
         )
 
         with self.assertNoMessages():
-            self.checker.visit_import(numpy_import_node)
+            self.checker.visit_import(import_node)
 
     def test_incorrect_numpy_import(self):
-        numpy_import_node = astroid.extract_node(
+        import_node = astroid.extract_node(
             """
-        import numpy as npy
+        import numpy as npy #@
         """
         )
 
         with self.assertAddsMessages(
             pylint.testutils.MessageTest(
                 msg_id="numpy-import",
                 confidence=HIGH,
-                node=numpy_import_node,
+                node=import_node,
             ),
             ignore_position=True,
         ):
-            self.checker.visit_import(numpy_import_node)
+            self.checker.visit_import(import_node)
 
     def test_incorrect_numpy_import_from(self):
-        numpy_importfrom_node = astroid.extract_node(
+        importfrom_node = astroid.extract_node(
             """
-        from numpy import min
+        from numpy import min #@
         """
         )
 
         with self.assertAddsMessages(
             pylint.testutils.MessageTest(
                 msg_id="numpy-importfrom",
                 confidence=HIGH,
-                node=numpy_importfrom_node,
+                node=importfrom_node,
             ),
             ignore_position=True,
         ):
-            self.checker.visit_importfrom(numpy_importfrom_node)
+            self.checker.visit_importfrom(importfrom_node)

tests/checkers/test_numpy/test_numpy_import.py

@@ -9,36 +9,33 @@ class TestNumpyNaNComparison(pylint.testutils.CheckerTestCase):
     CHECKER_CLASS = NumpyNaNComparisonChecker
 
     def test_singleton_nan_compare(self):
-        code = """
+        singleton_node, chained_node, great_than_node = astroid.extract_node(
+            """
         a_nan = np.array([0, 1, np.nan])
-
         np.nan == a_nan #@
-
         1 == 1 == np.nan #@
-
         1 > 0 > np.nan #@
-
         """
-        singleton_nan_compare, chained_nan_compare, great_than_nan_compare = astroid.extract_node(code)
+        )
 
         with self.assertAddsMessages(
             pylint.testutils.MessageTest(
                 msg_id="numpy-nan-compare",
-                node=singleton_nan_compare,
+                node=singleton_node,
                 confidence=HIGH,
             ),
             pylint.testutils.MessageTest(
                 msg_id="numpy-nan-compare",
-                node=chained_nan_compare,
+                node=chained_node,
                 confidence=HIGH,
             ),
             pylint.testutils.MessageTest(
                 msg_id="numpy-nan-compare",
-                node=great_than_nan_compare,
+                node=great_than_node,
                 confidence=HIGH,
             ),
             ignore_position=True,
         ):
-            self.checker.visit_compare(singleton_nan_compare)
-            self.checker.visit_compare(chained_nan_compare)
-            self.checker.visit_compare(great_than_nan_compare)
+            self.checker.visit_compare(singleton_node)
+            self.checker.visit_compare(chained_node)
+            self.checker.visit_compare(great_than_node)

tests/checkers/test_numpy/test_numpy_nan_comparison.py

@@ -12,7 +12,7 @@ def test_array_missing_object(self):
         node = astroid.extract_node(
             """
             import numpy as np
-            arr = np.array()  # [numpy-parameter]
+            arr = np.array()  #@
             """
         )
 
@@ -33,7 +33,7 @@ def test_zeros_without_shape(self):
         node = astroid.extract_node(
             """
             import numpy as np
-            arr = np.zeros()  # [numpy-parameter]
+            arr = np.zeros()  #@
             """
         )
 
@@ -54,7 +54,7 @@ def test_random_rand_without_shape(self):
         node = astroid.extract_node(
             """
             import numpy as np
-            arr = np.random.rand()  # [numpy-parameter]
+            arr = np.random.rand()  #@
             """
         )
 
@@ -75,7 +75,7 @@ def test_dot_without_b(self):
         node = astroid.extract_node(
             """
             import numpy as np
-            arr = np.dot(a=[1, 2, 3])  # [numpy-parameter]
+            arr = np.dot(a=[1, 2, 3])  #@
             """
         )
 
@@ -96,7 +96,7 @@ def test_percentile_without_q(self):
         node = astroid.extract_node(
             """
             import numpy as np
-            result = np.percentile(a=[1, 2, 3])  # [numpy-parameter]
+            result = np.percentile(a=[1, 2, 3])  #@
             """
         )
 

tests/checkers/test_numpy/test_numpy_parameter.py

@@ -13,7 +13,7 @@ def test_incorrect_column_selection(self):
             """
             import pandas as pd
             df_sales = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-            value = df_sales.A  # [pandas-column-selection]
+            value = df_sales.A  #@
             """
         )
 

tests/checkers/test_pandas/pandas_dataframe_column_selection.py

@@ -13,7 +13,7 @@ def test_dataframe_bool_usage(self):
             """
             import pandas as pd
             df_customers = pd.DataFrame(data)
-            df_customers.bool()  # [pandas-dataframe-bool]
+            df_customers.bool() #@
             """
         )
         with self.assertAddsMessages(
@@ -31,7 +31,7 @@ def test_no_bool_usage(self):
             """
             import pandas as pd
             df_customers = pd.DataFrame(data)
-            df_customers.sum()  # This should pass without warnings
+            df_customers.sum()  #@
             """
         )
         with self.assertNoMessages():