roboherd 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

roboherd/__main__.py

@@ -10,6 +10,7 @@ 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
+from roboherd.validators import validators
 
 logging.basicConfig(level=logging.INFO)
 
@@ -32,6 +33,7 @@ def main(ctx, connection_string, base_url, config_file):
     settings = dynaconf.Dynaconf(
         settings_files=[config_file],
         envvar_prefix="ROBOHERD",
+        validators=validators,
     )
     ctx.ensure_object(dict)
 
@@ -41,12 +43,12 @@ def main(ctx, connection_string, base_url, config_file):
     if connection_string:
         ctx.obj["connection_string"] = connection_string
     else:
-        ctx.obj["connection_string"] = settings.get("connection_string")
+        ctx.obj["connection_string"] = settings.connection_string
 
     if base_url:
         ctx.obj["base_url"] = base_url
     else:
-        ctx.obj["base_url"] = settings.get("base_url")
+        ctx.obj["base_url"] = settings.base_url
 
 
 @main.command()

roboherd/annotations/__init__.py

@@ -5,11 +5,11 @@ from almabtrieb import Almabtrieb
 
 
 def get_raw(data: dict) -> dict:
-    return data.get("data").get("raw")
+    return data.get("data", {}).get("raw")
 
 
 def get_parsed(data: dict) -> dict:
-    result = data.get("data").get("parsed")
+    result = data.get("data", {}).get("parsed")
     if result is None:
         raise ValueError("No parsed data found")
     return result
@@ -23,11 +23,17 @@ ParsedData = Annotated[dict, Depends(get_parsed)]
 
 
 def get_activity(parsed: ParsedData) -> dict:
-    return parsed.get("activity")
+    result = parsed.get("activity")
+    if not result:
+        raise ValueError("No activity found")
+    return result
 
 
 def get_embedded_object(parsed: ParsedData) -> dict:
-    return parsed.get("embeddedObject")
+    result = parsed.get("embeddedObject")
+    if not result:
+        raise ValueError("No embedded object found")
+    return result
 
 
 Activity = Annotated[dict, Depends(get_activity)]
@@ -37,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:
@@ -46,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/annotations/bovine.py

@@ -7,19 +7,19 @@ from .common import Profile
 try:
     from bovine.activitystreams import factories_for_actor_object
     from bovine.activitystreams.activity_factory import (
-        ActivityFactory as BovineActivityFactory,
+        ActivityFactory as BovineActivityFactory,  # type: ignore
     )
     from bovine.activitystreams.object_factory import (
-        ObjectFactory as BovineObjectFactory,
+        ObjectFactory as BovineObjectFactory,  # type: ignore
     )
 
-    def get_activity_factory(profile: Profile) -> BovineActivityFactory:
+    def get_activity_factory(profile: Profile) -> BovineActivityFactory:  # type: ignore
         activity_factory, _ = factories_for_actor_object(profile)
-        return activity_factory
+        return activity_factory  # type: ignore
 
-    def get_object_factory(profile: Profile) -> BovineObjectFactory:
+    def get_object_factory(profile: Profile) -> BovineObjectFactory:  # type: ignore
         _, object_factory = factories_for_actor_object(profile)
-        return object_factory
+        return object_factory  # type: ignore
 
 except ImportError:
 
@@ -34,8 +34,8 @@ except ImportError:
         raise ImportError("bovine not installed")
 
 
-ActivityFactory = Annotated[BovineActivityFactory, Depends(get_activity_factory)]
+ActivityFactory = Annotated[BovineActivityFactory, Depends(get_activity_factory)]  # type: ignore
 """The activity factory of type [bovine.activitystreams.activity_factory.ActivityFactory][]"""
 
-ObjectFactory = Annotated[BovineObjectFactory, Depends(get_object_factory)]
+ObjectFactory = Annotated[BovineObjectFactory, Depends(get_object_factory)]  # type: ignore
 """The object factory of type [bovine.activitystreams.object_factory.ObjectFactory][]"""

roboherd/annotations/common.py

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

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,75 +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:
-            result = await connection.fetch(self.actor_id, self.actor_id)
-            self.profile = result.data
+        if self.internals.profile is None:
+            if not self.internals.actor_id:
+                raise ValueError("Actor ID is not set")
+            result = await connection.fetch(
+                self.internals.actor_id, self.internals.actor_id
+            )
+            if not result.data:
+                raise ValueError("Could not retrieve profile")
+            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/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/cow/profile.py

@@ -1,5 +1,15 @@
 from urllib.parse import urlparse
-from bovine.activitystreams.utils import as_list
+
+try:
+    from bovine.activitystreams.utils import as_list
+except ImportError:
+
+    def as_list(value):
+        if isinstance(value, list):
+            return value
+
+        return [value]
+
 
 from .types import Information
 
