roboherd 0.1.2__py3-none-any.whl

roboherd/herd/manager/test_config.py

@@ -0,0 +1,65 @@
+import pytest
+
+from dynaconf import Dynaconf
+
+from roboherd.cow import RoboCow
+
+from .config import CowConfig, HerdConfig
+
+
+@pytest.fixture
+def test_config():
+    config = Dynaconf()
+    config.update(
+        {
+            "cow": {
+                "moocow": {
+                    "bot": "moocow:bot",
+                },
+                "rooster": {
+                    "bot": "rooster:bot",
+                },
+            },
+        }
+    )
+    return config
+
+
+def test_from_name_and_dict():
+    name = "cow"
+    value = {
+        "bot": "module:attribute",
+    }
+
+    cow = CowConfig.from_name_and_dict(name, value)
+
+    assert cow.name == name
+    assert cow.module == "module"
+    assert cow.attribute == "attribute"
+
+
+def test_load_config(test_config):
+    herd = HerdConfig.from_settings(test_config)
+
+    assert len(herd.cows) == 2
+
+    moocow = herd.for_name("moocow")
+
+    assert moocow.name == "moocow"
+
+
+def test_load_from_cow_config():
+    name = "cow"
+    value = {
+        "bot": "roboherd.examples.moocow:moocow",
+    }
+
+    cow = CowConfig.from_name_and_dict(name, value)
+
+    assert isinstance(cow.load(), RoboCow)
+
+
+def test_names(test_config):
+    herd = HerdConfig.from_settings(test_config)
+
+    assert herd.names == {"moocow", "rooster"}

roboherd/herd/manager/test_manager.py

@@ -0,0 +1,42 @@
+import pytest
+from dynaconf import Dynaconf
+
+from almabtrieb.model import ActorInformation
+
+
+from . import HerdManager
+
+
+@pytest.fixture
+def test_config():
+    config = Dynaconf()
+    config.update(
+        {
+            "cow": {
+                "moocow": {
+                    "bot": "roboherd.examples.moocow:moocow",
+                },
+                "rooster": {
+                    "bot": "roboherd.examples.rooster:bot",
+                },
+            },
+        }
+    )
+    return config
+
+
+@pytest.mark.parametrize(
+    "actor_info,result_lenth",
+    [
+        ([], 2),
+        ([ActorInformation(name="bot:moocow", id="http://host.test/actor")], 1),
+        ([ActorInformation(name="moocow", id="http://host.test/actor")], 2),
+        ([ActorInformation(name="bot:other", id="http://host.test/actor")], 2),
+    ],
+)
+def test_cows_to_create(test_config, actor_info, result_lenth):
+    manager = HerdManager.from_settings(test_config)
+
+    result = manager.cows_to_create(actor_info)
+
+    assert len(result) == result_lenth

roboherd/herd/processor.py

@@ -0,0 +1,39 @@
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import List
+
+from almabtrieb import Almabtrieb
+
+from roboherd.cow import RoboCow
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class HerdProcessor:
+    connection: Almabtrieb
+    incoming_handlers: List[RoboCow]
+
+    def create_tasks(self, task_group: asyncio.TaskGroup):
+        tasks = []
+        if len(self.incoming_handlers) > 0:
+            tasks.append(task_group.create_task(self.process_incoming(self.connection)))
+
+        return tasks
+
+    async def process_incoming(self, connection):
+        actor_id_to_cow_map = {}
+        for cow in self.incoming_handlers:
+            actor_id_to_cow_map[cow.actor_id] = cow
+
+        async for msg in connection.incoming():
+            actor_id = msg["actor"]
+
+            cow = actor_id_to_cow_map.get(actor_id)
+            logger.info(cow)
+            if cow:
+                await cow.handlers.handle(
+                    msg, "incoming", connection, actor_id, cow=cow
+                )

roboherd/herd/scheduler.py

@@ -0,0 +1,50 @@
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import List, Tuple
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from fast_depends import inject
+
+from almabtrieb import Almabtrieb
+
+from roboherd.cow import RoboCow, CronEntry
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class HerdScheduler:
+    entries: List[Tuple[RoboCow, CronEntry]]
+    connection: Almabtrieb
+
+    def create_task(self, task_group: asyncio.TaskGroup):
+        if len(self.entries) == 0:
+            logger.info("No tasks to schedule")
+            return
+        task_group.create_task(self.run())
+
+    async def run(self):
+        if len(self.entries) == 0:
+            return
+
+        scheduler = AsyncIOScheduler()
+
+        for cow, entry in self.entries:
+            trigger = CronTrigger.from_crontab(entry.crontab)
+            scheduler.add_job(
+                inject(entry.func),
+                trigger=trigger,
+                kwargs={
+                    "actor_id": cow.actor_id,
+                    "connection": self.connection,
+                    "cow": cow,
+                },
+            )
+
+        scheduler.start()
+
+        while True:
+            await asyncio.sleep(60 * 60)

