yuce / pyswip / 111

pending completion

Build # 111

Build Type

Pull #97

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/yuce/pyswip/commit/<a class=hub.com/yuce/pyswip/commit/<a class="double-link" href="https://git"><a class=hub.com/yuce/pyswip/commit/<a class="double-link" href="https://git"><a class=hub.com/yuce/pyswip/commit/<a class="double-link" href="https://git"><a class=hub.com/yuce/pyswip/commit/21b7763544f3372fd97908ebb081c64a3cbaa679">21b776354">&lt;a href=&quot;https://github.com/yuce/pyswip/commit/</a><a class="double-link" href="https://github.com/yuce/pyswip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/yuce/pyswip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/yuce/pyswip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/yuce/pyswip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/yuce/pyswip/commit/21b7763544f3372fd97908ebb081c64a3cbaa679">21b776354</a><a href="https://github.com/yuce/pyswip/commit/21b7763544f3372fd97908ebb081c64a3cbaa679">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/yuce/pyswip/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/yuce/pyswip/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/yuce/pyswip/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/yuce/pyswip/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/yuce/pyswip/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/yuce/pyswip/commit/21b7763544f3372fd97908ebb081c64a3cbaa679&quot;&gt;21b776354&lt;/a&gt;&lt;a href=&quot;https://github.com/yuce/pyswip/commit/21b7763544f3372fd97908ebb081c64a3cbaa679&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/yuce/pyswip/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/yuce/pyswip/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp... (continued)

Pull Request Pull Request #97: Improve list representations, unicode support and multiple threading usage

Run Details

79 of 79 new or added lines in 3 files covered. (100.0%)

906 of 1150 relevant lines covered (78.78%)

0.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.33

/pyswip/easy.py

# -*- coding: utf-8 -*-


# pyswip.easy -- PySwip helper functions
# Copyright (c) 2007-2018 Yüce Tekol
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.


from pyswip.core import *


class InvalidTypeError(TypeError):
    def __init__(self, *args):
        type_ = args and args[0] or "Unknown"
        msg = "Term is expected to be of type: '%s'" % type_
        Exception.__init__(self, msg, *args)


class ArgumentTypeError(Exception):
    """
    Thrown when an argument has the wrong type.
    """
    def __init__(self, expected, got):
        msg = "Expected an argument of type '%s' but got '%s'" % (expected, got)
        Exception.__init__(self, msg)


class Atom(object):
    __slots__ = "handle", "chars"

    def __init__(self, handleOrChars, chars=None):
        """Create an atom.
        ``handleOrChars``: handle or string of the atom.
        """

        if isinstance(handleOrChars, str):
            self.handle = PL_new_atom(handleOrChars)
            self.chars = handleOrChars
        else:
            self.handle = handleOrChars
            PL_register_atom(self.handle)
            if chars is None:
                slen = c_size_t()
                self.chars = PL_atom_wchars(self.handle, byref(slen))
            else: # WA: PL_atom_wchars can fail to return correct string
                self.chars = chars

    def fromTerm(cls, term):
        """Create an atom from a Term or term handle."""

        if isinstance(term, Term):
            term = term.handle
        elif not isinstance(term, (c_void_p, int)):
            raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))

        a = atom_t()
        if PL_get_atom(term, byref(a)):
            return cls(a.value, getAtomChars(term))
    fromTerm = classmethod(fromTerm)

    def __del__(self):
        if not cleaned:
            PL_unregister_atom(self.handle)

    def get_value(self):
        ret = self.chars
        if not isinstance(ret, str):
            ret = ret.decode()
        return ret

    value = property(get_value)

    def __str__(self):
        if self.chars is not None:
            return self.value
        else:
            return self.__repr__()

    def __repr__(self):
        return str(self.handle).join(["Atom('", "')"])

    def __eq__(self, other):
        if type(self) != type(other):
            return False
        else:
            return self.handle == other.handle

    def __hash__(self):
        return self.handle


class Term(object):
    __slots__ = "handle", "chars", "__value", "a0"

    def __init__(self, handle=None, a0=None):
        if handle:
            #self.handle = PL_copy_term_ref(handle)
            self.handle = handle
        else:
            self.handle = PL_new_term_ref()
        self.chars = None
        self.a0 = a0

    def __invert__(self):
        return _not(self)

    def get_value(self):
        pass

    def __eq__(self, other):
        if type(self) != type(other):
            return False
        else:
            return PL_compare(self.handle, other.handle) == 0

    def __hash__(self):
        return self.handle


# support unicode also in python 2
try:
    isinstance("", basestring)
    def isstr(s):
        return isinstance(s, basestring)
except NameError:
    def isstr(s):
        return isinstance(s, str)


