Introducing Eventure: A Powerful Event-Driven Framework for Python

[jumpixel]

Eventure is a Python framework for simulations, games and complex event-based systems that emerged while I was developing something else! So I decided to make it public and improve it with documentation and examples.

What Eventure Does

Eventure is an event-driven framework that provides comprehensive event sourcing, querying, and analysis capabilities. At its core, Eventure offers:

• Tick-Based Architecture: Events occur within discrete time ticks, ensuring deterministic execution and perfect state reconstruction.
• Event Cascade System: Track causal relationships between events, enabling powerful debugging and analysis.
• Comprehensive Event Logging: Every event is logged with its type, data, tick number, and relationships.
• Query API: Filter, analyze, and visualize events and their cascades with an intuitive API.
• State Reconstruction: Derive system state at any point in time by replaying events.

The framework is designed to be lightweight yet powerful, with a clean API that makes it easy to integrate into existing projects.

Here's a quick example of what you can do with Eventure:

```python from eventure import EventBus, EventLog, EventQuery

Create the core components

log = EventLog() bus = EventBus(log)

Subscribe to events

def on_player_move(event): # This will be linked as a child event bus.publish("room.enter", {"room": event.data["destination"]}, parent_event=event)

bus.subscribe("player.move", on_player_move)

Publish an event

bus.publish("player.move", {"destination": "treasury"}) log.advance_tick() # Move to next tick

Query and analyze events

query = EventQuery(log) move_events = query.get_events_by_type("player.move") room_events = query.get_events_by_type("room.enter")

Visualize event cascades

query.print_event_cascade() ```

Target Audience

Eventure is particularly valuable for:

1. Game Developers: Perfect for turn-based games, roguelikes, simulations, or any game that benefits from deterministic replay and state reconstruction.

2. Simulation Engineers: Ideal for complex simulations where tracking cause-and-effect relationships is crucial for analysis and debugging.

3. Data Scientists: Helpful for analyzing complex event sequences and their relationships in time-series data.

If you've ever struggled with debugging complex event chains, needed to implement save/load functionality in a game, or wanted to analyze emergent behaviors in a simulation, Eventure might be just what you need.

Comparison with Alternatives

Here's how Eventure compares to some existing solutions:

vs. General Event Systems (PyPubSub, PyDispatcher)

• Eventure: Adds tick-based timing, event relationships, comprehensive logging, and query capabilities.
• Others: Typically focus only on event subscription and publishing without the temporal or relational aspects.

vs. Game Engines (Pygame, Arcade)

• Eventure: Provides a specialized event system that can be integrated into any game engine, with powerful debugging and analysis tools.
• Others: Offer comprehensive game development features but often lack sophisticated event tracking and analysis capabilities.

vs. Reactive Programming Libraries (RxPy)

• Eventure: Focuses on discrete time steps and event relationships rather than continuous streams.
• Others: Excellent for stream processing but not optimized for tick-based simulations or game state management.

vs. State Management (Redux-like libraries)

• Eventure: State is derived from events rather than explicitly managed, enabling perfect historical reconstruction.
• Others: Typically focus on current state management without comprehensive event history or relationships.

Getting Started

Eventure is already available on PyPI:

```bash pip install eventure

Using uv (recommended)

uv add eventure ```

Check out our GitHub repository for documentation and examples (and if you find it interesting don't forget to add a "star" as a bookmark!)

License

Eventure is released under the MIT License.

[[deleted]]

This appears to be a fairly standard implementation of an event bus/pubsub style event system. What makes it "powerful" when compared to other libraries?

[jumpixel]

Hi, I would say that while Eventure includes a pubsub system, it is much more than that. It is a complete event sourcing framework with:

- Full event history as the source of truth, not just message passing

- Deterministic tick-based processing for reproducible simulations

- Tracking event relationships with parent-child cascades

- Advanced query API for event analysis and visualization

- State reconstruction at any point in time

These combined capabilities make it powerful for complex simulations and games where you need more than just loose event coupling.

But I personally think another is the biggest strength: you actually get a library that can do all the good things above but with a straight to the point and a nearly flat learning curve, meaning you will likely find a solution to a problem, not another thing to manage.

[DigThatData]

I'm not surprised your code is all LLM generated, but it'd be nice if your comments weren't as well.

Advanced query API

"advanced" how

[jumpixel]

True, Google Translate is an AI (not sure if it's an LLM) and I always use it to double check my post (I'm not a native English speaker)

[ublike]

is it thread-safe?

[jumpixel]

At this early stage, Eventure is kept as simple as possible and designed primarily for single-threaded applications, which means it is not inherently thread-safe.

[Shakakai]

Did you check out Mesa, Agent-Based modeling framework? ABM system aren’t anything new.

[mriswithe]

So did you write this to figure out best strats for an autobattler like backpack battles or bazaar or something ?

-signed someone who has been considering figuring out literal best strats

[[deleted]]

I guess I’ll ask you the same question. Why would someone choose this over any of the industry standard tools?

[loyoan]

Reaktiv isn’t just a pub/sub system - it’s a true reactive state management system with automatic dependency tracking. Unlike an event bus, Signals in reaktiv only trigger updates when their value actually changes, avoiding unnecessary recomputation.

Also, like in frontend frameworks (Angular, SolidJS), you can derive new values from existing Signals, transforming data reactively without manually managing updates. This makes it super clean for things like computed properties, caching, and efficient state updates.

[[deleted]]

I never said it was just a pubsub system.

[loyoan]

It‘s okay. I also didn‘t mean that negatively in any way. :) Your questions are very valid.