@@ -14,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
 
 
@@ -27,7 +40,7 @@ def key_index_from_attachment(attachments: list[dict], key: str) -> int | None:
 
 
 def determine_action_for_key_and_value(
-    attachments: list[dict], key: str, value: str
+    attachments: list[dict], key: str, value: str | None
 ) -> dict | None:
     idx = key_index_from_attachment(attachments, key)
     if idx is None:
@@ -78,19 +91,19 @@ def determine_actions(information: Information, profile: dict) -> list[dict] | N
                 "identifier": "acct:"
                 + information.handle
                 + "@"
-                + urlparse(profile.get("id")).netloc,
+                + str(urlparse(profile.get("id")).netloc),
                 "primary": True,
             }
         )
 
-    actions = list(filter(lambda x: x, actions))
+    actions = [x for x in actions if x is not None]
 
     if len(actions) == 0:
         return None
     return actions
 
 
-def determine_profile_update(information: Information, profile: dict) -> dict:
+def determine_profile_update(information: Information, profile: dict) -> dict | None:
     """Returns the update for the profile"""
 
     update = {"actor": profile.get("id")}
@@ -100,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/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/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/cow/types.py

@@ -1,18 +1,20 @@
 from pydantic import BaseModel, Field
 
+from .const import default_icon
+
 
 class MetaInformation(BaseModel):
     """Meta Information about the bot. This includes
     information such as the author and the source repository"""
 
     source: str | None = Field(
-        None,
+        default=None,
         examples=["https://forge.example/repo"],
         description="The source repository",
     )
 
     author: str | None = Field(
-        None,
+        default=None,
         examples=["acct:author@domain.example"],
         description="The author, often a Fediverse handle",
     )
@@ -22,23 +24,25 @@ class Information(BaseModel):
     """Information about the cow"""
 
     type: str = Field(
-        "Service", examples=["Service"], description="ActivityPub type of the actor."
+        default="Service",
+        examples=["Service"],
+        description="ActivityPub type of the actor.",
     )
 
     handle: str | None = Field(
-        None,
+        default=None,
         examples=["moocow"],
         description="Used as the handle in `acct:handle@domain.example`",
     )
 
     name: str | None = Field(
-        None,
+        default=None,
         examples=["The mooing cow 🐮"],
         description="The display name of the cow",
     )
 
     description: str | None = Field(
-        None,
+        default=None,
         examples=[
             "I'm a cow that moos.",
             """<p>An example bot to illustrate Roboherd</p><p>For more information on RoboHerd, see <a href="https://codeberg.org/bovine/roboherd">its repository</a>.</p>""",
@@ -46,13 +50,18 @@ 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(
-        None,
+        default=None,
         examples=["daily"],
         description="Frequency of posting. Is set automatically if cron expressions are used.",
     )
 
     meta_information: MetaInformation = Field(
-        MetaInformation(),
+        default=MetaInformation(),
         description="Meta information about the cow, such as the source repository",
     )

roboherd/cow/util.py

@@ -19,5 +19,8 @@ async def call_handler(
     cow=None,
 ):
     return await inject(handler_info.func)(
-        data=data, connection=connection, actor_id=actor_id, cow=cow
+        data=data,  # type: ignore
+        connection=connection,
+        actor_id=actor_id,
+        cow=cow,
     )

roboherd/examples/json_echo.py

@@ -45,7 +45,7 @@ async def create(
     raw: RawData, publish_object: PublishObject, object_factory: ObjectFactory
 ):
     note = (
-        object_factory.reply(
+        object_factory.reply(  # type: ignore
             raw.get("object"),
             content=reply_content(raw),
         )

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/examples/number.py

@@ -51,7 +51,7 @@ async def post_number(
 ):
     number = random.randint(0, 1000)
 
-    note = factory.note(content=f"Number: {number}").as_public().build()
+    note = factory.note(content=f"Number: {number}").as_public().build()  # type: ignore
     await publisher(note)
 
     handle = "even" if number % 2 == 0 else "odd"

roboherd/examples/rooster.py

@@ -18,5 +18,5 @@ bot = RoboCow(
 @bot.cron("42 * * * *")
 async def crow(publisher: PublishObject, object_factory: ObjectFactory):
     await publisher(
-        object_factory.note(content="cock-a-doodle-doo").as_public().build()
+        object_factory.note(content="cock-a-doodle-doo").as_public().build()  # type: ignore
     )

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())
+    note = object_factory.note(content="Booo! 🐦").as_public().build()  # type: ignore
+    await publish_object(note)

roboherd/herd/__init__.py

@@ -29,6 +29,9 @@ class RoboHerd:
             await self.process(connection)
 
     async def startup(self, connection: Almabtrieb):
+        if not connection.information:
+            raise Exception("Could not get information from server")
+
         self.cows = self.manager.existing_cows(connection.information.actors)
 
         cows_to_create = self.manager.cows_to_create(connection.information.actors)
@@ -38,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)
 
@@ -60,9 +63,6 @@ class RoboHerd:
             scheduler = HerdScheduler(self.cron_entries(), connection)
             scheduler.create_task(tg)
 
-    def introduce(self, cow: RoboCow):
-        self.manager.add_to_herd(cow)
-
     def validate(self, connection):
         result = connection.information
 
@@ -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/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
@@ -43,4 +43,6 @@ class HerdManager:
         }
         names_to_create = self.herd_config.names - existing_names
 
-        return {self.herd_config.for_name(name) for name in names_to_create}
+        cows = {self.herd_config.for_name(name) for name in names_to_create}
+
+        return {cow for cow in cows if cow}

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/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/herd/manager/test_config.py

@@ -21,7 +21,7 @@ def test_config():
                 },
             },
         }
