Merge pull request #55 from pylint-dev/54-add-library-parameter-checker

add lib parameter checkers

Author: PeterHamfelt

pylint_ml/checkers/numpy/numpy_parameter.py

@@ -0,0 +1,104 @@
+# 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 numpy functions with required parameters."""
+
+from astroid import nodes
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import only_required_for_messages
+from pylint.interfaces import HIGH
+
+
+class NumPyParameterChecker(BaseChecker):
+    name = "numpy-parameter"
+    msgs = {
+        "W8111": (
+            "Ensure that required parameters %s are explicitly specified in numpy method %s.",
+            "numpy-parameter",
+            "Explicitly specifying required parameters improves model performance and prevents unintended behavior.",
+        ),
+    }
+
+    REQUIRED_PARAMS = {
+        # Array Creation
+        "array": ["object"],
+        "zeros": ["shape"],
+        "ones": ["shape"],
+        "full": ["shape", "fill_value"],
+        "empty": ["shape"],
+        "arange": ["start"],
+        "linspace": ["start", "stop"],
+        "logspace": ["start", "stop"],
+        "eye": ["N"],
+        "identity": ["n"],
+        # Random Sampling
+        "random.rand": ["d0"],
+        "random.randn": ["d0"],
+        "random.randint": ["low", "high"],
+        "random.choice": ["a"],
+        "random.uniform": ["low", "high"],
+        "random.normal": ["loc", "scale"],
+        # Mathematical Functions
+        "sum": ["a"],
+        "mean": ["a"],
+        "median": ["a"],
+        "std": ["a"],
+        "var": ["a"],
+        "prod": ["a"],
+        "min": ["a"],
+        "max": ["a"],
+        "ptp": ["a"],
+        # Array Manipulation
+        "reshape": ["newshape"],
+        "transpose": [],
+        "concatenate": ["arrays"],
+        "stack": ["arrays"],
+        "vstack": ["arrays"],
+        "hstack": ["arrays"],
+        # Linear Algebra
+        "dot": ["a", "b"],
+        "matmul": ["a", "b"],
+        "linalg.inv": ["a"],
+        "linalg.eig": ["a"],
+        "linalg.solve": ["a", "b"],
+        # Statistical Functions
+        "percentile": ["a", "q"],
+        "quantile": ["a", "q"],
+        "corrcoef": ["x"],
+        "cov": ["m"],
+    }
+
+    @only_required_for_messages("numpy-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        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}
+            # Collect all missing parameters
+            missing_params = [param for param in self.REQUIRED_PARAMS[method_name] if param not in provided_keywords]
+            if missing_params:
+                self.add_message(
+                    "numpy-parameter",
+                    node=node,
+                    confidence=HIGH,
+                    args=(", ".join(missing_params), method_name),
+                )
+
+    @staticmethod
+    def _get_full_method_name(node: nodes.Call) -> str:
+        """
+        Extracts the full method name, including chained attributes (e.g., np.random.rand).
+        """
+        func = node.func
+        method_chain = []
+
+        # Traverse the attribute chain
+        while isinstance(func, nodes.Attribute):
+            method_chain.insert(0, func.attrname)
+            func = func.expr
+
+        # Check if the root of the chain is "np" (as NumPy functions are expected to use np. prefix)
+        if isinstance(func, nodes.Name) and func.name == "np":
+            return ".".join(method_chain)
+        return ""

pylint_ml/checkers/pandas/pandas_dataframe_merge.py

@@ -0,0 +1,90 @@
+# 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 Pandas functions with required parameters."""
+
+from astroid import nodes
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import only_required_for_messages
+from pylint.interfaces import HIGH
+
+
+class PandasParameterChecker(BaseChecker):
+    name = "pandas-parameter"
+    msgs = {
+        "W8111": (
+            "Ensure that required parameters %s are explicitly specified in Pandas method %s.",
+            "pandas-parameter",
+            "Explicitly specifying required parameters improves model performance and prevents unintended behavior.",
+        ),
+    }
+
+    # Define required parameters for specific Pandas classes and methods
+    REQUIRED_PARAMS = {
+        # DataFrame creation
+        "DataFrame": ["data"],  # The primary input data for DataFrame creation
+        # Concatenation
+        "concat": ["objs"],  # The list or dictionary of DataFrames/Series to concatenate
+        # DataFrame I/O (Input/Output)
+        "read_csv": ["filepath_or_buffer", "dtype"],  # Path to CSV file or file-like object; column data types
+        "read_excel": ["io", "dtype"],  # Path to Excel file or file-like object; column data types
+        "read_table": ["filepath_or_buffer", "dtype"],  # Path to delimited text-file or file object; column data types
+        "to_csv": ["path_or_buf"],  # File path or buffer to write the DataFrame to
+        "to_excel": ["excel_writer"],  # File path or ExcelWriter object to write the data to
+        # Merging and Joining
+        "merge": ["right", "how", "on", "validate"],  # The DataFrame or Serie to merge with
+        "join": ["other"],  # The DataFrame or Series to join
+        # DataFrame Operations
+        "pivot_table": ["index"],  # The column to pivot on (values and columns have defaults)
+        "groupby": ["by"],  # The key or list of keys to group by
+        "resample": ["rule"],  # The frequency rule to resample by
+        # Data Cleaning and Transformation
+        "fillna": ["value"],  # Value to use to fill NA/NaN values
+        "drop": ["labels"],  # Labels to drop
+        "drop_duplicates": ["subset"],  # Subset of columns to consider when dropping duplicates
+        "replace": ["to_replace"],  # Values to replace
+        # Plotting
+        "plot": ["x"],  # x-values or index for plotting
+        "hist": ["column"],  # Column to plot the histogram for
+        "boxplot": ["column"],  # Column(s) to plot boxplot for
+        # DataFrame Sorting
+        "sort_values": ["by"],  # Column(s) to sort by
+        "sort_index": ["axis"],  # Axis to sort along (index=0, columns=1)
+        # Statistical Functions
+        "corr": ["method"],  # Method to use for correlation ('pearson', 'kendall', 'spearman')
+        "describe": [],  # No required parameters, but additional ones could be specified
+        # Windowing/Resampling Functions
+        "rolling": ["window"],  # Size of the moving window
+        "ewm": ["span"],  # Span for exponentially weighted calculations
+        # Miscellaneous Functions
+        "apply": ["func"],  # Function to apply to the data
+        "agg": ["func"],  # Function or list of functions for aggregation
+    }
+
+    @only_required_for_messages("pandas-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        method_name = self._get_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}
+            # Collect all missing parameters
+            missing_params = [param for param in self.REQUIRED_PARAMS[method_name] if param not in provided_keywords]
+            if missing_params:
+                self.add_message(
+                    "pandas-parameter",
+                    node=node,
+                    confidence=HIGH,
+                    args=(", ".join(missing_params), method_name),
+                )
+
+    @staticmethod
+    def _get_method_name(node: nodes.Call) -> str:
+        """Extracts the method name from a Call node, including handling chained calls."""
+        func = node.func
+        while isinstance(func, nodes.Attribute):
+            func = func.expr
+        return (
+            node.func.attrname
+            if isinstance(node.func, nodes.Attribute)
+            else func.name if isinstance(func, nodes.Name) else ""
+        )

pylint_ml/checkers/pandas/pandas_dtype_param.py

@@ -25,8 +25,9 @@ class ScipyImportChecker(BaseChecker):
         ),
     }
 
