update to pydantic > 2 and koil 1.0.0

.python-version

@@ -0,0 +1 @@
+3.10

pyproject.toml

@@ -8,9 +8,9 @@ packages = [{ include = "rath" }]
 
 [tool.poetry.dependencies]
 python = "^3.8"
-koil = ">=0.3.5"
+koil = ">=1.0.0"
 graphql-core = "^3.2.0"
-pydantic = "^1.9.0"
+pydantic = ">2"
 websockets = { version = "^10.2", optional = true }
 aiohttp = { version = "^3.8.2", optional = true }
 certifi = { version = ">2021", optional = true }
@@ -31,16 +31,15 @@ pytest = "^7.2.0"
 testcontainers = "^3.7.0"
 pytest-qt = "^4.2.0"
 pytest-asyncio = "^0.20.2"
-turms = { version = ">=0.2.3", python = "^3.9" }
 aiohttp = "^3.8.3"
 websockets = "^10.4"
 black = "^22.10.0"
 pytest-cov = "^4.0.0"
 ruff = "^0.0.282"
 cryptography = "^41.0.3"
 pyjwt = "^2.8.0"
-fakts = "^0.3.48"
-herre = "^0.3.31"
+fakts = "1.0.0"
+herre = "1.0.0"
 mypy = "^1.7.1"
 
 [build-system]

rath/links/aiohttp.py

@@ -163,8 +163,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
 
                 yield GraphQLResult(data=json_response["data"])
 
-    class Config:
-        """pydantic config"""
-
-        arbitrary_types_allowed = True
-        underscore_attrs_are_private = True

rath/links/auth.py

