Merge pull request #60 from eseglem/develop

Update to Pydantic v2.

Fixes: #40

Author: eseglem

.github/workflows/tests.yaml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
     steps:
       - uses: actions/checkout@v4
@@ -36,10 +36,10 @@ jobs:
       - uses: actions/checkout@v4
       - name: Install poetry
         run: pipx install poetry
-      - name: Set up Python 3.11
+      - name: Set up Python 3.12
         uses: actions/setup-python@v5
         with:
-          python-version: 3.11
+          python-version: 3.12
           cache: "poetry"
       - name: Install dependencies
         run: poetry install --no-dev

.pre-commit-config.yaml

@@ -18,7 +18,7 @@ repos:
       - id: pyupgrade
         args: ["--py38-plus", "--keep-runtime-typing"]
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.9
+    rev: v0.1.11
     hooks:
       - id: ruff
         args: ["--fix"]
@@ -27,10 +27,6 @@ repos:
     hooks:
       - id: black
         language_version: python
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.13.2
-    hooks:
-      - id: isort
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v1.8.0
     hooks:

poetry.lock

@@ -46,9 +46,9 @@ start: boolean_expression
 is_like_predicate: character_expression _LIKE pattern_expression       -> like
                  | character_expression _NOT _LIKE pattern_expression  -> not_like
 
-pattern_expression: "CASEI"i "(" pattern_expression ")"    -> casei
-                  | "ACCENTI"i "(" pattern_expression ")"  -> accenti
-                  | CHARACTER_LITERAL
+?pattern_expression: "CASEI"i "(" pattern_expression ")"    -> casei_pattern
+                   | "ACCENTI"i "(" pattern_expression ")"  -> accenti_pattern
+                   | CHARACTER_LITERAL
 
 // Between Predicate
 is_between_predicate: numeric_expression _BETWEEN numeric_expression _AND numeric_expression         -> is_between
@@ -205,11 +205,11 @@ _argument: character_clause
          | property_name
          | function
 
-character_expression: character_clause
+?character_expression: character_clause
                      | property_name
                      | function
-?character_clause: "CASEI"i "(" character_expression ")"      -> casei
-                 | "ACCENTI"i "(" character_expression ")"    -> accenti
+?character_clause: "CASEI"i "(" character_expression ")"      -> casei_character
+                 | "ACCENTI"i "(" character_expression ")"    -> accenti_character
                  | CHARACTER_LITERAL
 
 // WKT Definitions
@@ -249,7 +249,7 @@ linestring_coordinates: "(" coordinate ("," coordinate)+ ")"
 // BNF does not include linear ring, but you cannot have a polygon without 4 points.
 linear_ring_coordinates: "(" coordinate "," coordinate "," coordinate ("," coordinate)+ ")"
 polygon_coordinates:  "(" linear_ring_coordinates ("," linear_ring_coordinates)* ")"
-multi_point_coordinates: "(" coordinate ("," coordinate)* ")"
+multi_point_coordinates: "(" point_coordinates ("," point_coordinates)* ")"
 multi_linestring_coordinates: "(" linestring_coordinates ("," linestring_coordinates)* ")"
 multi_polygon_coordinates: "(" polygon_coordinates ("," polygon_coordinates)* ")"
 

pycql2/cql2.lark

@@ -4,19 +4,27 @@
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
-    Generic,
+    Any,
     List,
     Literal,
+    MutableSequence,
     Sequence,
     Tuple,
-    TypeVar,
     Union,
 )
 
 from geojson_pydantic.geometries import Geometry, GeometryCollection
 from geojson_pydantic.types import BBox