roboherd/herd/test_herd.py

@@ -0,0 +1,37 @@
+import pytest
+
+from roboherd.examples.moocow import moocow
+from roboherd.examples.rooster import bot
+from roboherd.examples.dev_null import bot as dev_null
+
+from roboherd.cow import CronEntry
+
+from . import RoboHerd
+
+
+@pytest.mark.parametrize("cow, length", [(moocow, 0), (bot, 1)])
+def test_cron_entries(cow, length):
+    manager = RoboHerd(cows=[cow])
+
+    assert len(manager.cron_entries()) == length
+
+
+def test_cron_entries_result():
+    manager = RoboHerd(cows=[bot])
+
+    result = manager.cron_entries()[0]
+
+    assert result[0] == bot
+    assert isinstance(result[1], CronEntry)
+
+
+def test_incoming_handlers_no_result():
+    manager = RoboHerd(cows=[dev_null])
+
+    assert len(manager.incoming_handlers()) == 0
+
+
+def test_incoming_handlers_result():
+    manager = RoboHerd(cows=[moocow])
+
+    assert len(manager.incoming_handlers()) == 1

roboherd/herd/test_scheduler.py

@@ -0,0 +1,17 @@
+import asyncio
+from unittest.mock import AsyncMock
+
+from .scheduler import HerdScheduler
+
+
+async def test_empty_scheduler_exits():
+    scheduler = HerdScheduler(entries=[], connection=AsyncMock())
+
+    await scheduler.run()
+
+
+async def test_scheduler_runs_with_task_group_exits():
+    scheduler = HerdScheduler(entries=[], connection=AsyncMock())
+
+    async with asyncio.TaskGroup() as tg:
+        scheduler.create_task(tg)

roboherd/herd/types.py

@@ -0,0 +1,12 @@
+from typing import Callable
+from dataclasses import dataclass
+
+from roboherd.cow import RoboCow
+
+
+@dataclass
+class HandlerInformation:
+    action: str
+    activity_type: str
+    func: Callable
+    cow: RoboCow

roboherd/register.py

@@ -0,0 +1,38 @@
+import aiohttp
+import tomli_w
+
+
+def create_config(name, password, domain="dev.bovine.social"):
+    """
+
+    ```
+    >>> create_config("alice", "pass")
+    {'base_url': 'https://dev.bovine.social',
+        'connection_string': 'wss://alice:pass@dev.bovine.social/mooqtt',
+        'echo': False}
+
+    ```
+    """
+
+    return {
+        "base_url": f"https://{domain}",
+        "connection_string": f"wss://{name}:{password}@{domain}/mooqtt",
+        "echo": False,
+    }
+
+
+async def register(config_file, name, password, fediverse):
+    async with aiohttp.ClientSession() as session:
+        result = await session.post(
+            "https://dev.bovine.social/register",
+            json={
+                "name": name,
+                "password": password,
+                "fediverse": fediverse,
+            },
+        )
+
+        assert result.status == 201, "Something went wrong"
+
+    with open(config_file, "wb") as f:
+        tomli_w.dump(create_config(name, password), f)

roboherd/test_util.py

@@ -0,0 +1,24 @@
+import pytest
+
+from roboherd.cow import RoboCow
+
+from .util import import_cow
+
+
+def test_import_cow():
+    cow = import_cow("roboherd.examples.moocow:moocow")
+
+    assert isinstance(cow, RoboCow)
+    assert cow.information.handle == "moocow"
+
+
+def test_import_cow_failed():
+    with pytest.raises(ImportError):
+        import_cow("robocow:nocow")
+
+
+def test_import_cow_with_handle():
+    cow = import_cow("roboherd.examples.moocow:moocow?handle=horse")
+
+    assert isinstance(cow, RoboCow)
+    assert cow.information.handle == "horse"

roboherd/util.py