-    )
+    )  # type: ignore
     return config
 
 
@@ -38,13 +38,29 @@ 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)
 
     assert len(herd.cows) == 2
 
     moocow = herd.for_name("moocow")
-
+    assert moocow
     assert moocow.name == "moocow"
 
 

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/herd/manager/test_manager.py

@@ -21,7 +21,7 @@ def test_config():
                 },
             },
         }
-    )
+    )  # type: ignore
     return config
 
 

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/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,
                 },

roboherd/test_validators.py

@@ -0,0 +1,10 @@
+from dynaconf import Dynaconf
+
+from .validators import validators
+
+
+def test_validators():
+    settings = Dynaconf(validators=validators)
+
+    assert settings.base_url is None
+    assert settings.connection_string is None

roboherd/util.py

@@ -1,13 +1,9 @@
 import click
 import logging
-import copy
-import importlib
-from importlib import import_module
-from urllib.parse import parse_qs, urlparse
 
+from urllib.parse import urlparse
 from almabtrieb import Almabtrieb
 
-from roboherd.cow import RoboCow
 
 logger = logging.getLogger(__name__)
 
@@ -47,52 +43,6 @@ def parse_connection_string(connection_string: str) -> dict:
     }
 
 
-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"]

roboherd/validators.py

@@ -0,0 +1,6 @@
+from dynaconf import Validator
+
+validators = [
+    Validator("base_url", default=None),
+    Validator("connection_string", default=None),
+]