@@ -100,11 +100,6 @@ async def aexecute(
             async for result in self.aexecute(operation, retry=retry + 1):
                 yield result
 
-    class Config:
-        """pydantic configuration for the AuthTokenLink"""
-
-        underscore_attrs_are_private = True
-        arbitary_types_allowed = True
 
 
 class ComposedAuthLink(AuthTokenLink):

rath/links/compose.py

@@ -1,6 +1,6 @@
 from typing import AsyncIterator, List, Optional, Type, Any
 
-from pydantic import validator
+from pydantic import field_validator
 from rath.links.base import ContinuationLink, Link, TerminatingLink
 from rath.operation import GraphQLResult, Operation
 from rath.errors import NotComposedError
@@ -19,8 +19,8 @@ class ComposedLink(TerminatingLink):
     """The links that are composed to form the chain. pydantic will validate 
     that the last link is a terminating link."""
 
-    @validator("links")
-    def validate(cls: Type["ComposedLink"], value: Any) -> List[Link]:
+    @field_validator("links")
+    def validate(cls: Type["ComposedLink"], value: Any, info) -> List[Link]:
         """Validate that the links are valid"""
         if not value:
             raise ValueError("ComposedLink requires at least one link")
@@ -119,10 +119,6 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
         async for result in self._firstlink.aexecute(operation):
             yield result
 
-    class Config:
-        """pydantic config"""
-
-        underscore_attrs_are_private = True
 
 
 def compose(*links: Link) -> ComposedLink:

rath/links/dictinglink.py

@@ -44,7 +44,7 @@ def recurse_extract(obj: ValidNestedTypes) -> ValidNestedTypes:
                 nulled_obj[key] = value
             return nulled_obj
         elif isinstance(obj, BaseModel):
-            return json.loads(obj.json(by_alias=by_alias))
+            return json.loads(obj.model_dump_json(by_alias=by_alias))
         else:
             # base case: pass through unchanged
             return obj

rath/links/foward.py

@@ -35,8 +35,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
         async for result in self.next.aexecute(operation):
             yield result
 
-    class Config:
-        """pydantic config for the link"""
-
-        underscore_attrs_are_private = True
-        arbitary_types_allowed = True

rath/links/graphql_ws.py

@@ -79,20 +79,22 @@ class GraphQLWSLink(AsyncTerminatingLink):
     """ The endpoint url to connect to """
     allow_reconnect: bool = True
     """ Should the websocket try to reconnect if it fails """
-    time_between_retries = 4
+    time_between_retries: float = 4
     """ The sleep time between retries """
-    max_retries = 3
+    max_retries: int = 3
     """ The maximum amount of retries before giving up """
     ssl_context: SSLContext = Field(
         default_factory=lambda: ssl.create_default_context(cafile=certifi.where())
     )
 
     on_connect: Optional[Callable[[InitialConnectPayload], Awaitable[None]]] = Field(
-        exclude=True
+        exclude=True, default=None
     )
     """ A function that is called before the connection is established. If an exception is raised, the connection is not established. Return is ignored."""
 
-    on_pong: Optional[Callable[[PongPayload], Awaitable[None]]] = Field(exclude=True)
+    on_pong: Optional[Callable[[PongPayload], Awaitable[None]]] = Field(
+        exclude=True, default=None
+    )
     """ A function that is called before a pong is received. If an exception is raised, the connection is not established. Return is ignored."""
     heartbeat_interval_ms: Optional[int] = None
     """ The heartbeat interval in milliseconds (None means no heartbeats are 
@@ -473,9 +475,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
             logger.debug(f"Subcription ended {operation}")
             await self.aforward(json.dumps({"id": id, "type": GQL_STOP}))
             raise e
-
-    class Config:
-        """pydantic config"""
-
-        arbitrary_types_allowed = True
-        underscore_attrs_are_private = True

rath/links/httpx.py

@@ -109,9 +109,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
                     raise Exception(f"Response does not contain data {json_response}")
 
                 yield GraphQLResult(data=json_response["data"])
-
-    class Config:
-        """the config for the link"""
-
-        arbitrary_types_allowed = True
-        underscore_attrs_are_private = True

rath/links/log.py

@@ -42,9 +42,3 @@ async def aexecute(
         await self.log(operation)
         async for result in self.next.aexecute(operation, **kwargs):
             yield result
-
-    class Config:
-        """pydantic config for the link"""
-
-        underscore_attrs_are_private = True
-        arbitary_types_allowed = True

rath/links/retry.py

@@ -19,9 +19,9 @@ class RetryLink(ContinuationLink):
     This link is stateful, and will keep track of the number of times the
     subscription has been retried."""
 
-    maximum_retry_attempts = 3
+    maximum_retry_attempts: int = 3
     """The maximum number of times the operation function will be called, before the operation fails."""
-    sleep_interval: Optional[int]
+    sleep_interval: Optional[int] = None
     """The number of seconds to wait before retrying the operation."""
 
     async def aexecute(
@@ -61,10 +61,4 @@ async def aexecute(
 
             logger.info(f"Subscription {operation} disconnected. Retrying {retry}")
             async for result in self.aexecute(operation, retry=retry + 1):
-                yield result
-
-    class Config:
-        """pydantic config for the link"""
-
-        underscore_attrs_are_private = True
-        arbitary_types_allowed = True
+                yield result

rath/links/sign_local_link.py

@@ -1,7 +1,7 @@
 from .auth import AuthTokenLink
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.backends import default_backend
-from pydantic import validator
+from pydantic import field_validator
 from cryptography.hazmat.primitives.asymmetric import rsa
 from typing import Any, Callable, Awaitable, Dict, Type
 import jwt
@@ -19,7 +19,7 @@ class SignLocalLink(AuthTokenLink):
 
     private_key: rsa.RSAPrivateKey
 
-    @validator("private_key", pre=True, always=True)
+    @field_validator("private_key", mode="before")
     def must_be_valid_pem_key(cls: Type["SignLocalLink"], v: Any) -> rsa.RSAPrivateKey:
         """Validates that the private key is a valid PEM key"""
         try:

rath/links/subscription_transport_ws.py

@@ -78,9 +78,9 @@ class SubscriptionTransportWsLink(AsyncTerminatingLink):
     """ The endpoint url to connect to """
     allow_reconnect: bool = True
     """ Should the websocket try to reconnect if it fails """
-    time_between_retries = 4
+    time_between_retries: float = 4
     """ The sleep time between retries """
-    max_retries = 3
+    max_retries: int = 3
     """ The maximum amount of retries before giving up """
     ssl_context: SSLContext = Field(
         default_factory=lambda: ssl.create_default_context(cafile=certifi.where())
@@ -475,9 +475,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
             logger.debug(f"Subcription ended {operation}")
             await self.aforward(json.dumps({"id": id, "type": GQL_STOP}))
             raise e
-
-    class Config:
-        """The config for the link"""
-
-        arbitrary_types_allowed = True
-        underscore_attrs_are_private = True

rath/links/testing/mock.py

@@ -1,7 +1,7 @@
 import asyncio
 from typing import AsyncIterator, Awaitable, Callable, Dict, Type, Any
 
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 from rath.links.base import AsyncTerminatingLink
 from rath.operation import GraphQLResult, Operation
 from graphql import FieldNode, OperationType
@@ -57,12 +57,12 @@ class AsyncMockLink(AsyncTerminatingLink):
     )
     resolver: ResolverDict = Field(default_factory=dict, exclude=True)
 
-    @validator(
+    @field_validator(
         "query_resolver",
         "mutation_resolver",
         "subscription_resolver",
         "resolver",
-        pre=True,
+        mode="before",
     )
     @classmethod
     def coerce_resolver(cls: Type["AsyncMockLink"], v: Any) -> ResolverDict:

rath/links/testing/statefulmock.py

@@ -1,7 +1,7 @@
 import asyncio
 from typing import AsyncIterator, Awaitable, Callable, Dict, Optional, Type, Any
 
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 from rath.links.base import AsyncTerminatingLink
 from rath.links.testing.mock import AsyncMockResolver
 from rath.operation import GraphQLResult, Operation
@@ -60,12 +60,12 @@ class AsyncStatefulMockLink(AsyncTerminatingLink):
     _inqueue: Optional[asyncio.Queue] = None
     _connection_task: Optional[asyncio.Task] = None
 
-    @validator(
+    @field_validator(
         "query_resolver",
         "mutation_resolver",
         "subscription_resolver",
         "resolver",
-        pre=True,
+        mode="before",
     )
     @classmethod
     def coerce_resolver(cls: Type["AsyncStatefulMockLink"], v: Any) -> Dict[str, Any]:
@@ -245,9 +245,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
 
         else:
             raise NotImplementedError("Only subscription are mocked")
-
-    class Config:
-        """Pydantic Config"""
-
-        arbitrary_types_allowed = True
-        underscore_attrs_are_private = True

rath/links/transpile.py

@@ -7,7 +7,7 @@
     OperationDefinitionNode,
     TypeNode,
 )
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 from rath.links.parsing import ParsingLink
 from rath.operation import Operation
 
@@ -21,34 +21,23 @@ class TranspileHandler(BaseModel):
     The default TranspileHandler is the identity function, which returns the
     type passed to it.
     """
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     graphql_type: str
     name: str
     predicate: Callable[[Any], bool] = Field(exclude=True)
     parser: Callable[[Any], Any] = Field(exclude=True)
-
-    class Config:
-        """pydantic config"""
-
-        arbitrary_types_allowed = True
-
-
 class ListTranspileHandler(BaseModel):
     """A List Transpile Handler
 
     Similar to a TranspileHandler, but takes act on GraphqQLList Type of that type
     """
-
+    model_config = ConfigDict(arbitrary_types_allowed=True)
     graphql_type: str
     name: str
     predicate: Callable[[Any, int], bool] = Field(exclude=True)
     parser: Callable[[Any, int], Any] = Field(exclude=True)
 
-    class Config:
-        """pydantic config"""
-
-        arbitrary_types_allowed = True
-
 
 class TranspilationError(Exception):
     """A transpilation Exception"""

rath/links/validate.py

@@ -8,7 +8,7 @@
     IntrospectionQuery,
 )
 from graphql.language.parser import parse
-from pydantic import root_validator
+from pydantic import model_validator
 from rath.links.base import ContinuationLink
 from rath.links.errors import ContinuationLinkError
 from rath.operation import GraphQLResult, Operation, opify
@@ -75,23 +75,23 @@ class ValidatingLink(ContinuationLink):
     graphql_schema: Optional[GraphQLSchema] = None
     """ The schema to validate against. If not provided, the link will introspect the server to get the schema if allow_introspection is set to True."""
 
-    @root_validator(allow_reuse=True)
+    @model_validator(mode="after")
     @classmethod
-    def check_schema_dsl_or_schema_glob(cls: Type["ValidatingLink"], values: Dict[str, Any]) -> Dict[str, Any]:  # type: ignore
+    def check_schema_dsl_or_schema_glob(cls: Type["ValidatingLink"], self: "ValidatingLink", *info) -> Dict[str, Any]:  # type: ignore
         """Validates and checks that either a schema_dsl or schema_glob is provided, or that allow_introspection is set to True"""
-        if not values.get("schema_dsl") and not values.get("schema_glob"):
-            if not values.get("allow_introspection"):
+        if not self.schema_dsl and not self.schema_glob:
+            if not self.allow_introspection:
                 raise ValueError(
                     "Please provide either a schema_dsl or schema_glob or allow introspection"
                 )
 
         else:
-            values["graphql_schema"] = schemify(
-                schema_dsl=values.get("schema_dsl"),
-                schema_glob=values.get("schema_glob"),
+            self.graphql_schema = schemify(
+                schema_dsl=self.schema_dsl,
+                schema_glob=self.schema_glob,
             )
 
-        return values
+        return self
 
     async def introspect(self, starting_operation: Operation) -> GraphQLSchema:  # type: ignore
         """Introspects the server to get the schema
@@ -148,8 +148,3 @@ async def aexecute(self, operation: Operation) -> AsyncIterator[GraphQLResult]:
 
         async for result in self.next.aexecute(operation):
             yield result
-
-    class Config:
-        """Config for pydantic"""
-
-        arbitrary_types_allowed = True