Fix warnings introduced by upgrades

Signed-off-by: Beat Buesser <beat.buesser@ibm.com>

Author: beat-buesser

.github/workflows/ci-style-checks.yml

@@ -49,16 +49,13 @@ jobs:
         run: pycodestyle --ignore=C0330,C0415,E203,E231,W503 --max-line-length=120 art
       - name: pylint
         if: ${{ always() }}
-        run: pylint --disable=C0330,C0415,E203,E1136,E0401,E1102 -rn art
+        run: pylint --fail-under=9.67 art/
       - name: mypy
         if: ${{ always() }}
         run: mypy art
       - name: ruff
         if: ${{ always() }}
-        run: |
-          ruff check art/
-          ruff check tests/
-          ruff check examples/
+        run: ruff check art/ tests/ examples/
       - name: black
         if: ${{ always() }}
         run: |

.pylintrc

@@ -109,7 +109,15 @@ disable=
     # We anticipate #3512 where it will become optional
     fixme,
     consider-using-assignment-expr,
-
+    # ART
+    duplicate-code,
+    no-member,
+    import-outside-toplevel,
+    import-error,
+    not-callable,
+    too-many-arguments,
+    too-many-locals,
+    unsupported-binary-operation,
 
 [REPORTS]
 

art/__init__.py

@@ -15,8 +15,6 @@
 # Semantic Version
 __version__ = "1.18.1"
 