class Variable(object):
    __slots__ = "handle", "chars"

    def __init__(self, handle=None, name=None):
        self.chars = None
        if name:
            self.chars = name
        if handle:
            self.handle = handle
            s = create_string_buffer(b"\00"*64)  # FIXME:
            ptr = cast(s, c_char_p)
            if PL_get_chars(handle, byref(ptr), CVT_VARIABLE|BUF_RING|REP_UTF8):
                self.chars = ptr.value
        else:
            self.handle = PL_new_term_ref()
            #PL_put_variable(self.handle)
        if (self.chars is not None) and not isinstance(self.chars, str):
            self.chars = self.chars.decode()

    def unify(self, value):
        if isstr(value):
            fun = PL_unify_atom_chars
            value = value.encode()
        elif type(value) == int:
            fun = PL_unify_integer
        elif type(value) == bool:
            fun = PL_unify_bool
        elif type(value) == float:
            fun = PL_unify_float
        elif type(value) == list:
            fun = PL_unify_list
        else:
            raise TypeError('Cannot unify {} with value {} due to the value unknown type {}'.
                            format(self, value, type(value)))

        if self.handle is None:
            t = PL_new_term_ref(self.handle)
        else:
            t = PL_copy_term_ref(self.handle)

        if type(value) == list:
            a = PL_new_term_ref(self.handle)
            if type(value[0]) == int:
                element_fun = PL_unify_integer
            elif type(value[0]) == float:
                element_fun = PL_unify_float
            else:
                raise
            if value:
                for element in value:
                    fun(t, a, t)
                    element_fun(a, element)
        else:
            fun(t, value)
        self.handle = t

    def get_value(self):
        return getTerm(self.handle)

    value = property(get_value, unify)

    def unified(self):
        return PL_term_type(self.handle) == PL_VARIABLE

    def __str__(self):
        if self.chars is not None:
            return self.chars
        else:
            return self.__repr__()

    def __repr__(self):
        return "Variable(%s)" % self.handle

    def put(self, term):
        #PL_put_variable(term)
        PL_put_term(term, self.handle)

    def __eq__(self, other):
        if type(self) != type(other):
            return False
        else:
            return PL_compare(self.handle, other.handle) == 0

    def __hash__(self):
        return self.handle


class Functor(object):
    __slots__ = "handle", "name", "arity", "args", "__value", "a0"
    func = {}

    def __init__(self, handleOrName, arity=1, args=None, a0=None):
        """Create a functor.
        ``handleOrName``: functor handle, a string or an atom.
        """

        self.args = args or []
        self.arity = arity
        self.a0 = a0

        if isinstance(handleOrName, str):
            self.name = Atom(handleOrName)
            self.handle = PL_new_functor(self.name.handle, arity)
            self.__value = "Functor%d" % self.handle
        elif isinstance(handleOrName, Atom):
            self.name = handleOrName
            self.handle = PL_new_functor(self.name.handle, arity)
            self.__value = "Functor%d" % self.handle
        else:
            self.handle = handleOrName
            self.name = Atom(PL_functor_name(self.handle))
            self.arity = PL_functor_arity(self.handle)
            try:
                self.__value = self.func[self.handle](self.arity, *self.args)
            except KeyError:
                self.__value = str(self)

    def fromTerm(cls, term):
        """Create a functor from a Term or term handle."""

        if isinstance(term, Term):
            term = term.handle
        elif not isinstance(term, (c_void_p, int)):
            raise ArgumentTypeError((str(Term), str(int)), str(type(term)))

        f = functor_t()
        if PL_get_functor(term, byref(f)):
            # get args
            args = []
            arity = PL_functor_arity(f.value)
            # let's have all args be consecutive
            a0 = PL_new_term_refs(arity)
            for i, a in enumerate(range(1, arity + 1)):
                if PL_get_arg(a, term, a0 + i):
                    args.append(getTerm(a0 + i))

            return cls(f.value, args=args, a0=a0)
    fromTerm = classmethod(fromTerm)

    value = property(lambda s: s.__value)

    def __call__(self, *args):
        assert self.arity == len(args)   # FIXME: Put a decent error message
        a = PL_new_term_refs(len(args))
        for i, arg in enumerate(args):
            putTerm(a + i, arg)

        t = PL_new_term_ref()
        PL_cons_functor_v(t, self.handle, a)
        return Term(t)

    def __str__(self):
        if self.name is not None and self.arity is not None:
            return "%s(%s)" % (self.name,
                               ', '.join([str(arg) for arg in self.args]))
        else:
            return self.__repr__()

    def __repr__(self):
        return "".join(["Functor(", ",".join(str(x) for x
            in [self.handle,self.arity]+self.args), ")"])

    def __eq__(self, other):
        if type(self) != type(other):
            return False
        else:
            return PL_compare(self.handle, other.handle) == 0

    def __hash__(self):
        return self.handle


