Fix CI errors

Author: ruivieira

.github/workflows/workflow.yml

@@ -34,7 +34,7 @@ jobs:
           ./deps.sh
       - name: Lint
         run: |
-          pylint $(find trustyai -type f -name "*.py")
+          pylint --ignore-imports=yes $(find trustyai -type f -name "*.py")
       - name: Test with pytest
         run: |
           pytest

README.md

@@ -1,5 +1,4 @@
 [![Tests](https://github.com/ruivieira/python-trustyai/actions/workflows/workflow.yml/badge.svg)](https://github.com/ruivieira/python-trustyai/actions/workflows/workflow.yml)
-
 # python-trustyai
 
 Python bindings to [TrustyAI](https://kogito.kie.org/trustyai/)'s explainability library.

tests/common.py

@@ -0,0 +1,29 @@
+# pylint: disable=R0801
+"""Common methods and models for tests"""
+from trustyai.model import (
+    FeatureFactory,
+    Output,
+    PredictionOutput,
+    Type,
+    Value,
+)
+
+
+def mock_feature(value):
+    """Create a mock numerical feature"""
+    return FeatureFactory.newNumericalFeature("f-num", value)
+
+
+def sum_skip_model(inputs):
+    """SumSkip test model"""
+    prediction_outputs = []
+    for prediction_input in inputs:
+        features = prediction_input.getFeatures()
+        result = 0.0
+        for i in range(features.size()):
+            if i != 0:
+                result += features.get(i).getValue().asNumber()
+        output = [Output("sum-but0", Type.NUMBER, Value(result), 1.0)]
+        prediction_output = PredictionOutput(output)
+        prediction_outputs.append(prediction_output)
+    return prediction_outputs

tests/test_counterfactualexplainer.py

@@ -1,3 +1,5 @@
+# pylint: disable=import-error, wrong-import-position, wrong-import-order, R0801
+"""Test suite for counterfactual explanations"""
 import os
 import sys
 import uuid
@@ -7,17 +9,23 @@
 
 import trustyai
 
-trustyai.init(path=[
-    "./dep/org/kie/kogito/explainability-core/1.8.0.Final/*",
-    "./dep/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar",
-    "./dep/org/apache/commons/commons-lang3/3.12.0/commons-lang3-3.12.0.jar",
-    "./dep/org/optaplanner/optaplanner-core/8.8.0.Final/optaplanner-core-8.8.0.Final.jar",
-    "./dep/org/apache/commons/commons-math3/3.6.1/commons-math3-3.6.1.jar",
-    "./dep/org/kie/kie-api/7.55.0.Final/kie-api-7.55.0.Final.jar",
-    "./dep/io/micrometer/micrometer-core/1.6.6/micrometer-core-1.6.6.jar",
-])
-
-from trustyai.local.counterfactual import CounterfactualExplainer, CounterfactualConfigurationFactory
+trustyai.init(
+    path=[
+        "./dep/org/kie/kogito/explainability-core/1.8.0.Final/*",
+        "./dep/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar",
+        "./dep/org/apache/commons/commons-lang3/3.12.0/commons-lang3-3.12.0.jar",
+        "./dep/org/optaplanner/optaplanner-core/8.8.0.Final/optaplanner-core-8.8.0.Final.jar",
+        "./dep/org/apache/commons/commons-math3/3.6.1/commons-math3-3.6.1.jar",
+        "./dep/org/kie/kie-api/7.55.0.Final/kie-api-7.55.0.Final.jar",
+        "./dep/io/micrometer/micrometer-core/1.6.6/micrometer-core-1.6.6.jar",
+    ]
+)
+
+from trustyai.local.counterfactual import (
+    CounterfactualExplainer,
+    CounterfactualConfigurationFactory,
+)
+from trustyai.utils import TestUtils, Config
 from trustyai.model.domain import NumericalFeatureDomain
 from trustyai.model import (
     CounterfactualPrediction,
@@ -32,81 +40,88 @@
 )
 from java.util import Random
 from java.lang import Long
-from trustyai.utils import TestUtils, Config
+
 from org.optaplanner.core.config.solver.termination import TerminationConfig
 
 jrandom = Random()
 jrandom.setSeed(0)
 
 
-def mockFeature(d):
-    return FeatureFactory.newNumericalFeature("f-num", d)
-
-
-def sumSkipModel(inputs):
-    """SumSkip test model"""
-    prediction_outputs = []
-    for predictionInput in inputs:
-        features = predictionInput.getFeatures()
-        result = 0.0
-        for i in range(features.size()):
-            if i != 0:
-                result += features.get(i).getValue().asNumber()
-        o = [Output(f"sum-but0", Type.NUMBER, Value(result), 1.0)]
-        prediction_output = PredictionOutput(o)
-        prediction_outputs.append(prediction_output)
-    return prediction_outputs
-
-
-def runCounterfactualSearch(goal,
-                            constraints,
-                            dataDomain,
-                            features,
-                            model):
-    terminationConfig = TerminationConfig().withScoreCalculationCountLimit(Long.valueOf(10_000))
-    solverConfig = CounterfactualConfigurationFactory \
-        .builder().withTerminationConfig(terminationConfig).build()
-
-    explainer = CounterfactualExplainer \
-        .builder() \
-        .withSolverConfig(solverConfig) \
+def run_counterfactual_search(goal, constraints, data_domain, features, model):
+    """Creates a CF explainer and returns a result"""
+    termination_config = TerminationConfig().withScoreCalculationCountLimit(
+        Long.valueOf(10_000)
+    )
+    solver_config = (
+        CounterfactualConfigurationFactory.builder()
+        .withTerminationConfig(termination_config)
         .build()
-    input = PredictionInput(features)
+    )
+
+    explainer = (
+        CounterfactualExplainer.builder().withSolverConfig(solver_config).build()
+    )
+    input_ = PredictionInput(features)
     output = PredictionOutput(goal)
-    domain = PredictionFeatureDomain(dataDomain.getFeatureDomains())
-    prediction = CounterfactualPrediction(input, output, domain, constraints, None, uuid.uuid4())
-    return explainer.explainAsync(prediction, model) \
-        .get(Config.INSTANCE.getAsyncTimeout(), Config.INSTANCE.getAsyncTimeUnit())
+    domain = PredictionFeatureDomain(data_domain.getFeatureDomains())
+    prediction = CounterfactualPrediction(
+        input_, output, domain, constraints, None, uuid.uuid4()
+    )
+    return explainer.explainAsync(prediction, model).get(
+        Config.INSTANCE.getAsyncTimeout(), Config.INSTANCE.getAsyncTimeUnit()
+    )
 
 
-def testNonEmptyInput():
+def test_non_empty_input():
     """Checks whether the returned CF entities are not null"""
-    termination_config = TerminationConfig().withScoreCalculationCountLimit(Long.valueOf(1000))
-    solver_config = CounterfactualConfigurationFactory.builder().withTerminationConfig(termination_config).build()
+    termination_config = TerminationConfig().withScoreCalculationCountLimit(
+        Long.valueOf(1000)
+    )
+    solver_config = (
+        CounterfactualConfigurationFactory.builder()
+        .withTerminationConfig(termination_config)
+        .build()
+    )
     n_features = 10
-    explainer = CounterfactualExplainer.builder().withSolverConfig(solver_config).build()
-    goal = [Output(f"f-num{i + 1}", Type.NUMBER, Value(10.0), 0.0) for i in range(n_features - 1)]
-    features = [FeatureFactory.newNumericalFeature(f"f-num{i}", i * 2.0) for i in range(n_features)]
+    explainer = (
+        CounterfactualExplainer.builder().withSolverConfig(solver_config).build()
+    )
+    goal = [
+        Output(f"f-num{i + 1}", Type.NUMBER, Value(10.0), 0.0)
+        for i in range(n_features - 1)
+    ]
+    features = [
+        FeatureFactory.newNumericalFeature(f"f-num{i}", i * 2.0)
+        for i in range(n_features)
+    ]
     constraints = [False] * n_features
     feature_boundaries = [NumericalFeatureDomain.create(0.0, 1000.0)] * n_features
 
     model = TestUtils.getSumSkipModel(0)
     _input = PredictionInput(features)
     output = PredictionOutput(goal)
-    prediction = CounterfactualPrediction(_input, output, PredictionFeatureDomain(feature_boundaries), constraints,
-                                          None,
-                                          uuid.uuid4())
+    prediction = CounterfactualPrediction(
+        _input,
+        output,
+        PredictionFeatureDomain(feature_boundaries),
+        constraints,
+        None,
+        uuid.uuid4(),
+    )
 
     counterfactual_result = explainer.explainAsync(prediction, model).get()
     for entity in counterfactual_result.getEntities():
         print(entity)
         assert entity is not None
 
 
-def testCounterfactualMatch():
+def test_counterfactual_match():
+    """Test if there's a valid counterfactual"""
     goal = [Output("inside", Type.BOOLEAN, Value(True), 0.0)]
 
-    features = [FeatureFactory.newNumericalFeature(f"f-num{i+1}", 10.0) for i in range(4)]
+    features = [
+        FeatureFactory.newNumericalFeature(f"f-num{i+1}", 10.0) for i in range(4)
+    ]
     constraints = [False] * 4
     feature_boundaries = [NumericalFeatureDomain.create(0.0, 1000.0)] * 4
 
@@ -115,11 +130,13 @@ def testCounterfactualMatch():
     center = 500.0
     epsilon = 10.0
 
-    result = \
-        runCounterfactualSearch(goal,
-                                constraints,
-                                data_domain, features,
-                                TestUtils.getSumThresholdModel(center, epsilon))
+    result = run_counterfactual_search(
+        goal,
+        constraints,
+        data_domain,
+        features,
+        TestUtils.getSumThresholdModel(center, epsilon),
+    )
 
     total_sum = 0
     for entity in result.getEntities():

tests/test_datautils.py

@@ -1,7 +1,8 @@
-import sys, os
-import pytest
+# pylint: disable=import-error, wrong-import-position, wrong-import-order, invalid-name
+"""Data utils test suite"""
+import sys
+import os
 from pytest import approx
-import math
 import random
 
 myPath = os.path.dirname(os.path.abspath(__file__))
@@ -12,23 +13,26 @@
 trustyai.init()
 
 from trustyai.utils import DataUtils
-from trustyai.model import PerturbationContext, Feature, FeatureFactory
+from trustyai.model import PerturbationContext, FeatureFactory
 from java.util import Random
 
 jrandom = Random()
 
 
-def test_GetMean():
+def test_get_mean():
+    """Test GetMean"""
     data = [2, 4, 3, 5, 1]
     assert DataUtils.getMean(data) == approx(3, 1e-6)
 
 
-def test_GetStdDev():
+def test_get_std_dev():
+    """Test GetStdDev"""
     data = [2, 4, 3, 5, 1]
     assert DataUtils.getStdDev(data, 3) == approx(1.41, 1e-2)
 
 
-def test_GaussianKernel():
+def test_gaussian_kernel():
+    """Test Gaussian Kernel"""
     x = 0.0
     k = DataUtils.gaussianKernel(x, 0, 1)
     assert k == approx(0.398, 1e-2)
@@ -37,28 +41,32 @@ def test_GaussianKernel():
     assert k == approx(0.389, 1e-2)
 
 
-def test_EuclideanDistance():
+def test_euclidean_distance():
+    """Test Euclidean distance"""
     x = [1, 1]
     y = [2, 3]
     distance = DataUtils.euclideanDistance(x, y)
-    assert 2.236 == approx(distance, 1e-3)
+    assert approx(distance, 1e-3) == 2.236
 
 
-def test_HammingDistanceDouble():
+def test_hamming_distance_double():
+    """Test Hamming distance for doubles"""
     x = [2, 1]
     y = [2, 3]
     distance = DataUtils.hammingDistance(x, y)
     assert distance == approx(1, 1e-1)
 
 
-def test_HammingDistanceString():
+def test_hamming_distance_string():
+    """Test Hamming distance for strings"""
     x = "test1"
     y = "test2"
     distance = DataUtils.hammingDistance(x, y)
     assert distance == approx(1, 1e-1)
 
 
-def test_DoublesToFeatures():
+def test_doubles_to_features():
+    """Test doubles to features"""
     inputs = [1 if i % 2 == 0 else 0 for i in range(10)]
     features = DataUtils.doublesToFeatures(inputs)
     assert features is not None
@@ -69,36 +77,41 @@ def test_DoublesToFeatures():
         assert f.getValue() is not None
 
 
-def test_ExponentialSmoothingKernel():
+def test_exponential_smoothing_kernel():
+    """Test exponential smoothing kernel"""
     x = 0.218
     k = DataUtils.exponentialSmoothingKernel(x, 2)
     assert k == approx(0.994, 1e-3)
 
 
-def test_PerturbFeaturesEmpty():
+def test_perturb_features_empty():
+    """Test perturb empty features"""
     features = []
     perturbationContext = PerturbationContext(jrandom, 0)
     newFeatures = DataUtils.perturbFeatures(features, perturbationContext)
     assert newFeatures is not None
     assert len(features) == newFeatures.size()
 
 
-def testRandomDistributionGeneration():
+def test_random_distribution_generation():
+    """Test random distribution generation"""
     dataDistribution = DataUtils.generateRandomDataDistribution(10, 10, jrandom)
     assert dataDistribution is not None
     assert dataDistribution.asFeatureDistributions() is not None
     for featureDistribution in dataDistribution.asFeatureDistributions():
         assert featureDistribution is not None
 
 
-def testLinearizedNumericFeatures():
+def test_linearized_numeric_features():
+    """Test linearised numeric features"""
     f = FeatureFactory.newNumericalFeature("f-num", 1.0)
     features = [f]
     linearizedFeatures = DataUtils.getLinearizedFeatures(features)
     assert len(features) == linearizedFeatures.size()
 
 
-def testSampleWithReplacement():
+def test_sample_with_replacement():
+    """Test sample with replacement"""
     emptyValues = []
     emptySamples = DataUtils.sampleWithReplacement(emptyValues, 1, jrandom)
     assert emptySamples is not None