def removeFirst(self, car_list):
result = re.search("c\(.+?\)(]|,c)(.*)]", car_list.string)
if result:
rest = result.group(2)
yield clingo.String(f"[c({rest}]")
elif car_list.string != "[]":
yield clingo.String("[]")
def setUp(self):
self.inf = clingo.Infimum
self.sup = clingo.Supremum
self.s1 = clingo.String("aaaa")
self.s2 = clingo.String("bbbb")
self.n1 = clingo.Number(24)
self.n2 = clingo.Number(60)
self.f1 = clingo.Function("",[self.s1, self.s2])
self.f2 = clingo.Function("func1", [self.n1])
self.f3 = clingo.Function("func2", [self.n2, self.f1])
self.f4 = clingo.Function("func1", [], False)
self.alls = [self.inf, self.sup, self.s1, self.s2, self.n1, \
self.n2, self.f1, self.f2, self.f3, self.f4 ]
self.str_inf = '{"clingo.SymbolType": "Infimum"}'
self.str_sup = '{"clingo.SymbolType": "Supremum"}'
self.str_s1 = '{"clingo.SymbolType": "String", "string": "aaaa"}'
self.str_s2 = '{"clingo.SymbolType": "String", "string": "bbbb"}'
self.str_n1 = '{"clingo.SymbolType": "Number", "number": 24}'
self.str_n2 = '{"clingo.SymbolType": "Number", "number": 60}'
self.str_f1 = '{"clingo.SymbolType": "Function", "name": "", "arguments": [' \
+ self.str_s1 + ', ' + self.str_s2 + '], "positive": true}'
self.str_f2 = '{"clingo.SymbolType": "Function", "name": "func1", "arguments": [' \
+ self.str_n1 + '], "positive": true}'
self.str_f3 = '{"clingo.SymbolType": "Function", "name": "func2", "arguments": [' \
+ self.str_n2 + ', ' + self.str_f1 + '], "positive": true}'
self.str_f4 = '{"clingo.SymbolType": "Function", "name": "func1", "arguments": []' \
+ ', "positive": false}'
self.str_alls = '[' + self.str_inf + ', ' + self.str_sup + ', ' + \
self.str_s1 + ', ' + self.str_s2 + ', ' + self.str_n1 + ', ' +\
self.str_n2 + ', ' + self.str_f1 + ', ' + self.str_f2 + ', ' +\
self.str_f3 + ', ' + self.str_f4 + ']'
def argify(arg):
if isinstance(arg, bool):
return clingo.String(str(arg))
elif isinstance(arg, int):
return clingo.Number(arg)
else:
return clingo.String(str(arg))
def to_symbol(obj):
if isinstance(obj, int):
return clingo.Number(obj)
if isinstance(obj, str):
return clingo.String(obj)
return clingo.Number(obj)
if isinstance(obj, str):
return clingo.String(obj)
raise NotImplementedError(f"conversion of {type(obj)} to {clingo.Symbol}")
def storeConstant(self, s: str):
if len(s) == 0 or (s[0] == '"' and s[1] == '"'):
# TODO this is only for backwards compatibility, should be removed in V2
logging.warning(
"storeConstant() was used on string '%s', use storeString in the future",
s)
if len(s) == 0:
return ClingoID(self.ccontext, SymLit(clingo.String(''), None))
else:
return ClingoID(self.ccontext, SymLit(clingo.String(s), None))
return ClingoID(self.ccontext, SymLit(clingo.Function(s), None))
def __on_model(self, model):
ass = self.prop.assignment(model.thread_id)
if ass is not None:
(opt, values) = ass
model.extend(
[clingo.Function('_lp_optimum', [clingo.String(str(opt))])])
for name in values:
model.extend([
clingo.Function('_lp_solution', [
clingo.Function(name, []),
clingo.String(str(values[name]))
])
])
def test_comparison_ops(self):
nc1 = noclingo.Number(34)
nc2 = noclingo.Number(43)
self.assertTrue(nc1 <= nc2)
self.assertTrue(nc1 < nc2)
self.assertTrue(nc2 >= nc1)
self.assertTrue(nc2 > nc1)
nc3 = noclingo.String("abcd")
nc4 = noclingo.String("bcde")
self.assertTrue(nc3 <= nc4)
self.assertTrue(nc3 < nc4)
self.assertTrue(nc4 >= nc3)
self.assertTrue(nc4 > nc3)
nc5 = noclingo.Function("abc", [noclingo.Number(45)])
nc6 = noclingo.Function("abc", [noclingo.String("45")])
c5 = clingo.Function("abc", [clingo.Number(45)])
c6 = clingo.Function("abc", [clingo.String("45")])
if c5 < c6: self.assertTrue(nc5 < nc6)
else: self.assertTrue(nc5 > nc6)
nc7 = noclingo.Function(
"abc",
[noclingo.String("45"), noclingo.Number(5)])
self.assertTrue(nc6 < nc7)
if noclingo.SymbolType.Number < noclingo.SymbolType.String:
self.assertTrue(nc1 < nc3)
else:
self.assertTrue(nc1 > nc3)
def test_function(self):
nc = noclingo.Function("atest")
c = clingo.Function("atest")
self.assertEqual(str(nc), str(c))
self.assertEqual(nc.type, noclingo.SymbolType.Function)
nc1 = noclingo.Function("aaaa")
nc2 = noclingo.String("bbb")
nc3 = noclingo.Function("ccc", [noclingo.Number(10)])
c1 = clingo.Function("aaaa")
c2 = clingo.String("bbb")
c3 = clingo.Function("ccc", [clingo.Number(10)])
nc = noclingo.Function("atest", [nc1, nc2, nc3])
c = clingo.Function("atest", [c1, c2, c3])
self.assertEqual(str(nc), str(c))
self.assertEqual(nc.name, c.name)
self.assertEqual(nc.name, "atest")
self.assertEqual(len(nc.arguments), len(c.arguments))
self.assertEqual(nc.arguments[0].name, c.arguments[0].name)
self.assertEqual(nc.arguments[0].name, "aaaa")
self.assertEqual(nc.arguments[1].string, c.arguments[1].string)
nc4 = noclingo.Function("ccc", [noclingo.Number(10)], False)
c4 = clingo.Function("ccc", [clingo.Number(10)], False)
self.assertEqual(str(nc4), str(c4))
self.assertEqual(nc4.positive, c4.positive)
self.assertEqual(nc4.negative, c4.negative)
def parallel_plan(self):
"""Planning function for the parallel mode, based on clingo incremental mode
Here no additional inputs are needed"""
prg = clingo.Control(arguments=["-Wnone"])
prg.load(self.encoding)
prg.load(self.instance)
imin = self.get(prg.get_const("imin"), clingo.Number(0))
imax = prg.get_const("imax")
istop = self.get(prg.get_const("istop"), clingo.String("SAT"))
step, ret = 0, None
while ((imax is None or step < imax.number)
and (step == 0 or step < imin.number or
((istop.string == "SAT" and not ret.satisfiable) or
(istop.string == "UNSAT" and not ret.unsatisfiable) or
(istop.string == "UNKNOWN" and not ret.unknown)))):
parts = []
parts.append(("check", [step]))
if step > 0:
prg.release_external(clingo.Function("query", [step - 1]))
parts.append(("step", [step]))
prg.cleanup()
else:
parts.append(("base", []))
prg.ground(parts)
prg.assign_external(clingo.Function("query", [step]), True)
ret, step = prg.solve(on_model=self.get_parallel_plan), step + 1
# save plan length for benchmark output
self.plan_length = step - 1
def test_tuple(self):
nc1 = noclingo.Function("aaaa")
nc2 = noclingo.String("bbb")
c1 = clingo.Function("aaaa")
c2 = clingo.String("bbb")
nc = noclingo.Function("", [nc1, nc2])
c = clingo.Function("", [c1, c2])
def _copy_symbol(self, symbol) -> clingo.Symbol:
if symbol.type == clingo.SymbolType.String:
return clingo.String(symbol.string)
elif symbol.type == clingo.SymbolType.Number:
return clingo.Number(symbol.number)
raise NotImplementedError(
"_copy_symbol for symbol type {}".format(symbol.type)
)
def symbol_of_py(obj):
if isinstance(obj, str):
return asp.String(obj)
elif isinstance(obj, int):
return asp.Number(obj)
elif isinstance(obj, tuple):
return clingo_Tuple([symbol_of_py(o) for o in obj])
return obj
def test_symbol_generator(self):
csg = get_symbol_generator(SymbolMode.CLINGO)
ncsg = get_symbol_generator(SymbolMode.NOCLINGO)
self.assertEqual(csg.mode, SymbolMode.CLINGO)
self.assertEqual(ncsg.mode, SymbolMode.NOCLINGO)
cli = clingo.Infimum
cls = clingo.Supremum
cl1 = clingo.Function("const")
cl2 = clingo.Number(3)
cl3 = clingo.String("No")
cl4 = clingo.Function("", [cl1, cl2])
cl5 = clingo.Function("f", [cl3, cl4, cl1], False)
ncli = noclingo.Infimum
ncls = noclingo.Supremum
ncl1 = noclingo.Function("const")
ncl2 = noclingo.Number(3)
ncl3 = noclingo.String("No")
ncl4 = noclingo.Function("", [ncl1, ncl2])
ncl5 = noclingo.Function("f", [ncl3, ncl4, ncl1], False)
csg_cli = csg.Infimum
csg_cls = csg.Supremum
csg_cl1 = csg.Function("const")
csg_cl2 = csg.Number(3)
csg_cl3 = csg.String("No")
csg_cl4 = csg.Function("", [cl1, cl2])
csg_cl5 = csg.Function("f", [cl3, cl4, cl1], False)
ncsg_ncli = ncsg.Infimum
ncsg_ncls = ncsg.Supremum
ncsg_ncl1 = ncsg.Function("const")
ncsg_ncl2 = ncsg.Number(3)
ncsg_ncl3 = ncsg.String("No")
ncsg_ncl4 = ncsg.Function("", [ncsg_ncl1, ncsg_ncl2])
ncsg_ncl5 = ncsg.Function("f", [ncsg_ncl3, ncsg_ncl4, ncsg_ncl1],
False)
self.assertEqual(cli, csg_cli)
self.assertEqual(cls, csg_cls)
self.assertEqual(cl1, csg_cl1)
self.assertEqual(cl2, csg_cl2)
self.assertEqual(cl3, csg_cl3)
self.assertEqual(cl4, csg_cl4)
self.assertEqual(cl5, csg_cl5)
self.assertEqual(ncli, ncsg_ncli)
self.assertEqual(ncls, ncsg_ncls)
self.assertEqual(ncl1, ncsg_ncl1)
self.assertEqual(ncl2, ncsg_ncl2)
self.assertEqual(ncl3, ncsg_ncl3)
self.assertEqual(ncl4, ncsg_ncl4)
self.assertEqual(ncl5, ncsg_ncl5)
def test_noclingo(self):
from clingo import Control
import clingo
import clorm.noclingo as noclingo
self.assertEqual(clingo.String("blah"), noclingo.String("blah"))
self.assertEqual(clingo.Number(5), noclingo.Number(5))
with self.assertRaises(TypeError) as ctx:
instance = Control()
with self.assertRaises(TypeError) as ctx:
instance = clingo.Control()
def hex2clingo(self, term):
if isinstance(term, ClingoID):
return term.symlit.sym
elif isinstance(term, str):
if term[0] == '"':
ret = clingo.String(term[1:-1])
else:
try:
ret = clingo.parse_term(term)
except:
logging.warning(
"cannot parse external atom term {} with clingo! (creating a string out of it)"
.format(repr(term)))
ret = clingo.String(str(term))
elif isinstance(term, int):
ret = clingo.Number(term)
else:
raise Exception(
"cannot convert external atom term {} to clingo term!".format(
repr(term)))
return ret
def noclingo_to_clingo(nclsym):
if isinstance(nclsym, clingo.Symbol): return nclsym
if nclsym.type == SymbolType.Infimum: return clingo.Infimum
elif nclsym.type == SymbolType.Supremum: return clingo.Supremum
elif nclsym.type == SymbolType.Number: return clingo.Number(nclsym.number)
elif nclsym.type == SymbolType.String: return clingo.String(nclsym.string)
elif nclsym.type != SymbolType.Function:
raise TypeError(("Symbol '{}' ({}) is not of type noclingo.SymbolType."
"Function").format(nclsym, type(nclsym)))
return clingo.Function(
nclsym.name, tuple(noclingo_to_clingo(t) for t in nclsym.arguments),
nclsym.positive)
def hex2clingo(self, term):
if isinstance(term, ClingoID):
return term.symlit.sym
elif isinstance(term, str):
if term[0] == '"':
ret = clingo.String(term[1:-1])
else:
ret = clingo.parse_term(term)
elif isinstance(term, int):
ret = clingo.Number(term)
else:
raise Exception("cannot convert external atom term {} to clingo term!".format(repr(term)))
return ret
def plan(self):
"""Planning function for the sequential mode, based on clingo incremental mode
Additionally adds atoms for which robot and for which orders a plan needs to be found,
and plans of all previous robots are added as input"""
prg = clingo.Control(arguments=["-Wnone"])
prg.load(self.encoding)
prg.load(self.instance)
# which robot is planning
prg.add("base", [],
"planning(robot(" + str(self.current_robot) + ")).")
# which orders need to be planned
for oid in self.assignment[self.current_robot]:
prg.add("base", [], "process(order(" + str(oid) + ")).")
prg.add("base", [], "planLength(" + str(self.plan_length) + ").")
# add plans of all previous robots
if self.current_robot != 1:
for i in range(1, self.current_robot):
for atom in self.plans[i]:
prg.add("base", [], str(atom) + ".")
# incremental solving
imin = self.get(prg.get_const("imin"), clingo.Number(0))
imax = prg.get_const("imax")
istop = self.get(prg.get_const("istop"), clingo.String("SAT"))
step, ret = 0, None
while ((imax is None or step < imax.number)
and (step == 0 or step < imin.number or
((istop.string == "SAT" and not ret.satisfiable) or
(istop.string == "UNSAT" and not ret.unsatisfiable) or
(istop.string == "UNKNOWN" and not ret.unknown)))):
parts = []
parts.append(("check", [step]))
if step > 0:
prg.release_external(clingo.Function("query", [step - 1]))
parts.append(("step", [step]))
prg.cleanup()
else:
parts.append(("base", []))
prg.ground(parts)
prg.assign_external(clingo.Function("query", [step]), True)
ret, step = prg.solve(on_model=self.get_plan), step + 1
if self.debug:
print(str(step - 1))
# save maximum plan length
if self.plan_length < step - 1:
self.plan_length = step - 1
def test_comparison_ops(self):
nc1 = noclingo.Number(34)
nc2 = noclingo.Number(43)
self.assertTrue(nc1 <= nc2)
self.assertTrue(nc1 < nc2)
self.assertTrue(nc2 >= nc1)
self.assertTrue(nc2 > nc1)
nc3 = noclingo.String("abcd")
nc4 = noclingo.String("bcde")
self.assertTrue(nc3 <= nc4)
self.assertTrue(nc3 < nc4)
self.assertTrue(nc4 >= nc3)
self.assertTrue(nc4 > nc3)
nc5 = noclingo.Function("abc", [noclingo.Number(45)])
nc6 = noclingo.Function("abc", [noclingo.String("45")])
c5 = clingo.Function("abc", [clingo.Number(45)])
c6 = clingo.Function("abc", [clingo.String("45")])
if c5 < c6: self.assertTrue(nc5 < nc6)
else: self.assertTrue(nc5 > nc6)
nc7 = noclingo.Function(
"abc",
[noclingo.String("45"), noclingo.Number(5)])
self.assertTrue(nc6 < nc7)
def compare_ordering(a, b):
if noclingo_to_clingo(a) < noclingo_to_clingo(b):
self.assertTrue(a < b)
elif noclingo_to_clingo(b) < noclingo_to_clingo(a):
self.assertTrue(b < a)
else:
self.assertEqual(a, b)
compare_ordering(noclingo.String("1"), noclingo.Number(2))
compare_ordering(noclingo.Number(1), noclingo.String("2"))
compare_ordering(noclingo.String("1"), noclingo.Function("2"))
compare_ordering(noclingo.Function("2"), noclingo.String("1"))
compare_ordering(noclingo.Number(1), noclingo.Function("2"))
compare_ordering(noclingo.Function("1"), noclingo.Number(2))
compare_ordering(noclingo.Infimum, noclingo.Supremum)
compare_ordering(noclingo.Supremum, noclingo.Infimum)
compare_ordering(noclingo.Infimum, noclingo.Number(2))
compare_ordering(noclingo.Infimum, noclingo.String("2"))
compare_ordering(noclingo.Infimum, noclingo.Function("2"))
compare_ordering(noclingo.Supremum, noclingo.Function("2"))
compare_ordering(noclingo.Supremum, noclingo.String("2"))
compare_ordering(noclingo.Supremum, noclingo.Number(2))
def move_right(self, state):
# print(type(state))
cur_pos = re.search("robot_pos\((\d+)\)", state.string).group(1)
end_pos = re.search("end_pos\((\d+)\)", state.string).group(1)
if int(cur_pos) < int(end_pos):
return [
clingo.String(
re.sub(
"robot_pos\((\d+)\)",
f"robot_pos({int(cur_pos)+1})",
state.string,
))
]
return []
def setUp(self):
class Fun(ComplexTerm):
aint = IntegerField()
astr = StringField()
class Tup(ComplexTerm):
aint = IntegerField()
astr = StringField()
class Meta: is_tuple = True
class Afact(Predicate):
aint = IntegerField()
afun = Fun.Field()
class Bfact(Predicate):
astr = StringField()
atup = Tup.Field()
class Cfact(ComplexTerm):
aint = IntegerField()
astr = StringField()
afact1 = Afact(aint=10, afun=Fun(aint=1, astr="a"))
afact2 = Afact(aint=20, afun=Fun(aint=2, astr="b"))
bfact1 = Bfact(astr="aa", atup=Tup(aint=1, astr="a"))
bfact2 = Bfact(astr="bb", atup=Tup(aint=2, astr="b"))
self.allf = [ afact1, bfact1, afact2, bfact2 ]
self.Fun = Fun
self.Tup = Tup
self.Afact = Afact
self.Bfact = Bfact
self.Cfact = Cfact
self.n1 = clingo.Number(60)
self.s1 = clingo.String("aaaa")
self.f1 = clingo.Function("",[self.n1, self.s1])
self.p1 = Cfact(aint=60, astr="aaaa")
self.fb1 = FactBase(facts=[self.p1])
self.str_n1 = '{"clingo.SymbolType": "Number", "number": 60}'
self.str_s1 = '{"clingo.SymbolType": "String", "string": "aaaa"}'
self.str_f1 = '{"clingo.SymbolType": "Function", "name": "cfact", ' \
+ '"arguments": [' + self.str_n1 + ', ' + self.str_s1 + ']' + ', "positive": true}'
self.str_p1 = '{"clorm.Predicate": "Cfact", "raw": ' + self.str_f1 + '}'
self.str_fb1 = '{"clorm.FactBase": [], "facts": ['+ self.str_p1 + ']}'
def test_tuple(self):
nc1 = noclingo.Function("aaaa")
nc2 = noclingo.String("bbb")
c1 = clingo.Function("aaaa")
c2 = clingo.String("bbb")
nc = noclingo.Function("", [nc1, nc2])
c = clingo.Function("", [c1, c2])
self.assertEqual(str(nc), str(c))
# Check that a tuple with a single element is represented correctly
nc_one_tuple = noclingo.Function("", [nc2])
c_one_tuple = clingo.Function("", [c2])
self.assertEqual(str(nc_one_tuple), str(c_one_tuple))
# Check using the convenience Tuple_() function
self.assertEqual(noclingo.Tuple_([nc2]), nc_one_tuple)
self.assertEqual(noclingo.Tuple_([nc1, nc2]), nc)
def test_clingo_to_noclingo(self):
# Converting the Infimum and Supremum
cli = clingo.Infimum
ncli = noclingo.Infimum
cls = clingo.Supremum
ncls = noclingo.Supremum
self.assertEqual(clingo_to_noclingo(cli), ncli)
self.assertEqual(clingo_to_noclingo(cls), ncls)
self.assertEqual(noclingo_to_clingo(ncli), cli)
self.assertEqual(noclingo_to_clingo(ncls), cls)
# Converting simple structures
cl1 = clingo.Function("const")
ncl1 = noclingo.Function("const")
cl2 = clingo.Number(3)
ncl2 = noclingo.Number(3)
cl3 = clingo.String("No")
ncl3 = noclingo.String("No")
self.assertEqual(clingo_to_noclingo(cl1), ncl1)
self.assertEqual(clingo_to_noclingo(cl2), ncl2)
self.assertEqual(clingo_to_noclingo(cl3), ncl3)
self.assertEqual(noclingo_to_clingo(ncl1), cl1)
self.assertEqual(noclingo_to_clingo(ncl2), cl2)
self.assertEqual(noclingo_to_clingo(ncl3), cl3)
# More complex function structures
cl4 = clingo.Function("", [cl1, cl2])
ncl4 = noclingo.Function("", [ncl1, ncl2])
self.assertEqual(clingo_to_noclingo(cl4), ncl4)
self.assertEqual(noclingo_to_clingo(ncl4), cl4)
cl5 = clingo.Function("f", [cl3, cl4, cl1], False)
ncl5 = noclingo.Function("f", [ncl3, ncl4, ncl1], False)
self.assertEqual(clingo_to_noclingo(cl5), ncl5)
self.assertEqual(noclingo_to_clingo(ncl5), cl5)
# If it is already the correct symbol type then no conversion required
self.assertEqual(clingo_to_noclingo(ncl1), ncl1)
self.assertEqual(noclingo_to_clingo(cl1), cl1)
self.assertTrue(clingo_to_noclingo(ncl1) is ncl1)
self.assertTrue(noclingo_to_clingo(cl1) is cl1)
def pour_coffee(self, state):
cur_pos = re.search("robot_pos\((\d+)\)", state.string).group(1)
end_pos = re.search("end_pos\((\d+)\)", state.string).group(1)
if int(cur_pos) < int(end_pos):
cup_state = re.search(f"place\({cur_pos},\w+,cup\((.+?)\)",
state.string).group(1)
wants = re.search(f"place\({cur_pos},(\w+),cup",
state.string).group(1)
if cup_state == "up,empty":
return [
clingo.String(
re.sub(
f"place\({cur_pos},\w+,cup\((.+?)\)",
f"place({cur_pos},{wants},cup(up,coffee)",
state.string,
))
]
return []
def turn_cup_over(self, state):
cur_pos = re.search("robot_pos\((\d+)\)", state.string).group(1)
end_pos = re.search("end_pos\((\d+)\)", state.string).group(1)
if int(cur_pos) < int(end_pos):
cup_state = re.search(f"place\({cur_pos},\w+,cup\((.+?),",
state.string).group(1)
wants = re.search(f"place\({cur_pos},(\w+),cup",
state.string).group(1)
if cup_state == "down":
return [
clingo.String(
re.sub(
f"place\({cur_pos},\w+,cup\((.+?),",
f"place({cur_pos},{wants},cup(up,",
state.string,
))
]
return []
def create_symbol(rep):
"""
Returns the symbolic representation of the given theory term.
Throws an error if rep it is not a valid symbol.
Arguments:
rep -- Theory term to translate.
"""
if rep.type == _clingo.TheoryTermType.Number:
return _clingo.Number(rep.number)
elif rep.type in [_clingo.TheoryTermType.List, _clingo.TheoryTermType.Set]:
raise RuntimeError("invalid symbol: {}".format(rep))
elif rep.type == _clingo.TheoryTermType.Function and rep.name in g_arithmetic_operators:
if len(rep.arguments) == 1:
rhs = create_symbol(rep.arguments[0])
if rep.name == "-":
if rhs.type == _clingo.SymbolType.Number:
return _clingo.Number(-rhs.number)
elif rhs.type == _clingo.SymbolType.Function and len(
rep.name) > 0:
return _clingo.Function(rhs.name, rhs.arguments,
not rhs.positive)
elif len(rep.arguments) == 2:
return _clingo.Number(create_number(rep))
raise RuntimeError("invalid symbol: {}".format(rep))
else:
name = "" if rep.type == _clingo.TheoryTermType.Tuple else rep.name
if name in g_binary_operators or name in g_unary_operators or name in g_tel_operators:
raise RuntimeError("invalid symbol: {}".format(rep))
args = [] if rep.type == _clingo.TheoryTermType.Symbol else rep.arguments
if len(args) == 0:
if name == "#inf":
return _clingo.Infimum
elif name == "#sup":
return _clingo.Supremum
elif len(name) > 1 and name.startswith('"') and name.endswith('"'):
return _clingo.String(name[1:-1])
return _clingo.Function(name, [create_symbol(arg) for arg in args])
def symbol_decoder(obj):
'''A JSON Decoder for clingo.Symbol objects.
Example usage:
symbol = json.loads(json, default=encoder)
Args:
obj: a JSON object
'''
if not isinstance(obj, Mapping): return obj
if "clingo.SymbolType" not in obj: return obj
stype_str = obj["clingo.SymbolType"]
if stype_str == "Infimum": return clingo.Infimum
if stype_str == "Supremum": return clingo.Supremum
if stype_str == "String": return clingo.String(obj["string"])
if stype_str == "Number": return clingo.Number(obj["number"])
if stype_str == "Function":
args = [ symbol_decoder(a) for a in obj["arguments"] ]
positive = obj["positive"]
return clingo.Function(obj["name"], args, positive)
# A bad encoding?
return obj
def test_is_functions(self):
cli = clingo.Infimum
cls = clingo.Supremum
cl1 = clingo.Function("const")
cl2 = clingo.Number(3)
cl3 = clingo.String("No")
cl4 = clingo.Function("", [cl1, cl2])
ncli = noclingo.Infimum
ncls = noclingo.Supremum
ncl1 = noclingo.Function("const")
ncl2 = noclingo.Number(3)
ncl3 = noclingo.String("No")
ncl4 = noclingo.Function("", [ncl1, ncl2])
self.assertTrue(is_Infimum(cli))
self.assertTrue(is_Infimum(ncli))
self.assertTrue(is_Supremum(cls))
self.assertTrue(is_Supremum(ncls))
self.assertTrue(is_Number(cl2))
self.assertTrue(is_Number(ncl2))
self.assertTrue(is_String(cl3))
self.assertTrue(is_String(ncl3))
self.assertTrue(is_Function(cl4))
self.assertTrue(is_Function(ncl4))
self.assertFalse(is_Infimum(cls))
self.assertFalse(is_Supremum(cli))
self.assertFalse(is_Function(cli))
self.assertFalse(is_Number(cli))
self.assertFalse(is_String(cli))
self.assertFalse(is_Supremum(4))
def switch(self, string):
cs = [c for c in string.string if c not in "[,]"]
if len(cs) >= 2:
yield clingo.String(f"[{','.join([cs[1], cs[0]] + cs[2:])}]")
def remove(self, string):
cs = [c for c in string.string if c not in "[,]"]
if len(cs) > 0:
yield clingo.String(f"[{','.join(cs[1:])}]")