def _unifier(arity, *args):
    assert arity == 2
    #if PL_is_variable(args[0]):
    #    args[0].unify(args[1])
    try:
        return {args[0].value:args[1].value}
    except AttributeError:
        return {args[0].value:args[1]}

_unify = Functor("=", 2)
Functor.func[_unify.handle] = _unifier
_not = Functor("not", 1)
_comma = Functor(",", 2)


def putTerm(term, value):
    if isinstance(value, Term):
        PL_put_term(term, value.handle)
    elif isinstance(value, str):
        PL_put_atom_chars(term, value)
    elif isinstance(value, int):
        PL_put_integer(term, value)
    elif isinstance(value, Variable):
        value.put(term)
    elif isinstance(value, list):
        putList(term, value)
    elif isinstance(value, Atom):
        print("ATOM")
    elif isinstance(value, Functor):
        PL_put_functor(term, value.handle)
    else:
        raise Exception("Not implemented")


def putList(l, ls):
    PL_put_nil(l)
    for item in reversed(ls):
        a = PL_new_term_ref()  #PL_new_term_refs(len(ls))
        putTerm(a, item)
        PL_cons_list(l, a, l)


def getAtomChars(t):
    """If t is an atom, return it as a string, otherwise raise InvalidTypeError.
    """
    s = c_char_p()
    if PL_get_chars(t, byref(s), CVT_ATOM|REP_UTF8):
        return s.value
    else:
        raise InvalidTypeError("atom")


def getAtom(t):
    """If t is an atom, return it , otherwise raise InvalidTypeError.
    """
    return Atom.fromTerm(t)


def getBool(t):
    """If t is of type bool, return it, otherwise raise InvalidTypeError.
    """
    b = c_int()
    if PL_get_long(t, byref(b)):
        return bool(b.value)
    else:
        raise InvalidTypeError("bool")


def getLong(t):
    """If t is of type long, return it, otherwise raise InvalidTypeError.
    """
    i = c_long()
    if PL_get_long(t, byref(i)):
        return i.value
    else:
        raise InvalidTypeError("long")


getInteger = getLong  # just an alias for getLong


def getFloat(t):
    """If t is of type float, return it, otherwise raise InvalidTypeError.
    """
    d = c_double()
    if PL_get_float(t, byref(d)):
        return d.value
    else:
        raise InvalidTypeError("float")


def getString(t):
    """If t is of type string, return it, otherwise raise InvalidTypeError.
    """
    s = c_char_p()
    if PL_get_chars(t, byref(s), REP_UTF8|CVT_STRING):
        return s.value
    else:
        raise InvalidTypeError("string")


mappedTerms = {}
def getTerm(t):
    if t is None:
        return None
    global mappedTerms
    #print 'mappedTerms', mappedTerms

    #if t in mappedTerms:
    #    return mappedTerms[t]
    p = PL_term_type(t)
    if p < PL_TERM:
        res = _getterm_router[p](t)
    elif PL_is_list(t):
        res = getList(t)
    else:
        res = getFunctor(t)
    mappedTerms[t] = res
    return res


def getList(x):
    """
    Return t as a list.
    """

    t = PL_copy_term_ref(x)
    head = PL_new_term_ref()
    result = []
    while PL_get_list(t, head, t):
        result.append(getTerm(head))
        head = PL_new_term_ref()

    return result


def getFunctor(t):
    """Return t as a functor
    """
    return Functor.fromTerm(t)


def getVariable(t):
    return Variable(t)


_getterm_router = {
                   PL_VARIABLE: getVariable,
                   PL_ATOM: getAtom,
                   PL_STRING: getString,
                   PL_INTEGER: getInteger,
                   PL_FLOAT: getFloat,
                   PL_TERM: getTerm,
                  }

arities = {}

def _callbackWrapper(arity=1, nondeterministic=False):
    global arities

    res = arities.get((arity, nondeterministic))
    if res is None:
        if nondeterministic:
            res = CFUNCTYPE(*([foreign_t] + [term_t] * arity + [control_t]))
        else:
            res = CFUNCTYPE(*([foreign_t] + [term_t] * arity))
        arities[(arity, nondeterministic)] = res
    return res


funwraps = {}


def _foreignWrapper(fun, nondeterministic=False):
    global funwraps

    res = funwraps.get(fun)
    if res is None:
        def wrapper(*args):
            if nondeterministic:
                args = [getTerm(arg) for arg in args[:-1]] + [args[-1]]
            else:
                args = [getTerm(arg) for arg in args]
            r = fun(*args)
            return (r is None) and True or r

        res = wrapper
        funwraps[fun] = res
    return res


