Пример #1
0
 def remove_item(self, tok):
     
     BetaMemory.remove_item(self, tok)
     
     # dopo la rimozione devo anche notificare
     # che l'attivazione non e' piu disponibile
     
     self.__onDeactive(self, tok)
Пример #2
0
    def __init__(self, parent,
                 # informazioni sulla produzione
                 name,
                 actions,
                 properties,
                 symbols,
                 # triggers
                 reteNetwork,
                 onActive=lambda pnode,token:None,
                 onDeactive=lambda pnode,token:None,
                 assertFunc=lambda fact:(None,None,False),
                 retractFunc=lambda wme:None,
                 addProduction=lambda production:None,
                 removeProduction=lambda pnode:None
                ):
        '''
        Constructor
        '''
        self.__onActive = onActive
        self.__onDeactive = onDeactive
        self.__assertFunc = assertFunc
        self.__retractFunc = retractFunc
        self.__addProduction = addProduction
        self.__removeProduction = removeProduction
        
        self.__actions = actions
        self.__name = name
        self.__symbols = symbols
        self.__properties = properties
        self.__reteNetwork = reteNetwork
        
        # sanitarizza la salience
        try:
            if self.__properties.has_key('salience') \
                and not isinstance(self.__properties['salience'], int):
                self.__properties['salience'] = int(self.__properties['salience'])
        except:
            self.__properties['salience'] = 0

        BetaMemory.__init__(self, parent)
Пример #3
0
def network_factory(alpha_root, parent, conditions, earlier_conditions=None, builtins=None):
    """
    Crea una sottorete di nodi (appropriati)
    in base alle nuove condizioni (e alle precedenti)
    e le inserisce nella rete. Inoltre, restituisce
    l'ultimo nodo della sottorete
    @return: ReteNode
    """

    # movimento di bacino per evitare che il default
    # sia condiviso fra successive chiamate :)
    if earlier_conditions == None:
        earlier_conditions = []

    # lo uso per memorizzare la presenza di variabili
    # gia parsate
    if not isinstance(builtins, dict):

        # builtins conterra' un dizionario indicizzato
        # dei risconti di variabile al quale corrispondera'
        # ad ogni variabile
        # una lista di posizioni in cui la variabile
        # e' stata trovata
        # [(cond_index, field_index), (cond_index, field_index)...]
        builtins = {}

    assert isinstance(conditions, list), "conditions non e' una list"

    assert isinstance(earlier_conditions, list), "conditions non e' una list"

    # probabilmente dovro super classare
    # AlphaNode e ReteNode con Node
    # assert isinstance(parent, ReteNode), \
    #    "parent non e' un ReteNode"

    # se il padre e' constant-test-node
    #    devo scomporre o condividere le condizioni sui test
    #    fino ad arrivare ad una alpha-memory
    #    alla quale

    # quello che ci arriva dalla lhs
    """
    [
        (PositivePredicate, [(Eq, "sym"), (Eq, "p"), (Variable, "b") ]),
        (PositivePredicate, [(Eq, "sym"), (Eq, "c"), (Variable, "b") ]),
        (NegativePredicate, [(Eq, "sym"), (Eq, "a"), (Not, (Variable, "b"))]),
        (NccPredicate, [
            [(Eq, "sym"), (Eq, "l"), (Not, (Variable, "b"))],
            [(Eq, "sym"), (Eq, "l"), (Not, (Variable, "b"))],
            ),
    ]
    """

    current_node = parent

    # ciclo per ogni condizione separatamente
    for cond_index, cc in enumerate(conditions):

        # il terzo campo viene usano
        # per memorizzare il nome della variabile
        # per le assigned_pattern_CE
        # per adesso le ignoro
        if len(cc) == 2:
            c_type, c = cc
        elif len(cc) == 3:
            c_type, c, var_binding = cc
            builtins[var_binding] = (cond_index, None)

        if issubclass(c_type, PositivePredicate):
            # siamo in una condizione positiva

            current_node = BetaMemory.factory(current_node)
            tests = JoinTest.build_tests(c, earlier_conditions, builtins)
            amem = AlphaMemory.factory(c, alpha_root)
            current_node = JoinNode.factory(current_node, amem, tests)

        elif issubclass(c_type, TestPredicate):

            current_node = BetaMemory.factory(current_node)
            tests = FilterTest.build_tests(c, earlier_conditions, builtins, c_type.get_predicate())
            current_node = FilterNode.factory(current_node, tests)

        elif issubclass(c_type, NegativePredicate):
            # siamo in una negazione semplice
            # cioe la negazione di una sola condizione

            # se questa e' la prima condizione della regola
            # devo provvedere a linkare il dummy-negative-node
            # a sinsitra con un dummy-join-node collegato a sua volta con il root-node
            # perche ogni WME sia ingresso da sinistra
            if current_node == None:
                # il negative e' primo in sequenza
                djn_amem = AlphaMemory.factory([], alpha_root)
                current_node = JoinNode.factory(None, djn_amem, [])

            tests = JoinTest.build_tests(c, earlier_conditions, builtins)
            amem = AlphaMemory.factory(c, alpha_root)
            current_node = NegativeNode.factory(current_node, amem, tests)

        elif issubclass(c_type, NccPredicate):
            # siamo in una ncc
            # cioe la negazione di un insieme di condizioni

            # se questa e' la prima condizione della regola
            # devo provvedere a linkare il ncc node
            # a sinsitra con un dummy-join-node collegato a sua volta con il root-node
            # perche ogni WME sia ingresso da sinistra
            if current_node == None:
                # il negative e' primo in sequenza
                djn_amem = AlphaMemory.factory([], alpha_root)
                current_node = JoinNode.factory(None, djn_amem, [])

            current_node = NccNode.factory(current_node, c, earlier_conditions, builtins, alpha_root)

        else:
            print "Regola non riconosciuta"
            print

        earlier_conditions.append(c)

    return current_node