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]))