cwraps = []


def registerForeign(func, name=None, arity=None, flags=0):
    """Register a Python predicate
    ``func``: Function to be registered. The function should return a value in
    ``foreign_t``, ``True`` or ``False``.
    ``name`` : Name of the function. If this value is not used, ``func.func_name``
    should exist.
    ``arity``: Arity (number of arguments) of the function. If this value is not
    used, ``func.arity`` should exist.
    """
    global cwraps

    if arity is None:
        arity = func.arity

    if name is None:
        name = func.__name__

    nondeterministic = bool(flags & PL_FA_NONDETERMINISTIC)

    cwrap = _callbackWrapper(arity, nondeterministic)
    fwrap = _foreignWrapper(func, nondeterministic)
    fwrap2 = cwrap(fwrap)
    cwraps.append(fwrap2)
    return PL_register_foreign(name, arity, fwrap2, flags)
    # return PL_register_foreign(name, arity,
    #            _callbackWrapper(arity)(_foreignWrapper(func)), flags)


newTermRef = PL_new_term_ref


def newTermRefs(count):
    a = PL_new_term_refs(count)
    return list(range(a, a + count))


def call(*terms, **kwargs):
    """Call term in module.
    ``term``: a Term or term handle
    """
    for kwarg in kwargs:
        if kwarg not in ["module"]:
            raise KeyError

    module = kwargs.get("module", None)

    t = terms[0]
    for tx in terms[1:]:
        t = _comma(t, tx)

    return PL_call(t.handle, module)


def newModule(name):
    """Create a new module.
    ``name``: An Atom or a string
    """
    if isinstance(name, str):
        name = Atom(name)

    return PL_new_module(name.handle)


class Query(object):
    qid = None
    fid = None

    def __init__(self, *terms, **kwargs):
        for key in kwargs:
            if key not in ["flags", "module"]:
                raise Exception("Invalid kwarg: %s" % key, key)

        flags = kwargs.get("flags", PL_Q_NODEBUG|PL_Q_CATCH_EXCEPTION)
        module = kwargs.get("module", None)

        t = terms[0]
        for tx in terms[1:]:
            t = _comma(t, tx)

        f = Functor.fromTerm(t)
        p = PL_pred(f.handle, module)
        Query.qid = PL_open_query(module, flags, p, f.a0)

#    def __del__(self):
#        self.closeQuery()

    def nextSolution():
        return PL_next_solution(Query.qid)
    nextSolution = staticmethod(nextSolution)

    def cutQuery():
        PL_cut_query(Query.qid)
    cutQuery = staticmethod(cutQuery)

    def closeQuery():
        if Query.qid is not None:
            PL_close_query(Query.qid)
            Query.qid = None
    closeQuery = staticmethod(closeQuery)

