roboherd 0.1.4__tar.gz → 0.1.5__tar.gz

{roboherd-0.1.4 → roboherd-0.1.5}/.woodpecker/test.yml

@@ -13,8 +13,10 @@ steps:
   test_format:
     image: ghcr.io/astral-sh/uv:python3.11-alpine
     commands:
-      - uv run ruff format .
+      - uv run ruff format --check .
       - uv run ruff check .
+    when:
+      - matrix: { extras: "--all-extras" }
   test_pytest:
     image: ghcr.io/astral-sh/uv:python3.11-alpine
     commands:

{roboherd-0.1.4 → roboherd-0.1.5}/CHANGES.md

@@ -1,5 +1,14 @@
 # Changes to roboherd
 
+## 0.1.5 ([Milestone](https://codeberg.org/bovine/roboherd/milestone/10581))
+
+- Allow overriding the base_url [roboherd#12](https://codeberg.org/bovine/roboherd/issues/12)
+- Separate out the internal state of a RoboCow
+- If no preferredUsername is set and handle is updated, send Update Service [roboherd#33](https://codeberg.org/bovine/roboherd/issues/33)
+- Add an icon property [roboherd#10](https://codeberg.org/bovine/roboherd/issues/10)
+- Added a logo [roboherd#32](https://codeberg.org/bovine/roboherd/issues/32)
+- Add PublishActivity annotation [roboherd#30](https://codeberg.org/bovine/roboherd/issues/30)
+
 ## 0.1.4 ([Milestone](https://codeberg.org/bovine/roboherd/milestone/10442))
 
 - Type check the project

{roboherd-0.1.4 → roboherd-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboherd
-Version: 0.1.4
+Version: 0.1.5
 Summary: A Fediverse bot framework
 Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.11.12

{roboherd-0.1.4 → roboherd-0.1.5}/docs/index.md

@@ -93,8 +93,23 @@ Setting me as the author and the source code is contained in [meta_information][
 --8<-- "roboherd/examples/meta.py"
 ```
 
-!!! todo
-    How to configure a profile picture [roboherd#10](https://codeberg.org/bovine/roboherd/issues/10)
+By setting to `icon` property of [roboherd.cow.types.Information][], one can
+change the profile picture.
+
+### Config overrides
+
+By running
+
+```toml title="roboherd.toml"
+base_url = "https://dev.bovine.social"
+
+[cow.devnull]
+bot = "roboherd.examples.dev_null:bot"
+handle = "nothingness"
+```
+
+one would instead create a bot with the handle `acct:nothingness@dev.bovine.social`.
+Similarly, one can override the name and the `base_url` to use.
 
 ### Posting on startup
 
@@ -103,7 +118,8 @@ By adding
 ```python
 @bot.startup
 async def startup(publish_object: PublishObject, object_factory: ObjectFactory):
-    await publish_object(object_factory.note(content="Booo! 🐦").as_public().build())
+    note = object_factory.note(content="Booo! 🐦").as_public().build()
+    await publish_object(note)
 ```
 
 one can post on startup. Here  [PublishObject][roboherd.annotations.PublishObject]
@@ -119,6 +135,11 @@ ObjectFactory injects an [ObjectFactory][bovine.activitystreams.object_factory.O
     --8<-- "roboherd/examples/scarecrow.py"
     ```
 
+!!! hint
+    Similarly to PublishObject, one can use
+    [PublishActivity][roboherd.annotations.PublishActivity]
+    to post activities.
+
 ### Replying to messages
 
 By adding a block such as
@@ -322,3 +343,7 @@ version, have a [milestone](https://codeberg.org/bovine/roboherd/milestones)
 matching the new version, and appropriate entries in
 `CHANGES.md`. Then once a pull request with this is merged,
 the rest happens automatically.
+
+## Acknowledgements
+
+Logo via [Lorc](https://game-icons.net/1x1/lorc/bull-horns.html).

{roboherd-0.1.4 → roboherd-0.1.5}/mkdocs.yml

@@ -5,6 +5,8 @@ repo_url: https://codeberg.org/bovine/roboherd/
 repo_name: bovine/roboherd
 theme:
   name: material
+  logo: assets/bull-horns.png
+  favicon: assets/bull-horns.png
   icon:
     repo: fontawesome/brands/git-alt
   palette:

{roboherd-0.1.4 → roboherd-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "roboherd"
-version = "0.1.4"
+version = "0.1.5"
 description = "A Fediverse bot framework"
 readme = "README.md"
 requires-python = ">=3.11"

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/annotations/__init__.py

@@ -43,6 +43,7 @@ EmbeddedObject = Annotated[dict, Depends(get_embedded_object)]
 """The embedded object in the activity as parsed by muck_out"""
 
 Publisher = Callable[[dict], Awaitable[None]]
+"""Type returned by the publishing functions"""
 
 
 def construct_publish_object(connection: Almabtrieb, actor_id: str) -> Publisher:
@@ -52,5 +53,16 @@ def construct_publish_object(connection: Almabtrieb, actor_id: str) -> Publisher
     return publish
 
 
+def construct_publish_activity(connection: Almabtrieb, actor_id: str) -> Publisher:
+    async def publish(data: dict):
+        await connection.trigger("publish_activity", {"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"""
+
+
+PublishActivity = Annotated[Publisher, Depends(construct_publish_activity)]
+"""Allows one to publish an activity as the actor. Assumes cattle_grid has the extension `simple_object_storage` or equivalent"""

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/annotations/common.py

@@ -5,9 +5,9 @@ from roboherd.cow import RoboCow
 
 
 def get_profile(cow: RoboCow) -> dict:
-    if cow.profile is None:
+    if cow.internals.profile is None:
         raise ValueError("Cow has no profile")
-    return cow.profile
+    return cow.internals.profile
 
 
 Profile = Annotated[dict, Depends(get_profile)]

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/cow/__init__.py

@@ -25,17 +25,8 @@ class CronEntry:
 
 
 @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"""
-        ),
-    )
+class RoboCowInternals:
+    """Internal data for the cow"""
 
     profile: dict | None = field(
         default=None,
@@ -69,6 +60,27 @@ class RoboCow:
 
     startup_routine: Callable | None = None
 
+    base_url: str | None = field(default=None)
+
+
+@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"""
+        ),
+    )
+
+    internals: RoboCowInternals = field(
+        default_factory=RoboCowInternals,
+        metadata=dict(description="Internal data for the cow"),
+    )
+
     def action(self, action: str = "*", activity_type: str = "*"):
         """Adds a handler for an event. Use "*" as a wildcard.
 
@@ -90,15 +102,15 @@ class RoboCow:
 
         def inner(func):
             config.func = func
-            self.handlers.add_handler(config, func)
-            self.handler_configuration.append(config)
+            self.internals.handlers.add_handler(config, func)
+            self.internals.handler_configuration.append(config)
             return func
 
         return inner
 
     def cron(self, crontab):
         def inner(func):
-            self.cron_entries.append(CronEntry(crontab, func))
+            self.internals.cron_entries.append(CronEntry(crontab, func))
 
             return func
 
@@ -119,7 +131,7 @@ class RoboCow:
             action="incoming",
             activity_type="*",
         )
-        self.handlers.add_handler(config, func)
+        self.internals.handlers.add_handler(config, func)
         return func
 
     def incoming_create(self, func):
@@ -137,79 +149,57 @@ class RoboCow:
         config = HandlerConfiguration(
             action="incoming", activity_type="Create", func=func
         )
-        self.handler_configuration.append(config)
-        self.handlers.add_handler(config, func)
+        self.internals.handler_configuration.append(config)
+        self.internals.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
+        self.internals.startup_routine = func
 
     def needs_update(self):
         """Checks if the cow needs to be updated"""
-        if self.profile is None:
+        if self.internals.profile is None:
             return True
 
-        if self.information.name != self.profile.get("name"):
+        if self.information.name != self.internals.profile.get("name"):
             return True
 
-        if self.information.description != self.profile.get("summary"):
+        if self.information.description != self.internals.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:
-            if not self.actor_id:
+        if self.internals.profile is None:
+            if not self.internals.actor_id:
                 raise ValueError("Actor ID is not set")
-            result = await connection.fetch(self.actor_id, self.actor_id)
+            result = await connection.fetch(
+                self.internals.actor_id, self.internals.actor_id
+            )
             if not result.data:
                 raise ValueError("Could not retrieve profile")
-            self.profile = result.data
+            self.internals.profile = result.data
 
-        if self.cron_entries:
+        if self.internals.cron_entries:
             frequency = ", ".join(
-                get_description(entry.crontab) for entry in self.cron_entries
+                get_description(entry.crontab) for entry in self.internals.cron_entries
             )
             self.information.frequency = frequency
 
-        update = determine_profile_update(self.information, self.profile)
+        update = determine_profile_update(self.information, self.internals.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,
-            )
+        if self.internals.startup_routine:
+            await inject(self.internals.startup_routine)(
+                cow=self,  # type:ignore
+                connection=connection,  # type:ignore
+                actor_id=self.internals.actor_id,  # type:ignore
+            )  # type:ignore

roboherd-0.1.5/roboherd/cow/const.py

@@ -0,0 +1,6 @@
+default_icon = {
+    "mediaType": "image/png",
+    "type": "Image",
+    "url": "https://dev.bovine.social/assets/bull-horns.png",
+}
+"""The default icon to be used"""

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/cow/profile.py

@@ -24,6 +24,9 @@ def profile_part_needs_update(information: Information, profile: dict) -> bool:
     if information.type != profile.get("type"):
         return True
 
+    if information.icon != profile.get("icon"):
+        return True
+
     return False
 
 
@@ -110,6 +113,7 @@ def determine_profile_update(information: Information, profile: dict) -> dict |
             "type": information.type,
             "name": information.name,
             "summary": information.description,
+            "icon": information.icon,
         }
 
     actions = determine_actions(information, profile)

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/cow/test_init.py

@@ -27,7 +27,8 @@ def test_needs_update(name, summary, profile, expected):
         name=name,
         description=summary,
     )
-    cow = RoboCow(information=info, profile=profile)
+    cow = RoboCow(information=info)
+    cow.internals.profile = profile
 
     assert cow.needs_update() == expected
 
@@ -40,13 +41,13 @@ def test_cron():
     async def test_func():
         pass
 
-    assert len(cow.cron_entries) == 1
+    assert len(cow.internals.cron_entries) == 1
 
 
 async def test_startup():
     info = Information(handle="testcow")
     cow = RoboCow(information=info)
-    cow.profile = {"id": "http://host.test/actor/cow"}
+    cow.internals.profile = {"id": "http://host.test/actor/cow"}
     mock = AsyncMock()
 
     cow.startup(mock)

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/cow/test_profile.py

@@ -1,7 +1,7 @@
 import pytest
 
 from .types import Information, MetaInformation
-
+from .const import default_icon
 from .profile import determine_profile_update
 
 
@@ -14,6 +14,7 @@ from .profile import determine_profile_update
     ],
 )
 def test_determine_profile_update_no_update(info_params, profile):
+    profile["icon"] = default_icon
     info = Information(**info_params)
 
     assert determine_profile_update(info, profile) is None
@@ -27,13 +28,22 @@ def test_determine_profile_update():
 
     assert result == {
         "actor": "http://host.test/actor/1",
-        "profile": {"type": "Service", "name": "name", "summary": "description"},
+        "profile": {
+            "type": "Service",
+            "name": "name",
+            "summary": "description",
+            "icon": default_icon,
+        },
     }
 
 
 def test_determine_profile_update_author():
     info = Information(meta_information=MetaInformation(author="acct:author@host.test"))
-    profile = {"id": "http://host.test/actor/1", "type": "Service"}
+    profile = {
+        "id": "http://host.test/actor/1",
+        "type": "Service",
+        "icon": default_icon,
+    }
 
     result = determine_profile_update(info, profile)
 
@@ -47,3 +57,25 @@ def test_determine_profile_update_author():
             }
         ],
     }
+
+
+def test_profile_update_for_new_preferredUsername():
+    info = Information(handle="handle")
+    profile = {
+        "id": "http://host.test/actor/1",
+        "type": "Service",
+        "icon": default_icon,
+    }
+
+    result = determine_profile_update(info, profile)
+
+    assert result == {
+        "actor": "http://host.test/actor/1",
+        "actions": [
+            {
+                "action": "add_identifier",
+                "identifier": "acct:handle@host.test",
+                "primary": True,
+            }
+        ],
+    }

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/cow/types.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, Field
 
+from .const import default_icon
+
 
 class MetaInformation(BaseModel):
     """Meta Information about the bot. This includes
@@ -48,6 +50,11 @@ class Information(BaseModel):
         description="The description of the cow, used as summary of the actor",
     )
 
+    icon: dict = Field(
+        default=default_icon,
+        description="The profile image",
+    )
+
     frequency: str | None = Field(
         default=None,
         examples=["daily"],

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/examples/moocow.py

@@ -21,7 +21,9 @@ See <a href="https://codeberg.org/helge/roboherd">codeberg.org</a>.""",
 
 
 @moocow.incoming_create
-async def on_incoming_create(obj: EmbeddedObject, publisher: PublishObject):
+async def on_incoming_create(
+    obj: EmbeddedObject, publisher: PublishObject, actor_id: str
+):
     recipient = obj.get("attributedTo")
 
     logger.info("Replying to %s", recipient)
@@ -29,7 +31,7 @@ async def on_incoming_create(obj: EmbeddedObject, publisher: PublishObject):
     obj = {
         "@context": "https://www.w3.org/ns/activitystreams",
         "type": "Note",
-        "attributedTo": moocow.actor_id,
+        "attributedTo": actor_id,
         "to": [recipient],
         "cc": ["https://www.w3.org/ns/activitystreams#Public"],
         "content": "moo",

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/examples/scarecrow.py

@@ -18,4 +18,5 @@ bot = RoboCow(
 
 @bot.startup
 async def startup(publish_object: PublishObject, object_factory: ObjectFactory):
-    await publish_object(object_factory.note(content="Booo! 🐦").as_public().build())  # type: ignore
+    note = object_factory.note(content="Booo! 🐦").as_public().build()  # type: ignore
+    await publish_object(note)

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/herd/__init__.py

@@ -41,12 +41,12 @@ class RoboHerd:
             cow = cow_config.load()
             result = await connection.create_actor(
                 name=f"{self.manager.prefix}{cow_config.name}",
-                base_url=self.base_url,
+                base_url=cow.internals.base_url or self.base_url,
                 preferred_username=cow.information.handle,
                 profile={"type": "Service"},
                 automatically_accept_followers=True,
             )
-            cow.actor_id = result.get("id")
+            cow.internals.actor_id = result.get("id")
 
             self.cows.append(cow)
 
@@ -81,7 +81,7 @@ class RoboHerd:
 
         result = []
         for cow in self.cows:
-            for cron_entry in cow.cron_entries:
+            for cron_entry in cow.internals.cron_entries:
                 result.append((cow, cron_entry))
 
         return result
@@ -89,6 +89,6 @@ class RoboHerd:
     def incoming_handlers(self) -> List[RoboCow]:
         result = []
         for cow in self.cows:
-            if cow.handlers.has_handlers:
+            if cow.internals.handlers.has_handlers:
                 result.append(cow)
         return result

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/herd/manager/__init__.py

@@ -30,7 +30,7 @@ class HerdManager:
                 cow_config = self.herd_config.for_name(cow_name)
                 if cow_config:
                     cow = cow_config.load()
-                    cow.actor_id = info.id
+                    cow.internals.actor_id = info.id
                     existing_cows.append(cow)
 
         return existing_cows

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/herd/manager/config.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 
 from roboherd.cow import RoboCow
-from roboherd.util import load_cow
+from .load import load_cow
 
 
 @dataclass
@@ -9,19 +9,26 @@ class CowConfig:
     name: str = field(metadata={"description": "Name of the cow, must be unique"})
     module: str
     attribute: str
+    config: dict
 
     @staticmethod
     def from_name_and_dict(name, cow: dict) -> "CowConfig":
         module, attribute = cow["bot"].split(":")
 
-        return CowConfig(
-            name=name,
-            module=module,
-            attribute=attribute,
-        )
+        return CowConfig(name=name, module=module, attribute=attribute, config=cow)
 
     def load(self) -> RoboCow:
-        return load_cow(self.module, self.attribute)
+        cow = load_cow(self.module, self.attribute)
+
+        if "name" in self.config:
+            cow.information.name = self.config["name"]
+        if "handle" in self.config:
+            cow.information.handle = self.config["handle"]
+
+        if "base_url" in self.config:
+            cow.internals.base_url = self.config["base_url"]
+
+        return cow
 
     def __hash__(self):
         return hash(self.name)

roboherd-0.1.5/roboherd/herd/manager/load.py

@@ -0,0 +1,15 @@
+import copy
+import importlib
+from importlib import import_module
+
+from roboherd.cow import RoboCow
+
+
+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)

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/herd/manager/test_config.py

@@ -38,6 +38,22 @@ def test_from_name_and_dict():
     assert cow.attribute == "attribute"
 
 
+def test_from_name_and_dict_with_new_name():
+    name = "cow"
+    value = {
+        "bot": "roboherd.examples.moocow:moocow",
+        "handle": "new_handle",
+        "name": "new name",
+    }
+
+    config = CowConfig.from_name_and_dict(name, value)
+
+    cow = config.load()
+
+    assert cow.information.name == "new name"
+    assert cow.information.handle == "new_handle"
+
+
 def test_load_config(test_config):
     herd = HerdConfig.from_settings(test_config)
 

roboherd-0.1.5/roboherd/herd/manager/test_load.py

@@ -0,0 +1,19 @@
+from roboherd.cow import RoboCow
+
+from .load import load_cow
+
+
+def test_load_cow():
+    cow = load_cow("roboherd.examples.moocow", "moocow")
+    assert isinstance(cow, RoboCow)
+
+
+def test_load_cow_can_overwrite_variables():
+    one = load_cow("roboherd.examples.moocow", "moocow")
+
+    one.information.name = "A cow eating watermelons"
+
+    two = load_cow("roboherd.examples.moocow", "moocow")
+
+    assert two.information.name == "The mooing cow 🐮"
+    assert one.information.name == "A cow eating watermelons"

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/herd/processor.py

@@ -26,7 +26,7 @@ class HerdProcessor:
     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
+            actor_id_to_cow_map[cow.internals.actor_id] = cow
 
         async for msg in connection.incoming():
             actor_id = msg["actor"]
@@ -34,6 +34,6 @@ class HerdProcessor:
             cow = actor_id_to_cow_map.get(actor_id)
             logger.info(cow)
             if cow:
-                await cow.handlers.handle(
+                await cow.internals.handlers.handle(
                     msg, "incoming", connection, actor_id, cow=cow
                 )

{roboherd-0.1.4 → roboherd-0.1.5}/roboherd/herd/scheduler.py

@@ -38,7 +38,7 @@ class HerdScheduler:
                 inject(entry.func),
                 trigger=trigger,
                 kwargs={
-                    "actor_id": cow.actor_id,
+                    "actor_id": cow.internals.actor_id,
                     "connection": self.connection,
                     "cow": cow,
                 },