-from pydantic import BaseModel, StrictBool, StrictFloat, StrictInt, StrictStr, conlist
-from pydantic.generics import GenericModel
+from pydantic import (
+    BaseModel,
+    Field,
+    RootModel,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+from typing_extensions import Annotated
 
 # The use of `Strict*` is necessary in a few places because pydantic will convert
 # booleans to numbers and vice versa. As well as various types to strings. This
@@ -130,18 +138,18 @@ def __str__(self) -> str:
         return f"{self.op.upper()}({self.args[0]}, {self.args[1]})"
 
 
-class Array(BaseModel):
-    __root__: List[ArrayElement]
+class Array(RootModel):
+    root: MutableSequence[ArrayElement]
 
     def __str__(self) -> str:
-        return f"({join_list(self.__root__, ', ')})"
+        return f"({join_list(self.root, ', ')})"
 
 
-class ArrayExpression(BaseModel):
-    __root__: Tuple[ArrayExpressionItems, ArrayExpressionItems]
+class ArrayExpression(RootModel):
+    root: Tuple[ArrayExpressionItems, ArrayExpressionItems]
 
     def __str__(self) -> str:
-        return f"({self.__root__[0]}, {self.__root__[1]})"
+        return f"({self.root[0]}, {self.root[1]})"
 
 
 class ArrayOperator(str, Enum):
@@ -159,15 +167,15 @@ def __str__(self) -> str:
         return f"{self.op.upper()}{self.args}"
 
 
-class BooleanExpression(BaseModel):
-    __root__: BooleanExpressionItems
+class BooleanExpression(RootModel):
+    root: BooleanExpressionItems
 
     def __str__(self) -> str:
         # If it's a bool, we uppercase it.
-        if isinstance(self.__root__, bool):
-            return str(self.__root__).upper()
+        if isinstance(self.root, bool):
+            return str(self.root).upper()
         # Otherwise, we return the string representation of the root.
-        return str(self.__root__)
+        return str(self.root)
 
 
 # Type checking does not like `conlist`, so use a conditional here to avoid the error.
@@ -176,7 +184,7 @@ def __str__(self) -> str:
 if TYPE_CHECKING:
     BooleanExpressionList = List[BooleanExpression]
 else:
-    BooleanExpressionList = conlist(item_type=BooleanExpression, min_items=2)
+    BooleanExpressionList = Annotated[List[BooleanExpression], Field(min_length=2)]
 
 
 class AndOrExpression(BaseModel):
@@ -245,21 +253,21 @@ def __str__(self) -> str:
         return f"BBOX{self.bbox}"
 
 
-class IntervalArrayItems(BaseModel):
-    __root__: Union[datetime, date, Literal[".."], PropertyRef, FunctionRef]
+class IntervalArrayItems(RootModel):
+    root: Union[datetime, date, Literal[".."], PropertyRef, FunctionRef]
 
     def __str__(self) -> str:
         # If it is a datetime, format it as iso with `Z` at the end. Note this will
         # always include the microseconds, even if they are 0.
-        if isinstance(self.__root__, datetime):
-            return f"""'{self.__root__.strftime("%Y-%m-%dT%H:%M:%S.%fZ")}'"""
+        if isinstance(self.root, datetime):
+            return f"""'{self.root.strftime("%Y-%m-%dT%H:%M:%S.%fZ")}'"""
         # If it is a date, format with built-in isoformat
-        if isinstance(self.__root__, date):
-            return f"'{self.__root__.isoformat()}'"
-        if self.__root__ == "..":
+        if isinstance(self.root, date):
+            return f"'{self.root.isoformat()}'"
+        if self.root == "..":
             return "'..'"
         # Otherwise use the string representation of the root.
-        return str(self.__root__)
+        return str(self.root)
 
 
 class IntervalInstance(BaseModel):
@@ -269,50 +277,60 @@ def __str__(self) -> str:
         return f"INTERVAL({self.interval[0]}, {self.interval[1]})"
 
 
-class CharacterExpression(BaseModel):
-    __root__: CharacterExpressionItems
+class Casei(BaseModel):
+    casei: Union[CharacterExpression, PatternExpression]
 
     def __str__(self) -> str:
-        # If it is already a string, make it a char literal
-        if isinstance(self.__root__, str):
-            return make_char_literal(self.__root__)
-        # Otherwise, return the string representation of the root
-        return str(self.__root__)
+        return f"CASEI({self.casei})"
 
 
-class PatternExpression(BaseModel):
-    __root__: PatternExpressionItems
+class CaseiCharacterExpression(Casei):
+    casei: CharacterExpression
+
+
+class CaseiPatternExpression(Casei):
+    casei: PatternExpression
+
+
+class Accenti(BaseModel):
+    accenti: Union[CharacterExpression, PatternExpression]
 
     def __str__(self) -> str:
-        # If it is already a string, make it a char literal
-        if isinstance(self.__root__, str):
-            return make_char_literal(self.__root__)
-        # Otherwise, return the string representation of the root
-        return str(self.__root__)
+        return f"ACCENTI({self.accenti})"
+
 
+class AccentiCharacterExpression(Accenti):
+    accenti: CharacterExpression
 
-E = TypeVar("E", bound=Union[CharacterExpression, PatternExpression])
 
+class AccentiPatternExpression(Accenti):
+    accenti: PatternExpression
 
-class Casei(GenericModel, Generic[E]):
-    casei: E
+
+class GeometryLiteral(RootModel):
+    root: Union[Geometry, GeometryCollection]
 
     def __str__(self) -> str:
-        return f"CASEI({self.casei})"
+        return self.root.wkt
 
 
-class Accenti(GenericModel, Generic[E]):
-    accenti: E
+class CharLiteralRootModel(RootModel):
+    root: Any
 
     def __str__(self) -> str:
-        return f"ACCENTI({self.accenti})"
+        # If it is already a string, make it a char literal
+        if isinstance(self.root, str):
+            return make_char_literal(self.root)
+        # Otherwise, return the string representation of the root
+        return str(self.root)
 
 
-class GeometryLiteral(BaseModel):
-    __root__: Union[Geometry, GeometryCollection]
+class CharacterClause(CharLiteralRootModel):
+    root: CharacterClauseItems
 
-    def __str__(self) -> str:
-        return self.__root__.wkt
+
+class PatternExpression(CharLiteralRootModel):
+    root: PatternExpressionItems
 
 
 ComparisonPredicate = Union[
@@ -332,33 +350,36 @@ def __str__(self) -> str:
 TemporalExpression = Union[TemporalInstance, PropertyRef, FunctionRef]
 TemporalInstantExpression = Union[InstantInstance, PropertyRef, FunctionRef]
 ScalarExpression = Union[
-    TemporalInstantExpression, BooleanExpression, CharacterExpression, NumericExpression
+    TemporalInstantExpression, BooleanExpression, CharacterClause, NumericExpression
 ]
 ArithmeticOperandsItems = Union[
     ArithmeticExpression, PropertyRef, FunctionRef, StrictFloatOrInt
 ]
 ArrayExpressionItems = Union[Array, PropertyRef, FunctionRef]
 PatternExpressionItems = Union[
-    Casei[PatternExpression], Accenti[PatternExpression], StrictStr
+    CaseiPatternExpression, AccentiPatternExpression, StrictStr
 ]
-CharacterExpressionItems = Union[
-    Casei[CharacterExpression],
-    Accenti[CharacterExpression],
+CharacterClauseItems = Union[
+    CaseiCharacterExpression,
+    AccentiCharacterExpression,
     StrictStr,
+]
+CharacterExpression = Union[
+    CharacterClause,
     PropertyRef,
     FunctionRef,
 ]
 
 # Extra types to match the cql2-text grammar better
 IsNullOperand = Union[
-    CharacterExpression,
+    CharacterClause,
     NumericExpression,
     TemporalExpression,
     BooleanExpression,
     GeomExpression,
 ]
 ArrayElement = Union[
-    CharacterExpression,
+    CharacterClause,
     NumericExpression,
     BooleanExpression,
     GeomExpression,
@@ -369,7 +390,7 @@ def __str__(self) -> str:
     None,
     List[
         Union[
-            CharacterExpression,
+            CharacterClause,
             NumericExpression,
             BooleanExpression,
             GeomExpression,
@@ -389,28 +410,29 @@ def __str__(self) -> str:
 ]
 
 # Update all the forward references
-Accenti.update_forward_refs()
-AndOrExpression.update_forward_refs()
-ArithmeticExpression.update_forward_refs()
-ArrayExpression.update_forward_refs()
-Array.update_forward_refs()
-ArrayPredicate.update_forward_refs()
-BboxLiteral.update_forward_refs()
-BinaryComparisonPredicate.update_forward_refs()
-BooleanExpression.update_forward_refs()
-Casei.update_forward_refs()
-CharacterExpression.update_forward_refs()
-DateInstant.update_forward_refs()
-Function.update_forward_refs()
-FunctionRef.update_forward_refs()
-IntervalInstance.update_forward_refs()
-IsBetweenPredicate.update_forward_refs()
-IsInListPredicate.update_forward_refs()
-IsLikePredicate.update_forward_refs()
-IsNullPredicate.update_forward_refs()
-NotExpression.update_forward_refs()
-PatternExpression.update_forward_refs()
-PropertyRef.update_forward_refs()
-SpatialPredicate.update_forward_refs()
-TemporalPredicate.update_forward_refs()
-TimestampInstant.update_forward_refs()
+AccentiCharacterExpression.model_rebuild()
+AccentiPatternExpression.model_rebuild()
+AndOrExpression.model_rebuild()
+ArithmeticExpression.model_rebuild()
+ArrayExpression.model_rebuild()
+ArrayPredicate.model_rebuild()
+BboxLiteral.model_rebuild()
+BinaryComparisonPredicate.model_rebuild()
+BooleanExpression.model_rebuild()
+CaseiCharacterExpression.model_rebuild()
+CaseiPatternExpression.model_rebuild()
+CharacterClause.model_rebuild()
+DateInstant.model_rebuild()
+Function.model_rebuild()
+FunctionRef.model_rebuild()
+IntervalInstance.model_rebuild()
+IsBetweenPredicate.model_rebuild()
+IsInListPredicate.model_rebuild()
+IsLikePredicate.model_rebuild()
+IsNullPredicate.model_rebuild()
+NotExpression.model_rebuild()
+PatternExpression.model_rebuild()
+PropertyRef.model_rebuild()
+SpatialPredicate.model_rebuild()
+TemporalPredicate.model_rebuild()
+TimestampInstant.model_rebuild()