roboherd 0.1.2__py3-none-any.whl

roboherd/__main__.py

@@ -0,0 +1,106 @@
+import asyncio
+import logging
+import os
+
+import click
+import dynaconf
+import watchfiles
+
+from roboherd.herd import RoboHerd
+from roboherd.herd.manager import HerdManager
+from roboherd.util import create_connection
+from roboherd.register import register as run_register
+
+logging.basicConfig(level=logging.INFO)
+
+
+@click.group()
+@click.option(
+    "--connection_string",
+    default=None,
+    help="Connection string to the websocket mqtt broker",
+)
+@click.option(
+    "--base_url",
+    default=None,
+    help="Base url to create cows with",
+)
+@click.option("--config_file", default="roboherd.toml", help="Configuration file")
+@click.pass_context
+def main(ctx, connection_string, base_url, config_file):
+    """Configuration is usually loaded from the config_file. These options can be overwritten by passing as a command line argument."""
+    settings = dynaconf.Dynaconf(
+        settings_files=[config_file],
+        envvar_prefix="ROBOHERD",
+    )
+    ctx.ensure_object(dict)
+
+    ctx.obj["config_file"] = config_file
+    ctx.obj["settings"] = settings
+
+    if connection_string:
+        ctx.obj["connection_string"] = connection_string
+    else:
+        ctx.obj["connection_string"] = settings.get("connection_string")
+
+    if base_url:
+        ctx.obj["base_url"] = base_url
+    else:
+        ctx.obj["base_url"] = settings.get("base_url")
+
+
+@main.command()
+@click.pass_context
+def run(ctx):
+    """Runs the roboherd by connecting to the server."""
+
+    create_connection(ctx)
+
+    herd = RoboHerd(base_url=ctx.obj["base_url"])
+
+    settings = ctx.obj["settings"]
+
+    if settings.get("cow"):
+        herd.manager = HerdManager.from_settings(settings)
+        asyncio.run(herd.run(ctx.obj["connection"]))
+    else:
+        click.echo("No cows specified")
+        exit(1)
+
+
+@main.command()
+@click.pass_context
+def watch(ctx):
+    """Watches the file the module is in for changes and then restarts roboherd.
+
+    Note: Options for roboherd are currently ignored (FIXME)."""
+
+    watchfiles.run_process("roboherd", target="roboherd run")
+
+
+@main.command()
+@click.pass_context
+@click.option("--name", help="Name for the account to be created", prompt=True)
+@click.option(
+    "--password",
+    help="Password for the account to be created",
+    hide_input=True,
+    prompt=True,
+)
+@click.option("--fediverse", help="Fediverse handle", prompt=True)
+def register(ctx, name, password, fediverse):
+    """Registers a new account on dev.bovine.social. All three options are required. If not provided, you will be prompted for them."""
+
+    if os.path.exists(ctx.obj["config_file"]):
+        click.echo("Config file already exists")
+        exit(1)
+
+    if len(password) < 6:
+        click.echo("Password should have at least 6 characters")
+        exit(1)
+
+    asyncio.run(run_register(ctx.obj["config_file"], name, password, fediverse))
+
+
+if __name__ == "__main__":
+    main()

roboherd/annotations/__init__.py

@@ -0,0 +1,50 @@
+from fast_depends import Depends
+from typing import Annotated, Callable, Awaitable
+
+from almabtrieb import Almabtrieb
+
+
+def get_raw(data: dict) -> dict:
+    return data.get("data").get("raw")
+
+
+def get_parsed(data: dict) -> dict:
+    result = data.get("data").get("parsed")
+    if result is None:
+        raise ValueError("No parsed data found")
+    return result
+
+
+RawData = Annotated[dict, Depends(get_raw)]
+"""The raw data as received by cattle_grid"""
+
+ParsedData = Annotated[dict, Depends(get_parsed)]
+"""The parsed data as transformed by muck_out"""
+
+
+def get_activity(parsed: ParsedData) -> dict:
+    return parsed.get("activity")
+
+
+def get_embedded_object(parsed: ParsedData) -> dict:
+    return parsed.get("embeddedObject")
+
+
+Activity = Annotated[dict, Depends(get_activity)]
+"""The activity parsed by muck_out"""
+
+EmbeddedObject = Annotated[dict, Depends(get_embedded_object)]
+"""The embedded object in the activity as parsed by muck_out"""
+
+Publisher = Callable[[dict], Awaitable[None]]
+
+
+def construct_publish_object(connection: Almabtrieb, actor_id: str) -> Publisher:
+    async def publish(data: dict):
+        await connection.trigger("publish_object", {"actor": actor_id, "data": data})
+
+    return publish
+
+
+PublishObject = Annotated[Publisher, Depends(construct_publish_object)]
+"""Allows one to publish an object as the actor. Assumes cattle_grid has the extension `simple_object_storage` or equivalent"""