1	# -- coding: utf-8 --
2
3
4	# pyswip.easy -- PySwip helper functions
5	# Copyright (c) 2007-2018 Yüce Tekol
6	#
7	# Permission is hereby granted, free of charge, to any person obtaining a copy
8	# of this software and associated documentation files (the "Software"), to deal
9	# in the Software without restriction, including without limitation the rights
10	# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11	# copies of the Software, and to permit persons to whom the Software is
12	# furnished to do so, subject to the following conditions:
13	#
14	# The above copyright notice and this permission notice shall be included in all
15	# copies or substantial portions of the Software.
16	#
17	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18	# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19	# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20	# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21	# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22	# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23	# SOFTWARE.
24
25
26	from pyswip.core import *	1✔
27
28
29	class InvalidTypeError(TypeError):	1✔
30	def __init__(self, *args):	1✔
31	type_ = args and args[0] or "Unknown"	×
32	msg = "Term is expected to be of type: '%s'" % type_	×
33	Exception.__init__(self, msg, *args)	×
34
35
36	class ArgumentTypeError(Exception):	1✔
37	"""
38	Thrown when an argument has the wrong type.
39	"""
40	def __init__(self, expected, got):	1✔
41	msg = "Expected an argument of type '%s' but got '%s'" % (expected, got)	×
42	Exception.__init__(self, msg)	×
43
44
45	class Atom(object):	1✔
46	__slots__ = "handle", "chars"	1✔
47
48	def __init__(self, handleOrChars, chars=None):	1✔
49	"""Create an atom.
50	``handleOrChars``: handle or string of the atom.
51	"""
52
53	if isinstance(handleOrChars, str):	1✔
54	self.handle = PL_new_atom(handleOrChars)	1✔
55	self.chars = handleOrChars	1✔
56	else:
57	self.handle = handleOrChars	1✔
58	PL_register_atom(self.handle)	1✔
59	if chars is None:	1✔
60	slen = c_size_t()	1✔
61	self.chars = PL_atom_wchars(self.handle, byref(slen))	1✔
62	else: # WA: PL_atom_wchars can fail to return correct string
63	self.chars = chars	1✔
64
65	def fromTerm(cls, term):	1✔
66	"""Create an atom from a Term or term handle."""
67
68	if isinstance(term, Term):	1✔
69	term = term.handle	×
70	elif not isinstance(term, (c_void_p, int)):	1✔
71	raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))	×
72
73	a = atom_t()	1✔
74	if PL_get_atom(term, byref(a)):	1✔
75	return cls(a.value, getAtomChars(term))	1✔
76	fromTerm = classmethod(fromTerm)	1✔
77
78	def __del__(self):	1✔
79	if not cleaned:	1✔
80	PL_unregister_atom(self.handle)	×
81
82	def get_value(self):	1✔
83	ret = self.chars	1✔
84	if not isinstance(ret, str):	1✔
85	ret = ret.decode()	1✔
86	return ret	1✔
87
88	value = property(get_value)	1✔
89
90	def __str__(self):	1✔
91	if self.chars is not None:	1✔
92	return self.value	1✔
93	else:
94	return self.__repr__()	×
95
96	def __repr__(self):	1✔
97	return str(self.handle).join(["Atom('", "')"])	1✔
98
99	def __eq__(self, other):	1✔
100	if type(self) != type(other):	1✔
101	return False	×
102	else:
103	return self.handle == other.handle	1✔
104
105	def __hash__(self):	1✔
106	return self.handle	1✔
107
108
109	class Term(object):	1✔
110	__slots__ = "handle", "chars", "__value", "a0"	1✔
111
112	def __init__(self, handle=None, a0=None):	1✔
113	if handle:	1✔
114	#self.handle = PL_copy_term_ref(handle)
115	self.handle = handle	1✔
116	else:
117	self.handle = PL_new_term_ref()	×
118	self.chars = None	1✔
119	self.a0 = a0	1✔
120
121	def __invert__(self):	1✔
122	return _not(self)	×
123
124	def get_value(self):	1✔
125	pass	×
126
127	def __eq__(self, other):	1✔
128	if type(self) != type(other):	×
129	return False	×
130	else:
131	return PL_compare(self.handle, other.handle) == 0	×
132
133	def __hash__(self):	1✔
134	return self.handle	×
135
136
137	# support unicode also in python 2
138	try:	1✔
139	isinstance("", basestring)	1✔
140	def isstr(s):	1✔
141	return isinstance(s, basestring)	1✔
142	except NameError:	×
143	def isstr(s):	×
144	return isinstance(s, str)	×
145
146
147	class Variable(object):	1✔
148	__slots__ = "handle", "chars"	1✔
149
150	def __init__(self, handle=None, name=None):	1✔
151	self.chars = None	1✔
152	if name:	1✔
153	self.chars = name	×
154	if handle:	1✔
155	self.handle = handle	1✔
156	s = create_string_buffer(b"\00"*64) # FIXME:	1✔
157	ptr = cast(s, c_char_p)	1✔
158	if PL_get_chars(handle, byref(ptr), CVT_VARIABLE\|BUF_RING\|REP_UTF8):	1✔
159	self.chars = ptr.value	×
160	else:
161	self.handle = PL_new_term_ref()	1✔
162	#PL_put_variable(self.handle)
163	if (self.chars is not None) and not isinstance(self.chars, str):	1✔
164	self.chars = self.chars.decode()	×
165
166	def unify(self, value):	1✔
167	if isstr(value):	1✔
168	fun = PL_unify_atom_chars	×
169	value = value.encode()	×
170	elif type(value) == int:	1✔
171	fun = PL_unify_integer	1✔
172	elif type(value) == bool:	×
173	fun = PL_unify_bool	×
174	elif type(value) == float:	×
175	fun = PL_unify_float	×
176	elif type(value) == list:	×
177	fun = PL_unify_list	×
178	else:
179	raise TypeError('Cannot unify {} with value {} due to the value unknown type {}'.	×
180	format(self, value, type(value)))
181
182	if self.handle is None:	1✔
183	t = PL_new_term_ref(self.handle)	×
184	else:
185	t = PL_copy_term_ref(self.handle)	1✔
186
187	if type(value) == list:	1✔
188	a = PL_new_term_ref(self.handle)	×
189	if type(value[0]) == int:	×
190	element_fun = PL_unify_integer	×
191	elif type(value[0]) == float:	×
192	element_fun = PL_unify_float	×
193	else:
194	raise	×
195	if value:	×
196	for element in value:	×
197	fun(t, a, t)	×
198	element_fun(a, element)	×
199	else:
200	fun(t, value)	1✔
201	self.handle = t	1✔
202
203	def get_value(self):	1✔
204	return getTerm(self.handle)	1✔
205
206	value = property(get_value, unify)	1✔
207
208	def unified(self):	1✔
209	return PL_term_type(self.handle) == PL_VARIABLE	×
210
211	def __str__(self):	1✔
212	if self.chars is not None:	1✔
213	return self.chars	×
214	else:
215	return self.__repr__()	1✔
216
217	def __repr__(self):	1✔
218	return "Variable(%s)" % self.handle	1✔
219
220	def put(self, term):	1✔
221	#PL_put_variable(term)
222	PL_put_term(term, self.handle)	1✔
223
224	def __eq__(self, other):	1✔
225	if type(self) != type(other):	1✔
226	return False	×
227	else:
228	return PL_compare(self.handle, other.handle) == 0	1✔
229
230	def __hash__(self):	1✔
231	return self.handle	1✔
232
233
234	class Functor(object):	1✔
235	__slots__ = "handle", "name", "arity", "args", "__value", "a0"	1✔
236	func = {}	1✔
237
238	def __init__(self, handleOrName, arity=1, args=None, a0=None):	1✔
239	"""Create a functor.
240	``handleOrName``: functor handle, a string or an atom.
241	"""
242
243	self.args = args or []	1✔
244	self.arity = arity	1✔
245	self.a0 = a0	1✔
246
247	if isinstance(handleOrName, str):	1✔
248	self.name = Atom(handleOrName)	1✔
249	self.handle = PL_new_functor(self.name.handle, arity)	1✔
250	self.__value = "Functor%d" % self.handle	1✔
251	elif isinstance(handleOrName, Atom):	1✔
252	self.name = handleOrName	×
253	self.handle = PL_new_functor(self.name.handle, arity)	×
254	self.__value = "Functor%d" % self.handle	×
255	else:
256	self.handle = handleOrName	1✔
257	self.name = Atom(PL_functor_name(self.handle))	1✔
258	self.arity = PL_functor_arity(self.handle)	1✔
259	try:	1✔
260	self.__value = self.func[self.handle](self.arity, *self.args)	1✔
261	except KeyError:	1✔
262	self.__value = str(self)	1✔
263
264	def fromTerm(cls, term):	1✔
265	"""Create a functor from a Term or term handle."""
266
267	if isinstance(term, Term):	1✔
268	term = term.handle	1✔
269	elif not isinstance(term, (c_void_p, int)):	1✔
270	raise ArgumentTypeError((str(Term), str(int)), str(type(term)))	×
271
272	f = functor_t()	1✔
273	if PL_get_functor(term, byref(f)):	1✔
274	# get args
275	args = []	1✔
276	arity = PL_functor_arity(f.value)	1✔
277	# let's have all args be consecutive
278	a0 = PL_new_term_refs(arity)	1✔
279	for i, a in enumerate(range(1, arity + 1)):	1✔
280	if PL_get_arg(a, term, a0 + i):	1✔
281	args.append(getTerm(a0 + i))	1✔
282
283	return cls(f.value, args=args, a0=a0)	1✔
284	fromTerm = classmethod(fromTerm)	1✔
285
286	value = property(lambda s: s.__value)	1✔
287
288	def __call__(self, *args):	1✔
289	assert self.arity == len(args) # FIXME: Put a decent error message	1✔
290	a = PL_new_term_refs(len(args))	1✔
291	for i, arg in enumerate(args):	1✔
292	putTerm(a + i, arg)	1✔
293
294	t = PL_new_term_ref()	1✔
295	PL_cons_functor_v(t, self.handle, a)	1✔
296	return Term(t)	1✔
297
298	def __str__(self):	1✔
299	if self.name is not None and self.arity is not None:	1✔
300	return "%s(%s)" % (self.name,	1✔
301	', '.join([str(arg) for arg in self.args]))
302	else:
303	return self.__repr__()	×
304
305	def __repr__(self):	1✔
306	return "".join(["Functor(", ",".join(str(x) for x	1✔
307	in [self.handle,self.arity]+self.args), ")"])
308
309	def __eq__(self, other):	1✔
310	if type(self) != type(other):	×
311	return False	×
312	else:
313	return PL_compare(self.handle, other.handle) == 0	×
314
315	def __hash__(self):	1✔
316	return self.handle	×
317
318
319	def _unifier(arity, *args):	1✔
320	assert arity == 2	1✔
321	#if PL_is_variable(args[0]):
322	# args[0].unify(args[1])
323	try:	1✔
324	return {args[0].value:args[1].value}	1✔
325	except AttributeError:	1✔
326	return {args[0].value:args[1]}	1✔
327
328	_unify = Functor("=", 2)	1✔
329	Functor.func[_unify.handle] = _unifier	1✔
330	_not = Functor("not", 1)	1✔
331	_comma = Functor(",", 2)	1✔
332
333
334	def putTerm(term, value):	1✔
335	if isinstance(value, Term):	1✔
336	PL_put_term(term, value.handle)	1✔
337	elif isinstance(value, str):	1✔
338	PL_put_atom_chars(term, value)	1✔
339	elif isinstance(value, int):	1✔
340	PL_put_integer(term, value)	1✔
341	elif isinstance(value, Variable):	1✔
342	value.put(term)	1✔
343	elif isinstance(value, list):	1✔
344	putList(term, value)	1✔
345	elif isinstance(value, Atom):	×
346	print("ATOM")	×
347	elif isinstance(value, Functor):	×
348	PL_put_functor(term, value.handle)	×
349	else:
350	raise Exception("Not implemented")	×
351
352
353	def putList(l, ls):	1✔
354	PL_put_nil(l)	1✔
355	for item in reversed(ls):	1✔
356	a = PL_new_term_ref() #PL_new_term_refs(len(ls))	1✔
357	putTerm(a, item)	1✔
358	PL_cons_list(l, a, l)	1✔
359
360
361	def getAtomChars(t):	1✔
362	"""If t is an atom, return it as a string, otherwise raise InvalidTypeError.
363	"""
364	s = c_char_p()	1✔
365	if PL_get_chars(t, byref(s), CVT_ATOM\|REP_UTF8):	1✔
366	return s.value	1✔
367	else:
368	raise InvalidTypeError("atom")	×
369
370
371	def getAtom(t):	1✔
372	"""If t is an atom, return it , otherwise raise InvalidTypeError.
373	"""
374	return Atom.fromTerm(t)	1✔
375
376
377	def getBool(t):	1✔
378	"""If t is of type bool, return it, otherwise raise InvalidTypeError.
379	"""
380	b = c_int()	×
381	if PL_get_long(t, byref(b)):	×
382	return bool(b.value)	×
383	else:
384	raise InvalidTypeError("bool")	×
385
386
387	def getLong(t):	1✔
388	"""If t is of type long, return it, otherwise raise InvalidTypeError.
389	"""
390	i = c_long()	1✔
391	if PL_get_long(t, byref(i)):	1✔
392	return i.value	1✔
393	else:
394	raise InvalidTypeError("long")	×
395
396
397	getInteger = getLong # just an alias for getLong	1✔
398
399
400	def getFloat(t):	1✔
401	"""If t is of type float, return it, otherwise raise InvalidTypeError.
402	"""
403	d = c_double()	×
404	if PL_get_float(t, byref(d)):	×
405	return d.value	×
406	else:
407	raise InvalidTypeError("float")	×
408
409
410	def getString(t):	1✔
411	"""If t is of type string, return it, otherwise raise InvalidTypeError.
412	"""
413	s = c_char_p()	1✔
414	if PL_get_chars(t, byref(s), REP_UTF8\|CVT_STRING):	1✔
415	return s.value	1✔
416	else:
417	raise InvalidTypeError("string")	×
418
419
420	mappedTerms = {}	1✔
421	def getTerm(t):	1✔
422	if t is None:	1✔
423	return None	×
424	global mappedTerms
425	#print 'mappedTerms', mappedTerms
426
427	#if t in mappedTerms:
428	# return mappedTerms[t]
429	p = PL_term_type(t)	1✔
430	if p < PL_TERM:	1✔
431	res = _getterm_router[p](t)	1✔
432	elif PL_is_list(t):	1✔
433	res = getList(t)	1✔
434	else:
435	res = getFunctor(t)	1✔
436	mappedTerms[t] = res	1✔
437	return res	1✔
438
439
440	def getList(x):	1✔
441	"""
442	Return t as a list.
443	"""
444
445	t = PL_copy_term_ref(x)	1✔
446	head = PL_new_term_ref()	1✔
447	result = []	1✔
448	while PL_get_list(t, head, t):	1✔
449	result.append(getTerm(head))	1✔
450	head = PL_new_term_ref()	1✔
451
452	return result	1✔
453
454
455	def getFunctor(t):	1✔
456	"""Return t as a functor
457	"""
458	return Functor.fromTerm(t)	1✔
459
460
461	def getVariable(t):	1✔
462	return Variable(t)	1✔
463
464
465	_getterm_router = {	1✔
466	PL_VARIABLE: getVariable,
467	PL_ATOM: getAtom,
468	PL_STRING: getString,
469	PL_INTEGER: getInteger,
470	PL_FLOAT: getFloat,
471	PL_TERM: getTerm,
472	}
473
474	arities = {}	1✔
475
476	def _callbackWrapper(arity=1, nondeterministic=False):	1✔
477	global arities
478
479	res = arities.get((arity, nondeterministic))	1✔
480	if res is None:	1✔
481	if nondeterministic:	1✔
482	res = CFUNCTYPE(([foreign_t] + [term_t] arity + [control_t]))	1✔
483	else:
484	res = CFUNCTYPE(([foreign_t] + [term_t] arity))	1✔
485	arities[(arity, nondeterministic)] = res	1✔
486	return res	1✔
487
488
489	funwraps = {}	1✔
490
491
492	def _foreignWrapper(fun, nondeterministic=False):	1✔
493	global funwraps
494
495	res = funwraps.get(fun)	1✔
496	if res is None:	1✔
497	def wrapper(*args):	1✔
498	if nondeterministic:	1✔
499	args = [getTerm(arg) for arg in args[:-1]] + [args[-1]]	1✔
500	else:
501	args = [getTerm(arg) for arg in args]	1✔
502	r = fun(*args)	1✔
503	return (r is None) and True or r	1✔
504
505	res = wrapper	1✔
506	funwraps[fun] = res	1✔
507	return res	1✔
508
509
510	cwraps = []	1✔
511
512
513	def registerForeign(func, name=None, arity=None, flags=0):	1✔
514	"""Register a Python predicate
515	``func``: Function to be registered. The function should return a value in
516	``foreign_t``, ``True`` or ``False``.
517	``name`` : Name of the function. If this value is not used, ``func.func_name``
518	should exist.
519	``arity``: Arity (number of arguments) of the function. If this value is not
520	used, ``func.arity`` should exist.
521	"""
522	global cwraps
523
524	if arity is None:	1✔
525	arity = func.arity	1✔
526
527	if name is None:	1✔
528	name = func.__name__	1✔
529
530	nondeterministic = bool(flags & PL_FA_NONDETERMINISTIC)	1✔
531
532	cwrap = _callbackWrapper(arity, nondeterministic)	1✔
533	fwrap = _foreignWrapper(func, nondeterministic)	1✔
534	fwrap2 = cwrap(fwrap)	1✔
535	cwraps.append(fwrap2)	1✔
536	return PL_register_foreign(name, arity, fwrap2, flags)	1✔
537	# return PL_register_foreign(name, arity,
538	# _callbackWrapper(arity)(_foreignWrapper(func)), flags)
539
540
541	newTermRef = PL_new_term_ref	1✔
542
543
544	def newTermRefs(count):	1✔
545	a = PL_new_term_refs(count)	×
546	return list(range(a, a + count))	×
547
548
549	def call(terms, *kwargs):	1✔
550	"""Call term in module.
551	``term``: a Term or term handle
552	"""
553	for kwarg in kwargs:	1✔
554	if kwarg not in ["module"]:	1✔
555	raise KeyError	×
556
557	module = kwargs.get("module", None)	1✔
558
559	t = terms[0]	1✔
560	for tx in terms[1:]:	1✔
561	t = _comma(t, tx)	×
562
563	return PL_call(t.handle, module)	1✔
564
565
566	def newModule(name):	1✔
567	"""Create a new module.
568	``name``: An Atom or a string
569	"""
570	if isinstance(name, str):	1✔
571	name = Atom(name)	1✔
572
573	return PL_new_module(name.handle)	1✔
574
575
576	class Query(object):	1✔
577	qid = None	1✔
578	fid = None	1✔
579
580	def __init__(self, terms, *kwargs):	1✔
581	for key in kwargs:	1✔
582	if key not in ["flags", "module"]:	1✔
583	raise Exception("Invalid kwarg: %s" % key, key)	×
584
585	flags = kwargs.get("flags", PL_Q_NODEBUG\|PL_Q_CATCH_EXCEPTION)	1✔
586	module = kwargs.get("module", None)	1✔
587
588	t = terms[0]	1✔
589	for tx in terms[1:]:	1✔
590	t = _comma(t, tx)	1✔
591
592	f = Functor.fromTerm(t)	1✔
593	p = PL_pred(f.handle, module)	1✔
594	Query.qid = PL_open_query(module, flags, p, f.a0)	1✔
595
596	# def __del__(self):
597	# self.closeQuery()
598
599	def nextSolution():	1✔
600	return PL_next_solution(Query.qid)	1✔
601	nextSolution = staticmethod(nextSolution)	1✔
602
603	def cutQuery():	1✔
604	PL_cut_query(Query.qid)	×
605	cutQuery = staticmethod(cutQuery)	1✔
606
607	def closeQuery():	1✔
608	if Query.qid is not None:	1✔
609	PL_close_query(Query.qid)	1✔
610	Query.qid = None	1✔
611	closeQuery = staticmethod(closeQuery)	1✔

yuce / pyswip / 111

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous