🐛 Fixes linter and deap bugs

digneapy/archives/_grid_archive.py

@@ -13,7 +13,6 @@
 import copy
 import json
 from collections.abc import Iterable, Sequence
-from operator import attrgetter
 from typing import Dict, Optional, Tuple
 
 import numpy as np
@@ -134,7 +133,7 @@ def coverage(self):
 
     @property
     def filled_cells(self):
-        return len(self._grid)
+        return self._grid.keys()
 
     @property
     def instances(self):

digneapy/core/instance.py

@@ -15,7 +15,7 @@
 import reprlib
 from collections.abc import Iterable
 from functools import reduce
-from typing import Optional, TypeVar
+from typing import Optional
 
 import numpy as np
 

digneapy/core/solution.py

@@ -12,7 +12,7 @@
 
 import operator
 from collections.abc import Iterable
-from typing import Optional, TypeVar
+from typing import Optional
 
 
 class Solution:

digneapy/domains/bin_packing.py

@@ -205,8 +205,8 @@ def extract_features(self, instance: Instance) -> tuple:
         Returns:
             Tuple[float]: Values of each feature
         """
-        capacity = instance._variables[0]
-        vars = np.asarray(instance._variables[1:])
+        capacity = instance.variables[0]
+        vars = np.asarray(instance.variables[1:])
         vars_norm = vars / capacity
         huge = sum(k > 0.5 for k in vars_norm) / self._dimension
         large = sum(0.5 >= k > 1 / 3 for k in vars_norm) / self._dimension
@@ -242,8 +242,8 @@ def extract_features_as_dict(self, instance: Instance) -> Mapping[str, float]:
         return {k: v for k, v in zip(names.split(","), features)}
 
     def from_instance(self, instance: Instance) -> BPP:
-        items = instance._variables[1:]
-        capacity = int(instance._variables[0])
+        items = instance.variables[1:]
+        capacity = int(instance.variables[0])
         # Sets the capacity according to the method
         match self.capacity_approach:
             case "percentage":
@@ -252,5 +252,5 @@ def from_instance(self, instance: Instance) -> BPP:
                 capacity = self._max_capacity
 
         # The BPP capacity must be updated JIC
-        instance._variables[0] = capacity
+        instance.variables[0] = capacity
         return BPP(items=items, capacity=int(capacity))

digneapy/operators/replacement.py

@@ -105,4 +105,4 @@ def elitist_replacement(
         reverse=True,
     )
     top = combined_population[:hof]
-    return list(top, *offspring[1:])
+    return list(top + offspring[1:])

digneapy/qd/_desc_strategies.py

@@ -53,7 +53,7 @@ def features_strategy(iterable: Iterable[Instance]) -> np.ndarray:
     Returns:
         np.ndarray: Array of the feature descriptors of each instance
     """
-    return np.asarray([i._descriptor for i in iterable])
+    return np.asarray([i.descriptor for i in iterable])
 
 
 def performance_strategy(iterable: Iterable[Instance]) -> np.ndarray:

digneapy/solvers/evolutionary.py

