A few more

Author: Fokko

pyiceberg/expressions/__init__.py

@@ -20,7 +20,7 @@
 import builtins
 from abc import ABC, abstractmethod
 from functools import cached_property
-from typing import Any, Callable, Generic, Iterable, Sequence, cast
+from typing import Any, Callable, Iterable, Sequence, cast
 from typing import Literal as TypingLiteral
 
 from pydantic import ConfigDict, Field
@@ -489,7 +489,7 @@ def __getnewargs__(self) -> tuple[BoundTerm]:
 
 
 class BoundIsNull(BoundUnaryPredicate):
-    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore  # pylint: disable=W0221
+    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore[misc]  # pylint: disable=W0221
         if term.ref().field.required:
             return AlwaysFalse()
         return super().__new__(cls)
@@ -504,7 +504,7 @@ def as_unbound(self) -> type[IsNull]:
 
 
 class BoundNotNull(BoundUnaryPredicate):
-    def __new__(cls, term: BoundTerm):  # type: ignore  # pylint: disable=W0221
+    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore[misc]  # pylint: disable=W0221
         if term.ref().field.required:
             return AlwaysTrue()
         return super().__new__(cls)
@@ -543,7 +543,7 @@ def as_bound(self) -> builtins.type[BoundNotNull]:
 
 
 class BoundIsNaN(BoundUnaryPredicate):
-    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore  # pylint: disable=W0221
+    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore[misc]  # pylint: disable=W0221
         bound_type = term.ref().field.field_type
         if isinstance(bound_type, (FloatType, DoubleType)):
             return super().__new__(cls)
@@ -559,7 +559,7 @@ def as_unbound(self) -> type[IsNaN]:
 
 
 class BoundNotNaN(BoundUnaryPredicate):
-    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore  # pylint: disable=W0221
+    def __new__(cls, term: BoundTerm) -> BooleanExpression:  # type: ignore[misc]  # pylint: disable=W0221
         bound_type = term.ref().field.field_type
         if isinstance(bound_type, (FloatType, DoubleType)):
             return super().__new__(cls)
@@ -673,7 +673,7 @@ def as_unbound(self) -> type[SetPredicate]: ...
 
 
 class BoundIn(BoundSetPredicate):
-    def __new__(cls, term: BoundTerm, literals: set[LiteralValue]) -> BooleanExpression:  # type: ignore  # pylint: disable=W0221
+    def __new__(cls, term: BoundTerm, literals: set[LiteralValue]) -> BooleanExpression:  # type: ignore[misc]  # pylint: disable=W0221
         count = len(literals)
         if count == 0:
             return AlwaysFalse()
@@ -696,7 +696,7 @@ def as_unbound(self) -> type[In]:
 
 
 class BoundNotIn(BoundSetPredicate):
