class Consultor(object):
"""Clase que implementa el mecanismo de consultas a la base de conocimientos usando Prolog"""
def __init__(self, consulta):
self.consultor = Prolog()
self.consultor.consult(os.path.join(settings.MEDIA_ROOT, 'colombianCrush.pl').replace('\\','/'))
self.consulta = consulta
self.resultado = []
def buscarSugerencia(self):
"""Genera la respuesta a la consulta de una sugerencia de movimiento para el jugador"""
return self._validarConsulta(self.consultor.query("buscarSugerencia(X, " + self.consulta + ")"))
def buscarPosibilidad(self):
"""Genera la respuesta a la consulta de una posibilidad de destruccion de figuras"""
return self._validarConsulta(self.consultor.query("buscarPosibilidad(X, " + self.consulta + ")"))
def _validarConsulta(self, consulta):
"""Metodo interno que extrae el menor valor obtenido de Prolog al consultar la base de conocimiento"""
for valor in consulta:
self.resultado.append(valor["X"])
if len(self.resultado)>PASIVO:
return min(self.resultado)
else:
return PASIVO
class ConnectProlog(ConnectLivestatus):
"""As it is senseless to call Prolog without starting a connection to Nagios/Icinga, this module does it."""
def __init__(self):
prolog=None
ConnectLivestatus.__init__(self)
self.prolog=Prolog()
self.prolog.consult('vanyad.pl')
def main():
letters = "S E N D M O R Y".split()
prolog = Prolog()
sendmore = Functor("sendmore")
prolog.consult("money.pl")
X = Variable()
call(sendmore(X))
r = X.value
for i, letter in enumerate(letters):
print(letter, "=", r[i])
print("That's all...")
def test_swipl(self):
from pyswip import Prolog
from reloop.languages.rlp.logkb import PrologKB
prolog = Prolog()
prolog.consult("../examples/RLP/maxflow_swipl.pl")
logkb = PrologKB(prolog)
# BlockGrounding not supported yet
grounder = RecursiveGrounder(logkb)
solver = CvxoptSolver()
model = maxflow_example.maxflow(grounder, solver)
self.assertEqual(model, 0, "SWI-Prolog Recursive Failed")
def index(request):
if request.method == "GET":
print "AQUI"
prolog = Prolog()
print "AQUI TAMBIEN"
#prolog.consult("recetas.pl")
print "AQUI TAMBIEN ES"
ingredientes = list(prolog.query("ingrediente(X)"))
#salida = str(ingredientes)
salida = "Hola"
return HttpResponse(salida)
def query_hyp_in_event_db(hyp, event_db_file):
prolog = Prolog()
str2num_file = '/home/csunix/visdata/cofriend/sandeep/Dropbox/code/my_code/trunk/python/cofriend/str2num.pl'
prolog.consult(str2num_file)
print 'Reading event database ...'
all_prolog_modules = pickle.load(open(event_db_file))
(modeh, modeb) = all_prolog_modules['modes']
pos_ex = all_prolog_modules['pos_ex']
test_pos_ex = all_prolog_modules['test_pos_ex']
pos_prolog_modules = all_prolog_modules['pos']
neg_prolog_modules = all_prolog_modules['neg']
test_prolog_modules = all_prolog_modules['test']
pos_event_dbs = []
neg_event_dbs = []
print 'Asserting pos prolog modules ...'
for vid in pos_prolog_modules:
for i in xrange(len(pos_prolog_modules[vid])):
pos_prolog_module = pos_prolog_modules[vid][i][0]
pos_prolog_blanket = pos_prolog_modules[vid][i][1]
pos_event_dbs.append(pos_prolog_module)
assert_blanket_to_prolog_str_int(pos_prolog_blanket, prolog, pos_prolog_module)
print 'Asserting neg prolog modules ...'
for vid in neg_prolog_modules:
for i in xrange(len(neg_prolog_modules[vid])):
neg_prolog_module = neg_prolog_modules[vid][i][0]
neg_prolog_blanket = neg_prolog_modules[vid][i][1]
neg_event_dbs.append(neg_prolog_module)
assert_blanket_to_prolog_str_int(neg_prolog_blanket, prolog, neg_prolog_module)
print 'num of pos: ' + repr(len(pos_event_dbs))
print 'num of neg: ' + repr(len(neg_event_dbs))
print 'Querying in pos prolog modules ...'
t0 = time.clock()
print time.asctime()
for i in xrange(100000):
pos_cover = hyp.pyswip_covers(prolog, pos_event_dbs, True, False, neg=0)
print time.asctime()
pos_eval_time = (time.clock() - t0)
print 'Querying in neg prolog modules ...'
t0 = time.clock()
print time.asctime()
for i in xrange(100000):
neg_cover = hyp.pyswip_covers(prolog, neg_event_dbs, True, False, neg=1)
print time.asctime()
neg_eval_time = (time.clock() - t0)
print pos_eval_time
print neg_eval_time
def index(request, table):
import MySQLdb as db
conn = db.connect(host='localhost', user='******', passwd='prologpass', db='prolog_test')
cursor = conn.cursor()
cursor.execute('SELECT * FROM `children`')
result = cursor.fetchall()
prolog = Prolog()
for row in result:
prolog.assertz("father("+ row[1] +","+ row[2] +")")
prolog.consult('family')
prolog.assertz("father(michael,john)")
prolog.assertz("father(michael,gina)")
father = list(prolog.query("father(Y, X)"))
#return HttpResponse(response, mimetype="application/xml")
t = loader.get_template('index/select.html')
c = RequestContext(request, {'table': table, 'father': father})
return HttpResponse(
t.render(c),
mimetype="application/xml"
)
def test_issue_Unicode_consult(self):
"""
Unicode support
"""
from pyswip import Prolog
Prolog.consult('unicode.pl')
result = list(Prolog.query('мать(Мать,Ребенок)'))
k = len(result)
self.assertEqual(k, 2)
result = list(Prolog.query('дочь(света,саша)'))
self.assertEqual(result, [])
result = list(Prolog.query('дочь(света,аня)'))
self.assertNotEqual(result, [])
def test_issue_1(self):
"""
Segmentation fault when assertz-ing
Notes: This issue manifests only in 64bit stacks (note that a full 64
bit stack is needed. If running 32 in 64bit, it will not happen.)
http://code.google.com/p/pyswip/issues/detail?id=1
"""
# The simple code below should be enough to trigger the issue. As with
# issue 13, if it does not work, it will segfault Python.
from pyswip import Prolog
prolog = Prolog()
prolog.assertz("randomTerm(michael,john)")
def query_hyp_in_video_db(hyps, video_db):
prolog = Prolog()
str2num_file = '/home/csunix/visdata/cofriend/sandeep/Dropbox/code/my_code/trunk/python/cofriend/str2num.pl'
prolog.consult(str2num_file)
print 'Asserting the database ...'
assert_blanket_to_prolog_str_int(video_db, prolog, 'vid_db')
result = {}
for event in hyps:
result[event] = []
print 'Querying in the video for event: ' + event
for hyp in hyps[event]:
pos_cover = hyp.pyswip_covers(prolog, [('vid_db',video_db)], True, False, neg=0)
result[event].append(pos_cover)
return result
class GamePL(object):
def __init__(self):
self.prolog = Prolog()
self.prolog.consult("pl/GameDatabase.pl")
self.prolog.consult("pl/GameLogic.pl")
def nuevoJugador(self, name):
None
def actualizaPuntuacion(self, jugador, puntos):
None
def borrarMemoria(self):
None
def getPuntuacion(self, jugador):
None
def getCategorias(self):
return self.prolog.query("categoria(Categoria, Descripcion)")
def getPreguntas(self):
return self.prolog.query("pregunta(Numero, Pregunta, Categoria, Puntos)")
def getRespuestas(self):
return self.prolog.query("respuesta(Numero, Respuesta)")
def main():
prolog = Prolog()
prolog.consult("coins.pl")
count = int(input("How many coins (default: 100)? ") or 100)
total = int(input("What should be the total (default: 500)? ") or 500)
coins = Functor("coins", 3)
S = Variable()
q = Query(coins(S, count, total))
i = 0
while q.nextSolution():
## [1,5,10,50,100]
s = zip(S.value, [1, 5, 10, 50, 100])
print(i, end=" ")
for c, v in s:
print("%dx%d" % (c,v), end=" ")
print()
i += 1
q.closeQuery()
def solveSudoku(sudokuString):
print "in solve"
answerString = ""
prolog = Prolog()
prolog.consult('sudokusolver.pl')
queryString = "Puzzle = [" + sudokuString + "], Puzzle = [A,B,C,D,E,F,G,H,I], sudoku([A,B,C,D,E,F,G,H,I]). "
#queryString = queryS
res = list(prolog.query(queryString, maxresult=1))
print res
if not res:
#results is empty
return "Invalid Sudoku"
else:
final = []
cols = ["A","B","C","D","E","F","G","H","I"]
for col in cols:
final.append(" ".join(map( str,res[0][col])))
return "<br>".join(final)
def main():
mod = sys.argv[1]
what = sys.argv[2]
who = sys.argv[3]
find = False
prolog = Prolog()
prolog.consult(mod)
for soln in prolog.query("%s(X,%s)" % (what, who)):
if what == 'pere' :
print soln["X"], "est le %s de %s" % (what, who)
else :
print soln["X"], "est la %s de %s" % (what, who)
find = True
if not find:
print "Je suis désolé, je ne dispose pas des informations requise pour vous répondre. Souhaitez-vous que jeffectue une recherche sur Internet"
def __init__(self):
self.prolog = Prolog()
self.X = Variable()
self.resultado = ['corinthians', 'atletico_mg', 'gremio', 'santos', 'sao_paulo', 'palmeiras', 'flamengo', 'internacional', 'ponte_preta', 'sport', 'fluminense', 'atletico_pr', 'cruzeiro', 'chapecoense', 'figueirense', 'avai', 'coritiba', 'goias', 'vasco', 'joinville', 'botafogo']
arquivo_pl = open('jogos.pl')
for linha in arquivo_pl.readlines():
if linha[len(linha) - 1] == '\n':
linha = linha.replace("\n", "")
self.prolog.assertz(linha)
def index():
bs = BaseHandler()
dt = None
sol2 = None
error = None
form = HelpForm()
if form.validate_on_submit():
bsg = bs.big_suggest(str(form.quiz.data))
sol2 = bs.find_elements(bsg)
try:
from pyswip import Prolog
prolog = Prolog()
prolog.consult("kb.txt")
# prolog.assertz("father(michael,gina)")
# prolog.assertz("father(michael,john)")
dt = list(prolog.query("elements(X)"))
# sol2 = list(prolog.query("battery(hot,X)"))
except Exception,e:
error = e
traceback.print_exc()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--rules", dest="rule_path", default=None)
parser.add_argument("--db-source", dest="db_path", default="postgresql://dgarant@localhost:5432/movielens")
args = parser.parse_args()
if args.rule_path:
with open(args.rule_path, 'r') as rule_handle:
rules = [r.strip() for r in rule_handle.readlines()]
else:
rules = build_schema_rules(args.db_path)
rules.extend(register_qeds())
prolog = Prolog()
for rule in rules:
print(rule)
prolog.assertz(rule)
report_on_qeds(prolog, "movie_gross")
def __init__(self):
if self.band:
self.prolog = Prolog()
if not os.path.isfile('prolog/kb_recetas.pl'):
print "Generando Recetas..."
self.cargarRecetas()
print "Cargando Recetas..."
self.prolog.consult('prolog/kb_recetas.pl')
print "Cargando Querys..."
self.prolog.consult('prolog/motorinferencia.pl')
self.band = False
else:
print "Ya se cargo"
class PrologAA:
def __init__(self):
self.prolog = Prolog()
self.prolog.assertz(":-use_module(library(lists))")
self.ficheiro = None
def assercao(self,texto):
if self.ficheiro is None:
self.ficheiro = open(r"f:\temp\pee.pl","w")
self.ficheiro.write(texto+ '.\n')
def query(self, texto):
if self.ficheiro is None:
self.ficheiro = open(r"f:\temp\factos_pee.pl","w")
self.ficheiro.write(texto + '.\n')
self.ficheiro.close()
return dict(V=['a','b','c'])
def procurar(self, problema):
prlg = self.prolog
objectivo = [ (x,y) for (x,y) in problema.modelo_mundo._elementos if problema.modelo_mundo._elementos[(x,y)] == 'alvo'][0]
self.assercao( "final({}/{}/G/H/V,V,C) :- C is G+H.".format( objectivo[0], objectivo[1]))
posicoes = [ (x,y) for (x,y) in problema.modelo_mundo._elementos if problema.modelo_mundo._elementos[(x,y)] != 'obst']
for (x,y) in posicoes:
self.assercao("posicao({},{})".format(x,y))
accoes=[(1,0,1), (1,1,2), (0,1,3),(-1,1,4),(-1,0,5),(-1,-1,6),(0,-1,7),(1,-1,8)]
for (x,y, z) in accoes:
self.assercao("accao({},{},{},{})".format(x,y, z/8.0 * 2.0* math.pi, math.sqrt( x**2 + y**2)))
self.problema = problema
(xi, yi) = problema.estado_inicial() #(0,1)
caminho = list(self.query("teste( V, _) :- aStar( {}/{},V, C )".format(xi, yi)))
input("Parar aqui, foi apenas usado para obter a representacao do mundo num ficheiro de factos a usar em prolog")
def test_issue_8(self):
"""
Callbacks can cause segv's
https://code.google.com/p/pyswip/issues/detail?id=8
"""
from pyswip import Prolog, registerForeign
callsToHello = []
def hello(t):
callsToHello.append(t)
hello.arity = 1
registerForeign(hello)
prolog = Prolog()
prolog.assertz("parent(michael,john)")
prolog.assertz("parent(michael,gina)")
p = prolog.query("parent(michael,X), hello(X)")
result = list(p) # Will run over the iterator
self.assertEqual(len(callsToHello), 2) # ['john', 'gina']
self.assertEqual(len(result), 2) # [{'X': 'john'}, {'X': 'gina'}]
class Bridge:
def __init__(self):
self.prolog = Prolog()
self.prolog.consult('facts.pl')
self.prolog.consult('logic/agent.pl')
def best_action(self):
actions = list(self.prolog.query('best_action(Action, Arg1, Arg2)', maxresult=1))
if len(actions) > 0:
return actions[0]
else:
return None
def assertz(self, what):
return list(self.prolog.query("assertz(%s)" % what))
def retract(self, what):
return list(self.prolog.query("retract(%s)" % what))
def retractall(self, what):
return list(self.prolog.query("retractall(%s)" % what))
def assert_perceptions(self, perceptions, x, y):
for p in perceptions.keys():
self.retract("percept_%s(%d, %d)" % (p, x, y))
if perceptions[p] == True:
self.assertz("percept_%s(%d, %d)" % (p, x, y))
def assert_on(self, x, y):
self.retractall('on(X, Y)')
self.retract('visited(%d, %d)' % (x, y))
self.assertz('on(%d, %d)' % (x, y))
self.assertz('visited(%d, %d)' % (x, y))
self.retract('connex(%d, %d)' % (x, y))
self.assertz('connex(%d, %d)' % (x, y))
def assert_energy(self, e):
self.retractall('energy(E)')
self.assertz('energy(%d)' % e)
def assert_attacked(self, x, y):
self.assertz('attacked(%d, %d)' % (x, y))
def __init__(self,radius=80):
self.win = Tk()
self.radius = radius
self.pawnList1 = []
self.pawnList2 = []
self.generatePawns()
self.playerOne = True
self.pawnSelected = False
self.chaining = False
self.capturing = False
self.selectedPawn = None
self.captured = None
self.prolog = Prolog()
self.prolog.consult("clauses.pl")
self.prolog.asserta("hos(dummy)")
self.defaultPosition()
self.board = Board(self.pawnList1,self.pawnList2,self.radius,self.win,self)
self.board.mainloop()
def find_elements(self,long_string):
elements = []
solution = []
arr = long_string.strip().split(" ")
arr_len = len(arr)
from pyswip import Prolog
prolog = Prolog()
prolog.consult("kb.txt")
for x in xrange(arr_len):
q = list(prolog.query("elements(%s)"%arr[x]))
if len(q) > 0:
s = list(prolog.query("problem(%s,X)"%arr[x]))
kw = [x['X'] for x in s]
for k in kw:
if arr.__contains__(k):
solution.append(list(prolog.query("solution(%s,Y)"%k)))
for h in solution:
if len(h) > 0:
for j in h:
elements.append(j['Y'])
return elements
def pathplan(start,end):
prolog = Prolog()
prolog.consult('a_star_4.0.pl')
startlist=start.split('+')
len_start=len(startlist)
endlist=end.split('+')
len_end=len(endlist)
if len_start==3 and len_end==3 :
qqq = "once(path_plan1(" + startlist[0] + "," + startlist[1]+ "," + startlist[2]+ "," + endlist[0] + "," + endlist[1]+ "," + endlist[2] + ",Coorlist))"
for result in prolog.query(qqq):
path = result["Coorlist"]
print path
elif len_start==3 and len_end==1 and end=='last_starter' :
qqq = "once(path_plan3(" + startlist[0] + "," + startlist[1]+ "," + startlist[2]+ ",last_starter,Coorlist))"
for result in prolog.query(qqq):
path = result["Coorlist"]
print path
else :
qqq = "once(path_plan2(" + startlist[0] + "," + startlist[1]+ "," + startlist[2]+ "," + end + ",Coorlist))"
for result in prolog.query(qqq):
path = result["Coorlist"]
print path
from pyswip import Prolog
prolog = Prolog()
prolog.consult("./pl/engine.pl")
# def fact(string):
# prolog.assertz(string)
# def isOld(age):
# if(age > 60):
# fact("isOld(a)")
# return True
# fact("isOld(a):-false")
# return False
# def hasChild(has):
# if(has):
# fact("hasChild(a)")
# else:
# fact("hasChild(a):-false")
# return has
# def isTall(height):
# if(height > 180):
# fact("isTall(a)")
# return True
# fact("isTall(a):-false")
# return False
# def privacy(need_privacy):
# if(need_privacy):
# prolog.query("rules:private(a)")
from pyswip import Prolog
prolog = Prolog()
prolog.assertz("father(michael,john)")
prolog.assertz("father(michael,gina)")
list(prolog.query("father(michael,X)")) == [{'X': 'john'}, {'X': 'gina'}]
for soln in prolog.query("father(X,Y)"):
print(soln["X"], "is the father of", soln["Y"])
# michael is the father of john
# michael is the father of gina //
"""
PySWIP usage example. See also:
https://github.com/yuce/pyswip
"""
from pyswip import Prolog
prolog = Prolog()
prolog.assertz("father(michael,john)")
prolog.assertz("father(michael,gina)")
query_results = list(prolog.query("father(michael,X)"))
# check if results are correct:
if query_results == [{'X': 'john'}, {'X': 'gina'}]:
print("Correct results")
else:
print("Incorrect results")
for soln in prolog.query("father(X,Y)"):
print(soln["X"], "is the father of", soln["Y"])
# michael is the father of john
# michael is the father of gina
def cargarConocimientos(self):
self.prolog = None #Se elimina la base de conocimientos anterior
self.prolog = Prolog() #Se abre nuevamente prolog
self.prolog.consult(self.direccion) #Se carga el código con la dirección obtenida anteriormente
class PrologGrammarEngine:
"""
This class is used to :
- initialize a interface toward Prolog using pyswip
- transform and load a grammar into the prolog engine
- define methods to query the grammar
This class must be instanciate ony one
"""
all_ready_initialize = False
def __init__(self, path_to_methods_file: str):
"""
:param path_to_methods_file: path toward prolog knowledge base that contains
the predicates used to query the grammar
"""
assert not PrologGrammarEngine.all_ready_initialize
self.prolog = Prolog()
self.prolog.consult(path_to_methods_file)
# We keep in memory all the predicates that had been added to the prolog engine
# in order to be able to remove them if needed
self.current_predicates: List[str] = []
# We keep in memoery all the terminal symbol of the grammar
# in order to not have to communicate each time with prolog
# when we need to know if a symbol is terminal
self.terminals: Set[str] = set()
PrologGrammarEngine.all_ready_initialize = True
def delete_grammar(self):
"""
Remove all the grammar predicates from the prolog engine
"""
for rule in self.current_predicates:
self.prolog.retractall(rule)
self.current_predicates = []
self.terminals = {}
def retrieve_terminal(self):
"""
Load the terminal symbol in memory once for all
"""
answers = self.prolog.query("terminal(X)")
self.terminals = {answer["X"] for answer in answers}
def load_grammar(self, ntlk_str_grammar: str):
"""
Transform the grammar into prolog predicates
and load it in the prolog engine
"""
self.current_predicates = parse_to_prolog(ntlk_str_grammar)
for rule in self.current_predicates:
self.prolog.assertz(rule)
self.retrieve_terminal()
def valid_children(self, symbols: List[str]) -> List[List[str]]:
"""
Given a derivation (list of terms), return all the valide children node. Ie:
- all symbols string that can derivate from this derivation using only one rule
- all symbols string from which a terminal leaf can be reached
"""
try:
answer = next(
self.prolog.query("all_valid_children([%s], X)" %
join(symbols)))
return format_term(answer["X"])
except StopIteration:
return []
def leaf(self, symbols: List[str]) -> Union[List[str], None]:
"""
Given a derivation, return a random terminal leaf if it exists, None else
"""
answers = self.prolog.query("random_leaf([%s], X)" % join(symbols))
try:
answer = next(answers)
return format_term(answer["X"])
except StopIteration:
return None
def is_terminal(self, symbol: str) -> bool:
"""
return true is the symbol is terminal
"""
return symbol in self.terminals
def set_random_seed(self, seed: int):
"""
set the random seed of prolog engine
"""
# WARNING - This does not seem to work !
self.prolog.assertz("set_random(seed(%d))" % seed)
action='store_true',
help='test only accepted queries')
parser.add_argument('--rejected',
default=False,
action='store_true',
help='test only rejected queries')
parser.add_argument('--display',
default=False,
action='store_true',
help='display')
args = parser.parse_args()
queries = open('./tests/queries.txt', 'r')
prolog = Prolog()
prolog.consult(PROLOG_FILE)
def smoothen_print(str):
return str["PT"] + '\n'
def color_output(str, step):
linked_list = LinkedList()
for i in range(len(str)):
charac = str[i]
if (charac == "("):
linked_list.add(i, str)
elif (charac == ")"):
linked_list.close(i)
def give_graph(self):
if self._state is None: #exception-like condition, maybe NoStateException
print('No state is ready!')
return
state, n = self._state, self._state.length
if self._big_anchor_state is None:
print('No big anchor state is ready!')
return
if 'graph' in self._big_anchor_state:
return self._big_anchor_state['graph']
word_set = self._big_anchor_state['word_set']
self.decide_graph_module()
if self.graph_module == 'networkx':
import networkx as nx
G = nx.DiGraph()
index = word_set.index()
for i in range(n):
G.add_node(index[(i, 0)], word = self._l[i][0])
for j, word in enumerate(self._l[i][1:], 1):
G.add_edge(index[(i, j - 1)], index[(i, j)])
G.nodes[index[(i, j)]]['word'] = word
for j, word in enumerate(self._l[i]):
if 'appearance' not in G.nodes[index[(i, j)]]:
G.nodes[index[(i, j)]]['appearance'] = []
G.nodes[index[(i, j)]]['appearance'].append(i)
self._big_anchor_state['graph'] = G
return G
elif self.graph_module == 'pyswip':
from pyswip import Prolog
prolog = Prolog()
prolog.consult('knowledge.pl')
#clear the previos graph which is created in this object
deque(prolog.query(f'clear_register({id(self)})'), maxlen = 0)
index = word_set.index()
id_word_map = {} #prevent overlapping
for i in range(n):
id_word_map[index[(i, 0)]] = self._l[i][0]
for j, word in enumerate(self._l[i][1:], 1):
prolog.assertz(f'edge({index[(i, j - 1)]}, {index[(i, j)]})')
id_word_map[index[(i, j)]] = word
for j in range(len(self._l[i])):
prolog.assertz(f'appear({index[(i, j)]}, {i})')
for word_id, word in id_word_map.items():
prolog.assertz(f"word({word_id}, '{word}')") #word is atom, not string (list of codes)
prolog.assertz(f'node_register({id(self)}, {word_id})') #register the word ID under a key (python ID of self)
#prolog.assertz('all_node([{}])'.format(', '.join([str(i) for i in id_word_map.keys()])))
self._big_anchor_state['graph'] = prolog
return prolog
elif self.graph_module is None:
print('Failed to draw graph!')
return
#EQUIPO: CRISTIAN CAAMAL, HENRY UICAB, DIANA BALAM
#Importando pyswip para realizar el puente para python que permite consultar prolog
from pyswip import Prolog
prolog = Prolog()
#realizando la consulta en el programa prolog de los hechos
prolog.consult("hechos.pl")
#Imprimiendo el titulo
print("Sistema para la predicción de problemas de software y hardware de una laptop")
r = False
# REALIZANDO LOS CICLOS FOR PARA LAS CONSTRUCCIÓN DEL PROGRAMA, AQUÍ SE EJECUTAN LAS SENTENCIAS MIENTRAS LA CONDICIÓN SEA VERDADERA, AL MOMENTO DE SER FALSA TERMINA EL CICLO
while not r:
#LLAMA E IMPRIME LAS PERSONAS QUE TIENEN PROBLEMAS EN SU EQUIPO
for valor in prolog.query("reparacion(X,falla)"):
print (' REQUIERE VERIFICAR EL EQUIPO => ', valor ["X"])
#MUESTRAS LOS LAS PERSONAS QUE SU EQUIPO REQUIERE UNA REPARACION
for valor in prolog.query("sinreparacion(X)"):
print (' REQUIERE REPARACIÓN SU EQUIPO => ', valor ["X"])
#IMPRIME LAS PERSONAS QUE TIENEN UN DAÑO FISICO EN SU EQUIPO
for valor in prolog.query("equipodanado(X,covid)"):
print (' SU EQUIPO TIENE DAÑOS => ', valor ["X"])
#IMPRIME LAS PERSONAS QUE NO TIENEN DAÑO FISICO EN SU EQUIPO
for valor in prolog.query("sindano(X)"):
print (' SU EQUIPO NO TIENE DAÑOS => ', valor ["X"])
#LEE EL NOMBRE DE LA PERSONA INGRESADA CON PROBLEMAS DE SOFTWARE
X= input("----\nPor Software\n----\n Inserta el nombre de la persona ")
#DICE QUE PROBLEMA TIENE EL EQUIPO POR SOFTWARE
def get_expert_rule():
Rice = 'Rice'
# Rice = str(request.json[u'riceName'])
# if Rice == '' :
# Rice = 'Rice'
RiceType = str(request.json[u'riceType'])
if RiceType == '' :
RiceType = 'RiceType'
SubDis = str(request.json[u'subDis'])
if SubDis == '' :
SubDis = 'SubDis'
Disrict = str(request.json[u'district'])
if Disrict == '' :
Disrict = 'Disrict'
Province = str(request.json[u'province'])
if Province == '' :
Province = 'Province'
Price = str(request.json[u'price'])
if Price == '' :
Price = 'Price'
SellPlace = str(request.json[u'sellPlace'])
if SellPlace == '' :
SellPlace = 'SellPlace'
Humidity = str(request.json[u'humidity'])
if Humidity == '' :
Humidity = 'Humidity'
Season = str(request.json[u'season'])
if Season == '' :
Season = 'Season'
PhotoPeriod = str(request.json[u'photoPeriod'])
if PhotoPeriod == '' :
PhotoPeriod = 'PhotoPeriod'
Thrips = 'Thrips'
Mealybug = 'Mealybug'
BrownPlantHopper = 'BrownPlantHopper'
WhiteBackedPlantHopper = 'WhiteBackedPlantHopper'
ZigzagLeafHopper = 'ZigzagLeafHopper'
GreenRiceLeafHopper = 'GreenRiceLeafHopper'
RiceHispa = 'RiceHispa'
StemBorer = 'StemBorer'
CutWorm = 'CutWorm'
RiceEarCuttingCaterpilla = 'RiceEarCuttingCaterpilla'
RiceLeafFolder = 'RiceLeafFolder'
RiceCaseWorm = 'RiceCaseWorm'
RiceWhorlMaggot = 'RiceWhorlMaggot'
RiceBlackBug = 'RiceBlackBug'
RiceGallMidge = 'RiceGallMidge'
RiceBug = 'RiceBug'
pestGroup = request.json[u'pestGroup']
for i in pestGroup :
if i == 'thrips' :
Thrips = '"true"'
elif i == 'mealybug' :
Mealybug = '"true"'
elif i == 'brownPlantHopper' :
BrownPlantHopper = '"true"'
elif i == 'whiteBackedPlantHopper' :
WhiteBackedPlantHopper = '"true"'
elif i == 'greenRiceLeafHopper' :
GreenRiceLeafHopper = '"true"'
elif i == 'riceHispa' :
RiceHispa = '"true"'
elif i == 'stemBorer' :
StemBorer = '"true"'
elif i == 'cutWorm' :
CutWorm = '"true"'
elif i == 'riceEarCuttingCaterpilla' :
RiceEarCuttingCaterpilla = '"true"'
elif i == 'riceLeafFolder' :
RiceLeafFolder = '"true"'
elif i == 'riceCaseWorm' :
RiceCaseWorm = '"true"'
elif i == 'riceWhorlMaggot' :
RiceWhorlMaggot = '"true"'
elif i == 'riceBlackBug' :
RiceBlackBug = '"true"'
elif i == 'riceGallMidge' :
RiceGallMidge = '"true"'
elif i == 'riceBug' :
RiceBug = '"true"'
SeedlingRotInNurseyBox = 'SeedlingRotInNurseyBox'
SheathRot = 'SheathRot'
SheathBlight = 'SheathBlight'
BacterialLeafBlight = 'BacterialLeafBlight'
GrassyStunt = 'GrassyStunt'
FalseSmut = 'FalseSmut'
Bakanae = 'Bakanae'
BacterialLeafStreak = 'BacterialLeafStreak'
NarrowBrownSpot = 'NarrowBrownSpot'
BrownSpot = 'BrownSpot'
RedStripe = 'RedStripe'
LeafScald = 'LeafScald'
RiceTungro ='RiceTungro'
OrangeLeaf = 'OrangeLeaf'
RiceRaggedStunt = 'RiceRaggedStunt'
DirtyPanicle = 'DirtyPanicle'
Akiochi = 'Akiochi'
RootKnot = 'RootKnot'
StemRot = 'StemRot'
GallDwarf = 'GallDwarf'
YellowDwarf = 'YellowDwarf'
RiceBlast = 'RiceBlast'
disceaseGroup = request.json[u'diseaseGroup']
for i in pestGroup :
if i == 'seedlingRotInNurseyBox' :
SeedlingRotInNurseyBox = '"true"'
elif i == 'sheathRot' :
SheathRot = '"true"'
elif i == 'sheathBlight' :
SheathBlight = '"true"'
elif i == 'bacterialLeafBlight' :
BacterialLeafBlight = '"true"'
elif i == 'grassyStunt' :
GrassyStunt = '"true"'
elif i == 'falseSmut' :
FalseSmut = '"true"'
elif i == 'bakanae' :
Bakanae = '"true"'
elif i == 'bacterialLeafStreak' :
BacterialLeafStreak = '"true"'
elif i == 'narrowBrownSpot' :
NarrowBrownSpot = '"true"'
elif i == 'brownSpot' :
BrownSpot = '"true"'
elif i == 'redStripe' :
RedStripe = '"true"'
elif i == 'leafScald' :
LeafScald = '"true"'
elif i == 'riceTungro' :
RiceTungro ='"true"'
elif i == 'orangeLeaf' :
OrangeLeaf = '"true"'
elif i == 'riceRaggedStunt' :
RiceRaggedStunt = '"true"'
elif i == 'dirtyPanicle' :
DirtyPanicle = '"true"'
elif i == 'akiochi' :
Akiochi = '"true"'
elif i == 'rootKnot' :
RootKnot = '"true"'
elif i == 'stemRot' :
StemRot = '"true"'
elif i == 'gallDwarf' :
GallDwarf = '"true"'
elif i == 'yellowDwarf' :
YellowDwarf = '"true"'
elif i == 'riceBlast' :
RiceBlast = '"true"'
prolog = Prolog()
prolog.consult('src/engine.pl')
rule = 'expertRule('+Rice+','+RiceType+','+SubDis+','+Disrict+','+Province+','+Price+','+SellPlace+','+Humidity
rule = rule+','+Season+','+PhotoPeriod+','+Thrips+','+Mealybug+','+BrownPlantHopper+','+WhiteBackedPlantHopper
rule = rule+','+ZigzagLeafHopper+','+GreenRiceLeafHopper+','+RiceHispa+','+StemBorer+','+CutWorm+','
rule = rule+RiceEarCuttingCaterpilla+','+RiceLeafFolder+','+RiceCaseWorm+','+RiceWhorlMaggot+','
rule = rule+RiceBlackBug+','+RiceGallMidge+','+RiceBug+','+SeedlingRotInNurseyBox+','+SheathRot+','+SheathBlight
rule = rule+','+BacterialLeafBlight+','+GrassyStunt+','+FalseSmut+','+Bakanae+','+BacterialLeafStreak+','
rule = rule+NarrowBrownSpot+','+BrownSpot+','+RedStripe+','+LeafScald+','+RiceTungro+','+OrangeLeaf+','
rule = rule+RiceRaggedStunt+','+DirtyPanicle+','+Akiochi+','+RootKnot+','+StemRot+','+GallDwarf+','
rule = rule+YellowDwarf+','+RiceBlast+')'
re_list = list(prolog.query(rule))
return jsonify(re_list)
def buscardatos(self):
paciente = ""
inicio = "Y"
#inicio el ciclo solicitando campo "NOMBRE" y verificando que el campo
while paciente == "":
paciente = input("Inserte un nombre y apellido: ")
print()
print("\t*****************************************")
# se eliminan espacios entre el nombre y apellidos
query = paciente.replace(" ", "")
#se crea una instancia del metodo prolog
prolog = Prolog()
#se crea variable para controlar el bucle, en caso de que el usuario introduzca un campo vacio
paciente = ""
inicio = "Y"
while inicio == "Y":
#se cargan los documentos prolog para las consultas
prolog.consult("paciente.pl")
#se realiza una consulta para verificar que el nombre introducido exista entre la lista de pacientes
result = bool(list(prolog.query("paciente(" + query + ")")))
# si existe se realizan las busquedas adicionales
if result == True:
#se emite un mensaje que el paciente esta registrado
print("\tEl paciente " + paciente + " esta registrado")
#se carga el archivo edades.pl para ser analizado
prolog.consult("edades.pl")
#se construye la consulta
for valor in prolog.query("edad(" + query + ",Y)"):
#se imprime la edad del paciente
print("\tEdad: ", valor["Y"])
#se carga el archivo status.pl para ser analizado y conocer el estado del paciente
prolog.consult("status.pl")
# se crea y carga la consulta
for valor in prolog.query("status(" + query + ",Y)"):
# se emite el resultado y se almacena en la variable n
print("\tStatus: ", valor["Y"])
n = valor["Y"]
#se carga el archivo hospital.pl para ser analizado
prolog.consult("hospital.pl")
#se crea la consulta para conocer en que hospital se encuentra el paciente
for valor in prolog.query("hospital(" + query + ",Y)"):
#se almacena el hospital para luego conocer el estado en el que se encuentra el hospital
hospital = valor["Y"]
#se imprime el nombre del hospital
print("\tHospital: ", valor["Y"])
#se genera el query para conocer la entidad federativa del hospital
for valor in prolog.query("estado(" + hospital + ",Y)"):
# se emite la entidad federativa
print("\tEstado: ", valor["Y"])
#se almacena la entidad
estado = valor["Y"]
# se crea la consulta para saber en que ciudad se encuentra el hospital
for valor in prolog.query("ciudad(" + estado + ",Y)"):
# se emite la ciudad en donde se encuentra el hospital
print("\tCiudad: ", valor["Y"])
# se analiza el estado del ṕaciente para estimar una fecha de alta
if (n == 'recuperado'):
alta = date.today()
print("\tFecha de Alta: ", alta)
else:
#en caso de contrario se le notifica al usuario
print("\tFecha de Alta: No establecida")
# si no se encuentra el paciente se emite el mensaje
else:
print("El paciente " + paciente + " No ha sido registrado")
print("\t****************************************")
print()
inicio = input("¿Desea continuar? y/n: ")
if (inicio != "y"):
print("Sistema Finalizado")
else:
covid.buscardatos()
import time
from pyswip import Prolog
prolog = Prolog()
prolog.assertz('fun(X) :- red(X),car(X)')
prolog.assertz('happy(X) :- red(X);car(X)')
prolog.assertz('car(vw_beatle)')
prolog.assertz('car(ferrari)')
#prolog.assertz('car(hyundai)')
prolog.assertz('bike(harley_davidson)')
prolog.assertz('red(ferrari)')
prolog.assertz('red(vw_beatle)')
prolog.assertz('blue(hyundai)')
#print(list(prolog.query('car(Which)')))
#print(list(prolog.query('fun(Which)')))
print(list(prolog.query('car(ferrari)')))
inicio = time.time()
prolog.assertz('fatorial(0,1)')
prolog.assertz('fatorial(N,F) :- N>0,N1 is (N-1),fatorial(N1,F1),F is (N*F1)')
#print(list(prolog.query('fatorial(0,X)')))
print(list(prolog.query('fatorial(20,X)')))
fim = time.time()
print(fim - inicio)
# Basic Autonomous Rover Cognitive Architecture (BARCA)
# (Simple) World Model Test (Beta 0.01)
# www.revelation3.com
# insert 3 entries into the brain's "world model" memory component
# indicating what's been detected by Bot
# index (for ordering purposes), substance detected & timestamp
# setup SWI-Prolog to Python interface
from pyswip import Prolog
prolog = Prolog()
# declare what's been detected and when in a list (for testing)
# generated by Bot's sensors in the Real World!
detected = [
"'METAL','2027'", "'GAS','2028'", "'METAL','2029'", "'GAMMA','2033'",
"'SMOKE', '2045'"
]
# add the above list to the prolog world model plus the software generated index
index = 1
for x in detected:
prolog.assertz("brain(world_model(memory(detect(" + "'" + str(index) +
"'," + str(x) + "))))")
index = index + 1
# retrieve the detection list & index from the prolog world model memory & print
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and limitations under the License
'''
import os
import time
from pyswip import Prolog
import logging
import ast
behaviourFilePath = 'behaviour.pl'
logging.basicConfig(level=logging.INFO)
prologEngine = Prolog() # The engine given by Pyswip SWI Prolog library
print("Learning started...")
prologEngine.consult(behaviourFilePath)
print("Learning finished")
def eternity():
print('Loop started')
while (True):
patience = True
while (patience):
try:
inFile = open('query.txt')
patience = False
from pyswip import Prolog, Query, Variable, Functor
from tkinter import *
from tkinter import scrolledtext
from tkinter import ttk
from datetime import date
from tkinter.ttk import *
# Prolog instance created and opened file
prolog = Prolog()
prolog.consult("reglas_test.pl")
date = date.today()
def changeSalary(sueldo):
print(list(prolog.query("sueldo(X)")))
change = list(prolog.query("cambiar_sueldo(" + sueldo.get() + ")"))
save = list(prolog.query("guardar_sueldo"))
print(list(prolog.query("sueldo(X)")))
def create_window():
prolog.consult("a_db.txt")
window = Tk()
window.title("El presupuesto del bibliófilo")
window.geometry("720x480")
tabControl = ttk.Notebook(window)
#Label 1
lbl = Label(window,
text="El presupuesto del bibliófilo",
font=("Arial Bold", 15))
# This program is written in Python 3
from pyswip import Prolog
prolog = Prolog()
prolog.consult("project.pl")
plmode = False
# ===========================================================
# Main loop:
# 1. Repeat "input-response" cycle until input starts with "bye"
# Each "input-response" cycle consists of:
# 1.1 Reading an input string and convert it to a tokenized list
# 1.2 Processing tokenized list
# ===========================================================
def chat():
global plmode
while (True):
if plmode:
userInput = input()
else:
userInput = readinput()
if userInput[0].startswith("bye"):
print("Bye!")
break
elif userInput[0].startswith("plmode"):
plmode = True
continue
elif userInput[0].startswith("plend"):
plmode = False
from pyswip import Prolog
prolog = Prolog()
prolog.assertz("father(michael,john)")
prolog.assertz("father(michael,gina)")
result = list(prolog.query("father(michael,X)"))
print result
from pyswip import Prolog, registerForeign, Atom
def atom_checksum(*a):
if isinstance(a[0], Atom):
r = sum(ord(c)&0xFF for c in str(a[0]))
a[1].value = r&0xFF
return True
else:
return False
p = Prolog()
registerForeign(atom_checksum, arity=2)
print list(p.query("X='Python', atom_checksum(X, Y)", catcherrors=False))
def __init__(self, tilemap, tilemap_obs, prolog_facts): self.prolog = Prolog() self.prolog.consult(tilemap) self.prolog.consult(prolog_facts) self.prolog.consult(tilemap_obs)
class ManejoProlog:
#Definición de la función constructora.
#E: dirección del código de prolog.
#S: ninguna
#R: ninguna
def __init__(self, texto):
try: #Validación de que archivo exista.
archivo = open(texto, "r")
archivo.close
self.direccion = texto #Se define el atributo con la dirección del código de prolog.
self.cargarConocimientos() #Se cargan los conocimientos del código.
self.error = False
except:
archivo = open("Recetas.pl", "w") #Creación de uno nuevo.
archivo.close()
self.direccion = "Recetas.pl" #Se define el atributo con la dirección del código de prolog.
self.cargarConocimientos() #Se cargan los conocimientos del código.
self.error = True
#Definición de la función que crea una nueva regla.
#E: texto con el código de prolog.
#S: ninguna
#R: ninguna(método llamado internamente)
def nuevaRegla(self, texto):
archivo = open(self.direccion, "a")
archivo.write('\n' + texto + '.')
archivo.close()
self.cargarConocimientos()
#Definición de la función que lee el código de prolog y carga cada línea en una lista
#E: ninguna.
#S: lista con cada línea del código fuente de prolog.
#R: ninguna.
def leer(self):
archivo = open(self.direccion, "r")
lineas = archivo.readlines()
archivo.close()
return lineas
#Función que borra una receta.
#E: nombre de la receta por borrar.
#S: ninguna.
#R: ninguna.
def borrarReceta(self, receta):
lineas = self.leer()
contador = 0
for i in lineas: #Se recorre el código de prolog en busca de la receta.
if (i.startswith("receta("+receta+",")): #Se verifica que la receta sea igual a la ingresada.
lineas.pop(contador) #Se elimina de la lista
contador += 1
else:
contador += 1
archivo = open(self.direccion, "w") #Se reescribe el archivo con la receta eliminada.
for i in lineas:
archivo.write(i)
archivo.close()
self.cargarConocimientos()
box.showinfo("Éxito", "La receta se ha borrado con éxito.")
#Función que actualiza alguna receta.
#E: lista con las posiciones a modificar y todos los datos de la receta (dato vacío si no se va a modificar y nombre de la receta siempre estará).
#Ejemplo:
# Se tiene una receta(pizza, giovanni, italiana, queso, calentar)
# Se desea cambiar solamente el dato de 'giovanni'(autor) y 'queso'(ingredientes) por 'giussepe' y 'jamón'.
# Los datos de entrada serían: posiciones = [1,3], datos = ['pizza', 'giussepe', '', 'jamon', '']
#S: ninguna.
#R: ninguna.
def actualizarReceta(self, posiciones, datos):
lineas = self.leer()
contador = 0
for i in lineas: #Se recorre el código de prolog en busca de la receta a actualizar
if (i.startswith("receta("+datos[0]+",")): #Se verifica que la receta sea igual a la que se desee cambiar
lineas[contador] = self.actualizarReceta_aux(posiciones, datos, i[7:]) #Se sustituye la línea con el resultado de la función auxiliar.
contador += 1
else:
contador += 1
archivo = open(self.direccion, "w") #Se reescribe el archivo con los nuevos datos.
for i in lineas:
archivo.write(i)
archivo.close()
self.cargarConocimientos()
box.showinfo("Éxito", "La receta se ha borrado con éxito.")
#Función auxiliar que se encarga de actualizar los datos.
#E: lista de las posiciones por modificar, datos por cambiar, datos originales.
#Continuando el ejemplo:
#datos = ['pizza', 'giussepe', '', 'jamon', '']
#posiciones = [1,3]
#original = 'pizza, giovanni, italiana, queso, calentar'
#S: línea de código prolog con los nuevos valores.
#R: ninguna.
def actualizarReceta_aux(self, posiciones, datos, original):
separacion = original.split(",") #Se hace una lista con los datos viejos. Continuando el ejemplo anterior:
#Se obtiene separacion = ['pizza', 'giovanni', 'italiana', 'queso', 'calentar'] (DATOS ORIGINALES)
for i in posiciones: #Se recorre la lista con las posiciones de la lista separacion por cambiar.
separacion[i] = datos[i] #Se cambia la posición obtenida en la lista posiciones, con la misma posición de la lista datos.
#Se cambiaría la posición separacion[1] = datos[1] ('giussepe') y luego separacion[3] = datos[3] ('jamon')
return "receta({},{},{},{},{}).\n".format(separacion[0], separacion[1], separacion[2], separacion[3], separacion[4])
#Se retorna la nueva línea de código prolog.
#Función que se encarga de cargar los conocimientos.
#E: ninguna.
#S: código prolog cargado.
#R: ninguna.
def cargarConocimientos(self):
self.prolog = None #Se elimina la base de conocimientos anterior
self.prolog = Prolog() #Se abre nuevamente prolog
self.prolog.consult(self.direccion) #Se carga el código con la dirección obtenida anteriormente
from pyswip import Prolog
prolog = Prolog()
prolog.consult('sinonimos')
palabra = 'terminar'
solucion = list(prolog.query("P=%s,sinonimo_de(P, S)" % palabra, maxresult=-1))
for sinonimo in range(0, len(solucion)):
print(solucion[sinonimo]['S'])
def __init__(self, decisionsLen, factsLen):
self.__prologEngine = Prolog(
) # The engine given by Pyswip SWI Prolog library
self.__learning = learning.Learning(self.__prologEngine)
self.__memory = memory.Memory(decisionsLen, factsLen)
self.__behaviour = behaviour.Behaviour(self.__prologEngine)
parser.add_argument('-f',
help='Write to file.')
parser.add_argument('-n',
help='Number of answers.')
parser.add_argument('--module',
help='Name of module to compile. Shortcut for "-c module.cosmos -o module.pl"')
parser.add_argument('-s',
help='Blah.')
parser.add_argument('-q',
help='Blah.')
parser.add_argument('-i',
help='Open the interpreter.', action="store_true")
args = parser.parse_args()
p = Prolog()
if args.module:
module = args.module
else:
module = 'cosmos'
#raise "Required --module flag."
#Prolog Query
i = 0
if args.n:
n = int(args.n)
else:
n = float('inf')
#p.consult(module+'.pl')
from ConceptNetInterface import GetAllEdges
from pyswip import Prolog
import string
prolog = Prolog()
def isEnglish(s):
try:
s.encode(encoding='utf-8').decode('ascii')
except UnicodeDecodeError:
return False
else:
return True
Edges = GetAllEdges("word",1,100,False)
for edge in Edges:
Start = edge.Get_StartNode().lower()
End = edge.Get_EndNode().lower()
Relation = edge.Get_Relation().lower()
Con1 = Start.isalpha()
Con2 = End.isalpha()
def __init__(self):
prolog=None
ConnectLivestatus.__init__(self)
self.prolog=Prolog()
self.prolog.consult('vanyad.pl')
import logging
import json
import cgi
from urllib.parse import urlparse, parse_qs
from pyswip import Prolog
from http.server import BaseHTTPRequestHandler, HTTPServer
pl = Prolog()
# HTTP Server Handler Class.
class HttpServerHandler(BaseHTTPRequestHandler):
def _set_response(
self
): # função para ajustar os headers a retornarem conteúdo em formato HTML.
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.send_header("Access-Control-Allow-Headers", "X-Requested-With")
self.send_header('Content-type', 'text/html')
self.end_headers()
def _set_json_response(
self
): # função para ajustar os headers a retornarem conteúdo em formato JSON.
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.send_header("Access-Control-Allow-Headers", "X-Requested-With")
self.send_header('Content-type', 'application/json')
from pyswip import Prolog
p = Prolog()
p.consult("ds/minhaBD.pl")
q = list(p.query('filho(X,nao)'))
print(len(q))
from pyswip import Prolog, registerForeign, Atom
def atom_checksum(*a):
print a
if isinstance(a[0], Atom):
r = sum(ord(c)&0xFF for c in str(a[0]))
a[1].value = r&0xFF
return True
else:
return False
p = Prolog()
registerForeign(atom_checksum, arity=2)
print list(p.query("X='Python', atom_checksum(X, Y)"))
from pyswip import Prolog
from service.search_key import search_key
import knowledge.dictionary3_n as dct
prolog = Prolog()
prolog.consult("knowledge/task3_n.pl")
def to_swi_param(param):
for key, val in dct.dictionary.items():
if val.lower() == param.lower():
return key
return None
def print_result(query_result):
if query_result is not None:
for answer in query_result:
for key, value in answer.items():
print(dct.dictionary[str(value, 'utf-8')])
print()
def parse(msg):
msg = msg.lower()
cur_project = ""
for pr in dct.projects:
if pr.lower() in msg:
cur_project = pr
def __init__(self):
self.prolog = Prolog()
self.prolog.consult('facts.pl')
self.prolog.consult('logic/agent.pl')
from pyswip import Prolog
prolog = Prolog()
prolog.consult("utf_facts.pl", catcherrors=True)
print(list(prolog.query("current_prolog_flag(encoding,X)")))
print(list(prolog.query("father(X)")))
def __init__(self):
self.prolog = Prolog()
self.prolog.consult("pl/GameDatabase.pl")
self.prolog.consult("pl/GameLogic.pl")
import os
import io
import sys
import re
if __name__ == "__main__":
filename = str(sys.argv[1])
with open(filename, "r") as f:
raw_text = f.read()
inp = re.split('[\.\!\?\。\！\？\n]', raw_text)
print(inp)
query = 'author(_author,_work):-semantic(生成),type(X0,verb),(main(X0,書く);main(X0,描く)),role(X1,動作主),main(X1,_author),role(X2,対象),main(X2,_work).'
queryy = "author(X,Y)"
match = 0
prolog = Prolog()
print("以下の条件でパタンマッチを開始します")
print("-[条件1]", query)
print("")
print("")
start = time()
for i in range(len(inp) - 1):
# for i in range(len(inp)-1):
a2p = ASAtoProlog.ASAtoProlog(inp[i])
with open("testfile.pl", mode="w") as f:
f.write("\n".join(a2p) + "\n" + query)
from bottle import request, route, run, template
from pyswip import Prolog
import json
prolog = Prolog()
prolog.consult("ArbEstFam.pl")
@route('/agregarfamilia', method='POST')
def agregarfamilia():
data = request.json
for d in data["padres"]:
prolog.assertz('padres("' + d[0] + '","' + d[1] + '")')
return data
@route('/Tio', method='POST')
def tio():
data = request.json
for d in data["es_tio"]:
print(d[0])
print(d[1])
tt = prolog.query('tios("' + d[0] + '","' + d[1] + '")')
T = list(tt)
if T:
return {"Es Tio": T[1]}
else:
return {"No es Tio": T}
@route('/Primo', method='POST')
from pyswip import Prolog
from gifs import gif
import tkinter as tk
from ventana import ImageLabel
prolog = Prolog()
# Lectura del archivo
mapa = open("laberinto.txt")
map = []
for i in mapa:
map += [i.split(" ")]
def buscar_en_matriz(matriz, cont, para):
if matriz == []:
return (-1, -1)
if para in matriz[0]:
return [cont, matriz[0].index(para)]
return buscar_en_matriz(matriz[1:], cont + 1, para)
def caminoLlegada(pos, k, j):
alf = ["+", "|", "-"]
try:
for i in alf:
temStr = map[pos[0]+k][pos[1]+j].replace(i, "")
temInt = int(temStr)
prolog.assertz(
"conecta(" + map[pos[0]][pos[1]] + "," + temStr + ")")
except:
pass
def inicializar():
from pyswip import Prolog
interprete = Prolog()
interprete.consult("hanoi.pl")
solucion = interprete.query("mover_disco(3,1,3,2)")
for paso in solucion:
print(paso)
def test_issue_4(self):
"""
Patch for a dynamic method
Ensures that the patch is working.
https://code.google.com/p/pyswip/issues/detail?id=4
"""
from pyswip import Prolog
Prolog.dynamic('test_issue_4_d/1')
Prolog.assertz('test_issue_4_d(test1)')
Prolog.assertz('test_issue_4_d(test1)')
Prolog.assertz('test_issue_4_d(test1)')
Prolog.assertz('test_issue_4_d(test2)')
results = list(Prolog.query('test_issue_4_d(X)'))
self.assertEqual(len(results), 4)
Prolog.retract('test_issue_4_d(test1)')
results = list(Prolog.query('test_issue_4_d(X)'))
self.assertEqual(len(results), 3)
Prolog.retractall('test_issue_4_d(test1)')
results = list(Prolog.query('test_issue_4_d(X)'))
self.assertEqual(len(results), 1)
