pydantic2.0

dff/context_storages/json.py

@@ -16,14 +16,15 @@
 except ImportError:
     json_available = False
 
-from pydantic import BaseModel, Extra, root_validator
+from pydantic import BaseModel, model_validator
 
 from .database import DBContextStorage, threadsafe_method
 from dff.script import Context
 
 
-class SerializableStorage(BaseModel, extra=Extra.allow):
-    @root_validator
+class SerializableStorage(BaseModel, extra="allow"):
+    @model_validator(mode="before")
+    @classmethod
     def validate_any(cls, vals):
         for key, value in vals.items():
             vals[key] = Context.cast(value)
@@ -43,41 +44,41 @@ def __init__(self, path: str):
 
     @threadsafe_method
     async def len_async(self) -> int:
-        return len(self.storage.__dict__)
+        return len(self.storage.model_extra)
 
     @threadsafe_method
     async def set_item_async(self, key: Hashable, value: Context):
-        self.storage.__dict__.__setitem__(str(key), value)
+        self.storage.model_extra.__setitem__(str(key), value)
         await self._save()
 
     @threadsafe_method
     async def get_item_async(self, key: Hashable) -> Context:
         await self._load()
-        return Context.cast(self.storage.__dict__.__getitem__(str(key)))
+        return Context.cast(self.storage.model_extra.__getitem__(str(key)))
 
     @threadsafe_method
     async def del_item_async(self, key: Hashable):
-        self.storage.__dict__.__delitem__(str(key))
+        self.storage.model_extra.__delitem__(str(key))
         await self._save()
 
     @threadsafe_method
     async def contains_async(self, key: Hashable) -> bool:
         await self._load()
-        return self.storage.__dict__.__contains__(str(key))
+        return self.storage.model_extra.__contains__(str(key))
 
     @threadsafe_method
     async def clear_async(self):
-        self.storage.__dict__.clear()
+        self.storage.model_extra.clear()
         await self._save()
 
     async def _save(self):
         async with aiofiles.open(self.path, "w+", encoding="utf-8") as file_stream:
-            await file_stream.write(self.storage.json())
+            await file_stream.write(self.storage.model_dump_json())
 
     async def _load(self):
         if not await aiofiles.os.path.isfile(self.path) or (await aiofiles.os.stat(self.path)).st_size == 0:
             self.storage = SerializableStorage()
             await self._save()
         else:
             async with aiofiles.open(self.path, "r", encoding="utf-8") as file_stream:
-                self.storage = SerializableStorage.parse_raw(await file_stream.read())
+                self.storage = SerializableStorage.model_validate_json(await file_stream.read())

dff/context_storages/mongo.py

@@ -60,7 +60,7 @@ def _adjust_key(key: Hashable) -> Dict[str, ObjectId]:
     async def set_item_async(self, key: Hashable, value: Context):
         new_key = self._adjust_key(key)
         value = value if isinstance(value, Context) else Context.cast(value)
-        document = json.loads(value.json())
+        document = json.loads(value.model_dump_json())
 
         document.update(new_key)
         await self.collection.replace_one(new_key, document, upsert=True)

dff/context_storages/redis.py

@@ -49,7 +49,7 @@ async def contains_async(self, key: Hashable) -> bool:
     @threadsafe_method
     async def set_item_async(self, key: Hashable, value: Context):
         value = value if isinstance(value, Context) else Context.cast(value)
-        await self._redis.set(str(key), value.json())
+        await self._redis.set(str(key), value.model_dump_json())
 
     @threadsafe_method
     async def get_item_async(self, key: Hashable) -> Context:

dff/context_storages/sql.py

@@ -115,7 +115,7 @@ def __init__(self, path: str, table_name: str = "contexts", custom_driver: bool
     @threadsafe_method
     async def set_item_async(self, key: Hashable, value: Context):
         value = value if isinstance(value, Context) else Context.cast(value)
-        value = json.loads(value.json())
+        value = json.loads(value.model_dump_json())
 
         insert_stmt = insert(self.table).values(id=str(key), context=value)
         update_stmt = await self._get_update_stmt(insert_stmt)

dff/context_storages/ydb.py

@@ -74,7 +74,7 @@ async def callee(session):
 
             await session.transaction(ydb.SerializableReadWrite()).execute(
                 prepared_query,
-                {"$queryId": str(key), "$queryContext": value.json()},
+                {"$queryId": str(key), "$queryContext": value.model_dump_json()},
                 commit_tx=True,
             )
 

dff/messengers/telegram/message.py

@@ -22,7 +22,8 @@
     ChatJoinRequest,
 )
 
-from dff.script.core.message import Message, Location, Keyboard, DataModel, root_validator, ValidationError
+from dff.script.core.message import Message, Location, Keyboard, DataModel
+from pydantic import model_validator
 
 
 class TelegramUI(Keyboard):
@@ -34,13 +35,13 @@ class TelegramUI(Keyboard):
     row_width: int = 3
     """Limits the maximum number of buttons in a row."""
 
-    @root_validator
-    def validate_buttons(cls, values):
-        if not values.get("is_inline"):
-            for button in values.get("buttons"):
+    @model_validator(mode="after")
+    def validate_buttons(self, _):
+        if not self.is_inline:
+            for button in self.buttons:
                 if button.payload is not None or button.source is not None:
