def test_dump_multi_nested(query_factory):
"""Tests dumping a query with multiple nested system entities"""
query_text = "show me houses between 600,000 and 1,000,000 dollars"
query = query_factory.create_query(query_text)
lower = NestedEntity.from_query(query,
Span(8, 14),
parent_offset=15,
entity_type="sys_number")
upper = NestedEntity.from_query(query,
Span(20, 28),
parent_offset=15,
entity_type="sys_number")
raw_entity = Entity(
"between 600,000 dollars and 1,000,000",
"price",
value={"children": [lower, upper]},
)
entities = [QueryEntity.from_query(query, Span(15, 51), entity=raw_entity)]
processed_query = ProcessedQuery(query, entities=entities)
markup_text = ("show me houses {between {600,000|sys_number} and "
"{1,000,000|sys_number} dollars|price}")
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == markup_text
assert markup.dump_query(processed_query, no_entity=True) == query_text
def test_dump_group_with_role(query_factory):
"""Tests dumping a query with an entity group with role type"""
query_text = "a large latte with nonfat milk please"
query = query_factory.create_query(query_text)
size = QueryEntity.from_query(query, Span(2, 6), entity_type="size")
option = QueryEntity.from_query(query,
Span(19, 29),
entity_type="option",
role="beverage")
product = QueryEntity.from_query(
query,
Span(8, 12),
entity_type="dish-type",
role="beverage",
children=(size, option),
)
processed_query = ProcessedQuery(query, entities=[size, product, option])
markup_text = ("a [{large|size} {latte|dish-type|beverage} with "
"{nonfat milk|option|beverage}|dish-type] please")
entity_text = ("a {large|size} {latte|dish-type|beverage} with "
"{nonfat milk|option|beverage} please")
group_text = "a [large latte with nonfat milk|dish-type] please"
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == entity_text
assert (markup.dump_query(processed_query, no_entity=True,
no_role=True) == group_text)
assert (markup.dump_query(processed_query,
no_group=True,
no_entity=True,
no_role=True) == query_text)
def test_dump_entity(query_factory):
"""Tests dumping a basic query with an entity"""
query_text = "When does the Elm Street store close?"
query = query_factory.create_query(query_text)
entities = [QueryEntity.from_query(query, Span(14, 23), entity_type="store_name")]
processed_query = ProcessedQuery(query, entities=entities)
markup_text = "When does the {Elm Street|store_name} store close?"
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_entity=True) == query_text
def test_dump_entities(query_factory):
"""Tests dumping a basic query with two entities"""
query_text = 'When does the Elm Street store close on Monday?'
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(query, Span(14, 23), entity_type='store_name'),
QueryEntity.from_query(query, Span(40, 45), entity_type='sys_time')
]
processed_query = ProcessedQuery(query, entities=entities)
markup_text = 'When does the {Elm Street|store_name} store close on {Monday|sys_time}?'
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_entity=True) == query_text
def test_dump_basic(query_factory):
"""Tests dumping a basic query"""
query_text = "A basic query"
query = query_factory.create_query(query_text)
processed_query = ProcessedQuery(query)
assert markup.dump_query(processed_query) == query_text
def test_dump_groups(query_factory):
"""Tests dumping a query with multiple top level entity groups"""
query_text = (
"Order one large Tesora with medium cream from Philz in Downtown Sunnyvale"
)
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(query, Span(6, 8), entity_type="quantity"),
QueryEntity.from_query(query, Span(10, 14), entity_type="size"),
QueryEntity.from_query(query, Span(16, 21), entity_type="product"),
QueryEntity.from_query(query, Span(28, 33), entity_type="size"),
QueryEntity.from_query(query, Span(35, 39), entity_type="option"),
QueryEntity.from_query(query, Span(46, 50), entity_type="store"),
QueryEntity.from_query(query, Span(55, 72), entity_type="location"),
]
entities[4] = entities[4].with_children((entities[3], ))
entities[2] = entities[2].with_children(
(entities[0], entities[1], entities[4]))
entities[5] = entities[5].with_children((entities[6], ))
processed_query = ProcessedQuery(query, entities=entities)
markup_text = ("Order [{one|quantity} {large|size} {Tesora|product} with "
"[{medium|size} {cream|option}|option]|product] from "
"[{Philz|store} in {Downtown Sunnyvale|location}|store]")
assert markup.dump_query(processed_query) == markup_text
def test_dump_nested(query_factory):
"""Tests dumping a query with a nested system entity"""
query_text = "show me houses under 600,000 dollars"
query = query_factory.create_query(query_text)
nested = NestedEntity.from_query(
query, Span(0, 6), parent_offset=21, entity_type="sys_number"
)
raw_entity = Entity("600,000 dollars", "price", value={"children": [nested]})
entities = [QueryEntity.from_query(query, Span(21, 35), entity=raw_entity)]
processed_query = ProcessedQuery(query, entities=entities)
markup_text = "show me houses under {{600,000|sys_number} dollars|price}"
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == markup_text
assert markup.dump_query(processed_query, no_entity=True) == query_text
def test_dump_group_nested_2(query_factory):
"""Tests dumping a query with nested entity groups"""
query_text = "Can I get one curry sauce with my rice ball with house salad"
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(
query, Span(10, 12), entity_type="sys_number", role="quantity"
),
QueryEntity.from_query(query, Span(14, 24), entity_type="option"),
QueryEntity.from_query(query, Span(34, 59), entity_type="dish"),
]
entities[1] = entities[1].with_children((entities[0],))
entities[2] = entities[2].with_children((entities[1],))
processed_query = ProcessedQuery(query, entities=entities)
markup_text = (
"Can I get [[{one|sys_number|quantity} {curry sauce|option}|option] "
"with my {rice ball with house salad|dish}|dish]"
)
entity_text = (
"Can I get {one|sys_number|quantity} {curry sauce|option} "
"with my {rice ball with house salad|dish}"
)
role_text = (
"Can I get {one|quantity} curry sauce " "with my rice ball with house salad"
)
group_text = (
"Can I get [[one curry sauce|option] "
"with my rice ball with house salad|dish]"
)
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == entity_text
assert (
markup.dump_query(processed_query, no_group=True, no_entity=True) == role_text
)
assert (
markup.dump_query(processed_query, no_entity=True, no_role=True) == group_text
)
assert (
markup.dump_query(processed_query, no_group=True, no_entity=True, no_role=True)
== query_text
)
def test_load_dump_groups_roles(query_factory):
"""Tests that load_query and dump_query are reversible"""
text = (
"Order [{one|sys_number|quantity} {large|size} {Tesora|product|dish} with "
"[{medium|size} {cream|option|addin}|option]|product]")
processed_query = markup.load_query(text, query_factory)
markup_text = markup.dump_query(processed_query)
assert text == markup_text
def test_load_dump_groups(query_factory):
"""Tests that load_query and dump_query are reversible"""
text = ("Order [{one|quantity} {large|size} {Tesora|product} with "
"[{medium|size} {cream|option}|option]|product] from "
"[{Philz|store} in {Downtown Sunnyvale|location}|store]")
processed_query = markup.load_query(text, query_factory)
markup_text = markup.dump_query(processed_query)
assert text == markup_text
def test_dump_group_nested(query_factory):
"""Tests dumping a query with nested entity groups"""
query_text = "Order one large Tesora with medium cream and medium sugar"
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(query, Span(6, 8), entity_type="quantity"),
QueryEntity.from_query(query, Span(10, 14), entity_type="size"),
QueryEntity.from_query(query, Span(16, 21), entity_type="product"),
QueryEntity.from_query(query, Span(28, 33), entity_type="size"),
QueryEntity.from_query(query, Span(35, 39), entity_type="option"),
QueryEntity.from_query(query, Span(45, 50), entity_type="size"),
QueryEntity.from_query(query, Span(52, 56), entity_type="option"),
]
entities[4] = entities[4].with_children((entities[3],))
entities[6] = entities[6].with_children((entities[5],))
entities[2] = entities[2].with_children(
(entities[0], entities[1], entities[4], entities[6])
)
processed_query = ProcessedQuery(query, entities=entities)
markup_text = (
"Order [{one|quantity} {large|size} {Tesora|product} with [{medium|size} "
"{cream|option}|option] and [{medium|size} {sugar|option}|option]|product]"
)
entity_text = (
"Order {one|quantity} {large|size} {Tesora|product} with {medium|size} "
"{cream|option} and {medium|size} {sugar|option}"
)
group_text = (
"Order [one large Tesora with [medium "
"cream|option] and [medium sugar|option]|product]"
)
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == entity_text
assert markup.dump_query(processed_query, no_entity=True) == group_text
assert (
markup.dump_query(processed_query, no_group=True, no_entity=True) == query_text
)
def test_dump_group(query_factory):
"""Tests dumping a query with an entity group"""
query_text = 'a large latte with nonfat milk please'
query = query_factory.create_query(query_text)
size = QueryEntity.from_query(query, Span(2, 6), entity_type='size')
option = QueryEntity.from_query(query, Span(19, 29), entity_type='option')
product = QueryEntity.from_query(query,
Span(8, 12),
entity_type='product',
children=(size, option))
processed_query = ProcessedQuery(query, entities=[size, product, option])
markup_text = "a [{large|size} {latte|product} with {nonfat milk|option}|product] please"
entity_text = "a {large|size} {latte|product} with {nonfat milk|option} please"
group_text = "a [large latte with nonfat milk|product] please"
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == entity_text
assert markup.dump_query(processed_query, no_entity=True) == group_text
assert markup.dump_query(processed_query, no_group=True,
no_entity=True) == query_text
def test_dump_group_nested_2(query_factory):
"""Tests dumping a query with nested entity groups"""
query_text = 'Can I get one curry sauce with my rice ball with house salad'
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(query,
Span(10, 12),
entity_type='sys_number',
role='quantity'),
QueryEntity.from_query(query, Span(14, 24), entity_type='option'),
QueryEntity.from_query(query, Span(34, 59), entity_type='dish')
]
entities[1] = entities[1].with_children((entities[0], ))
entities[2] = entities[2].with_children((entities[1], ))
processed_query = ProcessedQuery(query, entities=entities)
markup_text = (
'Can I get [[{one|sys_number|quantity} {curry sauce|option}|option] '
'with my {rice ball with house salad|dish}|dish]')
entity_text = ('Can I get {one|sys_number|quantity} {curry sauce|option} '
'with my {rice ball with house salad|dish}')
role_text = ('Can I get {one|quantity} curry sauce '
'with my rice ball with house salad')
group_text = ('Can I get [[one curry sauce|option] '
'with my rice ball with house salad|dish]')
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_group=True) == entity_text
assert markup.dump_query(processed_query, no_group=True,
no_entity=True) == role_text
assert markup.dump_query(processed_query, no_entity=True,
no_role=True) == group_text
assert markup.dump_query(processed_query,
no_group=True,
no_entity=True,
no_role=True) == query_text
def test_load_dump_2(query_factory):
"""Tests that load_query and dump_query are reversible"""
text = (
"i'm extra hungry get me a {chicken leg|dish}, [{1|quantity} "
"{kheema nan|dish}|dish] [{2|quantity} regular {nans|dish}|dish] "
"[{one|quantity} {chicken karahi|dish}|dish], [{1|quantity} "
"{saag paneer|dish}|dish] and [{1|quantity} {chicken biryani|dish}|dish]"
)
processed_query = markup.load_query(text, query_factory)
markup_text = markup.dump_query(processed_query)
assert text == markup_text
def test_dump_role(query_factory):
"""Tests dumping a basic query with an entity with a role"""
query_text = "What stores are open between 3 and 5"
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(query,
Span(29, 29),
entity_type="sys_time",
role="open_hours"),
QueryEntity.from_query(query,
Span(35, 35),
entity_type="sys_time",
role="close_hours"),
]
processed_query = ProcessedQuery(query, entities=entities)
markup_text = ("What stores are open between {3|sys_time|open_hours} and "
"{5|sys_time|close_hours}")
entity_text = "What stores are open between {3|sys_time} and {5|sys_time}"
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_role=True) == entity_text
assert (markup.dump_query(processed_query, no_role=True,
no_entity=True) == query_text)
def test_dump_role(query_factory):
"""Tests dumping a basic query with an entity with a role"""
query_text = 'What stores are open between 3 and 5'
query = query_factory.create_query(query_text)
entities = [
QueryEntity.from_query(query,
Span(29, 29),
entity_type='sys_time',
role='open_hours'),
QueryEntity.from_query(query,
Span(35, 35),
entity_type='sys_time',
role='close_hours')
]
processed_query = ProcessedQuery(query, entities=entities)
markup_text = ('What stores are open between {3|sys_time|open_hours} and '
'{5|sys_time|close_hours}')
entity_text = 'What stores are open between {3|sys_time} and {5|sys_time}'
assert markup.dump_query(processed_query) == markup_text
assert markup.dump_query(processed_query, no_role=True) == entity_text
assert markup.dump_query(processed_query, no_role=True,
no_entity=True) == query_text
def queries_to_dict(queries: List) -> List:
"""Convert a list of ProcessedQueries into a list dictionaries.
Args:
queries (List): List of ProcessedQuery objects
Returns:
query_dicts (List): List of queries represented as a dict with the keys
"unannotated_text", "annotated_text", "domain", and "intent".
"""
return [
{
"unannotated_text": query.query.text,
"annotated_text": dump_query(query),
"domain": query.domain,
"intent": query.intent,
}
for query in queries
]
