"""each node descends from this base class"""

class Node:
    def __init__(self):
        """TBD"""
        self.ops = Ops()
        ''' there should be default ports, just to give people a template:
        self.iports = [InputPort("default")]
        self.oports = [OutputPort("default")]

        # no params
        self.params = []

        # initialize state with created op?  no way
        # here's why: 1. we would need to pass stateaccess into this function
        # and they would be allowed to initialize their state here
        # 2. scheduler/statemanager will call created when it's good and ready,
        # ok?  no need to push it!
        # unless... we should put real init code in NodeType or Node(Instance)
        # inits.  that might be better than having a whole op for it.
        
        '''
    def get_state(self, stateaccess):
        """This is similar to the pickle.__getstate__ method, except
        we need this alternate version in order to give the node
        (which holds no state) access to its instance's state.

        If your node keeps some transient items in its state dict
        (such as a buffer of recently received inputs), it may want to
        return a copy of the state dict without those items. set_state
        should restore them properly (if they're missing from the
        current state, which they might not be).

        get_state might be called at any time, and it's certainly not
        guaranteed that the node instance is going out of service.
        get_state might get called to checkpoint the nodes for a
        backup, for example. set_state might also get called anytime.
        """
        return stateaccess
    def set_state(self, stateaccess, dict):
        """dict (named after the pickle.__setstate__ argument) is
        always a value that was previously returned from
        get_state. Don't adjust the current node's state, of course;
        use dict to update stateaccess.  If there were elements
        missing from dict (see the note in get_state for why this
        might be the case), you should restore them here as
        appropriate.
        """        
        stateaccess.update(dict)

# warning: pseduocode
class NodeInstance:
    ip_addr?
    get_this_nodes_url()

    type = the node type (a subclass of Node)
        ops (get from type)
    input,output = the ports that are created for the node instance
    state = associated state