feat(checks): add operator composition and utility functions

[mvanhorn]

Summary

Adds ergonomic composition for checks via Python operators and utility functions, as requested in #2395.

Changes

Operator overloads on Check base class (core/check.py)

• check_a & check_b creates AllOf(checks=[check_a, check_b]) (flattens nested AllOf)
• check_a | check_b creates AnyOf(checks=[check_a, check_b]) (flattens nested AnyOf)
• ~check_a creates Not(check=check_a)

Utility functions (builtin/composition.py)

• all_of(*checks) - variadic AllOf constructor
• any_of(*checks) - variadic AnyOf constructor
• expect_fails(check) - readable alias for Not

Exports

• All three utilities exported from giskard.checks

Before/After

# Before
AllOf(checks=[Equals(expected_value="x", key="k"), Not(check=Equals(expected_value="y", key="k"))])

# After (utilities)
all_of(Equals(expected_value="x", key="k"), expect_fails(Equals(expected_value="y", key="k")))

# After (operators)
Equals(expected_value="x", key="k") & ~Equals(expected_value="y", key="k")

The existing AllOf, AnyOf, Not classes and their serialization are unchanged. Operators and utilities produce the same model instances.

Closes #2395

This contribution was developed with AI assistance (Claude Code).

[gemini-code-assist]

Code Review

This pull request introduces composition utilities for checks, adding functional helpers like all_of, any_of, and expect_fails, along with operator overloading (&, |, ~) for the base Check class to allow for more intuitive check combinations. The review feedback recommends replacing string-based class name comparisons with isinstance() checks in the __and__ and __or__ methods to improve code robustness and better support static analysis tools.

[gemini-code-assist]

Using isinstance() is preferred over comparing __class__.__name__ strings. It is more robust, idiomatic (PEP 8), and allows static analysis tools to correctly narrow the types of self and other. This ensures that the checks attribute is recognized by linters and avoids potential NameError issues with the Check type hint inside the class definition.

Suggested change

	from ..builtin.composition import AllOf
	my_checks: list[Check] = (
	list(self.checks) if hasattr(self, "checks") and self.__class__.__name__ == "AllOf" else [self]
	)
	other_checks: list[Check] = (
	list(other.checks) if hasattr(other, "checks") and other.__class__.__name__ == "AllOf" else [other]
	)
	return AllOf(checks=my_checks + other_checks)
	from ..builtin.composition import AllOf
	my_checks = list(self.checks) if isinstance(self, AllOf) else [self]
	other_checks = list(other.checks) if isinstance(other, AllOf) else [other]
	return AllOf(checks=my_checks + other_checks)

[gemini-code-assist]

Using isinstance() is preferred over comparing __class__.__name__ strings. It is more robust, idiomatic (PEP 8), and allows static analysis tools to correctly narrow the types of self and other. This ensures that the checks attribute is recognized by linters and avoids potential NameError issues with the Check type hint inside the class definition.

Suggested change

	from ..builtin.composition import AnyOf
	my_checks: list[Check] = (
	list(self.checks) if hasattr(self, "checks") and self.__class__.__name__ == "AnyOf" else [self]
	)
	other_checks: list[Check] = (
	list(other.checks) if hasattr(other, "checks") and other.__class__.__name__ == "AnyOf" else [other]
	)
	return AnyOf(checks=my_checks + other_checks)
	from ..builtin.composition import AnyOf
	my_checks = list(self.checks) if isinstance(self, AnyOf) else [self]
	other_checks = list(other.checks) if isinstance(other, AnyOf) else [other]
	return AnyOf(checks=my_checks + other_checks)

[mvanhorn]

Applied in 730102b - swapped both __class__.__name__ checks for isinstance(). AllOf/AnyOf are already imported inside the methods, so no scope change needed. The redundant hasattr(self, "checks") guard is also gone since isinstance(x, AllOf) already implies .checks exists.