{roboherd-0.1.3.dist-info → roboherd-0.1.5.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: roboherd
-Version: 0.1.3
+Version: 0.1.5
 Summary: A Fediverse bot framework
 Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.11.12
 Requires-Dist: almabtrieb[mqtt]>=0.1.0a1
 Requires-Dist: apscheduler>=3.11.0
 Requires-Dist: click>=8.1.8

roboherd-0.1.5.dist-info/RECORD

@@ -0,0 +1,44 @@
+roboherd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+roboherd/__main__.py,sha256=cY4f-39QCDhStJ4gDuuSz46RDFE_AKnu08sTCpQEEV4,2933
+roboherd/register.py,sha256=Gqa5aT2supVJMj7z21btMYRma3_WW0oK5gjZftr048s,976
+roboherd/test_validators.py,sha256=UiFgJkutmXBLjGpdLP2IBYCEf75quwnRHX7Z51G8Xqo,222
+roboherd/util.py,sha256=nrFRtyfvMQ8oXoGDYxmCAXcIN14dWBAPGv0cI_B_TP0,1710
+roboherd/validators.py,sha256=2mc43ZGwFazp4f3B9J4RxZCU4Y_ErSNotib8MnYVtmY,140
+roboherd/annotations/__init__.py,sha256=UhDSVQ4cj2iwIr5qn6dZMAyyY-A9KMJHnqhyVYsRYww,2095
+roboherd/annotations/bovine.py,sha256=qXkliFVT63BfGn820Bopwd7O41ofP7VbNomxyit4zBg,1494
+roboherd/annotations/common.py,sha256=DN1jt1P79pU7XnmiocwTQTTQnn3vJlSSkP8kiHGAbfs,334
+roboherd/cow/__init__.py,sha256=MlMvjFbodwZf6vpKlPfIpSn5SHu9IugacSH5ylbySTY,5826
+roboherd/cow/const.py,sha256=fj5nUJUIlcpr1AU2Ur55ToR7iVmYv4UnfdxiQwguv-k,166
+roboherd/cow/handlers.py,sha256=k5Tc1M--wqmZ2EZvzIfID4dp8XE0rN18puMTKkNVjjE,1491
+roboherd/cow/profile.py,sha256=ldeYq50lh97dl50QjOZiGopEbXtCoEsE5QJoXB5XUYU,3330
+roboherd/cow/test_handlers.py,sha256=SwrZZcU_BD2BpJUFg18mFEsyUqu7N81-MkjIaGv7whQ,1673
+roboherd/cow/test_init.py,sha256=bnK8IIbbeS1Y7vJaFg5HzCL6UoZeCl6mo_SAQqJAgQY,1409
+roboherd/cow/test_profile.py,sha256=f7HE0iVgbpuNv6znEqi-4l1o_8UZ9ufQpjSVP7Xf1wc,2160
+roboherd/cow/test_util.py,sha256=8FLRtVdSMmIo6NSpCpB9mS0PwOCpGgUeDAA1q6Gv0P4,430
+roboherd/cow/types.py,sha256=TGXTcPuND7xMly3xFXZyIR7UE3XWyF_MLRuBHWKoFEE,1925
+roboherd/cow/util.py,sha256=ASQn7AnSl5lskECqCyqOKn5BYC8yOces4FK3uNV8010,534
+roboherd/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+roboherd/examples/dev_null.py,sha256=6SZ9wlcawSBqhdq6Zv4xPXH5eKH2g1VaRwv3hSCDucE,308
+roboherd/examples/json_echo.py,sha256=EFqNwaSKs0hTQjKZVatjn6i3O7rQff2GTHnEfpL1ha0,1370
+roboherd/examples/meta.py,sha256=tFhHe-DJn2J13Mm22f-gFm5I8_3uQwLU4mAkrK2xzEM,170
+roboherd/examples/moocow.py,sha256=DMPuR8XBpRRHKXFZM-2_VLYLWx8Iz4OdcE0QTVtYSFs,1097
+roboherd/examples/number.py,sha256=Sj9aYfdtzANUfWVJnoX73zEvDNVcdrr-STZDSwNRHlI,2003
+roboherd/examples/rooster.py,sha256=5_rPGLQTLv1s0cyE6l7WXLum-QLpQZ2p63YBkfrxKFw,596
+roboherd/examples/scarecrow.py,sha256=KGZP0e5WHkCNSnGSlW3BeymcRZ4PqaWjAs_q5IC-1fE,649
+roboherd/herd/__init__.py,sha256=6jWgYnuJOpXtYS03mdjEgWd0zXv5kj9w9d7K6UsCPbc,3068
+roboherd/herd/builder.py,sha256=MSVPRF0Jsxure9kdyCoYJHQ7nYilGAD0_uQaGQ-rQyE,619
+roboherd/herd/processor.py,sha256=ncXsYfuTRTT_0-K453COF_oAiGBJN0u5eP8NoeZmWik,1042
+roboherd/herd/scheduler.py,sha256=pbWxOo9pnjAoAJhbvaczmSghkp6Y8Zp2HgXZ5zoOnDA,1276
+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=NqOJsp1CdAobjARJGmzvU1ceTW7j2bt0FdRbpM8iFUw,1464
+roboherd/herd/manager/config.py,sha256=VDuxB7GMoZdgSM2i1iG1o-IjtyScsSnO--6PEM8tx9U,1591
+roboherd/herd/manager/load.py,sha256=BoeBID2UGP--sIKwITABQkQv2lMc9Y8pyp7_nleu2bw,351
+roboherd/herd/manager/test_config.py,sha256=CnoqQ_exrpQdBWVoGxSns3HpccqgmhH9mNJIPTCKKAs,1665
+roboherd/herd/manager/test_load.py,sha256=zyu5LIChMfTnxu_tYK63-bSOHYn1K1zUlbDY5DkE3GY,514
+roboherd/herd/manager/test_manager.py,sha256=9pSMaH7zmN-zagYCIBpQcV3Q0sBT7XZSCvsmLVC0rOI,1047
+roboherd-0.1.5.dist-info/METADATA,sha256=TU89GQjIVilPWX8Lc_It5tNYKCPuoI0MXaWdN-t25CY,830
+roboherd-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+roboherd-0.1.5.dist-info/entry_points.txt,sha256=WebdVUmh8Ot-FupKJY6Du8LuFbmezt9yoy2UICqV3bE,52
+roboherd-0.1.5.dist-info/RECORD,,

roboherd/test_util.py

@@ -1,24 +0,0 @@
-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-0.1.3.dist-info/RECORD

@@ -1,40 +0,0 @@
-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.3.dist-info/METADATA,sha256=dsglqXLDAENTeakmj_vUQu8_jWg7JkRKjdOwMeuKm3s,798
-roboherd-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-roboherd-0.1.3.dist-info/entry_points.txt,sha256=WebdVUmh8Ot-FupKJY6Du8LuFbmezt9yoy2UICqV3bE,52
-roboherd-0.1.3.dist-info/RECORD,,