roboherd 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

roboherd/annotations/__init__.py

@@ -1,7 +1,7 @@
 from fast_depends import Depends
-from typing import Annotated, Callable, Awaitable
+from typing import Annotated
 
-from almabtrieb import Almabtrieb
+from .common import PublishObject, PublishActivity  # noqa
 
 
 def get_raw(data: dict) -> dict:
@@ -41,16 +41,3 @@ Activity = Annotated[dict, Depends(get_activity)]
 
 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

@@ -1,8 +1,8 @@
 """Test documentation"""
 
-from typing import Annotated
+from typing import Annotated, Awaitable, Callable
 from fast_depends import Depends
-from .common import Profile
+from .common import Profile, PublishObject
 
 try:
     from bovine.activitystreams import factories_for_actor_object
@@ -39,3 +39,29 @@ ActivityFactory = Annotated[BovineActivityFactory, Depends(get_activity_factory)
 
 ObjectFactory = Annotated[BovineObjectFactory, Depends(get_object_factory)]  # type: ignore
 """The object factory of type [bovine.activitystreams.object_factory.ObjectFactory][]"""
+
+
+try:
+    import markdown
+
+    def get_markdown_poster(  # type: ignore
+        object_factory: ObjectFactory, publish_object: PublishObject
+    ):
+        async def publish_markdown(message: str):
+            content = markdown.markdown(message)
+            note = object_factory.note(content=content).as_public().build()  # type: ignore
+            await publish_object(note)
+
+        return publish_markdown
+
+except ImportError:
+
+    def get_markdown_poster() -> None:
+        raise ImportError("bovine not installed")
+
+
+MarkdownPublisher = Callable[[str], Awaitable[None]]
+"""Type of the markdown publisher"""
+
+MarkdownPoster = Annotated[MarkdownPublisher, Depends(get_markdown_poster)]  # type: ignore
+"""A function that takes a markdown string and posts it as the content of a note"""

roboherd/annotations/common.py

@@ -1,14 +1,43 @@
 from fast_depends import Depends
-from typing import Annotated
+from typing import Annotated, Callable, Awaitable
+
+from almabtrieb import Almabtrieb
+
 
 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)]
 """The profile of the cow"""
+
+
+Publisher = Callable[[dict], Awaitable[None]]
+"""Type returned by the publishing functions"""
+
+
+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
+
+
+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/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/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

@@ -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/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,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/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/scarecrow.py

@@ -18,4 +18,10 @@ 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)
+
+
+# @bot.startup
+# async def startup(poster: MarkdownPoster):
+#     await poster("__Booo!__ 🐦")

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

@@ -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/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/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/util.py

@@ -1,12 +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__)
 
@@ -46,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-0.1.4.dist-info → roboherd-0.1.6.dist-info}/METADATA

@@ -1,7 +1,9 @@
 Metadata-Version: 2.4
 Name: roboherd
-Version: 0.1.4
+Version: 0.1.6
 Summary: A Fediverse bot framework
+Project-URL: Documentation, https://bovine.codeberg.page/roboherd/
+Project-URL: Repository, https://codeberg.org/bovine/roboherd
 Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.11.12
 Requires-Dist: almabtrieb[mqtt]>=0.1.0a1
@@ -14,6 +16,7 @@ Requires-Dist: tomli-w>=1.1.0
 Requires-Dist: watchfiles>=1.0.4
 Provides-Extra: bovine
 Requires-Dist: bovine>=0.5.15; extra == 'bovine'
+Requires-Dist: markdown>=3.7; extra == 'bovine'
 Description-Content-Type: text/markdown
 
 # Roboherd