roboherd/annotations/bovine.py

@@ -0,0 +1,41 @@
+"""Test documentation"""
+
+from typing import Annotated
+from fast_depends import Depends
+from .common import Profile
+
+try:
+    from bovine.activitystreams import factories_for_actor_object
+    from bovine.activitystreams.activity_factory import (
+        ActivityFactory as BovineActivityFactory,
+    )
+    from bovine.activitystreams.object_factory import (
+        ObjectFactory as BovineObjectFactory,
+    )
+
+    def get_activity_factory(profile: Profile) -> BovineActivityFactory:
+        activity_factory, _ = factories_for_actor_object(profile)
+        return activity_factory
+
+    def get_object_factory(profile: Profile) -> BovineObjectFactory:
+        _, object_factory = factories_for_actor_object(profile)
+        return object_factory
+
+except ImportError:
+
+    class BovineActivityFactory: ...
+
+    class BovineObjectFactory: ...
+
+    def get_activity_factory() -> None:
+        raise ImportError("bovine not installed")
+
+    def get_object_factory() -> None:
+        raise ImportError("bovine not installed")
+
+
+ActivityFactory = Annotated[BovineActivityFactory, Depends(get_activity_factory)]
+"""The activity factory of type [bovine.activitystreams.activity_factory.ActivityFactory][]"""
+
+ObjectFactory = Annotated[BovineObjectFactory, Depends(get_object_factory)]
+"""The object factory of type [bovine.activitystreams.object_factory.ObjectFactory][]"""

roboherd/annotations/common.py

@@ -0,0 +1,12 @@
+from fast_depends import Depends
+from typing import Annotated
+
+from roboherd.cow import RoboCow
+
+
+def get_profile(cow: RoboCow) -> dict:
+    return cow.profile
+
+
+Profile = Annotated[dict, Depends(get_profile)]
+"""The profile of the cow"""

roboherd/cow/__init__.py

