Feat/vk interface

.dockerignore

@@ -1,7 +1,6 @@
 *.DS_Store*
 *.egg-info/
 dist/
-venv/
 build/
 docs/source/apiref
 docs/source/_misc
@@ -22,7 +21,6 @@ GlobalUserTableAccessor*
 memory_debugging*
 opening_database*
 _globals.py
-venv*
 .vscode
 .coverage
 .coverage.*

.gitignore

@@ -22,7 +22,6 @@ GlobalUserTableAccessor*
 memory_debugging*
 opening_database*
 _globals.py
-venv*
 .vscode
 .coverage
 .coverage.*

bot_test.py

@@ -0,0 +1,51 @@
+from dff.script import conditions as cnd
+from dff.script import RESPONSE, TRANSITIONS, Message, Context
+from dff.pipeline import Pipeline
+
+from dff.messengers.vk import PollingVKInterface
+from tests.messengers.vk.vk_dummy import VKDummy
+
+
+
+script = {
+    "greeting_flow": {
+        "start_node": { 
+            RESPONSE: Message(),
+            TRANSITIONS: {"node1": cnd.exact_match(Message("Hi"))}
+        },
+        "node1": {
+            RESPONSE: Message(
+                text="Hi, how are you?"
+            ),
+            TRANSITIONS: {
+                "start_node": cnd.exact_match(Message("Nice"))
+            },
+        },
+        "fallback_node": {
+            RESPONSE: Message(text="Sorry, I don't understand."),
+            TRANSITIONS: {
+                "start_node": cnd.true(),
+            }
+        }
+    }
+}
+
+
+# KEY = "vk1.a.BvmniZCwChZfKGPWTUtHiFOC1GOQ7M7ePur6y9cs9YpKuKXLKQLDGZDy5fxhiJAFWXNLAKazSRjFqpw5WByX1x-KiEU3HcIb4QHSG_utQMjnqQ4UOYXcT7pn-8nUeo4hnf-nH4BIB3fdwq0WhZLTcnlLAok2sxd_yR2q8LVzElc-7rhZAuyNDcLzOxFx9Z9P3xsg5EEhDFBcWRvGk_1R1Q"
+# GROUP_ID = "224377718"
+
+
+vk_dummy = VKDummy()
+vk_interface = PollingVKInterface("KEY", "GROUP_ID")
+vk_interface.bot = vk_dummy
+
+pipeline = Pipeline.from_script(
+    script=script,
+    start_label=("greeting_flow", "start_node"),
+    fallback_label=("greeting_flow", "fallback_node"),
+    messenger_interface=vk_interface,
+)
+pipeline.run()
+# vk_interface._respond(ctx)
+print(vk_dummy.responses)
+

dff/messengers/common/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 
-from .interface import MessengerInterface, PollingMessengerInterface, CallbackMessengerInterface, CLIMessengerInterface
+from .interface import MessengerInterface, PollingMessengerInterface, CallbackMessengerInterface
 from .types import PollingInterfaceLoopFunction

dff/messengers/common/interface.py

@@ -9,14 +9,15 @@
 import abc
 import asyncio
 import logging
-import uuid
-from typing import Optional, Any, List, Tuple, TextIO, Hashable, TYPE_CHECKING
-
-from dff.script import Context, Message
-from dff.messengers.common.types import PollingInterfaceLoopFunction
+from pathlib import Path
+from tempfile import gettempdir
+from typing import Optional, Any, List, Tuple, Hashable, TYPE_CHECKING, Type
 
 if TYPE_CHECKING:
+    from dff.script import Context, Message
     from dff.pipeline.types import PipelineRunnerFunction
+    from dff.messengers.common.types import PollingInterfaceLoopFunction
+    from dff.script.core.message import Attachment, DataAttachment
 
 logger = logging.getLogger(__name__)
 
@@ -27,6 +28,24 @@ class MessengerInterface(abc.ABC):
     It is responsible for connection between user and pipeline, as well as for request-response transactions.
     """
 
+    supported_request_attachment_types: set[Type[Attachment]] = set()
+    supported_response_attachment_types: set[type[Attachment]] = set()
+
+    def __init__(self, attachments_directory: Optional[Path] = None) -> None:
+        tempdir = gettempdir()
+        if attachments_directory is not None and not str(attachments_directory.absolute()).startswith(tempdir):
+            self.attachments_directory = attachments_directory
+        else:
+            warning_start = f"Attachments directory for {type(self).__name__} messenger interface"
+            warning_end = "attachment data won't be cached locally!"
+            if attachments_directory is None:
+                self.attachments_directory = Path(tempdir) / f"dff-cache-{type(self).__name__}"
+                logger.warning(f"{warning_start} is None, so will be set to tempdir and {warning_end}")
+            else:
+                self.attachments_directory = attachments_directory
+                logger.warning(f"{warning_start} is in tempdir, so {warning_end}")
+        self.attachments_directory.mkdir(parents=True, exist_ok=True)
+
     @abc.abstractmethod
     async def connect(self, pipeline_runner: PipelineRunnerFunction):
         """