-# pylint: disable=C0103
-
 LOGGING = {
     "version": 1,
     "disable_existing_loggers": False,

art/attacks/attack.py

@@ -18,11 +18,11 @@
 """
 This module implements the abstract base classes for all attacks.
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
+from __future__ import absolute_import, division, print_function, unicode_literals, annotations
 
 import abc
 import logging
-from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 
@@ -38,17 +38,18 @@
 
 class InputFilter(abc.ABCMeta):  # pragma: no cover
     """
-    Metaclass to ensure that inputs are ndarray for all of the subclass generate and extract calls
+    Metaclass to ensure that inputs are ndarray for all the subclass generate and extract calls
     """
 
-    # pylint: disable=W0613
-    def __init__(cls, name, bases, clsdict):  # pylint: disable=W0231
+    def __init__(cls, name, bases, clsdict):
         """
         This function overrides any existing generate or extract methods with a new method that
         ensures the input is an `np.ndarray`. There is an assumption that the input object has implemented
         __array__ with np.array calls.
         """
 
+        super().__init__()
+
         def make_replacement(fdict, func_name):
             """
             This function overrides creates replacement functions dynamically
@@ -94,17 +95,17 @@ class Attack(abc.ABC):
     Abstract base class for all attack abstract base classes.
     """
 
-    attack_params: List[str] = []
+    attack_params: list[str] = []
     # The _estimator_requirements define the requirements an estimator must satisfy to be used as a target for an
     # attack. They should be a tuple of requirements, where each requirement is either a class the estimator must
     # inherit from, or a tuple of classes which define a union, i.e. the estimator must inherit from at least one class
     # in the requirement tuple.
-    _estimator_requirements: Optional[Union[Tuple[Any, ...], Tuple[()]]] = None
+    _estimator_requirements: tuple[Any, ...] | tuple[()] | None = None
 
     def __init__(
         self,
         estimator,
-        summary_writer: Union[str, bool, SummaryWriter] = False,
+        summary_writer: str | bool | SummaryWriter = False,
     ):
         """
         :param estimator: An estimator.
@@ -126,7 +127,7 @@ def __init__(
 
         self._estimator = estimator
         self._summary_writer_arg = summary_writer
-        self._summary_writer: Optional[SummaryWriter] = None
+        self._summary_writer: SummaryWriter | None = None
 
         if isinstance(summary_writer, SummaryWriter):  # pragma: no cover
             self._summary_writer = summary_writer
@@ -212,13 +213,13 @@ def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
 
     @abc.abstractmethod
-    def generate(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+    def generate(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> np.ndarray:
         """
         Generate adversarial examples and return them as an array. This method should be overridden by all concrete
         evasion attack implementations.
 
         :param x: An array with the original inputs to be attacked.
-        :param y: Correct labels or target labels for `x`, depending if the attack is targeted
+        :param y: Correct labels or target labels for `x`, depending on if the attack is targeted
                   or not. This parameter is only used by some of the attacks.
         :return: An array holding the adversarial examples.
         """
@@ -241,14 +242,14 @@ class PoisoningAttack(Attack):
     Abstract base class for poisoning attack classes
     """
 
-    def __init__(self, classifier: Optional["CLASSIFIER_TYPE"]) -> None:
+    def __init__(self, classifier: "CLASSIFIER_TYPE" | None) -> None:
         """
         :param classifier: A trained classifier (or none if no classifier is needed)
         """
         super().__init__(classifier)
 
     @abc.abstractmethod
-    def poison(self, x: np.ndarray, y=Optional[np.ndarray], **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def poison(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> tuple[np.ndarray, np.ndarray]:
         """
         Generate poisoning examples and return them as an array. This method should be overridden by all concrete
         poisoning attack implementations.
@@ -310,14 +311,8 @@ class PoisoningAttackTransformer(PoisoningAttack):
     These attacks have an additional method, `poison_estimator`, that returns the poisoned classifier.
     """
 
-    def __init__(self, classifier: Optional["CLASSIFIER_TYPE"]) -> None:
-        """
-        :param classifier: A trained classifier (or none if no classifier is needed)
-        """
-        super().__init__(classifier)
-
     @abc.abstractmethod
-    def poison(self, x: np.ndarray, y=Optional[np.ndarray], **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def poison(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> tuple[np.ndarray, np.ndarray]:
         """
         Generate poisoning examples and return them as an array. This method should be overridden by all concrete
         poisoning attack implementations.
@@ -354,16 +349,16 @@ def __init__(self):
     @abc.abstractmethod
     def poison(
         self,
-        x: Union[np.ndarray, List[np.ndarray]],
-        y: List[Dict[str, np.ndarray]],
+        x: np.ndarray | list[np.ndarray],
+        y: list[dict[str, np.ndarray]],
         **kwargs,
-    ) -> Tuple[Union[np.ndarray, List[np.ndarray]], List[Dict[str, np.ndarray]]]:
+    ) -> tuple[np.ndarray | list[np.ndarray], list[dict[str, np.ndarray]]]:
         """
         Generate poisoning examples and return them as an array. This method should be overridden by all concrete
         poisoning attack implementations.
 
         :param x: An array with the original inputs to be attacked.
-        :param y: True labels of type `List[Dict[np.ndarray]]`, one dictionary per input image.
+        :param y: True labels of type `list[dict[np.ndarray]]`, one dictionary per input image.
                   The keys and values of the dictionary are:
                   - boxes [N, 4]: the boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.
                   - labels [N]: the labels for each image
@@ -385,7 +380,7 @@ def __init__(self):
         super().__init__(None)  # type: ignore
 
     @abc.abstractmethod
-    def poison(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def poison(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> tuple[np.ndarray, np.ndarray]:
         """
         Generate poisoning examples and return them as an array. This method should be overridden by all concrete
         poisoning attack implementations.
@@ -403,7 +398,7 @@ class PoisoningAttackWhiteBox(PoisoningAttack):
     """
 
     @abc.abstractmethod
-    def poison(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def poison(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> tuple[np.ndarray, np.ndarray]:
         """
         Generate poisoning examples and return them as an array. This method should be overridden by all concrete
         poisoning attack implementations.
@@ -422,7 +417,7 @@ class ExtractionAttack(Attack):
     """
 
     @abc.abstractmethod
-    def extract(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> "CLASSIFIER_TYPE":
+    def extract(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> "CLASSIFIER_TYPE":
         """
         Extract models and return them as an ART classifier. This method should be overridden by all concrete extraction
         attack implementations.
@@ -448,7 +443,7 @@ def __init__(self, estimator):
         super().__init__(estimator)
 
     @abc.abstractmethod
-    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+    def infer(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> np.ndarray:
         """
         Infer sensitive attributes from the targeted estimator. This method
         should be overridden by all concrete inference attack implementations.
@@ -467,7 +462,7 @@ class AttributeInferenceAttack(InferenceAttack):
 
     attack_params = InferenceAttack.attack_params + ["attack_feature"]
 
-    def __init__(self, estimator, attack_feature: Union[int, slice] = 0):
+    def __init__(self, estimator, attack_feature: int | slice = 0):
         """
         :param estimator: A trained estimator targeted for inference attack.
         :type estimator: :class:`.art.estimators.estimator.BaseEstimator`
@@ -478,7 +473,7 @@ def __init__(self, estimator, attack_feature: Union[int, slice] = 0):
         self.attack_feature = get_feature_index(attack_feature)
 
     @abc.abstractmethod
-    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+    def infer(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> np.ndarray:
         """
         Infer sensitive attributes from the targeted estimator. This method
         should be overridden by all concrete inference attack implementations.
@@ -490,7 +485,7 @@ def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.n
         raise NotImplementedError
 
     @staticmethod
-    def _check_attack_feature(attack_feature: Union[int, slice]) -> None:
+    def _check_attack_feature(attack_feature: int | slice) -> None:
         if not isinstance(attack_feature, int) and not isinstance(attack_feature, slice):
             raise ValueError("Attack feature must be either an integer or a slice object.")
 
@@ -506,16 +501,8 @@ class MembershipInferenceAttack(InferenceAttack):
     Abstract base class for membership inference attack classes.
     """
 
-    def __init__(self, estimator):
-        """
-        :param estimator: A trained estimator targeted for inference attack.
-        :type estimator: :class:`.art.estimators.estimator.BaseEstimator`
-        :param attack_feature: The index of the feature to be attacked.
-        """
-        super().__init__(estimator)
-
     @abc.abstractmethod
-    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+    def infer(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> np.ndarray:
         """
         Infer membership status of samples from the target estimator. This method
         should be overridden by all concrete inference attack implementations.
@@ -552,7 +539,7 @@ def __init__(self, estimator):
         super().__init__(estimator)
 
     @abc.abstractmethod
-    def reconstruct(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def reconstruct(self, x: np.ndarray, y: np.ndarray | None = None, **kwargs) -> tuple[np.ndarray, np.ndarray]:
         """
         Reconstruct the training dataset of and from the targeted estimator. This method
         should be overridden by all concrete inference attack implementations.

art/attacks/evasion/__init__.py

@@ -2,7 +2,7 @@
 Module providing evasion attacks under a common interface.
 """
 
-# pylint: disable=C0413
+# pylint: disable=wrong-import-position
 import importlib
 
 from art.attacks.evasion.adversarial_patch.adversarial_patch import AdversarialPatch

art/attacks/evasion/adversarial_asr.py

@@ -72,10 +72,10 @@ def __init__(
         :param num_iter_decrease_eps: Iterations after which to decrease epsilon if attack succeeds (Paper default: 10).
         :param batch_size: Batch size.
         """
-        # pylint: disable=W0231
+        # pylint: disable=super-init-not-called
 
         # re-implement init such that inherited methods work
-        EvasionAttack.__init__(self, estimator=estimator)  # pylint: disable=W0233
+        EvasionAttack.__init__(self, estimator=estimator)  # pylint: disable=non-parent-init-called
         self.masker = None  # type: ignore
         self.eps = eps
         self.learning_rate_1 = learning_rate

art/attacks/evasion/adversarial_patch/adversarial_patch.py

@@ -21,10 +21,10 @@
 
 | Paper link: https://arxiv.org/abs/1712.09665
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
+from __future__ import absolute_import, division, print_function, unicode_literals, annotations
 
 import logging
-from typing import Optional, Tuple, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -71,7 +71,7 @@ def __init__(
         learning_rate: float = 5.0,
         max_iter: int = 500,
         batch_size: int = 16,
-        patch_shape: Optional[Tuple[int, int, int]] = None,
+        patch_shape: tuple[int | int | int] | None = None,
         targeted: bool = True,
         verbose: bool = True,
     ):
@@ -98,7 +98,7 @@ def __init__(
         if self.estimator.clip_values is None:  # pragma: no cover
             raise ValueError("Adversarial Patch attack requires a classifier with clip_values.")
 
-        self._attack: Union[AdversarialPatchTensorFlowV2, AdversarialPatchPyTorch, AdversarialPatchNumpy]
+        self._attack: AdversarialPatchTensorFlowV2 | AdversarialPatchPyTorch | AdversarialPatchNumpy
         if isinstance(self.estimator, TensorFlowV2Classifier):
             self._attack = AdversarialPatchTensorFlowV2(
                 classifier=classifier,
@@ -145,8 +145,8 @@ def __init__(
         self._check_params()
 
     def generate(  # type: ignore
-        self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs
-    ) -> Tuple[np.ndarray, np.ndarray]:
+        self, x: np.ndarray, y: np.ndarray | None = None, **kwargs
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Generate an adversarial patch and return the patch and its mask in arrays.
 
@@ -173,7 +173,7 @@ def generate(  # type: ignore
         return self._attack.generate(x=x, y=y, **kwargs)
 
     def apply_patch(
-        self, x: np.ndarray, scale: float, patch_external: Optional[np.ndarray] = None, **kwargs
+        self, x: np.ndarray, scale: float, patch_external: np.ndarray | None = None, **kwargs
     ) -> np.ndarray:
         """
         A function to apply the learned adversarial patch to images or videos.
@@ -185,7 +185,7 @@ def apply_patch(
         """
         return self._attack.apply_patch(x, scale, patch_external=patch_external, **kwargs)
 
-    def reset_patch(self, initial_patch_value: Optional[Union[float, np.ndarray]]) -> None:
+    def reset_patch(self, initial_patch_value: float | np.ndarray | None) -> None:
         """
         Reset the adversarial patch.