The build scripts currently follow the template logic for the most part (some values have been changed). The pyproject.toml, setup.cfg, make, and Dockerfile need to change to fit this project.

Message handlers are currently naive in that a consumer performs xreadgroup, grabs a message, and calls all the functions on it. Functions like update_handler_completion in event_stream.bus need to be called around the message processing in order to ensure operations that failed may be attempted again.

Correctly implementing the __main__.py functionality allows calling the application via python -m event_stream -v example.json instead of python ./src/event_stream/application.py -v example.json. That should all be set up correctly to make it easier to work with.

There needs to be a mechanism for full on deleting old messages once they should no longer be operated on. Currently, messages are xacked once processing complete or orphaned when they don't. If processing can't complete, handling should be able to continue with any other bus that can operate on the stream and its events.

Many similar applications have the user define something like:

app = ExampleApplication(**options_from_somewhere)

@app.register
def some_function(...):
     pass

@app.register
def other_function(...):
   pass

In order to simplify interaction and make it a little more extensible and less reliant on complex configurations.

This application should follow a similar model and have the ability to create one of these app objects that things may attached to. The current main functionality does not necessarily need to be removed.

There needs to be concrete and specific examples of how to use this

Issues arise when defining arguments of type Callable that may or may not accept variable arguments. There are two naive ways to define variable arguments typing.Callable[[int, str, typing.Tuple[typing.Any, ...], typing.Dict[str, typing.Any]], typing.Any] as read by PyCharm, or:

P = typing.ParamSpec("P")

EXAMPLE = typing.Callable[[int, str, P], typing.Any]

Both ways can trip up a linter when they are supposed to accept functions like def example(i: int, j: str = "nope", *args) or def example(i: int, j: str, q: bool = False, **kwargs) since neither correctly use a firm ParamSpec or use the tuple or dict and don't use the exact parameters.

The solution is to use:

P = typing.ParamSpec("P")

EXAMPLE = typing.Callable[typing.Concatenate[int, str, P], typing.Any]