@@ -38,6 +57,9 @@ async def connect(self, pipeline_runner: PipelineRunnerFunction):
         """
         raise NotImplementedError
 
+    async def populate_attachment(self, attachment: DataAttachment) -> bytes:
+        raise RuntimeError(f"Messanger interface {type(self).__name__} can't populate attachment {attachment}!")
+
 
 class PollingMessengerInterface(MessengerInterface):
     """
@@ -119,7 +141,8 @@ class CallbackMessengerInterface(MessengerInterface):
     Callback message interface is waiting for user input and answers once it gets one.
     """
 
-    def __init__(self):
+    def __init__(self, attachments_directory: Optional[Path] = None) -> None:
+        super().__init__(attachments_directory)
         self._pipeline_runner: Optional[PipelineRunnerFunction] = None
 
     async def connect(self, pipeline_runner: PipelineRunnerFunction):
@@ -142,43 +165,3 @@ def on_request(
         This method has the same signature as :py:class:`~dff.pipeline.types.PipelineRunnerFunction`.
         """
         return asyncio.run(self.on_request_async(request, ctx_id, update_ctx_misc))
-
-
-class CLIMessengerInterface(PollingMessengerInterface):
-    """
-    Command line message interface is the default message interface, communicating with user via `STDIN/STDOUT`.
-    This message interface can maintain dialog with one user at a time only.
-    """
-
-    def __init__(
-        self,
-        intro: Optional[str] = None,
-        prompt_request: str = "request: ",
-        prompt_response: str = "response: ",
-        out_descriptor: Optional[TextIO] = None,
-    ):
-        super().__init__()
-        self._ctx_id: Optional[Hashable] = None
-        self._intro: Optional[str] = intro
-        self._prompt_request: str = prompt_request
-        self._prompt_response: str = prompt_response
-        self._descriptor: Optional[TextIO] = out_descriptor
-
-    def _request(self) -> List[Tuple[Message, Any]]:
-        return [(Message(input(self._prompt_request)), self._ctx_id)]
-
-    def _respond(self, responses: List[Context]):
-        print(f"{self._prompt_response}{responses[0].last_response.text}", file=self._descriptor)
-
-    async def connect(self, pipeline_runner: PipelineRunnerFunction, **kwargs):
-        """
-        The CLIProvider generates new dialog id used to user identification on each `connect` call.
-
-        :param pipeline_runner: A function that should process user request and return context;
-            usually it's a :py:meth:`~dff.pipeline.pipeline.pipeline.Pipeline._run_pipeline` function.
-        :param \\**kwargs: argument, added for compatibility with super class, it shouldn't be used normally.
-        """
-        self._ctx_id = uuid.uuid4()
-        if self._intro is not None:
-            print(self._intro)
-        await super().connect(pipeline_runner, **kwargs)

dff/messengers/console.py

@@ -0,0 +1,49 @@
+from typing import Any, Hashable, List, Optional, TextIO, Tuple
+from uuid import uuid4
+from dff.messengers.common.interface import PollingMessengerInterface
+from dff.pipeline.types import PipelineRunnerFunction
+from dff.script.core.context import Context
+from dff.script.core.message import Message
+
+
+class CLIMessengerInterface(PollingMessengerInterface):
+    """
+    Command line message interface is the default message interface, communicating with user via `STDIN/STDOUT`.
+    This message interface can maintain dialog with one user at a time only.
+    """
+
+    supported_request_attachment_types = set()
+    supported_response_attachment_types = set()
+
+    def __init__(
+        self,
+        intro: Optional[str] = None,
+        prompt_request: str = "request: ",
+        prompt_response: str = "response: ",
+        out_descriptor: Optional[TextIO] = None,
+    ):
+        super().__init__()
+        self._ctx_id: Optional[Hashable] = None
+        self._intro: Optional[str] = intro
+        self._prompt_request: str = prompt_request
+        self._prompt_response: str = prompt_response
+        self._descriptor: Optional[TextIO] = out_descriptor
+
+    def _request(self) -> List[Tuple[Message, Any]]:
+        return [(Message(input(self._prompt_request)), self._ctx_id)]
+
+    def _respond(self, responses: List[Context]):
+        print(f"{self._prompt_response}{responses[0].last_response.text}", file=self._descriptor)
+
+    async def connect(self, pipeline_runner: PipelineRunnerFunction, **kwargs):
+        """
+        The CLIProvider generates new dialog id used to user identification on each `connect` call.
+
+        :param pipeline_runner: A function that should process user request and return context;
+            usually it's a :py:meth:`~dff.pipeline.pipeline.pipeline.Pipeline._run_pipeline` function.
+        :param \\**kwargs: argument, added for compatibility with super class, it shouldn't be used normally.
+        """
+        self._ctx_id = uuid4()
+        if self._intro is not None:
+            print(self._intro)
+        await super().connect(pipeline_runner, **kwargs)

dff/messengers/telegram/__init__.py

@@ -1,14 +1,4 @@
 # -*- coding: utf-8 -*-
 
-try:
-    import telebot
-except ImportError:
-    raise ImportError("telebot is not installed. Run `pip install dff[telegram]`")
-
-from .messenger import TelegramMessenger
+from .abstract import telegram_available
 from .interface import PollingTelegramInterface, CallbackTelegramInterface
-from .message import TelegramUI, TelegramMessage, RemoveKeyboard, ParseMode
-from .messenger import (
-    UpdateType,
-    telegram_condition,
-)