@@ -93,7 +93,7 @@ def __init__(
         self._toolbox.register("mutate", mut, low=min_g, up=max_g, indpb=(1.0 / dim))
         self._toolbox.register("select", tools.selTournament, tournsize=2)
 
-        self._stats = tools.Statistics(key=attrgetter("fitness"))
+        self._stats = tools.Statistics(key=lambda ind: ind.fitness.values)
         self._stats.register("avg", np.mean)
         self._stats.register("std", np.std)
         self._stats.register("min", np.min)

setup.py

@@ -10,9 +10,6 @@
 with open("README.md") as readme_file:
     readme = readme_file.read()
 
-with open("HISTORY.md") as history_file:
-    history = history_file.read()
-
 requirements = []
 
 test_requirements = [
@@ -79,7 +76,7 @@ def __str__(self):
     description="Python version of the DIGNEA code for instance generation",
     install_requires=requirements,
     license="GNU General Public License v3",
-    long_description=readme + "\n\n" + history,
+    long_description=readme + "\n\n",
     include_package_data=True,
     keywords=[
         "dignea",

tests/core/test_instance.py

@@ -33,7 +33,7 @@ def test_default_instance_attrs(default_instance):
     assert default_instance.p == 0.0
     assert default_instance.s == 0.0
     assert default_instance.fitness == 0.0
-    np.testing.assert_array_equal(default_instance._variables, np.zeros(0))
+    np.testing.assert_array_equal(default_instance.variables, np.zeros(0))
     assert not default_instance.descriptor
     assert not default_instance.portfolio_scores
 
@@ -89,14 +89,14 @@ def test_init_instance(initialised_instance):
     assert initialised_instance.s == 0.0
     assert initialised_instance.fitness == 0.0
     expected = np.asarray(list(range(100)))
-    np.testing.assert_array_equal(initialised_instance._variables, expected)
+    np.testing.assert_array_equal(initialised_instance.variables, expected)
     assert not initialised_instance.descriptor
     assert not initialised_instance.portfolio_scores
 
 
 def test_properties(initialised_instance):
     assert not initialised_instance.portfolio_scores
-    performances = list(range(4))
+    performances = tuple(range(4))
     initialised_instance.portfolio_scores = performances
     assert initialised_instance.portfolio_scores == performances
 
@@ -109,10 +109,16 @@ def test_properties(initialised_instance):
 def test_equal_instances(initialised_instance, default_instance):
     assert not initialised_instance == default_instance
     instance_2 = copy.copy(initialised_instance)
+
     assert initialised_instance == instance_2
-    assert default_instance.__eq__(list()) == NotImplemented
-    assert default_instance.__gt__(list()) == NotImplemented
-    assert default_instance.__ge__(list()) == NotImplemented
+
+    with pytest.raises(NotImplementedError) as _:
+        _ = default_instance == list()
+    with pytest.raises(NotImplementedError) as _:
+        _ = default_instance >= list()
+    with pytest.raises(NotImplementedError) as _:
+        _ = default_instance > list()
+
     instance_2.fitness = default_instance.fitness + 100.0
     assert instance_2 >= default_instance
 

tests/domains/test_bpp_domain.py

@@ -91,8 +91,8 @@ def test_bpp_domain_to_features():
     instance = domain.generate_instance()
     features = domain.extract_features(instance)
 
-    capacity = instance._variables[0]
-    items = np.asarray(instance._variables[1:])
+    capacity = instance.variables[0]
+    items = np.asarray(instance.variables[1:])
     items_norm = items / capacity
 
     assert isinstance(features, tuple)
@@ -107,8 +107,8 @@ def test_bpp_domain_to_features():
 
     domain.capacity_approach = "evolved"
     features = domain.extract_features(instance)
-    new_capacity = instance._variables[0]
-    items = np.asarray(instance._variables[1:])
+    new_capacity = instance.variables[0]
+    items = np.asarray(instance.variables[1:])
     items_norm = items / new_capacity
     expected_f = (
         np.mean(items_norm),
@@ -121,8 +121,8 @@ def test_bpp_domain_to_features():
 
     domain.capacity_approach = "percentage"
     features = domain.extract_features(instance)
-    new_capacity = instance._variables[0]
-    items = np.asarray(instance._variables[1:])
+    new_capacity = instance.variables[0]
+    items = np.asarray(instance.variables[1:])
     items_norm = items / new_capacity
     expected_f = (
         np.mean(items_norm),
@@ -132,7 +132,7 @@ def test_bpp_domain_to_features():
         np.min(items_norm),
     )
     assert expected_f == features[:5]
-    assert instance._variables[0] == new_capacity
+    assert instance.variables[0] == new_capacity
 
 
 def test_bpp_domain_to_features_dict():
@@ -141,8 +141,8 @@ def test_bpp_domain_to_features_dict():
     instance = domain.generate_instance()
     features = domain.extract_features_as_dict(instance)
 
-    capacity = instance._variables[0]
-    items = np.asarray(instance._variables[1:])
+    capacity = instance.variables[0]
+    items = np.asarray(instance.variables[1:])
     items_norm = items / capacity
 
     assert isinstance(features, dict)
@@ -179,10 +179,10 @@ def test_bpp_domain_to_instance():
     bpp_instance = domain.from_instance(instance)
     assert len(bpp_instance._items) == dimension
     assert len(bpp_instance) == dimension
-    items = instance._variables[1:]
+    items = instance.variables[1:]
     expected_q = np.sum(items) * domain.capacity_ratio
-    assert instance._variables[0] == bpp_instance._capacity
-    assert instance._variables[0] == int(expected_q)
+    assert instance.variables[0] == bpp_instance._capacity
+    assert instance.variables[0] == int(expected_q)
     assert bpp_instance._capacity == int(expected_q)
 
 
@@ -200,4 +200,4 @@ def test_bpp_problem(default_bpp):
 
     instance = default_bpp.to_instance()
     expected_vars = [default_bpp._capacity, *default_bpp._items]
-    assert all(v_i == e_i for v_i, e_i in zip(instance._variables, expected_vars))
+    assert all(v_i == e_i for v_i, e_i in zip(instance.variables, expected_vars))

tests/domains/test_knapsack_domain.py

@@ -102,16 +102,16 @@ def test_kp_domain_to_features():
     assert features[3] >= 1
     assert features[4] >= 1
     assert features[-3] != 0.0
-    assert features[-2] == np.mean(instance._variables[1:])
-    assert features[-1] == np.std(instance._variables[1:])
+    assert features[-2] == np.mean(instance.variables[1:])
+    assert features[-1] == np.std(instance.variables[1:])
 
     domain.capacity_approach = "evolved"
     features = domain.extract_features(instance)
     assert features[0] == instance[0]
 
     domain.capacity_approach = "percentage"
     features = domain.extract_features(instance)
-    expected_q = int(np.sum(instance._variables[1::2]) * 0.8)
+    expected_q = int(np.sum(instance.variables[1::2]) * 0.8)
     assert features[0] == expected_q
 
 
@@ -127,8 +127,8 @@ def test_kp_domain_to_features_dict():
     assert features["min_w"] >= 1
     assert features["min_p"] >= 1
     assert features["avg_eff"] != 0.0
-    assert features["mean"] == np.mean(instance._variables[1:])
-    assert features["std"] == np.std(instance._variables[1:])
+    assert features["mean"] == np.mean(instance.variables[1:])
+    assert features["std"] == np.std(instance.variables[1:])
 
 
 def test_kp_domain_to_instance():
@@ -171,4 +171,4 @@ def test_knapsack_to_instance(default_kp):
         itertools.chain.from_iterable([*zip(default_kp.weights, default_kp.profits)])
     )
     instance = default_kp.to_instance()
-    np.testing.assert_array_equal(instance._variables, expected_vars)
+    np.testing.assert_array_equal(instance.variables, expected_vars)

tests/generators/test_generator.py

@@ -113,7 +113,7 @@ def test_eig_gen_kp_perf_descriptor():
         assert all(s.s >= 0.0 for s in archive)
         assert all(len(s.descriptor) == len(portfolio) for s in archive)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in archive)
-        p_scores = [s._portfolio_m for s in archive]
+        p_scores = [s.portfolio_scores for s in archive]
         # The instances are biased to the performance of the target
         assert all(max(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))
 
@@ -124,7 +124,7 @@ def test_eig_gen_kp_perf_descriptor():
         assert all(s.s >= 0.0 for s in solution_set)
         assert all(len(s.descriptor) == len(portfolio) for s in solution_set)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in solution_set)
-        p_scores = [s._portfolio_m for s in solution_set]
+        p_scores = [s.portfolio_scores for s in solution_set]
         assert all(max(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))
 
 
@@ -155,7 +155,7 @@ def test_eig_gen_kp_feat_descriptor():
         assert all(s.s >= 0.0 for s in archive)
         assert all(len(s.descriptor) == 8 for s in archive)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in archive)
