Request to share selective memories from main component to other components

[patternspandemic]

Hi Pietro,

Might it be possible to allow access to certain memories set directly on the bot's main component from all or some other components? Such is the case when some number of components require the same shared resource like a DB connection. I suppose I could try sub-classing a component with a memory of a DB connection, but I'm not sure the base class' shared memory will translate to its sub-classes.

I think a builtin method that doesn't require sub-classing would be more useful and easier to use anyhow. Perhaps if nothing else a simple way to allow a component to access to the main_component's shared memory. Thoughts?

Thank you,
Brad

[pietroalbini]

Subclassing won't work, because components (and bots) have unique, random IDs assigned during initialization. This was made to prevent conflicts between components, but this also kills your use case as a side effect.

The hacky way to fix this issue is manually editing the Component._component_id right after you create the bot (or in the __init__).

I'll think about an API for this, but I don't think this will be implemented before a refactor of the shared memory I plan to do in the future (converting it to a drivers-powered thing, in order to provide a standardized API and different storage engines).

[patternspandemic]

Thanks for the info. I believe I've found a solution that will work for me given the backend I plan to use.

[pietroalbini]

I thought about it a bit, and I think I found a good API for this:

class MyComponent(botogram.Component):
    component_name = "test"
    component_isolated = False

That component_isolated attribute specifies if the component's resources should be isolated from the other components (currently only the shared memory), with True as the default (as it is right now). If the argument is set to False, the component shares the same resources as the main component.

I am, as always, open for feedback :)

[patternspandemic]

I like this. I'd assume any non-isolated component could still initialize a memory (not just the bot/main component). That way everything's still handled by the responsible component.

With this, one could also easily setup something like component dependencies. A BackendComponent can initialize a shared memory holding a connection to the backend. Then any number of other components expecting such a connection in the shared memory can simply depend on the BackendComponent. Maybe a check can be made from Bot.use.

Whether this fits in or is non-limiting to your future plans for shared memories, I'm not sure.

[pietroalbini]

I like this. I'd assume any non-isolated component could still initialize a memory (not just the bot/main component). That way everything's still handled by the responsible component.

Yeah, you should be able to initialize the memory from any non-isolated components.

With this, one could also easily setup something like component dependencies. A BackendComponent can initialize a shared memory holding a connection to the backend. Then any number of other components expecting such a connection in the shared memory can simply depend on the BackendComponent. Maybe a check can be made from Bot.use.

Maybe in the future. The problem with this is, there are no way to reference another component:

• The name of the component can't be enforced to be unique
• Moving around Components doesn't work on Windows (everytime the same issue)
• Random UUIDs are random (doh!)

Another possible API, which allows to use multiple shared shared memories:

class MyComponent(botogram.Component):
    component_name = "test"
    component_memory = "backend"

[patternspandemic]

there are no way to reference another component: ...

I see. Then having multiple named shared memories seems like a simple solution that requires only a little more thought when putting dependent components together. Any components that need to work together simply use the same shared memory space.

Should components be able to utilize multiple SharedMemory spaces? I.e.

component_memories = [
    'default',  # memories initialized from the main component (bot)
    'backend'  # memories initialized from a BackendComponent
]

How would memory initialization then work? It seems component should be able to initialize memories to any space.

# Initialize a memory into the "default" space
@bot.init_shared_memory(space="default")
def default_memory(shared)
    shared["example"] = 1

# Within a component, initialize a memory to the "backend" space
self.add_shared_memory_initializer("backend", connection_memory)

When accessing shared memories, perhaps the shared argument is then a dict of named SharedMemory spaces the component subscribed to? Or maybe just an object where the named spaces are attributes...

@bot.command("example")
def example_command(shared):
    num = shared["default"]["example"]  # or
    num = shared.default["example"]

I like the solution of named SharedMemory spaces, with the ability to initialize memories to any space from any component.

[pietroalbini]

Sorry for the delayed response! Had a busy week.

I'm not fully sure about multiple shared memories for every component. The first example breaks every current code, and the second one might break existing methods (it's a dict-like object). I'll think about this later.

[patternspandemic]

Another (perhaps common) use case I've come across where inter-component memory sharing is required is with OAuth type scenarios.

When looking to use various Web APIs which require authorization, access tokens are generally short lived, or can be revoked for a number of reasons. Once you have to renew access tokens, there's no way to provide the new tokens to all components that may need them.

By the way, congrats on releasing botogram to the wider world! Nice work.

[patternspandemic]

FYI, if anyone else is manually setting component_id on components to achieve inter-component memory sharing, note that only one component may initialize (prepare) memories. Namely, the first component to register memory initializers with the used ID.