def __init__(self,
server=DEFAULT_SERVER,
endpoint=None,
rules=None,
program=None):
self.server = server
self.endpoint = endpoint
self.rules = rules
self.renderer = PrologRenderer()
if program is not None:
if type(program) is not str:
program = self.renderer.render(program)
self.program = program
def __init__(self,
source: Union[Transformer, nx.MultiDiGraph] = None,
output_format=None,
**args):
super().__init__(source=source, **args)
if output_format is not None and output_format == 'prolog':
self.renderer = PrologRenderer()
else:
self.renderer = SExpressionRenderer()
def __init__(self,
schema: Union[str, TextIO, SchemaDefinition],
fmt: Optional[str] = None) -> None:
super().__init__(schema, fmt)
self.P = TermGenerator()
self.R = PrologRenderer() if fmt == 'lp' else SExpressionRenderer()
class SPARQLProg():
"""
Wrapper for pengines to call a SPARQLProg service
"""
def __init__(self,
server=DEFAULT_SERVER,
endpoint=None,
rules=None,
program=None):
self.server = server
self.endpoint = endpoint
self.rules = rules
self.renderer = PrologRenderer()
if program is not None:
if type(program) is not str:
program = self.renderer.render(program)
self.program = program
def query_to_dataframe(self, q, select=None, **args):
"""
As query(), but returns a pandas dataframe
"""
items = []
for r in self.query(q, select=select, **args):
items.append(r.toDict())
df = pd.DataFrame(items)
return df
def query(self, q, select=None, endpoint=None):
"""
Query a sparqlprog endpoint
Returns:
iterator
"""
P = TermGenerator()
opts = []
if self.rules is not None:
# force a tuple
opts = [P.rule( (r,) ) for r in self.rules]
opts_str = self.renderer.render(opts)
if select is None:
select = q
if select is not str:
select = self.renderer.render(select)
if type(q) is not str:
q = self.renderer.render(q)
if endpoint is None:
endpoint = self.endpoint
if endpoint is not None:
q = f"'??'({endpoint}, ({q}), ({select}), {opts_str})"
logging.info(f"Query={q}")
logging.info(f"Program={self.program}")
builder = PengineBuilder(urlserver=self.server,
destroy=False,
srctext=self.program,
ask=q)
pengine = Pengine(builder=builder, debug=False)
# note: may be rewritten after this is fixed and pushed to pypi:
# https://github.com/ian-andrich/PythonPengines/issues/14
if pengine.currentQuery is not None:
for r in pengine.currentQuery.availProofs:
yield self._translate(r)
pengine.currentQuery.availProofs = [] # reset
n=0
while pengine.currentQuery is not None and pengine.currentQuery.hasMore:
n += 1
logging.info(f"Next chunk={n}")
pengine.doNext(pengine.currentQuery)
if pengine.currentQuery is not None:
for r in pengine.currentQuery.availProofs:
yield self._translate(r)
pengine.currentQuery.availProofs = [] # reset
def _translate(self, term):
if type(term) == dict:
if 'args' in term and 'functor' in term:
if term['functor'] == 'literal':
return self._translate_literal(term['args'][0])
else:
for k,v in term.items():
v = self._translate(v)
term[k] = v
return DotMap(term)
else:
return term
def _translate_literal(self, v):
if type(v) == dict:
if v['functor'] == 'lang':
args = v['args']
return Literal(args[1], lang=args[0])
else:
return v
from prologterms import TermGenerator, PrologRenderer, Program, Var, SExpressionRenderer
P = TermGenerator()
X = Var('X')
Y = Var('Y')
Z = Var('Z')
R = PrologRenderer()
S = SExpressionRenderer()
def test_term():
t = P.member(X, [1, 2, 3])
print("TERM: {}\n".format(R.render(t)))
assert R.render(t) == "member(X, [1, 2, 3])"
assert S.render(t) == "(member ?X (list 1 2 3))"
def test_atom():
t = P.foo()
print("TERM: {}\n".format(R.render(t)))
assert R.render(t) == "foo"
assert S.render(t) == "(foo )"
def test_unary_neg():
t = (-X)
print("TERM: {}\n".format(R.render(t)))
assert R.render(t) == "-(X)"
assert S.render(t) == "(- ?X)"
def __init__(self, schema: Union[str, TextIO, SchemaDefinition],
**kwargs) -> None:
super().__init__(schema, **kwargs)
self.P = TermGenerator()
self.R = PrologRenderer(
) if self.format == 'lp' else SExpressionRenderer()
"""
Requires a neoplasmer service to run
See README.md
"""
import sys
from pengines.Builder import PengineBuilder
from pengines.Pengine import Pengine
from prologterms import TermGenerator, PrologRenderer, Program, Var
P = TermGenerator()
MatchID = Var('MatchID')
Score = Var('Score')
Prefix = Var('Prefix')
R = PrologRenderer()
#terms = ['neoplasm', 'glioma', 'astrocytoma']
terms = sys.argv[1:]
for t in terms:
q = P.term_best_match(t, MatchID, Score, Prefix)
factory = PengineBuilder(urlserver="http://localhost:9055",
ask=R.render(q))
pengine = Pengine(builder=factory, debug=False)
while pengine.currentQuery.hasMore:
pengine.doNext(pengine.currentQuery)
for p in pengine.currentQuery.availProofs:
print('Term: {} Match: {} {}'.format(t, p[MatchID.name], p[Score.name]))
from pengines.Builder import PengineBuilder
from pengines.Pengine import Pengine
from prologterms import TermGenerator, PrologRenderer, Program, Var
P = TermGenerator()
X = Var('X')
Y = Var('Y')
Z = Var('Z')
R = PrologRenderer()
p = Program(
P.ancestor(X,Y) <= (P.parent(X,Z), P.ancestor(Z,Y)),
P.ancestor(X,Y) <= P.parent(X,Y),
P.parent('a','b'),
P.parent('b','c'),
P.parent('c','d')
)
q = P.ancestor(X,Y)
factory = PengineBuilder(urlserver="http://localhost:4242",
srctext=R.render(p),
ask=R.render(q))
pengine = Pengine(builder=factory, debug=True)
while pengine.currentQuery.hasMore:
pengine.doNext(pengine.currentQuery)
for p in pengine.currentQuery.availProofs:
print('{} <- {}'.format(p[X.name], p[Y.name]))