-    def __new__(  # type: ignore  # pylint: disable=W0221
+    def __new__(  # type: ignore[misc]  # pylint: disable=W0221
         cls,
         term: BoundTerm,
         literals: set[LiteralValue],
@@ -721,7 +721,7 @@ def as_unbound(self) -> type[NotIn]:
 class In(SetPredicate):
     type: TypingLiteral["in"] = Field(default="in", alias="type")
 
-    def __new__(  # type: ignore  # pylint: disable=W0221
+    def __new__(  # type: ignore[misc]  # pylint: disable=W0221
         cls, term: str | UnboundTerm, literals: Iterable[Any] | Iterable[LiteralValue]
     ) -> BooleanExpression:
         literals_set: set[LiteralValue] = _to_literal_set(literals)
@@ -745,7 +745,7 @@ def as_bound(self) -> builtins.type[BoundIn]:
 class NotIn(SetPredicate, ABC):
     type: TypingLiteral["not-in"] = Field(default="not-in", alias="type")
 
-    def __new__(  # type: ignore  # pylint: disable=W0221
+    def __new__(  # type: ignore[misc]  # pylint: disable=W0221
         cls, term: str | UnboundTerm, literals: Iterable[Any] | Iterable[LiteralValue]
     ) -> BooleanExpression:
         literals_set: set[LiteralValue] = _to_literal_set(literals)
@@ -766,17 +766,17 @@ def as_bound(self) -> builtins.type[BoundNotIn]:
         return BoundNotIn
 
 
-class LiteralPredicate(IcebergBaseModel, UnboundPredicate, Generic[L], ABC):
+class LiteralPredicate(IcebergBaseModel, UnboundPredicate, ABC):
     type: TypingLiteral["lt", "lt-eq", "gt", "gt-eq", "eq", "not-eq", "starts-with", "not-starts-with"] = Field(alias="type")
     term: UnboundTerm
-    value: Literal[L] = Field()
+    value: LiteralValue = Field()
     model_config = ConfigDict(populate_by_name=True, frozen=True, arbitrary_types_allowed=True)
 
-    def __init__(self, term: str | UnboundTerm, literal: L | Literal[L]):
+    def __init__(self, term: str | UnboundTerm, literal: Any | LiteralValue):
         super().__init__(term=_to_unbound_term(term), value=_to_literal(literal))  # type: ignore[call-arg]
 
     @property
-    def literal(self) -> Literal[L]:
+    def literal(self) -> LiteralValue:
         return self.value
 
     def bind(self, schema: Schema, case_sensitive: bool = True) -> BoundLiteralPredicate:
@@ -816,9 +816,9 @@ def as_bound(self) -> builtins.type[BoundLiteralPredicate]: ...
 
 
 class BoundLiteralPredicate(BoundPredicate, ABC):
-    literal: Literal[Any]
+    literal: LiteralValue
 
-    def __init__(self, term: BoundTerm, literal: Literal[Any]):  # pylint: disable=W0621
+    def __init__(self, term: BoundTerm, literal: LiteralValue):  # pylint: disable=W0621
         super().__init__(term)
         self.literal = literal  # pylint: disable=W0621
 
@@ -834,7 +834,7 @@ def __repr__(self) -> str:
 
     @property
     @abstractmethod
-    def as_unbound(self) -> type[LiteralPredicate[Any]]: ...
+    def as_unbound(self) -> type[LiteralPredicate]: ...
 
 
 class BoundEqualTo(BoundLiteralPredicate):
@@ -843,7 +843,7 @@ def __invert__(self) -> BoundNotEqualTo:
         return BoundNotEqualTo(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[EqualTo[Any]]:
+    def as_unbound(self) -> type[EqualTo]:
         return EqualTo
 
 
@@ -853,7 +853,7 @@ def __invert__(self) -> BoundEqualTo:
         return BoundEqualTo(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[NotEqualTo[Any]]:
+    def as_unbound(self) -> type[NotEqualTo]:
         return NotEqualTo
 
 
@@ -863,7 +863,7 @@ def __invert__(self) -> BoundLessThan:
         return BoundLessThan(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[GreaterThanOrEqual[Any]]:
+    def as_unbound(self) -> type[GreaterThanOrEqual]:
         return GreaterThanOrEqual
 
 
@@ -873,7 +873,7 @@ def __invert__(self) -> BoundLessThanOrEqual:
         return BoundLessThanOrEqual(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[GreaterThan[Any]]:
+    def as_unbound(self) -> type[GreaterThan]:
         return GreaterThan
 
 
@@ -883,7 +883,7 @@ def __invert__(self) -> BoundGreaterThanOrEqual:
         return BoundGreaterThanOrEqual(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[LessThan[Any]]:
+    def as_unbound(self) -> type[LessThan]:
         return LessThan
 
 
@@ -893,7 +893,7 @@ def __invert__(self) -> BoundGreaterThan:
         return BoundGreaterThan(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[LessThanOrEqual[Any]]:
+    def as_unbound(self) -> type[LessThanOrEqual]:
         return LessThanOrEqual
 
 
@@ -903,7 +903,7 @@ def __invert__(self) -> BoundNotStartsWith:
         return BoundNotStartsWith(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[StartsWith[Any]]:
+    def as_unbound(self) -> type[StartsWith]:
         return StartsWith
 
 
@@ -913,14 +913,14 @@ def __invert__(self) -> BoundStartsWith:
         return BoundStartsWith(self.term, self.literal)
 
     @property
-    def as_unbound(self) -> type[NotStartsWith[Any]]:
+    def as_unbound(self) -> type[NotStartsWith]:
         return NotStartsWith
 
 
-class EqualTo(LiteralPredicate[L]):
+class EqualTo(LiteralPredicate):
     type: TypingLiteral["eq"] = Field(default="eq", alias="type")
 
-    def __invert__(self) -> NotEqualTo[Any]:
+    def __invert__(self) -> NotEqualTo:
         """Transform the Expression into its negated version."""
         return NotEqualTo(self.term, self.literal)
 
@@ -929,10 +929,10 @@ def as_bound(self) -> builtins.type[BoundEqualTo]:
         return BoundEqualTo
 
 
-class NotEqualTo(LiteralPredicate[L]):
+class NotEqualTo(LiteralPredicate):
     type: TypingLiteral["not-eq"] = Field(default="not-eq", alias="type")
 
-    def __invert__(self) -> EqualTo[Any]:
+    def __invert__(self) -> EqualTo:
         """Transform the Expression into its negated version."""
         return EqualTo(self.term, self.literal)
 
@@ -941,10 +941,10 @@ def as_bound(self) -> builtins.type[BoundNotEqualTo]:
         return BoundNotEqualTo
 
 
-class LessThan(LiteralPredicate[L]):
+class LessThan(LiteralPredicate):
     type: TypingLiteral["lt"] = Field(default="lt", alias="type")
 
-    def __invert__(self) -> GreaterThanOrEqual[Any]:
+    def __invert__(self) -> GreaterThanOrEqual:
         """Transform the Expression into its negated version."""
         return GreaterThanOrEqual(self.term, self.literal)
 
@@ -953,10 +953,10 @@ def as_bound(self) -> builtins.type[BoundLessThan]:
         return BoundLessThan
 
 
-class GreaterThanOrEqual(LiteralPredicate[L]):
+class GreaterThanOrEqual(LiteralPredicate):
     type: TypingLiteral["gt-eq"] = Field(default="gt-eq", alias="type")
 
-    def __invert__(self) -> LessThan[Any]:
+    def __invert__(self) -> LessThan:
         """Transform the Expression into its negated version."""
         return LessThan(self.term, self.literal)
 
@@ -965,10 +965,10 @@ def as_bound(self) -> builtins.type[BoundGreaterThanOrEqual]:
         return BoundGreaterThanOrEqual
 
 
-class GreaterThan(LiteralPredicate[L]):
+class GreaterThan(LiteralPredicate):
     type: TypingLiteral["gt"] = Field(default="gt", alias="type")
 
-    def __invert__(self) -> LessThanOrEqual[Any]:
+    def __invert__(self) -> LessThanOrEqual:
         """Transform the Expression into its negated version."""
         return LessThanOrEqual(self.term, self.literal)
 
@@ -977,10 +977,10 @@ def as_bound(self) -> builtins.type[BoundGreaterThan]:
         return BoundGreaterThan
 
 
-class LessThanOrEqual(LiteralPredicate[L]):
+class LessThanOrEqual(LiteralPredicate):
     type: TypingLiteral["lt-eq"] = Field(default="lt-eq", alias="type")
 
-    def __invert__(self) -> GreaterThan[Any]:
+    def __invert__(self) -> GreaterThan:
         """Transform the Expression into its negated version."""
         return GreaterThan(self.term, self.literal)
 
@@ -989,10 +989,10 @@ def as_bound(self) -> builtins.type[BoundLessThanOrEqual]:
         return BoundLessThanOrEqual
 
 
-class StartsWith(LiteralPredicate[L]):
+class StartsWith(LiteralPredicate):
     type: TypingLiteral["starts-with"] = Field(default="starts-with", alias="type")
 
-    def __invert__(self) -> NotStartsWith[Any]:
+    def __invert__(self) -> NotStartsWith:
         """Transform the Expression into its negated version."""
         return NotStartsWith(self.term, self.literal)
 
@@ -1001,10 +1001,10 @@ def as_bound(self) -> builtins.type[BoundStartsWith]:
         return BoundStartsWith
 
 
-class NotStartsWith(LiteralPredicate[L]):
+class NotStartsWith(LiteralPredicate):
     type: TypingLiteral["not-starts-with"] = Field(default="not-starts-with", alias="type")
 
-    def __invert__(self) -> StartsWith[Any]:
+    def __invert__(self) -> StartsWith:
         """Transform the Expression into its negated version."""
         return StartsWith(self.term, self.literal)
 

tests/expressions/test_evaluator.py

@@ -685,7 +685,7 @@ def data_file_nan() -> DataFile:
 
 
 def test_inclusive_metrics_evaluator_less_than_and_less_than_equal(schema_data_file_nan: Schema, data_file_nan: DataFile) -> None:
-    operators: tuple[type[LiteralPredicate[Any]], ...] = (LessThan, LessThanOrEqual)
+    operators: tuple[type[LiteralPredicate], ...] = (LessThan, LessThanOrEqual)
     for operator in operators:
         should_read = _InclusiveMetricsEvaluator(schema_data_file_nan, operator("all_nan", 1)).eval(data_file_nan)
         assert not should_read, "Should not match: all nan column doesn't contain number"
@@ -714,7 +714,7 @@ def test_inclusive_metrics_evaluator_less_than_and_less_than_equal(schema_data_f
 def test_inclusive_metrics_evaluator_greater_than_and_greater_than_equal(
     schema_data_file_nan: Schema, data_file_nan: DataFile
 ) -> None:
-    operators: tuple[type[LiteralPredicate[Any]], ...] = (GreaterThan, GreaterThanOrEqual)
+    operators: tuple[type[LiteralPredicate], ...] = (GreaterThan, GreaterThanOrEqual)
     for operator in operators:
         should_read = _InclusiveMetricsEvaluator(schema_data_file_nan, operator("all_nan", 1)).eval(data_file_nan)
         assert not should_read, "Should not match: all nan column doesn't contain number"