yuce / pyswip / 115

pending completion

Build # 115

Build Type

Pull #103

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/yuce/pyswip/commit/<a class=hub.com/yuce/pyswip/commit/3e969c5691c93e73e3c5470d71fcaec11868c329">3e969c569<a href="https://github.com/yuce/pyswip/commit/3e969c5691c93e73e3c5470d71fcaec11868c329">">Merge </a><a class="double-link" href="https://github.com/yuce/pyswip/commit/<a class="double-link" href="https://github.com/yuce/pyswip/commit/3a70b4361428ee3ebe5741b43a300486221470c6">3a70b4361</a>">3a70b4361</a><a href="https://github.com/yuce/pyswip/commit/3e969c5691c93e73e3c5470d71fcaec11868c329"> into c701878b2">c701878b2</a>

Pull Request Pull Request #103: Adding PL_STRINGS_MARK to getAtomChars

Run Details

17 of 17 new or added lines in 2 files covered. (100.0%)

920 of 1163 relevant lines covered (79.11%)

2.37 hits per line

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

78.67

/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.
    """
    with PL_STRINGS_MARK():
        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 *	3✔
27
28
29	class InvalidTypeError(TypeError):	3✔
30	def __init__(self, *args):	3✔
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):	3✔
37	"""
38	Thrown when an argument has the wrong type.
39	"""
40	def __init__(self, expected, got):	3✔
41	msg = "Expected an argument of type '%s' but got '%s'" % (expected, got)	×
42	Exception.__init__(self, msg)	×
43
44
45	class Atom(object):	3✔
46	__slots__ = "handle", "chars"	3✔
47
48	def __init__(self, handleOrChars, chars=None):	3✔
49	"""Create an atom.
50	``handleOrChars``: handle or string of the atom.
51	"""
52
53	if isinstance(handleOrChars, str):	3✔
54	self.handle = PL_new_atom(handleOrChars)	3✔
55	self.chars = handleOrChars	3✔
56	else:
57	self.handle = handleOrChars	3✔
58	PL_register_atom(self.handle)	3✔
59	if chars is None:	3✔
60	slen = c_size_t()	3✔
61	self.chars = PL_atom_wchars(self.handle, byref(slen))	3✔
62	else: # WA: PL_atom_wchars can fail to return correct string
63	self.chars = chars	3✔
64
65	def fromTerm(cls, term):	3✔
66	"""Create an atom from a Term or term handle."""
67
68	if isinstance(term, Term):	3✔
69	term = term.handle	×
70	elif not isinstance(term, (c_void_p, int)):	3✔
71	raise ArgumentTypeError((str(Term), str(c_void_p)), str(type(term)))	×
72
73	a = atom_t()	3✔
74	if PL_get_atom(term, byref(a)):	3✔
75	return cls(a.value, getAtomChars(term))	3✔
76	fromTerm = classmethod(fromTerm)	3✔
77
78	def __del__(self):	3✔
79	if not cleaned:	3✔
80	PL_unregister_atom(self.handle)	×
81
82	def get_value(self):	3✔
83	ret = self.chars	3✔
84	if not isinstance(ret, str):	3✔
85	ret = ret.decode()	3✔
86	return ret	3✔
87
88	value = property(get_value)	3✔
89
90	def __str__(self):	3✔
91	if self.chars is not None:	3✔
92	return self.value	3✔
93	else:
94	return self.__repr__()	×
95
96	def __repr__(self):	3✔
97	return str(self.handle).join(["Atom('", "')"])	3✔
98
99	def __eq__(self, other):	3✔
100	if type(self) != type(other):	3✔
101	return False	×
102	else:
103	return self.handle == other.handle	3✔
104
105	def __hash__(self):	3✔
106	return self.handle	3✔
107
108
109	class Term(object):	3✔
110	__slots__ = "handle", "chars", "__value", "a0"	3✔
111
112	def __init__(self, handle=None, a0=None):	3✔
113	if handle:	3✔
114	#self.handle = PL_copy_term_ref(handle)
115	self.handle = handle	3✔
116	else:
117	self.handle = PL_new_term_ref()	×
118	self.chars = None	3✔
119	self.a0 = a0	3✔
120
121	def __invert__(self):	3✔
122	return _not(self)	×
123
124	def get_value(self):	3✔
125	pass	×
126
127	def __eq__(self, other):	3✔
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):	3✔
134	return self.handle	×
135
136
137	# support unicode also in python 2
138	try:	3✔
139	isinstance("", basestring)	3✔
140	def isstr(s):	×
141	return isinstance(s, basestring)	×
142	except NameError:	3✔
143	def isstr(s):	3✔
144	return isinstance(s, str)	3✔
145
146
147	class Variable(object):	3✔
148	__slots__ = "handle", "chars"	3✔
149
150	def __init__(self, handle=None, name=None):	3✔
151	self.chars = None	3✔
152	if name:	3✔
153	self.chars = name	×
154	if handle:	3✔
155	self.handle = handle	3✔
156	s = create_string_buffer(b"\00"*64) # FIXME:	3✔
157	ptr = cast(s, c_char_p)	3✔
158	if PL_get_chars(handle, byref(ptr), CVT_VARIABLE\|BUF_RING\|REP_UTF8):	3✔
159	self.chars = ptr.value	×
160	else:
161	self.handle = PL_new_term_ref()	3✔
162	#PL_put_variable(self.handle)
163	if (self.chars is not None) and not isinstance(self.chars, str):	3✔
164	self.chars = self.chars.decode()	×
165
166	def unify(self, value):	3✔
167	if isstr(value):	3✔
168	fun = PL_unify_atom_chars	×
169	value = value.encode()	×
170	elif type(value) == int:	3✔
171	fun = PL_unify_integer	3✔
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:	3✔
183	t = PL_new_term_ref(self.handle)	×
184	else:
185	t = PL_copy_term_ref(self.handle)	3✔
186
187	if type(value) == list:	3✔
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)	3✔
201	self.handle = t	3✔
202
203	def get_value(self):	3✔
204	return getTerm(self.handle)	3✔
205
206	value = property(get_value, unify)	3✔
207
208	def unified(self):	3✔
209	return PL_term_type(self.handle) == PL_VARIABLE	×
210
211	def __str__(self):	3✔
212	if self.chars is not None:	3✔
213	return self.chars	×
214	else:
215	return self.__repr__()	3✔
216
217	def __repr__(self):	3✔
218	return "Variable(%s)" % self.handle	3✔
219
220	def put(self, term):	3✔
221	#PL_put_variable(term)
222	PL_put_term(term, self.handle)	3✔
223
224	def __eq__(self, other):	3✔
225	if type(self) != type(other):	3✔
226	return False	×
227	else:
228	return PL_compare(self.handle, other.handle) == 0	3✔
229
230	def __hash__(self):	3✔
231	return self.handle	3✔
232
233
234	class Functor(object):	3✔
235	__slots__ = "handle", "name", "arity", "args", "__value", "a0"	3✔
236	func = {}	3✔
237
238	def __init__(self, handleOrName, arity=1, args=None, a0=None):	3✔
239	"""Create a functor.
240	``handleOrName``: functor handle, a string or an atom.
241	"""
242
243	self.args = args or []	3✔
244	self.arity = arity	3✔
245	self.a0 = a0	3✔
246
247	if isinstance(handleOrName, str):	3✔
248	self.name = Atom(handleOrName)	3✔
249	self.handle = PL_new_functor(self.name.handle, arity)	3✔
250	self.__value = "Functor%d" % self.handle	3✔
251	elif isinstance(handleOrName, Atom):	3✔
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	3✔
257	self.name = Atom(PL_functor_name(self.handle))	3✔
258	self.arity = PL_functor_arity(self.handle)	3✔
259	try:	3✔
260	self.__value = self.func[self.handle](self.arity, *self.args)	3✔
261	except KeyError:	3✔
262	self.__value = str(self)	3✔
263
264	def fromTerm(cls, term):	3✔
265	"""Create a functor from a Term or term handle."""
266
267	if isinstance(term, Term):	3✔
268	term = term.handle	3✔
269	elif not isinstance(term, (c_void_p, int)):	3✔
270	raise ArgumentTypeError((str(Term), str(int)), str(type(term)))	×
271
272	f = functor_t()	3✔
273	if PL_get_functor(term, byref(f)):	3✔
274	# get args
275	args = []	3✔
276	arity = PL_functor_arity(f.value)	3✔
277	# let's have all args be consecutive
278	a0 = PL_new_term_refs(arity)	3✔
279	for i, a in enumerate(range(1, arity + 1)):	3✔
280	if PL_get_arg(a, term, a0 + i):	3✔
281	args.append(getTerm(a0 + i))	3✔
282
283	return cls(f.value, args=args, a0=a0)	3✔
284	fromTerm = classmethod(fromTerm)	3✔
285
286	value = property(lambda s: s.__value)	3✔
287
288	def __call__(self, *args):	3✔
289	assert self.arity == len(args) # FIXME: Put a decent error message	3✔
290	a = PL_new_term_refs(len(args))	3✔
291	for i, arg in enumerate(args):	3✔
292	putTerm(a + i, arg)	3✔
293
294	t = PL_new_term_ref()	3✔
295	PL_cons_functor_v(t, self.handle, a)	3✔
296	return Term(t)	3✔
297
298	def __str__(self):	3✔
299	if self.name is not None and self.arity is not None:	3✔
300	return "%s(%s)" % (self.name,	3✔
301	', '.join([str(arg) for arg in self.args]))
302	else:
303	return self.__repr__()	×
304
305	def __repr__(self):	3✔
306	return "".join(["Functor(", ",".join(str(x) for x	3✔
307	in [self.handle,self.arity]+self.args), ")"])
308
309	def __eq__(self, other):	3✔
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):	3✔
316	return self.handle	×
317
318
319	def _unifier(arity, *args):	3✔
320	assert arity == 2	3✔
321	#if PL_is_variable(args[0]):
322	# args[0].unify(args[1])
323	try:	3✔
324	return {args[0].value:args[1].value}	3✔
325	except AttributeError:	3✔
326	return {args[0].value:args[1]}	3✔
327
328	_unify = Functor("=", 2)	3✔
329	Functor.func[_unify.handle] = _unifier	3✔
330	_not = Functor("not", 1)	3✔
331	_comma = Functor(",", 2)	3✔
332
333
334	def putTerm(term, value):	3✔
335	if isinstance(value, Term):	3✔
336	PL_put_term(term, value.handle)	3✔
337	elif isinstance(value, str):	3✔
338	PL_put_atom_chars(term, value)	3✔
339	elif isinstance(value, int):	3✔
340	PL_put_integer(term, value)	3✔
341	elif isinstance(value, Variable):	3✔
342	value.put(term)	3✔
343	elif isinstance(value, list):	3✔
344	putList(term, value)	3✔
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):	3✔
354	PL_put_nil(l)	3✔
355	for item in reversed(ls):	3✔
356	a = PL_new_term_ref() #PL_new_term_refs(len(ls))	3✔
357	putTerm(a, item)	3✔
358	PL_cons_list(l, a, l)	3✔
359
360
361	def getAtomChars(t):	3✔
362	"""If t is an atom, return it as a string, otherwise raise InvalidTypeError.
363	"""
364	with PL_STRINGS_MARK():	3✔
365	s = c_char_p()	3✔
366	if PL_get_chars(t, byref(s), CVT_ATOM\|REP_UTF8):	3✔
367	return s.value	3✔
368	else:
369	raise InvalidTypeError("atom")	×
370
371
372	def getAtom(t):	3✔
373	"""If t is an atom, return it , otherwise raise InvalidTypeError.
374	"""
375	return Atom.fromTerm(t)	3✔
376
377
378	def getBool(t):	3✔
379	"""If t is of type bool, return it, otherwise raise InvalidTypeError.
380	"""
381	b = c_int()	×
382	if PL_get_long(t, byref(b)):	×
383	return bool(b.value)	×
384	else:
385	raise InvalidTypeError("bool")	×
386
387
388	def getLong(t):	3✔
389	"""If t is of type long, return it, otherwise raise InvalidTypeError.
390	"""
391	i = c_long()	3✔
392	if PL_get_long(t, byref(i)):	3✔
393	return i.value	3✔
394	else:
395	raise InvalidTypeError("long")	×
396
397
398	getInteger = getLong # just an alias for getLong	3✔
399
400
401	def getFloat(t):	3✔
402	"""If t is of type float, return it, otherwise raise InvalidTypeError.
403	"""
404	d = c_double()	×
405	if PL_get_float(t, byref(d)):	×
406	return d.value	×
407	else:
408	raise InvalidTypeError("float")	×
409
410
411	def getString(t):	3✔
412	"""If t is of type string, return it, otherwise raise InvalidTypeError.
413	"""
414	s = c_char_p()	3✔
415	if PL_get_chars(t, byref(s), REP_UTF8\|CVT_STRING):	3✔
416	return s.value	3✔
417	else:
418	raise InvalidTypeError("string")	×
419
420
421	mappedTerms = {}	3✔
422	def getTerm(t):	3✔
423	if t is None:	3✔
424	return None	×
425	global mappedTerms
426	#print 'mappedTerms', mappedTerms
427
428	#if t in mappedTerms:
429	# return mappedTerms[t]
430	p = PL_term_type(t)	3✔
431	if p < PL_TERM:	3✔
432	res = _getterm_router[p](t)	3✔
433	elif PL_is_list(t):	3✔
434	res = getList(t)	3✔
435	else:
436	res = getFunctor(t)	3✔
437	mappedTerms[t] = res	3✔
438	return res	3✔
439
440
441	def getList(x):	3✔
442	"""
443	Return t as a list.
444	"""
445
446	t = PL_copy_term_ref(x)	3✔
447	head = PL_new_term_ref()	3✔
448	result = []	3✔
449	while PL_get_list(t, head, t):	3✔
450	result.append(getTerm(head))	3✔
451	head = PL_new_term_ref()	3✔
452
453	return result	3✔
454
455
456	def getFunctor(t):	3✔
457	"""Return t as a functor
458	"""
459	return Functor.fromTerm(t)	3✔
460
461
462	def getVariable(t):	3✔
463	return Variable(t)	3✔
464
465
466	_getterm_router = {	3✔
467	PL_VARIABLE: getVariable,
468	PL_ATOM: getAtom,
469	PL_STRING: getString,
470	PL_INTEGER: getInteger,
471	PL_FLOAT: getFloat,
472	PL_TERM: getTerm,
473	}
474
475	arities = {}	3✔
476
477	def _callbackWrapper(arity=1, nondeterministic=False):	3✔
478	global arities
479
480	res = arities.get((arity, nondeterministic))	3✔
481	if res is None:	3✔
482	if nondeterministic:	3✔
483	res = CFUNCTYPE(([foreign_t] + [term_t] arity + [control_t]))	3✔
484	else:
485	res = CFUNCTYPE(([foreign_t] + [term_t] arity))	3✔
486	arities[(arity, nondeterministic)] = res	3✔
487	return res	3✔
488
489
490	funwraps = {}	3✔
491
492
493	def _foreignWrapper(fun, nondeterministic=False):	3✔
494	global funwraps
495
496	res = funwraps.get(fun)	3✔
497	if res is None:	3✔
498	def wrapper(*args):	3✔
499	if nondeterministic:	3✔
500	args = [getTerm(arg) for arg in args[:-1]] + [args[-1]]	3✔
501	else:
502	args = [getTerm(arg) for arg in args]	3✔
503	r = fun(*args)	3✔
504	return (r is None) and True or r	3✔
505
506	res = wrapper	3✔
507	funwraps[fun] = res	3✔
508	return res	3✔
509
510
511	cwraps = []	3✔
512
513
514	def registerForeign(func, name=None, arity=None, flags=0):	3✔
515	"""Register a Python predicate
516	``func``: Function to be registered. The function should return a value in
517	``foreign_t``, ``True`` or ``False``.
518	``name`` : Name of the function. If this value is not used, ``func.func_name``
519	should exist.
520	``arity``: Arity (number of arguments) of the function. If this value is not
521	used, ``func.arity`` should exist.
522	"""
523	global cwraps
524
525	if arity is None:	3✔
526	arity = func.arity	3✔
527
528	if name is None:	3✔
529	name = func.__name__	3✔
530
531	nondeterministic = bool(flags & PL_FA_NONDETERMINISTIC)	3✔
532
533	cwrap = _callbackWrapper(arity, nondeterministic)	3✔
534	fwrap = _foreignWrapper(func, nondeterministic)	3✔
535	fwrap2 = cwrap(fwrap)	3✔
536	cwraps.append(fwrap2)	3✔
537	return PL_register_foreign(name, arity, fwrap2, flags)	3✔
538	# return PL_register_foreign(name, arity,
539	# _callbackWrapper(arity)(_foreignWrapper(func)), flags)
540
541
542	newTermRef = PL_new_term_ref	3✔
543
544
545	def newTermRefs(count):	3✔
546	a = PL_new_term_refs(count)	×
547	return list(range(a, a + count))	×
548
549
550	def call(terms, *kwargs):	3✔
551	"""Call term in module.
552	``term``: a Term or term handle
553	"""
554	for kwarg in kwargs:	3✔
555	if kwarg not in ["module"]:	3✔
556	raise KeyError	×
557
558	module = kwargs.get("module", None)	3✔
559
560	t = terms[0]	3✔
561	for tx in terms[1:]:	3✔
562	t = _comma(t, tx)	×
563
564	return PL_call(t.handle, module)	3✔
565
566
567	def newModule(name):	3✔
568	"""Create a new module.
569	``name``: An Atom or a string
570	"""
571	if isinstance(name, str):	3✔
572	name = Atom(name)	3✔
573
574	return PL_new_module(name.handle)	3✔
575
576
577	class Query(object):	3✔
578	qid = None	3✔
579	fid = None	3✔
580
581	def __init__(self, terms, *kwargs):	3✔
582	for key in kwargs:	3✔
583	if key not in ["flags", "module"]:	3✔
584	raise Exception("Invalid kwarg: %s" % key, key)	×
585
586	flags = kwargs.get("flags", PL_Q_NODEBUG\|PL_Q_CATCH_EXCEPTION)	3✔
587	module = kwargs.get("module", None)	3✔
588
589	t = terms[0]	3✔
590	for tx in terms[1:]:	3✔
591	t = _comma(t, tx)	3✔
592
593	f = Functor.fromTerm(t)	3✔
594	p = PL_pred(f.handle, module)	3✔
595	Query.qid = PL_open_query(module, flags, p, f.a0)	3✔
596
597	# def __del__(self):
598	# self.closeQuery()
599
600	def nextSolution():	3✔
601	return PL_next_solution(Query.qid)	3✔
602	nextSolution = staticmethod(nextSolution)	3✔
603
604	def cutQuery():	3✔
605	PL_cut_query(Query.qid)	×
606	cutQuery = staticmethod(cutQuery)	3✔
607
608	def closeQuery():	3✔
609	if Query.qid is not None:	3✔
610	PL_close_query(Query.qid)	3✔
611	Query.qid = None	3✔
612	closeQuery = staticmethod(closeQuery)	3✔

yuce / pyswip / 115

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