✨ Make electro run with any client

.gitignore

@@ -18,6 +18,7 @@ Icon
 .Trashes
 .VolumeIcon.icns
 .com.apple.timemachine.donotpresent
+.bash_history
 
 # Directories potentially created on remote AFP share
 .AppleDB
@@ -150,6 +151,7 @@ celerybeat.pid
 
 # Environments
 examples/.env
+.env
 .venv
 env/
 venv/

.pylintrc

@@ -0,0 +1,16 @@
+[MAIN]
+
+max-line-length=120
+
+disable=
+    C0114,  # Missing module docstring
+    C0115,  # Missing class docstring
+    C0116,  # Missing function or method docstring
+    C0302,  # Too many lines in module
+    E0401,  # Import error: Ignored because imports actually work
+    R0801,  # Duplicate code
+    R0902,  # Too many instance attributes
+    R0903,  # Too few public methods
+    R0913,  # Too many arguments
+    R0917,  # Too many positional arguments
+    W0511,  # TODO

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python.analysis.extraPaths": ["./electro"],
+    "python.defaultInterpreterPath": ".venv/bin/python",
+}

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.12.6-slim AS builder
+
+ARG EXPORT_FLAG="--with dev"
+
+RUN pip install --upgrade pip poetry poetry-plugin-export
+
+COPY pyproject.toml poetry.lock ./
+
+RUN poetry export -f requirements.txt $EXPORT_FLAG --without-hashes --output /tmp/requirements.txt
+
+
+FROM python:3.12.6-slim
+
+WORKDIR /app
+
+RUN groupadd -g 10000 app && \
+  useradd -g app -d /app -u 10000 app && \
+  chown app:app /app && \
+  apt-get update && \
+  apt upgrade -y && \
+  apt-get install nano && \
+  apt-get install -y git && \
+  pip install --upgrade pip
+
+COPY --from=builder /tmp/requirements.txt .
+
+RUN pip install -r requirements.txt
+RUN pip install watchdog
+
+COPY . .
+
+USER app
+ENV PYTHONPATH="/app"
+
+CMD ["watchmedo", "auto-restart", "--pattern=*.py", "--recursive", "--", "python", "examples/test_flow.py"]

Makefile

@@ -15,7 +15,6 @@ style:
 	poetry run black $(SOURCES_DIR)
 	poetry run isort $(SOURCES_DIR)
 	poetry run pylint $(SOURCES_DIR)
-	poetry run pydocstyle $(SOURCES_DIR)
 
 .PHONY: docs
 docs:

README.md

@@ -18,12 +18,17 @@ A framework for building bots, made for humans.
     ```shell
     cp .env.example .env
     # vi .env
+
+4. Extract and compile translations:
+    ```shell
+    make upload-locales
+    make update-locales
     ```
 
-4. Run the `TestFlow`:
+5. Run the `TestFlow`:
    ```shell
    poetry run python ./test_flow.py
    ```
 
-5. Check the API server @ http://localhost:8000/docs.
-6. Use one of the clients to connect the platforms: [Discord](https://github.com/CyberCRI/ikigai-discord-client).
+6. Check the API server @ http://localhost:8000/docs.
+7. Use one of the clients to connect the platforms: [Whatsapp](https://github.com/CyberCRI/ikigai-whatsapp-bot).

docs/source/electro.toolkit.rst

@@ -20,14 +20,6 @@ electro.toolkit.buttons module
    :show-inheritance:
    :undoc-members:
 
-electro.toolkit.discord\_tweeks module
---------------------------------------
-
-.. automodule:: electro.toolkit.discord_tweeks
-   :members:
-   :show-inheritance:
-   :undoc-members:
-
 electro.toolkit.loguru\_logging module
 --------------------------------------
 

electro/app.py

@@ -1,11 +1,20 @@
 """The API server that works as an endpoint for all the Electro Interfaces."""
 
-from fastapi import FastAPI
+import asyncio
+from typing import Any, Dict, Optional
+
+from fastapi import Depends, FastAPI, HTTPException, Response, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.websockets import WebSocketState
 from tortoise.contrib.fastapi import register_tortoise
 
-from . import types_ as types
-from .flow_manager import global_flow_manager
+from .authentication import ElectroAuthentication
+from .interfaces import APIInterface, WebSocketInterface
+from .models import Message, PlatformId, User
+from .schemas import CookieToken
+from .settings import settings
 from .toolkit.tortoise_orm import get_tortoise_config
+from .utils import format_historical_message, limit_from_id_paginate_response
 
 app = FastAPI(
     title="Electro API",
@@ -16,17 +25,182 @@
 )
 
 
-@app.post("/message")
-async def process_message(message: types.Message) -> list[types.MessageToSend] | None:
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ALLOW_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.patch("/api/platform/{platform}/user/{user_id}")
+async def update_user(
+    platform: str,
+    user_id: str,
+    data: Dict[str, Any],
+    request_user: Optional[User] = Depends(ElectroAuthentication.authenticate_user),
+):
+    """
+    Update the user information.
+
+    Arguments:
+        platform: The platform where the user is registered.
+        user_id: The ID of the user on the platform.
+        username: Optional username to set for the user.
+    """
+    platform_id = await PlatformId.get_or_none(
+        platform_id=user_id, platform=platform, type=PlatformId.PlatformIdTypes.USER
+    )
+    if not platform_id:
+        raise HTTPException(status_code=404, detail="User not found.")
+    user: User = await platform_id.user
+    if request_user == user:
+        for field in ["username", "locale"]:
+            if field in data:
+                setattr(user, field, data[field])
+        await user.save()
+        return {
+            "id": user.id,
+            "username": user.username,
+            "locale": user.locale,
+            "platform_ids": [
+                {
+                    "platform": platform.platform,
+                    "platform_id": platform.platform_id,
+                    "type": platform.type,
+                }
+                for platform in await user.platform_ids.all()
+            ],
+        }
+    raise HTTPException(status_code=403, detail="You are not authorized to update this user's information.")
+
+
+@app.get("/api/platform/{platform}/user/{user_id}")
+async def get_user(
+    platform: str, user_id: str, request_user: Optional[User] = Depends(ElectroAuthentication.authenticate_user)
+):
+    """
+    Test the API endpoint.
+    """
+    platform_id = await PlatformId.get_or_none(
+        platform_id=user_id, platform=platform, type=PlatformId.PlatformIdTypes.USER
+    )
+    if not platform_id:
+        raise HTTPException(status_code=404, detail="User not found.")
+    user: User = await platform_id.user
+    # TODO: create a permission check to allow access to other users
+    if request_user == user:
+        return {
+            "id": user.id,
+            "username": user.username,
+            "locale": user.locale,
+            "platform_ids": [
+                {
+                    "platform": platform.platform,
+                    "platform_id": platform.platform_id,
+                    "type": platform.type,
+                }
+                for platform in await user.platform_ids.all()
+            ],
+        }
+    raise HTTPException(status_code=403, detail="You are not authorized to access this user's information.")
+
+
+@app.get("/api/platform/{platform}/user/{user_id}/flow/{flow_code}/messages")
+async def get_user_messages(
+    platform: str,
+    user_id: str,
+    flow_code: str,
+    request_user: Optional[User] = Depends(ElectroAuthentication.authenticate_user),
+    limit: int = 20,
+    from_id: Optional[int] = None,
+):
+    """
+    Get the message history for a user.
+
+    Arguments:
+        user: The user whose message history is to be retrieved.
+        limit: The maximum number of messages to retrieve.
+        offset: The number of messages to skip before retrieving the history.
+        from_id: If provided, this will override the offset to start from the latest message ID.
+    """
+    platform_id = await PlatformId.get_or_none(
+        platform_id=user_id, platform=platform, type=PlatformId.PlatformIdTypes.USER
+    )
+    if not platform_id:
+        raise HTTPException(status_code=404, detail="User not found.")
+    user = await platform_id.user
+    if request_user == user:
+        messages = Message.filter(user=user, flow_code=flow_code, is_temporary=False).order_by("-date_added")
+        return await limit_from_id_paginate_response(
+            messages,
+            format_historical_message,
+            limit=limit,
+            from_id=from_id,
+            url=f"/api/platform/{platform}/user/{user_id}/flow/{flow_code}/messages",
+        )
+    raise HTTPException(status_code=403, detail="You are not authorized to access this user's message history.")
+
+
+@app.post("/api/platform/{platform}/user/{user_id}/flow/{flow_code}/messages")
+async def process_message(
+    platform: str,
+    user_id: str,
+    flow_code: str,
+    data: Dict[str, Any],
+    request_user: Optional[User] = Depends(ElectroAuthentication.authenticate_user),
+):
     """Process the message."""
+    platform_id = await PlatformId.get_or_none(
+        platform_id=user_id, platform=platform, type=PlatformId.PlatformIdTypes.USER
+    )
+    if not platform_id:
+        raise HTTPException(status_code=404, detail="User not found.")
+    user = await platform_id.user
+    if request_user == user:
+        interface = APIInterface(flow_code=flow_code)
+        await interface.handle_incoming_action(user, platform, flow_code, data)
+        return interface.messages.get()
+    raise HTTPException(status_code=403, detail="You are not authorized to send messages on behalf of this user.")
 
-    return await global_flow_manager.on_message(message)
+
+@app.websocket("/websocket/platform/{platform}/user/{user_id}/flow/{flow_code}")
+async def websocket_endpoint(
+    websocket: WebSocket,
+    platform: str,
+    user_id: str,
+    flow_code: str,
+    request_user: Optional[User] = Depends(ElectroAuthentication.authenticate_user),
+):
+    """Handle the websocket connection."""
+    platform_id = await PlatformId.get_or_none(
+        platform_id=user_id, platform=platform, type=PlatformId.PlatformIdTypes.USER
+    )
+    if not platform_id:
+        raise HTTPException(status_code=404, detail="User not found.")
+    user = await platform_id.user
+    if request_user == user:
+        interface = WebSocketInterface(flow_code=flow_code)
+        await interface.connect(websocket)
+        try:
+            while websocket.application_state == WebSocketState.CONNECTED:
+                data = await websocket.receive_json()
+                asyncio.create_task(interface.handle_incoming_action(user, platform, flow_code, data))
+        except WebSocketDisconnect:
+            del interface
+    else:
+        raise HTTPException(status_code=403, detail="You are not authorized to send messages on behalf of this user.")
+
+
+@app.post("/api/cookies")
+async def set_cookie(data: CookieToken, response: Response):
+    cookie_value = "" if data.token is None else data.token
+    response.set_cookie(key="IKIGAI_AUTHORIZATION", value=cookie_value)
+    return {"status": "ok"}
 
 
 # region Register Tortoise
-register_tortoise(
-    app,
-    config=get_tortoise_config(),
-)
+register_tortoise(app, config=get_tortoise_config())
 
 # endregion