Question

Though the question is very specific, I’d also really appreciate general advice and other approaches that would make my question moot. I’m building a collection of AI programs, and many of the functions and classes need to deal with a lot of different states and actions that cause transitions between states, so I need a way to represent states and actions. Please note that I’m not building a simple state machine, but rather a number of different programs (agents) that all take states and return actions as a way of interacting with an environment.

I could use strings, but that’s messy if a particular algorithm needs to associate additional information with a state or action, and comparing strings over and over again in long-running programs is wasted overhead. The same sorts of problems arise with other kinds of constants. So my initial idea is to use nested classes, like so:

class DerivedAgent(Agent):
    class StateA(State): pass
    class StateB(State): pass
    ...
    def do_something(state):
        if state is self.StateA:
           ...

This works fairly well, but if there are a number of states and actions, it can take up a lot of space to declare them all, and all of the pass statements are annoying. I’d like to be able to do something like…

class DerivedAgent(Agent):
    states("StateA", "StateB", "StateC", ...)

But I don’t see a way to have the states method add the newly-created types to the DerivedAgent class. I think I might be able to do it with the inspect module, but that feels like it’s going too far for a small convenience. Is using types like this a bad idea? Is there a much more elegant approach? Code outside of the agent classes will need to be able to access the states and actions, and putting states into the module namespace isn’t a good option because a given module might have several agents in it.

Answer 1

You could use meta classes so that you would end up with code like:

class DerivedAgent(Agent):
    __states__ = ['StateA', 'StateB', ...]

for example:

class AgentMeta(type):
    def __new__(meta, classname, bases, classdict):
        for clsname in classdict['__states__']:
            classdict[clsname] = type(clsname, (State,), {})
        return type.__new__(meta, classname, bases, classdict))

then, just rewrite your Agent class so that it has the line

#python3.x
class Agent(Base1, Base2, ..., BaseN, metaclass=AgentMeta):
    #everything else unchanged

# 2.2 <= python <= 2.7 
class Agent(Base1, Base2, ..., BaseN):
    __metaclass__ = AgentMeta
    #everything else unchanged

If you don’t want to change the Agent class, you can just include the approriate declaration of metaclass in each subclass of it that you create.