Merge pull request #79 from cleophass/GCI106-python

GCI106 AvoidSqrtInLoop #Python #DLG #Build

Author: dedece35

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- [#79](https://github.com/green-code-initiative/creedengo-python/pull/79) Add rule GCI106 Avoid SQRT in a loop
 - [#71](https://github.com/green-code-initiative/creedengo-python/pull/71) Add rule GCI96 Require Usecols Argument in Pandas Read Functions
 - [#72](https://github.com/green-code-initiative/creedengo-python/pull/72) Add rule GCI97 Optimize square computation (scalar vs vectorized method)
 

pom.xml

@@ -70,7 +70,7 @@
         <lombok.version>1.18.38</lombok.version>
 
         <!-- temporary version waiting for a real automatic release in creedengo repository -->
-        <creedengo-rules-specifications.version>2.3.0</creedengo-rules-specifications.version>
+        <creedengo-rules-specifications.version>2.4.0</creedengo-rules-specifications.version>
 
         <!-- URL of the Maven repository where sonarqube will be downloaded -->
         <test-it.orchestrator.artifactory.url>https://repo1.maven.org/maven2</test-it.orchestrator.artifactory.url>

src/it/java/org/greencodeinitiative/creedengo/python/integration/tests/GCIRulesIT.java

@@ -287,6 +287,8 @@ void testGCI96() {
 
         checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_10MIN);
     }
+
+    @Test
     void testGCI97(){
         String filePath = "src/optimizeSquareComputation.py";
         String ruleId = "creedengo-python:GCI97";
@@ -301,4 +303,18 @@ void testGCI97(){
         checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_1MIN);
     }
 
+    @Test
+    void testGCI106() {
+        String filePath = "src/avoidSqrtInLoop.py";
+        String ruleId = "creedengo-python:GCI106";
+        String ruleMsg = "Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.";
+        int[] startLines = new int[]{
+            7, 11, 16, 21, 45, 52, 60
+        };
+        int[] endLines = new int[]{
+            7, 11, 16, 21, 45, 52, 60
+        };
+        checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_5MIN);
+    }
+
 }

src/it/test-projects/creedengo-python-plugin-test-project/src/avoidSqrtInLoop.py

@@ -0,0 +1,75 @@
+import math
+import numpy as np
+
+results = []
+numbers = [1, 2, 3, 4, 5]
+for n in numbers:
+    results.append(math.sqrt(n))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+
+results = []
+for x in [9, 16, 25]:
+    results.append(np.sqrt(x))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+
+results = []
+i = 0
+while i < 3:
+    results.append(np.sqrt(i))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    i += 1
+
+results = []
+for n in range(10):
+    val = math.sqrt(n)  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    results.append(val)
+
+class DataProcessor:
+    numbers = np.array([1, 4, 9])
+    sqrt_values = np.sqrt(numbers)
+
+x = math.sqrt(25)
+
+class Analyzer:
+    def __init__(self, data):
+        self.results = np.sqrt(np.array(data))
+
+intermediate = []
+for n in range(3):
+    intermediate.append(n)
+final = np.sqrt(np.array(intermediate))
+
+results = np.sqrt([x for x in range(5)])
+
+def non_compliant_math_sqrt_in_for_loop():
+    numbers = [1, 2, 3, 4, 5]
+    results = []
+    for num in numbers:
+        results.append(math.sqrt(num))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    return results
+
+def non_compliant_numpy_scalar_sqrt_in_for_loop():
+    numbers = [1, 2, 3, 4, 5]
+    results = []
+    for num in numbers:
+        results.append(np.sqrt(num))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    return results
+
+def non_compliant_math_sqrt_in_while_loop():
+    numbers = [1, 2, 3, 4, 5]
+    results = []
+    i = 0
+    while i < len(numbers):
+        results.append(math.sqrt(numbers[i]))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+        i += 1
+    return results
+
+def compliant_numpy_vectorized_sqrt():
+    numbers = np.array([1, 2, 3, 4, 5])
+    results = np.sqrt(numbers)
+    return results
+
+def compliant_list_comprehension_with_vectorized_operation():
+    numbers = [1, 2, 3, 4, 5]
+    return np.sqrt(np.array(numbers))
+
+def compliant_math_sqrt_outside_loop():
+    value = 16
+    return math.sqrt(value)

src/main/java/org/greencodeinitiative/creedengo/python/PythonRuleRepository.java

@@ -42,7 +42,8 @@ public class PythonRuleRepository implements RulesDefinition, PythonCustomRuleRe
             DetectUnoptimizedImageFormat.class,
             AvoidMultipleIfElseStatementCheck.class,
             PandasRequireUsecolsArgument.class,
-            OptimizeSquareComputation.class
+            OptimizeSquareComputation.class,
+            AvoidSqrtInLoop.class
     );
 
     public static final String LANGUAGE = "py";

src/main/java/org/greencodeinitiative/creedengo/python/checks/AvoidSqrtInLoop.java

@@ -0,0 +1,75 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.sonar.check.Rule;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.QualifiedExpression;
+import org.sonar.plugins.python.api.tree.Tree;
+
+@Rule(key = "GCI106")
+public class AvoidSqrtInLoop extends PythonSubscriptionCheck {
+
+    public static final String DESCRIPTION = "Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.";
+
+    @Override
+    public void initialize(Context context) {
+        context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, this::checkCallExpression);
+    }
+
+    private void checkCallExpression(SubscriptionContext context) {
+        CallExpression callExpression = (CallExpression) context.syntaxNode();
+        
+        if (isSqrtCall(callExpression) && hasLoopParent(callExpression)) {
+            context.addIssue(callExpression, DESCRIPTION);
+        }
+    }
+    
+    private boolean isSqrtCall(CallExpression callExpression) {
+        Expression callee = callExpression.callee();
+        
+        // Check for direct calls to math.sqrt
+        if (callee.is(Tree.Kind.QUALIFIED_EXPR)) {
+            QualifiedExpression qualifiedExpression = (QualifiedExpression) callee;
+            String methodName = qualifiedExpression.name().name();
+            
+            if ("sqrt".equals(methodName)) {
+                Expression qualifier = qualifiedExpression.qualifier();
+                if (qualifier != null && qualifier.is(Tree.Kind.NAME)) {
+                    String qualifierName = qualifier.firstToken().value();
+                    return "math".equals(qualifierName) || "np".equals(qualifierName) || "numpy".equals(qualifierName);
+                }
+            }
+        }
+        
+        return false;
+    }
+    
+    private boolean hasLoopParent(Tree tree) {
+        for (Tree parent = tree.parent(); parent != null; parent = parent.parent()) {
+            Tree.Kind kind = parent.getKind();
+            if (kind == Tree.Kind.FOR_STMT || kind == Tree.Kind.WHILE_STMT) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/resources/org/greencodeinitiative/creedengo/python/creedengo_way_profile.json

@@ -12,6 +12,7 @@
 		"GCI89",
 		"GCI96",
 		"GCI97",
+		"GCI106",
 		"GCI203",
 		"GCI404"
 	]

src/test/java/org/greencodeinitiative/creedengo/python/checks/AvoidSqrtInLoopTest.java

@@ -0,0 +1,28 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.junit.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+public class AvoidSqrtInLoopTest {
+    @Test
+    public void test() {
+        PythonCheckVerifier.verify("src/test/resources/checks/avoidSqrtInLoop.py", new AvoidSqrtInLoop());
+    }
+}

src/test/resources/checks/avoidSqrtInLoop.py

@@ -0,0 +1,75 @@
+import math
+import numpy as np
+
+results = []
+numbers = [1, 2, 3, 4, 5]
+for n in numbers:
+    results.append(math.sqrt(n))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+
+results = []
+for x in [9, 16, 25]:
+    results.append(np.sqrt(x))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+
+results = []
+i = 0
+while i < 3:
+    results.append(np.sqrt(i))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    i += 1
+
+results = []
+for n in range(10):
+    val = math.sqrt(n)  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    results.append(val)
+
+class DataProcessor:
+    numbers = np.array([1, 4, 9])
+    sqrt_values = np.sqrt(numbers)
+
+x = math.sqrt(25)
+
+class Analyzer:
+    def __init__(self, data):
+        self.results = np.sqrt(np.array(data))
+
+intermediate = []
+for n in range(3):
+    intermediate.append(n)
+final = np.sqrt(np.array(intermediate))
+
+results = np.sqrt([x for x in range(5)])
+
+def non_compliant_math_sqrt_in_for_loop():
+    numbers = [1, 2, 3, 4, 5]
+    results = []
+    for num in numbers:
+        results.append(math.sqrt(num))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    return results
+
+def non_compliant_numpy_scalar_sqrt_in_for_loop():
+    numbers = [1, 2, 3, 4, 5]
+    results = []
+    for num in numbers:
+        results.append(np.sqrt(num))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+    return results
+
+def non_compliant_math_sqrt_in_while_loop():
+    numbers = [1, 2, 3, 4, 5]
+    results = []
+    i = 0
+    while i < len(numbers):
+        results.append(math.sqrt(numbers[i]))  # Noncompliant {{Avoid using scalar sqrt functions in loops. Apply vectorized sqrt operations on arrays directly.}}
+        i += 1
+    return results
+
+def compliant_numpy_vectorized_sqrt():
+    numbers = np.array([1, 2, 3, 4, 5])
+    results = np.sqrt(numbers)
+    return results
+
+def compliant_list_comprehension_with_vectorized_operation():
+    numbers = [1, 2, 3, 4, 5]
+    return np.sqrt(np.array(numbers))
+
+def compliant_math_sqrt_outside_loop():
+    value = 16
+    return math.sqrt(value)