@@ -0,0 +1,116 @@
+import click
+import logging
+import copy
+import importlib
+from importlib import import_module
+from urllib.parse import parse_qs, urlparse
+
+from almabtrieb import Almabtrieb
+
+from roboherd.cow import RoboCow
+
+logger = logging.getLogger(__name__)
+
+
+def parse_connection_string(connection_string: str) -> dict:
+    """
+    Parse a connection string into a dictionary of connection parameters.
+
+    ```pycon
+    >>> parse_connection_string("ws://user:pass@host/ws")
+    {'host': 'host',
+        'port': 80,
+        'username': 'user',
+        'password': 'pass',
+        'websocket_path': '/ws'}
+
+    >>> parse_connection_string("wss://user:pass@host/ws")
+    {'host': 'host',
+        'port': 443,
+        'username': 'user',
+        'password': 'pass',
+        'websocket_path': '/ws'}
+
+    ```
+    """
+
+    parsed = urlparse(connection_string)
+
+    default_port = 80 if parsed.scheme == "ws" else 443
+
+    return {
+        "host": parsed.hostname,
+        "port": parsed.port or default_port,
+        "username": parsed.username,
+        "password": parsed.password,
+        "websocket_path": parsed.path,
+    }
+
+
+def load_cow(module_name: str, attribute: str) -> RoboCow:
+    """Loads a cow from module name and attribute"""
+    module = import_module(module_name)
+    importlib.reload(module)
+
+    cow = getattr(module, attribute)
+
+    return copy.deepcopy(cow)
+
+
+def import_cow(name: str) -> RoboCow:
+    """Imports a cow from a string of the form
+    `module.name:attribute`. Here attribute should
+    be of type [roboherd.cow.RoboCow][roboherd.cow.RoboCow].
+
+    ```pycon
+    >>> cow = import_cow("roboherd.examples.moocow:moocow")
+    >>> cow.information.handle
+    'moocow'
+
+    ```
+    """
+    try:
+        query = None
+        module_name, attribute = name.split(":")
+        if "?" in attribute:
+            attribute, query = attribute.split("?")
+
+        cow = load_cow(module_name, attribute)
+
+        if query:
+            parsed_query = parse_qs(query)
+            handle = parsed_query.get("handle", [None])[0]
+            if handle:
+                cow.information.handle = handle
+
+        return cow
+
+    except Exception as e:
+        logger.error("Failed to import cow with name: %s", name)
+        logger.error("names should have the form module:attribute")
+        logger.exception(e)
+
+        raise ImportError("Failed to load module")
+
+
+def create_connection(ctx):
+    connection_string = ctx.obj["connection_string"]
+    base_url = ctx.obj["base_url"]
+
+    if not connection_string:
+        click.echo("ERROR: No connection string provided")
+        click.echo(
+            "either provide one through --connection_string or set it in your configuration file"
+        )
+        exit(1)
+
+    if not base_url:
+        click.echo("ERROR: No base url for cows provided")
+        click.echo(
+            "either provide one through --base_url or set it in your configuration file"
+        )
+        exit(1)
+
+    ctx.obj["connection"] = Almabtrieb.from_connection_string(
+        connection_string, echo=ctx.obj["settings"].get("echo", False)
+    )

