def test_unify_complex():
assert unify((1, {2: 3}), (1, {2: 3}), {}) == {}
assert unify((1, {2: 3}), (1, {2: 4}), {}) == False
assert unify((1, {2: var(5)}), (1, {2: 4}), {}) == {var(5): 4}
assert unify({1: (2, 3)}, {1: (2, var(5))}, {}) == {var(5): 3}
assert unify({1: [2, 3]}, {1: [2, var(5)]}, {}) == {var(5): 3}
def test_unify_slice():
x = var('x')
y = var('y')
assert unify(slice(1), slice(1), {}) == {}
assert unify(slice(1, 2, 3), x, {}) == {x: slice(1, 2, 3)}
assert unify(slice(1, 2, None), slice(x, y), {}) == {x: 1, y: 2}
def test_unify_slice():
x = var('x')
y = var('y')
assert unify(slice(1), slice(1), {}) == {}
assert unify(slice(1, 2, 3), x, {}) == {x: slice(1, 2, 3)}
assert unify(slice(1, 2, None), slice(x, y), {}) == {x: 1, y: 2}
def test_unify_complex():
assert unify((1, {2: 3}), (1, {2: 3}), {}) == {}
assert unify((1, {2: 3}), (1, {2: 4}), {}) == False
assert unify((1, {2: var(5)}), (1, {2: 4}), {}) == {var(5): 4}
assert unify({1: (2, 3)}, {1: (2, var(5))}, {}) == {var(5): 3}
assert unify({1: [2, 3]}, {1: [2, var(5)]}, {}) == {var(5): 3}
def _cons_unify(lcons, rcons, s):
if not is_cons(lcons) or not is_cons(rcons):
# One of the arguments is necessarily a `ConsPair` object,
# but the other could be an empty iterable, which isn't a
# `cons`-derivable object.
return False
s = unify(car(lcons), car(rcons), s)
if s is not False:
return unify(cdr(lcons), cdr(rcons), s)
return False
def _cons_unify(lcons, rcons, s):
if not is_cons(lcons) or not is_cons(rcons):
# One of the arguments is necessarily a `ConsPair` object,
# but the other could be an empty iterable, which isn't a
# `cons`-derivable object.
return False
s = unify(car(lcons), car(rcons), s)
if s is not False:
return unify(cdr(lcons), cdr(rcons), s)
return False
def test_unify_slice():
x, y = var(), var()
assert unify(slice(1), slice(1), {}) == {}
assert unify(slice(1, 2, 1), slice(2, 2, 1), {}) is False
assert unify(slice(1, 2, 1), slice(x, 2, 1), {x: 2}) is False
assert unify(slice(1, 2, 1), slice(1, 3, 1), {}) is False
assert unify(slice(1, 4, 2), slice(1, 4, 1), {}) is False
assert unify(slice(x), slice(x), {}) == {}
assert unify(slice(1, 2, 3), x, {}) == {x: slice(1, 2, 3)}
assert unify(slice(1, 2, None), slice(x, y), {}) == {x: 1, y: 2}
def test_unify_recursion_limit():
a_lv = var()
b, _ = gen_long_chain("a")
b_var, _ = gen_long_chain(a_lv)
s = unify(b, b_var, {})
assert s[a_lv] == "a"
def test_objects_full():
_unify.add((Foo, Foo, Mapping), _unify_object)
_unify.add((Bar, Bar, Mapping), _unify_object)
_reify.add((Foo, Mapping), _reify_object)
_reify.add((Bar, Mapping), _reify_object)
x, y = var(), var()
assert unify(Foo(1, 2), Bar(1), {}) is False
assert unify(Foo(1, Bar(2)), Foo(1, Bar(x)), {}) == {x: 2}
assert reify(Foo(x, Bar(Foo(y, 3))), {
x: 1,
y: 2
}) == Foo(1, Bar(Foo(2, 3)))
class SubFoo(Foo):
pass
assert unify(Foo(1, 2), SubFoo(1, 2), {}) is False
def test_unify_seq():
x = var()
assert unify([], [], {}) == {}
assert unify([x], [x], {}) == {}
assert unify((1, 2), (1, 2), {}) == {}
assert unify([1, 2], [1, 2], {}) == {}
assert unify((1, 2), (1, 2, 3), {}) is False
assert unify((1, x), (1, 2), {}) == {x: 2}
assert unify((1, x), (1, 2), {x: 3}) is False
a, b, z = var(), var(), var()
assert unify([a, b], x, {x: [z, 1]}) == {x: [z, 1], a: z, b: 1}
def test_unify_isinstance_list():
class Foo2(Foo): pass
x = var('x')
y = var('y')
f, g = Foo2(1, 2), Foo2(x, y)
_unify.add((Foo, Foo, dict), unify_object)
_reify.add((Foo, dict), reify_object)
assert unify(f, g, {})
assert reify(g, {x: 1, y: 2}) == f
def test_unify_freeze():
# These will sometimes be in different orders after conversion to
# `iter`/`list`/`tuple`!
# u = frozenset({("name", a), ("debit", b)})
# v = frozenset({("name", "Bob"), ("debit", 100)})
a, b = var("name"), var("amount")
u = freeze({"name": a, "debit": b})
v = freeze({"name": "Bob", "debit": 100})
assert unify(u, v, {}) == {a: "Bob", b: 100}
def test_unify_dict():
x = var()
assert unify({1: 2}, {1: 2}, {}) == {}
assert unify({1: x}, {1: x}, {}) == {}
assert unify({1: 2}, {1: 3}, {}) is False
assert unify({2: 2}, {1: 2}, {}) is False
assert unify({2: 2, 3: 3}, {1: 2}, {}) is False
assert unify({1: x}, {1: 2}, {}) == {x: 2}
def test_unify_set():
x, y = var(), var()
assert unify(set(), set(), {}) == {}
assert unify({x}, {x}, {}) == {}
assert unify({1, 2}, {1, 2}, {}) == {}
assert unify({1, x}, {1, 2}, {}) == {x: 2}
assert unify({x, 2}, {1, 2}, {}) == {x: 1}
assert unify({1, y, x}, {2, 1}, {x: 2}) is False
def test_unify_complex():
x, y = var(), var()
assert unify((1, {2: 3}), (1, {2: 3}), {}) == {}
assert unify((1, {2: 3}), (1, {2: 4}), {}) is False
assert unify((1, {2: x}), (1, {2: 4}), {}) == {x: 4}
assert unify((1, {
2: x
}), (1, {
2: slice(1, y)
}), {y: 2}) == {
x: slice(1, y),
y: 2
}
assert unify({1: (2, 3)}, {1: (2, x)}, {}) == {x: 3}
assert unify({1: [2, 3]}, {1: [2, x]}, {}) == {x: 3}
def unify_MetaSymbol(u, v, s):
if type(u) != type(v):
return False
if getattr(u, "__all_props__", False):
s = unify(
[getattr(u, slot) for slot in u.__all_props__],
[getattr(v, slot) for slot in v.__all_props__],
s,
)
elif u != v:
return False
if s:
# If these two meta objects unified, and one has a logic
# variable as its base object, consider the unknown base
# object unified by the other's base object (if any).
# This way, the original base objects can be recovered during
# reification (preserving base object equality and such).
if isinstance(u.obj, Var) and v.obj:
s[u.obj] = v.obj
elif isinstance(v.obj, Var) and u.obj:
s[v.obj] = u.obj
return s
def test_unify_dict():
assert unify({1: 2}, {1: 2}, {}) == {}
assert unify({1: 2}, {1: 3}, {}) == False
assert unify({2: 2}, {1: 2}, {}) == False
assert unify({2: 2, 3: 3}, {1: 2}, {}) == False
assert unify({1: var(5)}, {1: 2}, {}) == {var(5): 2}
def test_unify_iter():
x = var()
assert unify([1], (1, )) is False
assert unify((i for i in [1, 2]), [1, 2]) is False
assert unify(iter([1, x]), iter([1, 2])) == {x: 2}
from unification.ranged_variable import RangedVar
from unification.value_space import RealRange
from unification.core import reify, unify
x = RangedVar()
y = RangedVar(range=RealRange([(0,1)]))
print(unify(x, y, {}))
s = {y:2}
y = reify(y, s)
print(y)
print(unify(x, y, s))
print(x, y)
def test_unify_seq():
assert unify((1, 2), (1, 2), {}) == {}
assert unify([1, 2], [1, 2], {}) == {}
assert unify((1, 2), (1, 2, 3), {}) == False
assert unify((1, var(1)), (1, 2), {}) == {var(1): 2}
assert unify((1, var(1)), (1, 2), {var(1): 3}) == False
def test_unify_seq():
assert unify((1, 2), (1, 2), {}) == {}
assert unify([1, 2], [1, 2], {}) == {}
assert unify((1, 2), (1, 2, 3), {}) == False
assert unify((1, var(1)), (1, 2), {}) == {var(1): 2}
assert unify((1, var(1)), (1, 2), {var(1): 3}) == False
def test_unify():
x, y, z = var(), var(), var()
assert unify(x, x, {}) == {}
assert unify(1, 1, {}) == {}
assert unify(1, 2, {}) is False
assert unify(x, 2, {}) == {x: 2}
assert unify(2, x, {}) == {x: 2}
assert unify(2, x, MappingProxyType({})) == {x: 2}
assert unify(x, y, {}) == {x: y}
assert unify(y, x, {}) == {y: x}
assert unify(y, x, {y: x}) == {y: x}
assert unify(x, y, {y: x}) == {y: x}
assert unify(y, x, {x: y}) == {x: y}
assert unify(x, y, {x: y}) == {x: y}
assert unify(y, x, {y: z}) == {y: z, z: x}
assert unify(x, y, {y: z}) == {y: z, x: z}
def test_unifiable():
x = var('x')
f = A(1, 2)
g = A(1, x)
assert unify(f, g, {}) == {x: 2}
assert reify(g, {x: 2}) == f
def test_unifiable_slots():
x = var()
f = Aslot(1, 2)
g = Aslot(1, x)
assert unify(f, g, {}) == {x: 2}
assert reify(g, {x: 2}) == f
def test_unify_set():
x = var('x')
assert unify(set((1, 2)), set((1, 2)), {}) == {}
assert unify(set((1, x)), set((1, 2)), {}) == {x: 2}
assert unify(set((x, 2)), set((1, 2)), {}) == {x: 1}
def test_unify_set():
x = var('x')
assert unify(set((1, 2)), set((1, 2)), {}) == {}
assert unify(set((1, x)), set((1, 2)), {}) == {x: 2}
assert unify(set((x, 2)), set((1, 2)), {}) == {x: 1}
def test_unifiable():
x = var('x')
f = Aslot(1, 2)
g = Aslot(1, x)
assert unify(f, g, {}) == {x: 2}
assert reify(g, {x: 2}) == f
def test_unify_nonstandard_object():
_unify.add((ast.AST, ast.AST, Mapping), _unify_object)
x = var()
assert unify(ast.Num(n=1), ast.Num(n=1), {}) == {}
assert unify(ast.Num(n=1), ast.Num(n=2), {}) is False
assert unify(ast.Num(n=1), ast.Num(n=x), {}) == {x: 1}
def test_unify():
assert unify(1, 1, {}) == {}
assert unify(1, 2, {}) == False
assert unify(var(1), 2, {}) == {var(1): 2}
assert unify(2, var(1), {}) == {var(1): 2}
def test_unify_dict():
assert unify({1: 2}, {1: 2}, {}) == {}
assert unify({1: 2}, {1: 3}, {}) == False
assert unify({2: 2}, {1: 2}, {}) == False
assert unify({1: var(5)}, {1: 2}, {}) == {var(5): 2}
def test_unify():
assert unify(1, 1, {}) == {}
assert unify(1, 2, {}) == False
assert unify(var(1), 2, {}) == {var(1): 2}
assert unify(2, var(1), {}) == {var(1): 2}