-        p_scores = [s._portfolio_m for s in archive]
+        p_scores = [s.portfolio_scores for s in archive]
         # The instances are biased to the performance of the target
         assert all(max(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))
 
@@ -166,7 +166,7 @@ def test_eig_gen_kp_feat_descriptor():
         assert all(s.s >= 0.0 for s in solution_set)
         assert all(len(s.descriptor) == 8 for s in solution_set)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in solution_set)
-        p_scores = [s._portfolio_m for s in solution_set]
+        p_scores = [s.portfolio_scores for s in solution_set]
         assert all(max(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))
 
     # Test the creation of the evolution images
@@ -207,7 +207,7 @@ def test_eig_gen_kp_inst_descriptor():
             len(s.descriptor) == len(s) for s in archive
         )  # Because we do not calculate features in this case
         assert all(len(s.portfolio_scores) == len(portfolio) for s in archive)
-        p_scores = [s._portfolio_m for s in archive]
+        p_scores = [s.portfolio_scores for s in archive]
         # The instances are biased to the performance of the target
         assert all(max(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))
 
@@ -218,7 +218,7 @@ def test_eig_gen_kp_inst_descriptor():
         assert all(s.s >= 0.0 for s in solution_set)
         assert all(len(s.descriptor) == len(s) for s in solution_set)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in solution_set)
-        p_scores = [s._portfolio_m for s in solution_set]
+        p_scores = [s.portfolio_scores for s in solution_set]
         assert all(max(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))
 
 
@@ -250,7 +250,7 @@ def test_eig_gen_kp_perf_descriptor_with_pisinger():
         assert all(s.s >= 0.0 for s in archive)
         assert all(len(s.descriptor) == len(portfolio) for s in archive)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in archive)
-        p_scores = [s._portfolio_m for s in archive]
+        p_scores = [s.portfolio_scores for s in archive]
         # The instances are biased to the performance of the target
         # in this case, the performance score is the minimum because
         # we are measuring running time
@@ -263,5 +263,5 @@ def test_eig_gen_kp_perf_descriptor_with_pisinger():
         assert all(s.s >= 0.0 for s in solution_set)
         assert all(len(s.descriptor) == len(portfolio) for s in solution_set)
         assert all(len(s.portfolio_scores) == len(portfolio) for s in solution_set)
-        p_scores = [s._portfolio_m for s in solution_set]
+        p_scores = [s.portfolio_scores for s in solution_set]
         assert all(min(p_scores[i]) == p_scores[i][0] for i in range(len(p_scores)))

tests/operators/test_selections.py

@@ -10,10 +10,6 @@
 @Desc    :   None
 """
 
-import copy
-import itertools
-from operator import attrgetter
-
 import numpy as np
 import pytest