@@ -0,0 +1,211 @@
+import logging
+
+from typing import Callable, List
+
+from dataclasses import dataclass, field
+from fast_depends import inject
+
+from cron_descriptor import get_description
+from almabtrieb import Almabtrieb
+
+from .types import Information
+from .handlers import Handlers, HandlerConfiguration
+from .profile import determine_profile_update
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CronEntry:
+    """A cron entry"""
+
+    crontab: str = field(metadata=dict(description="""The cron expression"""))
+
+    func: Callable = field(metadata=dict(description="""The function to be called"""))
+
+
+@dataclass
+class RoboCow:
+    information: Information = field(
+        metadata=dict(description="Information about the cow")
+    )
+
+    auto_follow: bool = field(
+        default=True,
+        metadata=dict(
+            description="""Whether to automatically accept follow requests"""
+        ),
+    )
+
+    profile: dict | None = field(
+        default=None,
+        metadata=dict(
+            description="""The profile of the cow, aka as the actor object in ActivityPub"""
+        ),
+    )
+
+    actor_id: str | None = field(
+        default=None,
+        metadata=dict(description="""Actor Id of the cow; loaded automatically"""),
+    )
+
+    handlers: Handlers = field(
+        default_factory=Handlers,
+        metadata=dict(
+            description="""Handlers for incoming and outgoing messages, added through annotations"""
+        ),
+    )
+    handler_configuration: List[HandlerConfiguration] = field(
+        default_factory=list,
+        metadata=dict(
+            description="""Handler configurations, added through annotations"""
+        ),
+    )
+
+    cron_entries: List[CronEntry] = field(
+        default_factory=list,
+        metadata=dict(description="""Cron entries, created through annotations"""),
+    )
+
+    startup_routine: Callable | None = None
+
+    def action(self, action: str = "*", activity_type: str = "*"):
+        """Adds a handler for an event. Use "*" as a wildcard.
+
+        Usage:
+
+        ```python
+        cow = Robocow(information=Information(handle="example"))
+
+        @cow.action(action="outgoing", activity_type="Follow")
+        async def handle_outgoing_follow(data):
+            ...
+        ```
+        """
+
+        config = HandlerConfiguration(
+            action=action,
+            activity_type=activity_type,
+        )
+
+        def inner(func):
+            config.func = func
+            self.handlers.add_handler(config, func)
+            self.handler_configuration.append(config)
+            return func
+
+        return inner
+
+    def cron(self, crontab):
+        def inner(func):
+            self.cron_entries.append(CronEntry(crontab, func))
+
+            return func
+
+        return inner
+
+    def incoming(self, func):
+        """Adds a handler for an incoming message. Usage:
+
+        ```python
+        cow = Robocow("example")
+
+        @cow.incoming
+        async def handle_incoming(data):
+            ...
+        ```
+        """
+        config = HandlerConfiguration(
+            action="incoming",
+            activity_type="*",
+        )
+        self.handlers.add_handler(config, func)
+        return func
+
+    def incoming_create(self, func):
+        """Adds a handler for an incoming activity if the
+        activity is of type_create
+
+        ```python
+        cow = Robocow("example")
+
+        @cow.incoming_create
+        async def handle_incoming(data):
+            ...
+        ```
+        """
+        config = HandlerConfiguration(
+            action="incoming", activity_type="Create", func=func
+        )
+        self.handler_configuration.append(config)
+        self.handlers.add_handler(config, func)
+        return func
+
+    def startup(self, func):
+        """Adds a startup routine to be run when the cow is started."""
+
+        self.startup_routine = func
+
+    def needs_update(self):
+        """Checks if the cow needs to be updated"""
+        if self.profile is None:
+            return True
+
+        if self.information.name != self.profile.get("name"):
+            return True
+
+        if self.information.description != self.profile.get("summary"):
+            return True
+
+        return False
+
+    def update_data(self):
+        """
+        Returns the update_actor message to send to cattle_grid
+
+        ```pycon
+        >>> info = Information(handle="moocow", name="name", description="description")
+        >>> cow = RoboCow(information=info, actor_id="http://host.example/actor/1")
+        >>> cow.update_data()
+        {'actor': 'http://host.example/actor/1',
+            'profile': {'name': 'name',
+                'summary': 'description'},
+            'automaticallyUpdateFollowers': True}
+
+        ```
+        """
+        return {
+            "actor": self.actor_id,
+            "profile": {
+                "name": self.information.name,
+                "summary": self.information.description,
+            },
+            "automaticallyUpdateFollowers": self.auto_follow,
+        }
+
+    async def run_startup(self, connection: Almabtrieb):
+        """Runs when the cow is birthed"""
+
+        if self.profile is None:
+            result = await connection.fetch(self.actor_id, self.actor_id)
+            self.profile = result.data
+
+        if self.cron_entries:
+            frequency = ", ".join(
+                get_description(entry.crontab) for entry in self.cron_entries
+            )
+            self.information.frequency = frequency
+
+        update = determine_profile_update(self.information, self.profile)
+
+        if update:
+            logger.info("Updating profile for %s", self.information.handle)
+
+            await connection.trigger("update_actor", update)
+
+        if self.startup_routine:
+            await inject(self.startup_routine)(
+                cow=self,
+                connection=connection,
+                actor_id=self.actor_id,
+            )

roboherd/cow/handlers.py

@@ -0,0 +1,54 @@
+import logging
+
+from typing import Callable
+from dataclasses import dataclass
+from collections import defaultdict
+from almabtrieb import Almabtrieb
+
+from .util import call_handler, HandlerInformation
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class HandlerConfiguration:
+    action: str
+    activity_type: str
+    func: Callable | None = None
+
+
+class Handlers:
+    def __init__(self):
+        self.handler_map = defaultdict(lambda: defaultdict(list))
+
+    @property
+    def has_handlers(self):
+        return len(self.handler_map) > 0
+
+    def add_handler(self, config: HandlerConfiguration, func):
+        self.handler_map[config.action][config.activity_type].append(
+            HandlerInformation(func=func)
+        )
+
+    async def handle(
+        self,
+        data: dict,
+        event_type: str,
+        connection: Almabtrieb,
+        actor_id: str | None = None,
+        cow=None,
+    ):
+        activity = data.get("data", {}).get("raw", {})
+        data_activity_type = activity.get("type")
+
+        if actor_id is None:
+            logger.warning("Skipping handlers due to missing actor_id")
+            return
+
+        for action in [event_type, "*"]:
+            for activity_type in [data_activity_type, "*"]:
+                handlers = self.handler_map[action][activity_type]
+                for handler_info in handlers:
+                    await call_handler(
+                        handler_info, data, connection, actor_id=actor_id, cow=cow
+                    )

roboherd/cow/profile.py

