def test_prepare_rule__or_starting_with_not():
from pyknow import Rule, InitialFact, NOT, Fact, OR, AND
rule = Rule(OR(NOT(Fact(1)), NOT(Fact(2))))(lambda: None)
assert list(utils.prepare_rule(rule)) == [
OR(AND(InitialFact(), NOT(Fact(1))), AND(InitialFact(), NOT(Fact(2))))
]
def test_prepare_rule_is_dnf():
from pyknow import Rule, NOT, AND, OR, Fact
from pyknow.matchers.rete.dnf import dnf
rule = Rule(AND(Fact(0), NOT(OR(Fact(1), Fact(2)))))(lambda: None)
assert list(
utils.prepare_rule(rule)) == [Fact(0),
NOT(Fact(1)),
NOT(Fact(2))]
class Engine(KnowledgeEngine):
@classmethod
def from_rulesets(cls, rulesets):
mixins = list()
for name, ruleset in rulesets.items():
mixins.append(RuleSet.build(name, ruleset))
return type("RuleEngine", tuple([cls] + mixins), {})
@DefFacts()
def initial_vector(self, vectors):
self.tasks = list()
for vector in vectors:
vector["_lineage"] = list()
yield vector
@Rule(AS.info << Info(_id=MATCH.id, _type=NE("error") & MATCH.type),
NOT(Vector(_id=MATCH.id, _type=MATCH.type)))
def info_to_vector_promotion(self, info):
"""New vector appeared."""
self.declare(Vector(**info.as_dict()))
@Rule(AS.task << TaskRequest())
def launch_task(self, task):
runner = plugin_runner(task["command"])
lineage = unfreeze(task["lineages"])
stdin = unfreeze(task["stdin"])
self.tasks.append(runner(lineage, stdin))
def start(self, vectors):
# Declare initial facts
self.reset(vectors=vectors)
fresh_facts = True
while self.tasks or fresh_facts:
self.run()
fresh_facts = False
try:
# Run all tasks and gather results
for task in self.tasks:
for lineage in task:
info = Info.from_lineage(lineage)
self.declare(info)
fresh_facts = True
except KeyboardInterrupt:
# The user aborted the task
break
self.tasks = list()
# Print a dirty report
for fact in self.facts.values():
if isinstance(fact, Info):
yield unfreeze(fact.as_dict())
class CharacterEvolution(KnowledgeEngine):
"""WorldFact evolution engine."""
@DefFacts()
def start(self, being, number): # noqa
"""Define facts."""
yield Fact(being=being)
yield Fact(number=number)
yield Fact(touched=being.touched)
@Rule(
AND(Fact(number=AS.number << W()), NOT(Fact(being=CALL.dead)),
NOT(Fact(touched=True))))
def is_not_dead(self, number):
"""Current character is not dead."""
being = self.beings[number]
self.result.append(replace(being))
@Rule(AND(Fact(being=CALL.reproduces), Fact(being=AS.being << W())))
def has_children(self, being):
"""Will have children."""
children = random.randint(0, being.species.avg_number_children)
self.result.extend([Being(0, being.species) for _ in range(children)])
class ControlEngine(KnowledgeEngine):
def __init__(self):
super().__init__()
self.returnv = {}
#### RULES TO MODIFY ####
@Rule(Input(coffee_time=MATCH.coffee_time), salience=3)
def no_coffee(self):
self.declare(Output(coffee_on=False))
@Rule(Input(coffee_time=MATCH.coffee_time, time=MATCH.time),
NOT(Output(coffee_on=True)),
TEST(lambda coffee_time, time: coffee_time == time),
salience=5)
def _time_for_coffee(self, time):
self.declare(Output(coffee_on=True))
print('something happened at %d' % time)
@Rule(Input(time=MATCH.time))
def _print_time(self, time):
print(time)
#### RULES FOR COFFEE MACHINE ####
# rule to return values last
@Rule(AS.out << Output(), salience=0) #
def _returnoutputs(self, out):
self.returnv.update(**out.retrieve())
#### END OF RULES ####
def get_return(self, key):
return self.returnv.get(key)
def set_return(self, returnvaluedict):
self.returnv = returnvaluedict
class KE(KnowledgeEngine):
@Rule(Fact(x='x' << W()), NOT(Fact(y='x' << W())))
def r1(self):
pass
class Bipolar(KnowledgeEngine):
"""
Coleta dos dados
"""
@Rule(Sintomas(verifica_humor_deprimido=None))
def ask_verifica_humor_deprimido(self):
self.declare(
Sintomas(
verifica_humor_deprimido=ask("verifica_humor_deprimido? ")))
@Rule(Sintomas(fisiologico=None))
def ask_data_fisiologico(self):
self.declare(Sintomas(fisiologico=ask("fisiologico? ")))
@Rule(Sintomas(prejuizo_social=None))
def ask_data_prejuizo_social(self):
self.declare(Sintomas(prejuizo_social=ask("prejuizo_social? ")))
@Rule(Sintomas(prejuiso_profissional=None))
def ask_data_prejuiso_profissional(self):
self.declare(
Sintomas(prejuiso_profissional=ask("prejuiso_profissional? ")))
@Rule(Sintomas(prejuizo_si=None))
def ask_data_prejuizo_si(self):
self.declare(Sintomas(prejuizo_si=ask("prejuizo_si? ")))
@Rule(Sintomas(prejuizo_outros=None))
def ask_data_prejuizo_outros(self):
self.declare(Sintomas(prejuizo_outros=ask("prejuizo_outros? ")))
@Rule(Sintomas(psicose=None))
def ask_data_psicose(self):
self.declare(Sintomas(psicose=ask("psicose? ")))
@Rule(NOT(Sintomas(autoestima_inflada=W())))
def ask_data_autoestima_inflada(self):
self.declare(Sintomas(autoestima_inflada=ask("autoestima_inflada? ")))
@Rule(NOT(Sintomas(grandiosidade=W())))
def ask_data_grandiosidade(self):
self.declare(Sintomas(grandiosidade=ask("grandiosidade? ")))
@Rule(NOT(Sintomas(loquaz=W())))
def ask_data_loquaz(self):
self.declare(Sintomas(loquaz=ask("loquaz? ")))
@Rule(NOT(Sintomas(pressao_continuar_falando=W())))
def ask_data_pressao_continuar_falando(self):
self.declare(
Sintomas(
pressao_continuar_falando=ask("pressao_continuar_falando? ")))
@Rule(NOT(Sintomas(fuga_ideias=W())))
def ask_data_fuga_ideias(self):
self.declare(Sintomas(fuga_ideias=ask("fuga_ideias? ")))
@Rule(NOT(Sintomas(pensamento_acelerado=W())))
def ask_data_pensamento_acelerado(self):
self.declare(
Sintomas(pensamento_acelerado=ask("pensamento_acelerado? ")))
@Rule(NOT(Sintomas(aumento_atividade_objetivo=W())))
def ask_data_aumento_atividade_objetivo(self):
self.declare(
Sintomas(aumento_atividade_objetivo=ask(
"aumento_atividade_objetivo? ")))
@Rule(NOT(Sintomas(agitacao_psicomotora=W())))
def ask_data_agitacao_psicomotora(self):
self.declare(
Sintomas(agitacao_psicomotora=ask("agitacao_psicomotora? ")))
@Rule(NOT(Sintomas(reducao_sono=W())))
def ask_data_reducao_sono(self):
self.declare(Sintomas(reducao_sono=ask("reducao_sono? ")))
@Rule(NOT(Sintomas(distrabilidade=W())))
def ask_data_distrabilidade(self):
self.declare(Sintomas(distrabilidade=ask("distrabilidade? ")))
@Rule(NOT(Sintomas(envolvimento_atividade_risco=W())))
def ask_data_envolvimento_atividade_risco(self):
self.declare(
Sintomas(envolvimento_atividade_risco=ask(
"envolvimento_atividade_risco? ")))
@Rule(NOT(Sintomas(irritavel=W())))
def ask_data_irritavel(self):
self.declare(Sintomas(irritavel=ask("irritavel? ")))
@Rule(NOT(Sintomas(verifica_perda_interesse=W())))
def aks_perda_interesse(self):
self.declare(
Sintomas(verifica_perda_interesse=ask("perda_interesse? ")))
@Rule(NOT(Sintomas(perda_prazer=W())))
def ask_data_perda_prazer(self):
self.declare(Sintomas(perda_prazer=ask("perda_prazer? ")))
@Rule(NOT(Sintomas(perda_peso=W())))
def ask_data_perda_peso(self):
self.declare(Sintomas(perda_peso=ask("perda_peso? ")))
@Rule(NOT(Sintomas(ganho_peso=W())))
def ask_data_ganho_peso(self):
self.declare(Sintomas(ganho_peso=ask("ganho_peso? ")))
@Rule(NOT(Sintomas(reducao_alimentacao=W())))
def ask_data_reducao_alimentacao(self):
self.declare(
Sintomas(reducao_alimentacao=ask("reducao_alimentacao? ")))
@Rule(NOT(Sintomas(aumento_alimentacao=W())))
def ask_data_aumento_alimentacao(self):
self.declare(
Sintomas(aumento_alimentacao=ask("aumento_alimentacao? ")))
@Rule(NOT(Sintomas(insonia=W())))
def ask_data_insonia(self):
self.declare(Sintomas(insonia=ask("insonia? ")))
@Rule(NOT(Sintomas(hipersonia=W())))
def ask_data_hipersonia(self):
self.declare(Sintomas(hipersonia=ask("hipersonia? ")))
@Rule(NOT(Sintomas(retardo_psicomotor=W())))
def ask_data_retardo_psicomotor(self):
self.declare(Sintomas(retardo_psicomotor=ask("retardo_psicomotor? ")))
@Rule(NOT(Sintomas(fadiga=W())))
def ask_data_fadiga(self):
self.declare(Sintomas(fadiga=ask("fadiga? ")))
@Rule(NOT(Sintomas(perda_energia=W())))
def ask_data_perda_energia(self):
self.declare(Sintomas(perda_energia=ask("perda_energia? ")))
@Rule(NOT(Sintomas(inutilidade=W())))
def ask_data_inutilidade(self):
self.declare(Sintomas(inutilidade=ask("inutilidade? ")))
@Rule(NOT(Sintomas(culpa_excessiva=W())))
def ask_data_culpa_excessiva(self):
self.declare(Sintomas(culpa_excessiva=ask("culpa_excessiva? ")))
@Rule(NOT(Sintomas(culpa_inapropriada=W())))
def ask_data_culpa_inapropriada(self):
self.declare(Sintomas(culpa_inapropriada=ask("culpa_inapropriada? ")))
@Rule(NOT(Sintomas(capacidade_diminuida=W())))
def ask_data_capacidade_diminuida(self):
self.declare(
Sintomas(capacidade_diminuida=ask("capacidade_diminuida? ")))
@Rule(NOT(Sintomas(indecisao=W())))
def ask_data_indecisao(self):
self.declare(Sintomas(indecisao=ask("indecisao? ")))
@Rule(NOT(Sintomas(pensamentos_morte=W())))
def ask_data_pensamentos_morte(self):
self.declare(Sintomas(pensamentos_morte=ask("pensamentos_morte? ")))
@Rule(NOT(Sintomas(sofrimento_clinico=W())))
def ask_data_sofrimento_clinico(self):
self.declare(Sintomas(sofrimento_clinico=ask("sofrimento_clinico? ")))
@Rule(NOT(Sintomas(prejuiso_social=W())))
def ask_data_prejuiso_social(self):
self.declare(Sintomas(prejuiso_social=ask("prejuiso_social? ")))
@Rule(NOT(Sintomas(prejuiso_area_importancia=W())))
def ask_data_prejuiso_area_importancia(self):
self.declare(
Sintomas(
prejuiso_area_importancia=ask("prejuiso_area_importancia? ")))
@Rule(
AND(
NOT(Sintomas(verifica_mudanca_comportamental=W())),
AND(
OR(Sintomas(autoestima_excessiva=0),
Sintomas(autoestima_excessiva=1)),
Sintomas(autoestima_excessiva=MATCH.autoestima_excessiva)),
AND(OR(Sintomas(reducao_sono=0), Sintomas(reducao_sono=1)),
Sintomas(reducao_sono=MATCH.reducao_sono)),
AND(OR(Sintomas(aumento_fala=0), Sintomas(aumento_fala=1)),
Sintomas(aumento_fala=MATCH.aumento_fala)),
AND(
OR(Sintomas(mudanca_modo_pensar=0),
Sintomas(mudanca_modo_pensar=1)),
Sintomas(mudanca_modo_pensar=MATCH.mudanca_modo_pensar)),
AND(OR(Sintomas(distrabilidade=0), Sintomas(distrabilidade=1)),
Sintomas(distrabilidade=MATCH.distrabilidade)),
AND(OR(Sintomas(agitacao=0), Sintomas(agitacao=1)),
Sintomas(agitacao=MATCH.agitacao)),
AND(
OR(Sintomas(envolvimento_atividade_risco=0),
Sintomas(envolvimento_atividade_risco=1)),
Sintomas(envolvimento_atividade_risco=MATCH.
envolvimento_atividade_risco))))
def define_mudanca_comportamental(self, autoestima_excessiva, reducao_sono,
aumento_fala, mudanca_modo_pensar,
distrabilidade, agitacao,
envolvimento_atividade_risco):
self.declare(
Sintomas(verifica_mudanca_comportamental=verifica_conjunto([
autoestima_excessiva, reducao_sono, aumento_fala,
mudanca_modo_pensar, distrabilidade, agitacao,
envolvimento_atividade_risco
], 3)))
@Rule(
AND(
NOT(Sintomas(verifica_sintomas_depressivos=W())),
AND(OR(Sintomas(humor_deprimido=0), Sintomas(humor_deprimido=1)),
Sintomas(humor_deprimido=MATCH.humor_deprimido)),
AND(OR(Sintomas(perda_interesse=0), Sintomas(perda_interesse=1)),
Sintomas(perda_interesse=MATCH.perda_interesse)),
AND(
OR(Sintomas(alteracao_alimentacao=0),
Sintomas(alteracao_alimentacao=1)),
Sintomas(alteracao_alimentacao=MATCH.alteracao_alimentacao)),
AND(OR(Sintomas(alteracao_sono=0), Sintomas(alteracao_sono=1)),
Sintomas(alteracao_sono=MATCH.alteracao_sono)),
AND(
OR(Sintomas(alteracao_comportamentao=0),
Sintomas(alteracao_comportamentao=1)),
Sintomas(
alteracao_comportamentao=MATCH.alteracao_comportamentao)),
AND(OR(Sintomas(cansaco=0), Sintomas(cansaco=1)),
Sintomas(cansaco=MATCH.cansaco)),
AND(
OR(Sintomas(sentimento_depressivo=0),
Sintomas(sentimento_depressivo=1)),
Sintomas(sentimento_depressivo=MATCH.sentimento_depressivo)),
AND(
OR(Sintomas(alteracao_pensamento=0),
Sintomas(alteracao_pensamento=1)),
Sintomas(alteracao_pensamento=MATCH.alteracao_pensamento)),
AND(
OR(Sintomas(pensamentos_morte=0),
Sintomas(pensamentos_morte=1)),
Sintomas(pensamentos_morte=MATCH.pensamentos_morte))))
def define_sintomas_depressivos(self, humor_deprimido, perda_interesse,
alteracao_alimentacao, alteracao_sono,
alteracao_comportamentao, cansaco,
sentimento_depressivo,
alteracao_pensamento, pensamentos_morte):
self.declare(
Sintomas(verifica_sintomas_depressivos=verifica_conjunto([
humor_deprimido, perda_interesse, alteracao_alimentacao,
alteracao_sono, alteracao_comportamentao, cansaco,
sentimento_depressivo, alteracao_pensamento, pensamentos_morte
], 5)))
"""
Verificação das regras
"""
@Rule(
AND(Sintomas(mudanca_comportamental=1), Sintomas(fisiologico=1),
Sintomas(psicose=1)))
def mania(self):
self.declare(Sintomas(mania=1))
@Rule(
AND(Sintomas(mudanca_comportamental=1), Sintomas(fisiologico=0),
Sintomas(psicose=1)))
def nao_mania(self):
self.declare(Sintomas(mania=0))
@Rule(
AND(Sintomas(mudanca_comportamental=0), Sintomas(fisiologico=0),
Sintomas(psicose=W())))
def nao_2_mania(self):
self.declare(Sintomas(mania=0))
@Rule(
AND(Sintomas(mudanca_comportamental=1), Sintomas(fisiologico=1),
Sintomas(psicose=0)))
def hipomania(self):
self.declare(Sintomas(hipomania=1))
@Rule(
AND(Sintomas(mudanca_comportamental=1), Sintomas(fisiologico=0),
Sintomas(psicose=0)))
def nao_hipomania(self):
self.declare(Sintomas(hipomania=0))
@Rule(
AND(Sintomas(mudanca_comportamental=0), Sintomas(fisiologico=W()),
Sintomas(psicose=0)))
def nao_2_hipomania(self):
self.declare(Sintomas(hipomania=0))
@Rule(OR(Sintomas(prejuizo_social=1), Sintomas(prejuiso_profissional=1)))
def prejuiso_acentuado(self):
self.declare(Sintomas(prejuizo_acentuado=1))
@Rule(OR(Sintomas(prejuizo_si=1), Sintomas(prejuizo_outros=1)))
def risco_potencial(self):
self.declare(Sintomas(risco_potencial=1))
@Rule(NOT(OR(Sintomas(prejuizo_si=1), Sintomas(prejuizo_outros=1))))
def risco_potencial(self):
self.declare(Sintomas(risco_potencial=0))
@Rule(
OR(OR(Sintomas(prejuizo_acentuado=1), Sintomas(risco_potencial=1)),
Sintomas(psicose=1)))
def perturbacao_humor(self):
self.declare(Sintomas(perturbacao_humor=1))
@Rule(
NOT(
OR(OR(Sintomas(prejuizo_acentuado=1), Sintomas(risco_potencial=1)),
Sintomas(psicose=1))))
def perturbacao_humor(self):
self.declare(Sintomas(perturbacao_humor=0))
@Rule(OR(Sintomas(autoestima_inflada=1), Sintomas(grandiosidade=1)))
def autoestima_excessiva(self):
self.declare(Sintomas(autoestima_excessiva=1))
@Rule(OR(Sintomas(loquaz=1), Sintomas(pressao_continuar_falando=1)))
def aumento_fala(self):
self.declare(Sintomas(aumento_fala=1))
@Rule(OR(Sintomas(fuga_ideias=1), Sintomas(pensamento_acelerado=1)))
def mudanca_modo_pensar(self):
self.declare(Sintomas(mudanca_modo_pensar=1))
@Rule(
OR(Sintomas(aumento_atividade_objetivo=1),
Sintomas(agitacao_psicomotora=1)))
def agitacao(self):
self.declare(Sintomas(agitacao=1))
@Rule(Sintomas(verifica_mudanca_comportamental=1))
def mudanca_comportamental(self):
self.declare(Sintomas(mudanca_comportamental=1))
@Rule(OR(Sintomas(verifica_humor_deprimido=1), Sintomas(irritavel=1)))
def humor_deprimido(self):
self.declare(Sintomas(humor_deprimido=1))
@Rule(OR(Sintomas(verifica_perda_interesse=1), Sintomas(perda_prazer=1)))
def perda_interesse(self):
self.declare(Sintomas(perda_interesse=1))
@Rule(
OR(
OR(Sintomas(perda_peso=1), Sintomas(ganho_peso=1)),
OR(Sintomas(reducao_alimentacao=1),
Sintomas(aumento_alimentacao=1))))
def alteracao_alimentacao(self):
self.declare(Sintomas(Sintomas(alteracao_alimentacao=1)))
@Rule(OR(Sintomas(insonia=1), Sintomas(hipersonia=1)))
def alteracao_sono(self):
self.declare(Sintomas(alteracao_sono=1))
@Rule(OR(Sintomas(agitacao=1), Sintomas(retardo_psicomotor=1)))
def alteracao_comportamentao(self):
self.declare(Sintomas(alteracao_comportamentao=1))
@Rule(OR(Sintomas(fadiga=1), Sintomas(perda_energia=1)))
def cansaco(self):
self.declare(Sintomas(cansaco=1))
@Rule(
OR(Sintomas(inutilidade=1), Sintomas(culpa_excessiva=1),
Sintomas(culpa_inapropriada=1)))
def sentimento_depressivo(self):
self.declare(Sintomas(sentimento_depressivo=1))
@Rule(OR(Sintomas(capacidade_diminuida=1), Sintomas(indecisao=1)))
def alteracao_pensamento(self):
self.declare(Sintomas(alteracao_pensamento=1))
@Rule(
AND(OR(Sintomas(humor_deprimido=1), Sintomas(perda_interesse=1)),
Sintomas(verifica_sintomas_depressivos=1)))
def sintomas_depressivos(self):
self.declare(Sintomas(sintomas_depressivos=1))
@Rule(
OR(
OR(Sintomas(sofrimento_clinico=1), Sintomas(prejuiso_social=1)),
OR(Sintomas(prejuiso_profissional=1),
Sintomas(prejuiso_area_importancia=1))))
def transtorno(self):
self.declare(Sintomas(transtorno=1))
@Rule(AND(Sintomas(sintomas_depressivos=1), Sintomas(fisiologico=1)))
def depressao(self):
self.declare(Sintomas(depressao=1))
self.facts()
self.get_rules()
@Rule(AND(Sintomas(mania=1), Sintomas(depressao=1)))
def bipolar_i(self):
self.declare(Sintomas(bipolar_i=1))
@Rule(AND(Sintomas(hipomania=1), Sintomas(depressao=1)))
def bipolar_ii(self):
self.declare(Sintomas(bipolar_ii=1))
@Rule(
AND(
OR(Sintomas(pensamentos_morte=1), Sintomas(psicose=1),
Sintomas(transtorno=1)), Sintomas(mania=0),
Sintomas(hipomania=0), Sintomas(depressao=0)))
def outro_transtorno(self):
self.declare(Sintomas(outro_transtorno=1))
@Rule(Sintomas(bipolar_i=1))
def tem_bipolar_i(self):
self.halt()
@Rule(Sintomas(bipolar_ii=1))
def tem_bipolar_ii(self):
self.halt()
@Rule(
OR(AND(Sintomas(mania=0), Sintomas(depressao=1)),
AND(Sintomas(hipomania=0), Sintomas(depressao=1))))
def tem_depressao(self):
self.halt()
@Rule(Sintomas(outro_transtorno=1))
def tem_outro_transtorno(self):
self.halt()
@Rule(Sintomas(outro_transtorno=0))
def nao_tem_outro_transtorno(self):
self.halt()
class ControlEngine(KnowledgeEngine):
def __init__(self):
super().__init__()
self.returnv={}
#### RULES TO MODIFY ####
## Input processing rules
@Rule(Input(T=MATCH.T,
T_max=MATCH.Tmax,
T_min=MATCH.Tmin,
heating=True),
TEST(lambda T,Tmax, Tmin : T >= Tmin + 0.1), #Tmax - (Tmax-Tmin)/2),
salience=5)
def _high_temp(self):
self.declare(State(heating = False))
@Rule(Input(T=MATCH.T,
T_min=MATCH.Tmin,
T_max = MATCH.Tmax,
heating=False,
P_max=MATCH.Pmax),
TEST(lambda T,Tmin, Tmax : T < Tmin+0.1),#Tmin + (Tmax-Tmin)/2),
salience=5)
def _low_temp(self):
self.declare(State(heating = True))
@Rule(Input(SOC=MATCH.soc),
TEST(lambda soc : soc < 0.9 and soc > 0.1),
salience=5)
def _SOCok(self,soc):
self.declare(State(SOCok= True, SOC=soc))
@Rule(Input(SOC=MATCH.soc),
TEST(lambda soc : soc >= 0.9 or soc <= 0.1),
salience=5)
def _SOCbad(self, soc):
self.declare(State(SOCok= False, SOC=soc))
## Decision processing rules
@Rule(Input(P_max=MATCH.Pmax, Pset_heat = MATCH.Pset),
State(heating=True),
salience=3)
def _heating1(self,Pmax, Pset):
self.declare(Output(newPset_heat = -0.1*Pmax + (1-0.1)*Pset , heating=True))
@Rule(State(heating=False),
salience=3)
def _heating2(self):
self.declare(Output(newPset_heat = 0.0, heating=False))
@Rule(Input(heating=True,
P_max=MATCH.Pmax, Pset_heat = MATCH.Pset),
NOT(State(heating=W())),
salience=3)
def _heating3(self,Pmax, Pset):
self.declare(Output(newPset_heat = -0.7*Pmax + (1-0.7)*Pset,heating=True))
@Rule(State(SOCok=True), Input(Pgrid = MATCH.P_grid),
TEST(lambda P_grid : P_grid <= 0),
salience=4)
def _socokout(self):
self.declare(Output(newPset_batt = -0.5)) # ADAPT this
#print("charging battery")
@Rule(State(SOCok=True), Input(Pgrid = MATCH.P_grid, P_max = MATCH.Pmax, SOC = MATCH.soc),
TEST(lambda P_grid :P_grid > 0), TEST(lambda soc : soc >0.2),
salience=3)
def _socokout1(self, Pmax):
self.declare(Output(newPset_batt = 0.4)) # ADAPT this
# print("discharging battery")
@Rule(State(SOCok=False),
salience=3)
def _socbadout(self):
self.declare(Output(newPset_batt = -0)) # this is the default
@Rule(Input(heating=False),
NOT(State(heating=W())),
salience=3)
def _heating4(self):
self.declare(Output(newPset_heat = 0.0,heating=False))
#@Rule(Input(zs = MATCH.ZS), TEST(lambda ZS: ZS>-0.01 ))
#def _too_much_sun(self):
# self.declare(Output(newPset_heat = 0.0,heating=False))
# rule to return values last
@Rule(AS.out << Output(),
salience=0) #
def _returnoutputs(self,out):
self.returnv.update(**out.retrieve())
#print("generated this output: " +str(out.retrieve()))
#### END OF RULES ####
def get_return(self,key):
return self.returnv.get(key)
def set_return(self,returnvaluedict):
self.returnv = returnvaluedict
class Person_KE(KnowledgeEngine):
@Rule(NOT(ConflictResolver(resolved=True)),
AND(Person(age=W('age')), Person(age=~W("age"))))
def same_name(self, age):
nonlocal executions
executions.append(age)
class Person_KE(KnowledgeEngine):
@Rule(Person(name=W("name")), NOT(Person(surname=W('name'))))
def same_name(self, name):
nonlocal executions
executions.append(name)
class Bipolar(KnowledgeEngine):
"""
Coleta dos dados
"""
@Rule(NOT(Sintomas(pensamentos_morte=W())))
def ask_pensamentos_morte(self):
self.declare(
Sintomas(pensamentos_morte=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(alteracao_pensamento=W())))
def ask_alteracao_pensamento(self):
self.declare(
Sintomas(alteracao_pensamento=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(sentimento_depressivo=W())))
def ask_sentimento_depressivo(self):
self.declare(
Sintomas(sentimento_depressivo=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(cansaco=W())))
def ask_cansaco(self):
self.declare(Sintomas(cansaco=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(alteracao_comportamentao=W())))
def ask_alteracao_comportamentao(self):
self.declare(
Sintomas(
alteracao_comportamentao=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(alteracao_sono=W())))
def ask_alteracao_sono(self):
self.declare(
Sintomas(alteracao_sono=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(alteracao_alimentacao=W())))
def ask_alteracao_alimentacao(self):
self.declare(
Sintomas(alteracao_alimentacao=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(perda_interesse=W())))
def ask_perda_interesse(self):
self.declare(
Sintomas(perda_interesse=ask("prejuiso_area_importancia? ")))
@Rule(NOT(Sintomas(humor_deprimido=W())))
def ask_humor_deprimido(self):
self.declare(
Sintomas(humor_deprimido=ask("prejuiso_area_importancia? ")))
@Rule(
AND(
NOT(Sintomas(verifica_sintomas_depressivos=W())),
AND(OR(Sintomas(humor_deprimido=0), Sintomas(humor_deprimido=1)),
Sintomas(humor_deprimido=MATCH.humor_deprimido)),
AND(OR(Sintomas(perda_interesse=0), Sintomas(perda_interesse=1)),
Sintomas(perda_interesse=MATCH.perda_interesse)),
AND(
OR(Sintomas(alteracao_alimentacao=0),
Sintomas(alteracao_alimentacao=1)),
Sintomas(alteracao_alimentacao=MATCH.alteracao_alimentacao)),
AND(OR(Sintomas(alteracao_sono=0), Sintomas(alteracao_sono=1)),
Sintomas(alteracao_sono=MATCH.alteracao_sono)),
AND(
OR(Sintomas(alteracao_comportamentao=0),
Sintomas(alteracao_comportamentao=1)),
Sintomas(
alteracao_comportamentao=MATCH.alteracao_comportamentao)),
AND(OR(Sintomas(cansaco=0), Sintomas(cansaco=1)),
Sintomas(cansaco=MATCH.cansaco)),
AND(
OR(Sintomas(sentimento_depressivo=0),
Sintomas(sentimento_depressivo=1)),
Sintomas(sentimento_depressivo=MATCH.sentimento_depressivo)),
AND(
OR(Sintomas(alteracao_pensamento=0),
Sintomas(alteracao_pensamento=1)),
Sintomas(alteracao_pensamento=MATCH.alteracao_pensamento)),
AND(
OR(Sintomas(pensamentos_morte=0),
Sintomas(pensamentos_morte=1)),
Sintomas(pensamentos_morte=MATCH.pensamentos_morte))))
def define_sintomas_depressivos(self, humor_deprimido, perda_interesse,
alteracao_alimentacao, alteracao_sono,
alteracao_comportamentao, cansaco,
sentimento_depressivo,
alteracao_pensamento, pensamentos_morte):
self.declare(
Sintomas(verifica_sintomas_depressivos=verifica_conjunto([
humor_deprimido, perda_interesse, alteracao_alimentacao,
alteracao_sono, alteracao_comportamentao, cansaco,
sentimento_depressivo, alteracao_pensamento, pensamentos_morte
], 5)))
@Rule(
AND(OR(Sintomas(humor_deprimido=1), Sintomas(perda_interesse=1)),
Sintomas(verifica_sintomas_depressivos=1)))
def sintomas_depressivos(self):
print("sintomas_depressivos")
self.declare(Sintomas(sintomas_depressivos=1))
def test_extract_facts():
from pyknow import Rule, NOT, AND, OR, Fact
rule = Rule(OR(AND(Fact(1), NOT(Fact(2))), Fact(3)))
assert utils.extract_facts(rule) == {Fact(1), Fact(2), Fact(3)}
def test_prepare_rule__rule_starting_with_not():
from pyknow import Rule, InitialFact, NOT, Fact
rule = Rule(NOT(Fact(1)))(lambda: None)
assert list(utils.prepare_rule(rule)) == [InitialFact(), NOT(Fact(1))]
class Mania(KnowledgeEngine):
"""
Coleta dos dados
"""
result = {
'variable': None,
'isFinalAnswer': False,
'answer': None,
}
is_rest = True
def ask(self, variable):
if not self.is_rest:
return ask(variable)
else:
self.result['variable'] = variable
self.result['isFinalAnswer'] = False
self.result['answer'] = None
self.halt()
def send(self, message):
if not self.is_rest:
print(message)
else:
self.result['variable'] = None
self.result['isFinalAnswer'] = True
self.result['answer'] = message
self.halt()
@Rule(Sintomas(fisiologico=None))
def ask_data_fisiologico(self):
self.declare(Sintomas(fisiologico=self.ask("fisiologico")))
@Rule(Sintomas(prejuizo_social=None))
def ask_data_prejuizo_social(self):
self.declare(Sintomas(prejuizo_social=self.ask("prejuizo_social")))
@Rule(Sintomas(prejuiso_profissional=None))
def ask_data_prejuiso_profissional(self):
self.declare(
Sintomas(prejuiso_profissional=self.ask("prejuiso_profissional")))
@Rule(Sintomas(psicose=None))
def ask_data_psicose(self):
self.declare(Sintomas(psicose=self.ask("psicose")))
@Rule(Sintomas(autoestima_inflada=None))
def ask_data_autoestima_inflada(self):
self.declare(
Sintomas(autoestima_inflada=self.ask("autoestima_inflada")))
@Rule(Sintomas(grafndiosidade=None))
def ask_data_grandiosidade(self):
self.declare(Sintomas(grandiosidade=self.ask("grandiosidade")))
@Rule(Sintomas(loquaz=None))
def ask_data_loquaz(self):
self.declare(Sintomas(loquaz=self.ask("loquaz")))
@Rule(Sintomas(pressao_continuar_falando=None))
def ask_data_pressao_continuar_falando(self):
self.declare(
Sintomas(pressao_continuar_falando=self.ask(
"pressao_continuar_falando")))
@Rule(Sintomas(fuga_ideias=None))
def ask_data_fuga_ideias(self):
self.declare(Sintomas(fuga_ideias=self.ask("fuga_ideias")))
@Rule(Sintomas(pensamento_acelerado=None))
def ask_data_pensamento_acelerado(self):
self.declare(
Sintomas(pensamento_acelerado=self.ask("pensamento_acelerado")))
@Rule(Sintomas(aumento_atividade_objetivo=None))
def ask_data_aumento_atividade_objetivo(self):
self.declare(
Sintomas(aumento_atividade_objetivo=self.ask(
"aumento_atividade_objetivo")))
@Rule(Sintomas(agitacao_psicomotora=None))
def ask_data_agitacao_psicomotora(self):
self.declare(
Sintomas(agitacao_psicomotora=self.ask("agitacao_psicomotora")))
@Rule(Sintomas(reducao_sono=None))
def ask_data_reducao_sono(self):
self.declare(Sintomas(reducao_sono=self.ask("reducao_sono")))
@Rule(Sintomas(distrabilidade=None))
def ask_data_distrabilidade(self):
self.declare(Sintomas(distrabilidade=self.ask("distrabilidade")))
@Rule(Sintomas(envolvimento_atividade_risco=None))
def ask_data_envolvimento_atividade_risco(self):
self.declare(
Sintomas(envolvimento_atividade_risco=self.ask(
"envolvimento_atividade_risco")))
@Rule(
AND(
NOT(Sintomas(mudanca_comportamental=W())),
AND(
OR(Sintomas(autoestima_excessiva=0),
Sintomas(autoestima_excessiva=1)),
Sintomas(autoestima_excessiva=MATCH.autoestima_excessiva)),
AND(OR(Sintomas(reducao_sono=0), Sintomas(reducao_sono=1)),
Sintomas(reducao_sono=MATCH.reducao_sono)),
AND(OR(Sintomas(aumento_fala=0), Sintomas(aumento_fala=1)),
Sintomas(aumento_fala=MATCH.aumento_fala)),
AND(
OR(Sintomas(mudanca_modo_pensar=0),
Sintomas(mudanca_modo_pensar=1)),
Sintomas(mudanca_modo_pensar=MATCH.mudanca_modo_pensar)),
AND(OR(Sintomas(distrabilidade=0), Sintomas(distrabilidade=1)),
Sintomas(distrabilidade=MATCH.distrabilidade)),
AND(OR(Sintomas(agitacao=0), Sintomas(agitacao=1)),
Sintomas(agitacao=MATCH.agitacao)),
AND(
OR(Sintomas(envolvimento_atividade_risco=0),
Sintomas(envolvimento_atividade_risco=1)),
Sintomas(envolvimento_atividade_risco=MATCH.
envolvimento_atividade_risco))))
def define_mudanca_comportamental(self, autoestima_excessiva, reducao_sono,
aumento_fala, mudanca_modo_pensar,
distrabilidade, agitacao,
envolvimento_atividade_risco):
self.declare(
Sintomas(mudanca_comportamental=verifica_conjunto([
autoestima_excessiva, reducao_sono, aumento_fala,
mudanca_modo_pensar, distrabilidade, agitacao,
envolvimento_atividade_risco
], 3)))
"""
Verificação das regras
"""
@Rule(
AND(Sintomas(mudanca_comportamental=1), Sintomas(fisiologico=1),
Sintomas(psicose=1)))
def mania(self):
self.declare(Sintomas(mania=1))
self.send("mania:1")
@Rule(
AND(Sintomas(mudanca_comportamental=1), Sintomas(fisiologico=1),
Sintomas(psicose=0)))
def hipomania(self):
self.declare(Sintomas(hipomania=1))
self.send("hipomania:1")
@Rule(Sintomas(fisiologico=0))
def nao_fisiologico(self):
self.declare(Sintomas(mania=0))
self.declare(Sintomas(hipomania=0))
self.send(":0")
@Rule(Sintomas(mudanca_comportamental=0))
def nao_mudanca_comportamental(self):
self.declare(Sintomas(mania=0))
self.declare(Sintomas(hipomania=0))
self.send(":0")
@Rule(OR(Sintomas(prejuizo_social=1), Sintomas(prejuiso_profissional=1)))
def prejuiso_acentuado(self):
self.declare(Sintomas(prejuizo_acentuado=1))
@Rule(AND(Sintomas(prejuizo_social=0), Sintomas(prejuiso_profissional=0)))
def nao_prejuiso_acentuado(self):
self.declare(Sintomas(prejuizo_acentuado=0))
@Rule(OR(Sintomas(autoestima_inflada=1), Sintomas(grandiosidade=1)))
def autoestima_excessiva(self):
self.declare(Sintomas(autoestima_excessiva=1))
@Rule(AND(Sintomas(autoestima_inflada=0), Sintomas(grandiosidade=0)))
def nao_autoestima_excessiva(self):
self.declare(Sintomas(autoestima_excessiva=0))
@Rule(OR(Sintomas(loquaz=1), Sintomas(pressao_continuar_falando=1)))
def aumento_fala(self):
self.declare(Sintomas(aumento_fala=1))
@Rule(AND(Sintomas(loquaz=0), Sintomas(pressao_continuar_falando=0)))
def nao_aumento_fala(self):
self.declare(Sintomas(aumento_fala=0))
@Rule(OR(Sintomas(fuga_ideias=1), Sintomas(pensamento_acelerado=1)))
def mudanca_modo_pensar(self):
self.declare(Sintomas(mudanca_modo_pensar=1))
@Rule(AND(Sintomas(fuga_ideias=0), Sintomas(pensamento_acelerado=0)))
def nao_mudanca_modo_pensar(self):
self.declare(Sintomas(mudanca_modo_pensar=0))
@Rule(
OR(Sintomas(aumento_atividade_objetivo=1),
Sintomas(agitacao_psicomotora=1)))
def agitacao(self):
self.declare(Sintomas(agitacao=1))
@Rule(
AND(Sintomas(aumento_atividade_objetivo=0),
Sintomas(agitacao_psicomotora=0)))
def nao_agitacao(self):
self.declare(Sintomas(agitacao=0))