roboherd-0.1.2.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: roboherd
+Version: 0.1.2
+Summary: A Fediverse bot framework
+Requires-Python: >=3.11
+Requires-Dist: almabtrieb[mqtt]>=0.1.0a1
+Requires-Dist: apscheduler>=3.11.0
+Requires-Dist: click>=8.1.8
+Requires-Dist: cron-descriptor>=1.4.5
+Requires-Dist: dynaconf>=3.2.6
+Requires-Dist: fast-depends>=2.4.12
+Requires-Dist: tomli-w>=1.1.0
+Requires-Dist: watchfiles>=1.0.4
+Provides-Extra: bovine
+Requires-Dist: bovine>=0.5.15; extra == 'bovine'
+Description-Content-Type: text/markdown
+
+# Roboherd
+
+Roboherd is a framework for building Fediverse bots
+using the [Cattle Drive Protocol](https://bovine.codeberg.page/cattle_grid/cattle_drive/).
+
+For more information, see the [documentation](https://bovine.codeberg.page/roboherd/) or the [repository](https://codeberg.org/bovine/roboherd/).

roboherd-0.1.2.dist-info/RECORD

@@ -0,0 +1,40 @@
+roboherd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+roboherd/__main__.py,sha256=y2Ge8zajHn4rB4SlunLzmH5MNMCxklrhTaDdMbujjq8,2873
+roboherd/register.py,sha256=Gqa5aT2supVJMj7z21btMYRma3_WW0oK5gjZftr048s,976
+roboherd/test_util.py,sha256=Yor_YgXtvK3WnZu6jr7DvNtTLdR9YWHCA5QufHo_w2s,535
+roboherd/util.py,sha256=23X_-CiJoW6xd36YhTzIkXoS3y_eN5ILJDCC0GnBhm0,3065
+roboherd/annotations/__init__.py,sha256=hdW1HypuV6duCYxEhR2a9eidgcrC5-oAM-hHyzVh10E,1425
+roboherd/annotations/bovine.py,sha256=3LnS19pJ6Z1pSB50IaTxDnvaPlU_4qp_lFyQjAtJ5P0,1366
+roboherd/annotations/common.py,sha256=xr8FanMMPA1DDnCdguY4DLG9DbqmziaZxNR4-ww2ewk,239
+roboherd/cow/__init__.py,sha256=j6a1i_kAndo71Ufoy1bZr1FC9othg-cz-6x9z5yQ75E,5866
+roboherd/cow/handlers.py,sha256=k5Tc1M--wqmZ2EZvzIfID4dp8XE0rN18puMTKkNVjjE,1491
+roboherd/cow/profile.py,sha256=XEFU8wJYVQxrlbAhUWZSDhfxBn1IXm_6f8YBlpHvUjM,3060
+roboherd/cow/test_handlers.py,sha256=SwrZZcU_BD2BpJUFg18mFEsyUqu7N81-MkjIaGv7whQ,1673
+roboherd/cow/test_init.py,sha256=Te-4Z8lPpMlSv99OkzPLMtB607NSOfdRD3EB-6_3n1A,1370
+roboherd/cow/test_profile.py,sha256=edWKVL8VmOb8XtE1OQmwDLuw4mcDtxMKBfA9Kbd71qU,1423
+roboherd/cow/test_util.py,sha256=8FLRtVdSMmIo6NSpCpB9mS0PwOCpGgUeDAA1q6Gv0P4,430
+roboherd/cow/types.py,sha256=GtDnvpiH0w-Ux6BkhjNOgRdZ9YOITPB16BZd51MzKfA,1709
+roboherd/cow/util.py,sha256=oBytl3cOhYgZCCnihM3wkMxG8xQZUlohVSxCaaHDsYc,493
+roboherd/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+roboherd/examples/dev_null.py,sha256=6SZ9wlcawSBqhdq6Zv4xPXH5eKH2g1VaRwv3hSCDucE,308
+roboherd/examples/json_echo.py,sha256=vOwbCX7apXh87RNFdwDWZXaIpJuJO5Tcsck_9qjRpqw,1354
+roboherd/examples/meta.py,sha256=tFhHe-DJn2J13Mm22f-gFm5I8_3uQwLU4mAkrK2xzEM,170
+roboherd/examples/moocow.py,sha256=OkceeaRqkjR31Nue8anHtL_DMqd7finLzs-gUaKsVBo,1083
+roboherd/examples/number.py,sha256=U71mcmLVqtOkl6vkudHKlJmxmLVCI11q1ekQOoQfTag,1987
+roboherd/examples/rooster.py,sha256=505MzfGM6iqQtffncLOA9Oj5aDeep-_oWS7yEzJbh4o,580
+roboherd/examples/scarecrow.py,sha256=o-54QN63LmxfufslmCDvx1ilWQ7KVMsUBtl1tPMbkEs,617
+roboherd/herd/__init__.py,sha256=DUvzuyB-JWD-awhNzseoMvluugeD02PZF-hJrGVNtJc,2981
+roboherd/herd/builder.py,sha256=MSVPRF0Jsxure9kdyCoYJHQ7nYilGAD0_uQaGQ-rQyE,619
+roboherd/herd/processor.py,sha256=NkROTAPs6ZoYW_0TSDnNkAfos4cTnaFgwtW3wOFSgQY,1022
+roboherd/herd/scheduler.py,sha256=fkR-74bFZ73DmlJje_dQSytxnFFLV5hCa067mXdwvXs,1266
+roboherd/herd/test_herd.py,sha256=sQkzGCWdFveLklhaOJUybtl7odO-QOSDdd-_gan1py8,845
+roboherd/herd/test_scheduler.py,sha256=wLisqRMSl734P_rjbqMNH5WTQKepwihgr7ZC32nEj80,424
+roboherd/herd/types.py,sha256=_EidQbglm0jpsKX1EsL6U2qm_J5wCPhwUi6Avac22Ow,210
+roboherd/herd/manager/__init__.py,sha256=n4QFJXQafHhOJZyDO-mAAWE_hoXcE9vYwFGOPqFOiJM,1409
+roboherd/herd/manager/config.py,sha256=qfcED9PfzKzDCWaYHefYj8AImcsOFs5daGpJwUrXlV4,1313
+roboherd/herd/manager/test_config.py,sha256=cSf6cqFFr5Hbubuc_tDHyDPbVnsKbRg12WUONn6RxIc,1260
+roboherd/herd/manager/test_manager.py,sha256=U6xLOry1K74hd_l8ZtO56v8h1TLNn-UYYfsZJuxuCDA,1031
+roboherd-0.1.2.dist-info/METADATA,sha256=cNehEq5m5RHO7ItfG40HFXYyPCn60hNw3cYJBgToz6E,798
+roboherd-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+roboherd-0.1.2.dist-info/entry_points.txt,sha256=WebdVUmh8Ot-FupKJY6Du8LuFbmezt9yoy2UICqV3bE,52
+roboherd-0.1.2.dist-info/RECORD,,

roboherd-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

roboherd-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+roboherd = roboherd.__main__:main