def test_or_check(self):
"""Test the or().check function."""
attribute_foo = Attribute("foo", int, True, "a foo attribute.")
attribute_bar = Attribute("bar", str, True, "a bar attribute.")
data_model_foobar = DataModel("foobar", [attribute_foo, attribute_bar], "A foobar data model.")
description_foobar = Description({"foo": 1, "bar": "baz"}, data_model=data_model_foobar)
constraint = Or([(Constraint("foo", ConstraintType("==", 1))),
(Constraint("bar", ConstraintType("==", "baz")))
])
assert constraint.check(description_foobar)
def build_goods_query(good_pbks: List[str], currency: str,
is_searching_for_sellers: bool) -> Query:
"""
Build buyer or seller search query.
Specifically, build the search query
- to look for sellers if the agent is a buyer, or
- to look for buyers if the agent is a seller.
In particular, if the agent is a buyer and the demanded good public keys are {'tac_good_0', 'tac_good_2', 'tac_good_3'}, the resulting constraint expression is:
tac_good_0 >= 1 OR tac_good_2 >= 1 OR tac_good_3 >= 1
That is, the OEF will return all the sellers that have at least one of the good in the query
(assuming that the sellers are registered with the data model specified).
:param good_pbks: the list of good public keys to put in the query
:param currency: the currency used for pricing and transacting.
:param is_searching_for_sellers: Boolean indicating whether the query is for sellers (supply) or buyers (demand).
:return: the query
"""
data_model = build_goods_datamodel(good_pbks=good_pbks,
is_supply=is_searching_for_sellers)
constraints = [
Constraint(good_pbk, ConstraintType(">=", 1)) for good_pbk in good_pbks
]
constraints.append(Constraint('currency', ConstraintType("==", currency)))
constraint_expr = cast(List[ConstraintExpr], constraints)
if len(good_pbks) > 1:
constraint_expr = [Or(constraint_expr)]
query = Query(constraint_expr, model=data_model)
return query
def build_query(good_pbks: Set[str], is_searching_for_sellers: bool) -> Query:
"""
Build buyer or seller search query.
Specifically, build the search query
- to look for sellers if the agent is a buyer, or
- to look for buyers if the agent is a seller.
In particular, if the agent is a buyer and the demanded good public keys are {'tac_good_0', 'tac_good_2', 'tac_good_3'}, the resulting constraint expression is:
tac_good_0 >= 1 OR tac_good_2 >= 1 OR tac_good_3 >= 1
That is, the OEF will return all the sellers that have at least one of the good in the query
(assuming that the sellers are registered with the data model specified).
:param good_pbks: the good public keys to put in the query
:param is_searching_for_sellers: Boolean indicating whether the query is for sellers (supply) or buyers (demand).
:return: the query
"""
data_model = None if good_pbks is None else build_datamodel(list(good_pbks), is_supply=is_searching_for_sellers)
constraints = [Constraint(good_pbk, GtEq(1)) for good_pbk in good_pbks]
if len(good_pbks) > 1:
constraints = [Or(constraints)]
query = Query(constraints, model=data_model)
return query
def test_query_check(self):
"""Test that the query.check() method works."""
attribute_foo = Attribute("foo", int, True, "a foo attribute.")
attribute_bar = Attribute("bar", str, True, "a bar attribute.")
data_model_foobar = DataModel("foobar", [attribute_foo, attribute_bar], "A foobar data model.")
description_foobar = Description({"foo": 1, "bar": "baz"}, data_model=data_model_foobar)
query = Query([
And([
Or([
Not(Constraint("foo", ConstraintType("==", 1))),
Not(Constraint("bar", ConstraintType("==", "baz")))
]),
Constraint("foo", ConstraintType("<", 2)),
])
],
data_model_foobar)
assert not query.check(description=description_foobar)
def test_query(self):
"""Test that the translation for the Query class works."""
attribute_foo = Attribute("foo", int, True, "a foo attribute.")
attribute_bar = Attribute("bar", str, True, "a bar attribute.")
data_model_foobar = DataModel("foobar", [attribute_foo, attribute_bar], "A foobar data model.")
query = Query([
And([
Or([
Not(Constraint("foo", ConstraintType("==", 1))),
Not(Constraint("bar", ConstraintType("==", "baz")))
]),
Constraint("foo", ConstraintType("<", 2)),
])
], data_model_foobar)
oef_query = OEFObjectTranslator.to_oef_query(query)
expected_query = OEFObjectTranslator.from_oef_query(oef_query)
actual_query = query
assert expected_query == actual_query
def test_pickable_query(self):
"""Test that an istance of the Query class is pickable."""
attribute_foo = Attribute("foo", int, True, "a foo attribute.")
attribute_bar = Attribute("bar", str, True, "a bar attribute.")
data_model_foobar = DataModel("foobar", [attribute_foo, attribute_bar], "A foobar data model.")
query = Query([
And([
Or([
Not(Constraint("foo", ConstraintType("==", 1))),
Not(Constraint("bar", ConstraintType("==", "baz")))
]),
Constraint("foo", ConstraintType("<", 2)),
])
],
data_model_foobar)
try:
pickle.dumps(query)
except Exception:
pytest.fail("Error during pickling.")
def from_oef_constraint_expr(
cls, oef_constraint_expr: OEFConstraintExpr) -> ConstraintExpr:
"""From our query to OEF query."""
if isinstance(oef_constraint_expr, OEFAnd):
return And([
cls.from_oef_constraint_expr(c)
for c in oef_constraint_expr.constraints
])
elif isinstance(oef_constraint_expr, OEFOr):
return Or([
cls.from_oef_constraint_expr(c)
for c in oef_constraint_expr.constraints
])
elif isinstance(oef_constraint_expr, OEFNot):
return Not(
cls.from_oef_constraint_expr(oef_constraint_expr.constraint))
elif isinstance(oef_constraint_expr, OEFConstraint):
return Constraint(oef_constraint_expr.attribute_name,
oef_constraint_expr.constraint)
else:
raise ValueError("OEF Constraint not supported.")