-                    raise ValidationError(f"`payload` and `source` are only used for inline keyboards: {button}")
-        return values
+                    raise AssertionError(f"`payload` and `source` are only used for inline keyboards: {button}")
+        return self
 
 
 class _ClickButton(DataModel):
@@ -66,9 +67,6 @@ class ParseMode(Enum):
 
 
 class TelegramMessage(Message):
-    class Config:
-        smart_union = True
-
     ui: Optional[
         Union[TelegramUI, RemoveKeyboard, ReplyKeyboardRemove, ReplyKeyboardMarkup, InlineKeyboardMarkup]
     ] = None
@@ -97,9 +95,9 @@ class Config:
 
     def __eq__(self, other):
         if isinstance(other, Message):
-            for field in self.__fields__:
+            for field in self.model_fields:
                 if field not in ("parse_mode", "update_id", "update", "update_type"):
-                    if field not in other.__fields__:
+                    if field not in other.model_fields:
                         return False
                     if self.__getattribute__(field) != other.__getattribute__(field):
                         return False

dff/script/__init__.py

@@ -15,10 +15,8 @@
 from .core.normalization import (
     normalize_label,
     normalize_condition,
-    normalize_transitions,
     normalize_response,
     normalize_processing,
-    normalize_script,
 )
 from .core.script import Node, Script
 from .core.types import (

dff/script/conditions/std_conditions.py

@@ -12,15 +12,15 @@
 import logging
 import re
 
-from pydantic import validate_arguments
+from pydantic import validate_call
 
 from dff.pipeline import Pipeline
 from dff.script import NodeLabel2Type, Context, Message
 
 logger = logging.getLogger(__name__)
 
 
-@validate_arguments
+@validate_call
 def exact_match(match: Message, skip_none: bool = True, *args, **kwargs) -> Callable[..., bool]:
     """
     Return function handler. This handler returns `True` only if the last user phrase
@@ -35,11 +35,11 @@ def exact_match_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwa
         request = ctx.last_request
         if request is None:
             return False
-        for field in match.__fields__:
+        for field in match.model_fields:
             match_value = match.__getattribute__(field)
             if skip_none and match_value is None:
                 continue
-            if field in request.__fields__.keys():
+            if field in request.model_fields.keys():
                 if request.__getattribute__(field) != match.__getattribute__(field):
                     return False
             else:
@@ -49,7 +49,7 @@ def exact_match_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwa
     return exact_match_condition_handler
 
 
-@validate_arguments
+@validate_call
 def regexp(
     pattern: Union[str, Pattern], flags: Union[int, re.RegexFlag] = 0, *args, **kwargs
 ) -> Callable[[Context, Pipeline, Any, Any], bool]:
@@ -75,7 +75,7 @@ def regexp_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwargs)
     return regexp_condition_handler
 
 
-@validate_arguments
+@validate_call
 def check_cond_seq(cond_seq: list):
     """
     Check if the list consists only of Callables.
@@ -97,7 +97,7 @@ def check_cond_seq(cond_seq: list):
 """
 
 
-@validate_arguments
+@validate_call
 def aggregate(
     cond_seq: list, aggregate_func: Callable = _any, *args, **kwargs
 ) -> Callable[[Context, Pipeline, Any, Any], bool]:
@@ -119,7 +119,7 @@ def aggregate_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwarg
     return aggregate_condition_handler
 
 
-@validate_arguments
+@validate_call
 def any(cond_seq: list, *args, **kwargs) -> Callable[[Context, Pipeline, Any, Any], bool]:
     """
     Return function handler. This handler returns `True`
@@ -135,7 +135,7 @@ def any_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwargs) ->
     return any_condition_handler
 
 
-@validate_arguments
+@validate_call
 def all(cond_seq: list, *args, **kwargs) -> Callable[[Context, Pipeline, Any, Any], bool]:
     """
     Return function handler. This handler returns `True` only
@@ -151,7 +151,7 @@ def all_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwargs) ->
     return all_condition_handler
 
 
-@validate_arguments
+@validate_call
 def negation(condition: Callable, *args, **kwargs) -> Callable[[Context, Pipeline, Any, Any], bool]:
     """
     Return function handler. This handler returns negation of the :py:func:`~condition`: `False`
@@ -166,7 +166,7 @@ def negation_condition_handler(ctx: Context, pipeline: Pipeline, *args, **kwargs
     return negation_condition_handler
 
 
-@validate_arguments
+@validate_call
 def has_last_labels(
     flow_labels: Optional[List[str]] = None,
     labels: Optional[List[NodeLabel2Type]] = None,
@@ -198,7 +198,7 @@ def has_last_labels_condition_handler(ctx: Context, pipeline: Pipeline, *args, *
     return has_last_labels_condition_handler
 
 
-@validate_arguments
+@validate_call
 def true(*args, **kwargs) -> Callable[[Context, Pipeline, Any, Any], bool]:
     """
     Return function handler. This handler always returns `True`.
@@ -210,7 +210,7 @@ def true_handler(ctx: Context, pipeline: Pipeline, *args, **kwargs) -> bool:
     return true_handler
 
 
-@validate_arguments
+@validate_call
 def false(*args, **kwargs) -> Callable[[Context, Pipeline, Any, Any], bool]:
     """
     Return function handler. This handler always returns `False`.