@@ -0,0 +1,113 @@
+from urllib.parse import urlparse
+from bovine.activitystreams.utils import as_list
+
+from .types import Information
+
+
+def profile_part_needs_update(information: Information, profile: dict) -> bool:
+    if information.name != profile.get("name"):
+        return True
+
+    if information.description != profile.get("summary"):
+        return True
+
+    if information.type != profile.get("type"):
+        return True
+
+    return False
+
+
+def key_index_from_attachment(attachments: list[dict], key: str) -> int | None:
+    for idx, attachment in enumerate(attachments):
+        if attachment is None:
+            continue
+        if attachment.get("type") == "PropertyValue" and attachment.get("name") == key:
+            return idx
+    return None
+
+
+def determine_action_for_key_and_value(
+    attachments: list[dict], key: str, value: str
+) -> dict | None:
+    idx = key_index_from_attachment(attachments, key)
+    if idx is None:
+        if value:
+            return {
+                "action": "update_property_value",
+                "key": key,
+                "value": value,
+            }
+        return None
+
+    if value is None:
+        return {
+            "action": "remove_property_value",
+            "key": key,
+        }
+    current_value = attachments[idx].get("value")
+    if value != current_value:
+        return {
+            "action": "update_property_value",
+            "key": key,
+            "value": value,
+        }
+
+    return None
+
+
+def determine_actions(information: Information, profile: dict) -> list[dict] | None:
+    attachments = as_list(profile.get("attachment", []))
+    meta_information = information.meta_information
+
+    actions = [
+        determine_action_for_key_and_value(
+            attachments, "Author", meta_information.author
+        ),
+        determine_action_for_key_and_value(
+            attachments, "Source", meta_information.source
+        ),
+        determine_action_for_key_and_value(
+            attachments, "Frequency", information.frequency
+        ),
+    ]
+
+    if information.handle and profile.get("preferredUsername") is None:
+        actions.append(
+            {
+                "action": "add_identifier",
+                "identifier": "acct:"
+                + information.handle
+                + "@"
+                + urlparse(profile.get("id")).netloc,
+                "primary": True,
+            }
+        )
+
+    actions = list(filter(lambda x: x, actions))
+
+    if len(actions) == 0:
+        return None
+    return actions
+
+
+def determine_profile_update(information: Information, profile: dict) -> dict:
+    """Returns the update for the profile"""
+
+    update = {"actor": profile.get("id")}
+
+    if profile_part_needs_update(information, profile):
+        update["profile"] = {
+            "type": information.type,
+            "name": information.name,
+            "summary": information.description,
+        }
+
+    actions = determine_actions(information, profile)
+
+    if actions:
+        update["actions"] = actions
+
+    if len(update) == 1:
+        return None
+
+    return update

roboherd/cow/test_handlers.py

@@ -0,0 +1,76 @@
+import pytest
+
+from unittest.mock import AsyncMock
+
+from almabtrieb.mqtt import MqttConnection
+
+from .handlers import Handlers, HandlerConfiguration
+
+
+@pytest.mark.parametrize(
+    "action,activity_type",
+    [
+        ("incoming", "AnimalSound"),
+        ("incoming", "*"),
+        ("*", "AnimalSound"),
+        ("*", "*"),
+    ],
+)
+async def test_handlers_should_run(action, activity_type):
+    handlers = Handlers()
+    connection = AsyncMock(MqttConnection)
+
+    mock = AsyncMock()
+
+    handlers.add_handler(
+        HandlerConfiguration(action=action, activity_type=activity_type), mock
+    )
+    await handlers.handle(
+        {"data": {"raw": {"type": "AnimalSound"}}},
+        "incoming",
+        connection,
+        actor_id="actor_id",
+    )
+
+    mock.assert_awaited_once()
+
+
+@pytest.mark.parametrize(
+    "action,activity_type",
+    [
+        ("outgoing", "AnimalSound"),
+        ("outgoing", "*"),
+        ("*", "Create"),
+        ("incoming", "Create"),
+    ],
+)
+async def test_handlers_should_nod_run(action, activity_type):
+    handlers = Handlers()
+    connection = AsyncMock(MqttConnection)
+
+    mock = AsyncMock()
+
+    handlers.add_handler(
+        HandlerConfiguration(action=action, activity_type=activity_type), mock
+    )
+
+    await handlers.handle(
+        {"data": {"raw": {"type": "AnimalSound"}}},
+        "incoming",
+        connection,
+        actor_id="actor_id",
+    )
+
+    mock.assert_not_awaited()
+
+
+def test_has_handlers():
+    handlers = Handlers()
+
+    assert not handlers.has_handlers
+
+    handlers.add_handler(
+        HandlerConfiguration(action="outgoing", activity_type="Create"), AsyncMock()
+    )
+
+    assert handlers.has_handlers