roboherd-0.1.6.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=BrP5UWiVnh8FwmHc6wEY3G69BStidGUpF8uP4Ea5-dg,1140
+roboherd/annotations/bovine.py,sha256=cFLUSFzTulikNjZb1lLq5v4tGjL1i7_dR3H6wimegCg,2322
+roboherd/annotations/common.py,sha256=n5rm8WTgsg116RczKdzm_VoPg1mBk_IMf2V7l8UgWKQ,1351
+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=CgQuI7smKBJdeMiL8fY5SP1itH5GaFRAoX3I3QGF3rw,748
+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.6.dist-info/METADATA,sha256=DvhOfgjAb92py9-vVqKR0bbsRhx5jau-_DVt_mLB31M,1007
+roboherd-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+roboherd-0.1.6.dist-info/entry_points.txt,sha256=WebdVUmh8Ot-FupKJY6Du8LuFbmezt9yoy2UICqV3bE,52
+roboherd-0.1.6.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.4.dist-info/RECORD

@@ -1,42 +0,0 @@
-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_util.py,sha256=Yor_YgXtvK3WnZu6jr7DvNtTLdR9YWHCA5QufHo_w2s,535
-roboherd/test_validators.py,sha256=UiFgJkutmXBLjGpdLP2IBYCEf75quwnRHX7Z51G8Xqo,222
-roboherd/util.py,sha256=xgOpGwgvj4QY-m687H7EcDPfIF-pFgdmCsYPmeK13to,3064
-roboherd/validators.py,sha256=2mc43ZGwFazp4f3B9J4RxZCU4Y_ErSNotib8MnYVtmY,140
-roboherd/annotations/__init__.py,sha256=z7Q-NwHtGm35AUcuc4SxmWGFLVQxCFhYNJlzOc2kdOY,1610
-roboherd/annotations/bovine.py,sha256=qXkliFVT63BfGn820Bopwd7O41ofP7VbNomxyit4zBg,1494
-roboherd/annotations/common.py,sha256=aeoWDEpWdX3llc-CiuifT4A8_Ote29PkELqOkF9Dy5o,314
-roboherd/cow/__init__.py,sha256=qS5ztkVa-vza6f-kZyn4fS5LVa4Fu5c083FyBcAEQC4,6051
-roboherd/cow/handlers.py,sha256=k5Tc1M--wqmZ2EZvzIfID4dp8XE0rN18puMTKkNVjjE,1491
-roboherd/cow/profile.py,sha256=NxnLdQYwOIjzZLu2iYEMMQyTOdUsGpLRe5nIN_jo-14,3223
-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=p2-7p936mm9E9slGnYbei-pui8FeMCNIuomLHcE7BuE,1790
-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=OkceeaRqkjR31Nue8anHtL_DMqd7finLzs-gUaKsVBo,1083
-roboherd/examples/number.py,sha256=Sj9aYfdtzANUfWVJnoX73zEvDNVcdrr-STZDSwNRHlI,2003
-roboherd/examples/rooster.py,sha256=5_rPGLQTLv1s0cyE6l7WXLum-QLpQZ2p63YBkfrxKFw,596
-roboherd/examples/scarecrow.py,sha256=gLbQFx7Hu0W0H3_d9yi0mAO4drXxBshM8Iwoc-NdrjY,633
-roboherd/herd/__init__.py,sha256=nhGfHkuAErP7MDh44IbfsonMd0UKeK8GqaHkEUAsZtc,3012
-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=yDVeSyJ3vIn9RMKR0FlobQA81oOQgdov5VVOIUAMwws,1454
-roboherd/herd/manager/config.py,sha256=qfcED9PfzKzDCWaYHefYj8AImcsOFs5daGpJwUrXlV4,1313
-roboherd/herd/manager/test_config.py,sha256=YQ-3huCZfHDqt2mdGjLs0ck5-DOkKdjKEzT3uhX0sLk,1293
-roboherd/herd/manager/test_manager.py,sha256=9pSMaH7zmN-zagYCIBpQcV3Q0sBT7XZSCvsmLVC0rOI,1047
-roboherd-0.1.4.dist-info/METADATA,sha256=55W2-6U-lsE1mibBgc9XaEx1Elo0BEQJTSxCxHWVvN0,830
-roboherd-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-roboherd-0.1.4.dist-info/entry_points.txt,sha256=WebdVUmh8Ot-FupKJY6Du8LuFbmezt9yoy2UICqV3bE,52
-roboherd-0.1.4.dist-info/RECORD,,