-    @only_required_for_messages("scipy-import")
+    @only_required_for_messages("scipy-import", "scipy-wildcard-import")
     def visit_import(self, node: nodes.Import) -> None:
-        for name, _ in node.names:
+        for name, _alias in node.names:
             if name == "scipy":
+                # Flag direct or aliased imports of scipy
                 self.add_message("scipy-import", node=node, confidence=HIGH)

pylint_ml/checkers/pandas/pandas_parameter.py

@@ -0,0 +1,75 @@
+# 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 Scipy functions with required parameters."""
+
+from astroid import nodes
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import only_required_for_messages
+from pylint.interfaces import HIGH
+
+
+class ScipyParameterChecker(BaseChecker):
+    name = "scipy-parameter"
+    msgs = {
+        "W8111": (
+            "Ensure that required parameters %s are explicitly specified in scipy method %s.",
+            "scipy-parameter",
+            "Explicitly specifying required parameters improves model performance and prevents unintended behavior.",
+        ),
+    }
+
+    # Define required parameters for specific Scipy classes and methods
+    REQUIRED_PARAMS = {
+        # scipy.optimize
+        "minimize": ["fun", "x0"],
+        "curve_fit": ["f", "xdata", "ydata"],
+        "root": ["fun", "x0"],
+        # scipy.integrate
+        "quad": ["func", "a", "b"],
+        "dblquad": ["func", "a", "b", "gfun", "hfun"],
+        "solve_ivp": ["fun", "t_span", "y0"],
+        # scipy.stats
+        "ttest_ind": ["a", "b"],
+        "ttest_rel": ["a", "b"],
+        "norm.pdf": ["x"],
+        # scipy.spatial
+        "distance.euclidean": ["u", "v"],  # Full chain
+        "euclidean": ["u", "v"],  # Direct import of euclidean
+        "KDTree.query": ["x"],
+    }
+
+    @only_required_for_messages("scipy-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        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}
+            # Collect all missing parameters
+            missing_params = [param for param in self.REQUIRED_PARAMS[method_name] if param not in provided_keywords]
+            if missing_params:
+                self.add_message(
+                    "scipy-parameter",
+                    node=node,
+                    confidence=HIGH,
+                    args=(", ".join(missing_params), method_name),
+                )
+
+    def _get_full_method_name(self, node: nodes.Call) -> str:
+        """
+        Extracts the full method name, including handling chained attributes (e.g., scipy.spatial.distance.euclidean)
+        and also handles direct imports like euclidean.
+        """
+        func = node.func
+        method_chain = []
+
+        # Traverse the attribute chain to get the full method name
+        while isinstance(func, nodes.Attribute):
+            method_chain.insert(0, func.attrname)
+            func = func.expr
+
+        # If it's a direct function name, like `euclidean`, return it
+        if isinstance(func, nodes.Name):
+            method_chain.insert(0, func.name)
+
+        return ".".join(method_chain)