text
stringlengths 43
210
| test
stringlengths 532
6.45k
| imports
stringclasses 2
values | guid
stringlengths 36
36
|
|---|---|---|---|
Add a bikram yoga class to my calendar Saturday at 9am and set an alarm for 7am for that same morning. | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="a bikram yoga class")
data_model.append(data_event_name)
data_event_calendar = EventCalendar(text="my calendar")
data_model.append(data_event_calendar)
data_date_time = DateTime(text="Saturday at 9am")
data_model.append(data_date_time)
data_date_time_alarm = DateTime(text="7am for that same morning")
data_model.append(data_date_time_alarm)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = [
{
"event_name": data_event_name,
"event_calendar": data_event_calendar,
"date_time": data_date_time,
}
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(AlarmEntity)
expected = [{"date_time": data_date_time_alarm}]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 114d4eef-de1d-ae39-83e7-a79f04c72feb |
Get directions to the party's address I have in my calendar and message Samantha to see what I should bring. | # test data
data_model = DataModel(reset=True)
data_destination = Location(text="the party's address I have in my calendar")
data_model.append(data_destination)
data_navigation_direction = NavigationDirectionEntity(destination=data_destination)
data_model.append(data_navigation_direction)
data_recipient = Contact(text="Samantha")
data_model.append(data_recipient)
data_content = Content(text="see what I should bring")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([NavigationDirectionEntity]))
actual = next(iterator, None)
expected = [data_navigation_direction]
response_assertions(expected, actual, test_results)
actual = data_model.get_data(MessageEntity)
expected = [{"recipient": data_recipient, "content": data_content}]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 8b7471f4-ae0b-f59f-5f0a-425068c05d96 |
Set an alarm for 6:30am this Tuesday, and make sure it repeats on Thursday and Saturday too. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="6:30am this Tuesday")
data_model.append(data_date_time)
data_date_time_repeat1 = DateTime(text="Thursday and Saturday", value="Thursday")
data_model.append(data_date_time_repeat1)
data_date_time_repeat2 = DateTime(text="Thursday and Saturday", value="Saturday")
data_model.append(data_date_time_repeat2)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{"date_time": date_time}
for date_time in [
data_date_time,
data_date_time_repeat1,
data_date_time_repeat2,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| e794a80e-b109-162d-579d-f51db6d52e22 |
Play my Intense Workout spotify playlist in the afternoon on Tuesday, Thursday, and Saturday. | # test data
data_model = DataModel(reset=True)
data_playlist = Playlist(text="my Intense Workout spotify playlist")
data_model.append(data_playlist)
data_date_time1 = DateTime(
text="afternoon on Tuesday, Thursday, and Saturday", value="Tuesday"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="afternoon on Tuesday, Thursday, and Saturday", value="Thursday"
)
data_model.append(data_date_time2)
data_date_time3 = DateTime(
text="afternoon on Tuesday, Thursday, and Saturday", value="Saturday"
)
data_model.append(data_date_time3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MusicEntity)
expected = [
{"playlist": data_playlist, "date_time": date_time}
for date_time in [
data_date_time1,
data_date_time2,
data_date_time3,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 91dfde1d-6e00-5e42-2f64-a59776234f1f |
Text everyone in my close friends group a photo of me at the ball game. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="text")
data_model.append(data_message_content_type)
data_recipient1 = Contact(text="everyone in my close friends group", value="John")
data_model.append(data_recipient1)
data_recipient2 = Contact(text="everyone in my close friends group", value="Henry")
data_model.append(data_recipient2)
data_content = Content(text="a photo of me at the ball game")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"content": data_content,
"message_content_type": data_message_content_type,
}
for data_recipient in [
data_recipient1,
data_recipient2,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 95e815d1-541b-f6f3-58cf-ffbe66ab3af0 |
Text everyone in my basketball group list that the referee fees increased by $3. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="text")
data_model.append(data_message_content_type)
data_recipient1 = Contact(text="everyone in my basketball group list", value="John")
data_model.append(data_recipient1)
data_recipient2 = Contact(
text="everyone in my basketball group list", value="Henry"
)
data_model.append(data_recipient2)
data_content = Content(text="the referee fees increased by $3")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"content": data_content,
"message_content_type": data_message_content_type,
}
for data_recipient in [
data_recipient1,
data_recipient2,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 56ad4d4d-eaec-9846-5c41-9b4a8ea7bfc1 |
Add a visit to the lake to my calendar for January 2nd at 3:00 and remind me every day leading up to the day. | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="a visit to the lake")
data_model.append(data_event_name)
data_date_time = DateTime(text="January 2nd at 3:00")
data_model.append(data_date_time)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_date_time_reminder1 = DateTime(
text="every day leading up to the day", value="1"
)
data_model.append(data_date_time_reminder1)
data_date_time_reminder2 = DateTime(
text="every day leading up to the day", value="2"
)
data_model.append(data_date_time_reminder2)
data_date_time_reminder3 = DateTime(
text="every day leading up to the day", value="3"
)
data_model.append(data_date_time_reminder3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = [
{
"date_time": data_date_time,
"event_name": data_event_name,
}
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(ReminderEntity)
expected = [
{
"person_reminded": data_person_reminded,
"date_time": date_time,
}
for date_time in [
data_date_time_reminder1,
data_date_time_reminder2,
data_date_time_reminder3,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| fa755791-d050-9bb0-6ae7-15a2072de724 |
Is there a Laker game on Monday, Wednesday, and Thursday? | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="a Laker game")
data_model.append(data_event_name)
data_date_time1 = DateTime(
text="on Monday, Wednesday, and Thursday", value="Monday"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="on Monday, Wednesday, and Thursday", value="Wednesday"
)
data_model.append(data_date_time2)
data_date_time3 = DateTime(
text="on Monday, Wednesday, and Thursday", value="Thursday"
)
data_model.append(data_date_time3)
data_event1 = EventEntity(event_name=data_event_name, date_time=data_date_time1)
data_model.append(data_event1)
data_event2 = EventEntity(event_name=data_event_name, date_time=data_date_time3)
data_model.append(data_event2)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([EventEntity]))
actual = next(iterator, None)
expected = [data_event1, data_event2]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 5fd38e5f-2b14-765e-1fd4-e398afeec130 |
Is there a Laker game on Monday, Wednesday, and Thursday? | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="a Laker game")
data_model.append(data_event_name)
data_date_time1 = DateTime(
text="on Monday, Wednesday, and Thursday", value="Monday"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="on Monday, Wednesday, and Thursday", value="Wednesday"
)
data_model.append(data_date_time2)
data_date_time3 = DateTime(
text="on Monday, Wednesday, and Thursday", value="Thursday"
)
data_model.append(data_date_time3)
data_date_time_neg = DateTime(text="Friday", value="Friday")
data_model.append(data_date_time_neg)
data_event1 = EventEntity(event_name=data_event_name, date_time=data_date_time_neg)
data_model.append(data_event1)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([EventEntity]))
actual = next(iterator, None)
expected = []
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| fad18dea-96e2-1081-a330-4ae341695005 |
Find directions to three closest Costco stores. | # test data
data_model = DataModel(reset=True)
data_location1 = Location(text="to three Costco stores", closest="100")
data_model.append(data_location1)
data_location2 = Location(text="to three Costco stores", closest="120")
data_model.append(data_location2)
data_location3 = Location(text="to three Costco stores", closest="35")
data_model.append(data_location3)
data_location4 = Location(text="to three Costco stores", closest="2000")
data_model.append(data_location4)
data_location5 = Location(text="to three Costco stores", closest="80")
data_model.append(data_location5)
data_navigation_directions1 = NavigationDirectionEntity(destination=data_location1)
data_model.append(data_navigation_directions1)
data_navigation_directions2 = NavigationDirectionEntity(destination=data_location2)
data_model.append(data_navigation_directions2)
data_navigation_directions3 = NavigationDirectionEntity(destination=data_location3)
data_model.append(data_navigation_directions3)
data_navigation_directions4 = NavigationDirectionEntity(destination=data_location4)
data_model.append(data_navigation_directions4)
data_navigation_directions5 = NavigationDirectionEntity(destination=data_location5)
data_model.append(data_navigation_directions5)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([NavigationDirectionEntity]))
actual = next(iterator, None)
expected = [
data_navigation_directions1,
data_navigation_directions2,
data_navigation_directions4,
]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 2a2b47bf-21a3-72f2-67de-ccbb420567f3 |
Buy cauliflower and broccoli online at the grocery store and have them shipped every 15th of the month. | # test data
data_model = DataModel(reset=True)
data_product_name1 = ProductName(
text="cauliflower and broccoli", value="cauliflower"
)
data_model.append(data_product_name1)
data_product_name2 = ProductName(text="cauliflower and broccoli", value="broccoli")
data_model.append(data_product_name2)
data_location = Location(text="the grocery store")
data_model.append(data_location)
data_date_time1 = DateTime(text="every 15th of the month", value="1/15")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="every 15th of the month", value="2/15")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="every 15th of the month", value="3/15")
data_model.append(data_date_time3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = []
for data_product_name in [data_product_name1, data_product_name2]:
for data_date_time in [data_date_time1, data_date_time2, data_date_time3]:
expected.append(
{
"product_name": data_product_name,
"location": data_location,
"date_time": data_date_time,
}
)
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 50336bc6-87eb-161e-e9fb-0ddb8cf2b7e6 |
Set an alarm for every 3 hours starting at 2 am and stopping at 10 pm. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="every 3 hours starting at 2 am", value="2am")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="every 3 hours starting at 2 am", value="5am")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="every 3 hours starting at 2 am", value="8am")
data_model.append(data_date_time3)
data_date_time4 = DateTime(text="every 3 hours starting at 2 am", value="11am")
data_model.append(data_date_time4)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = []
for data_date_time in [
data_date_time1,
data_date_time2,
data_date_time3,
data_date_time4,
]:
expected.append(
{
"date_time": data_date_time,
}
)
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3fcfb99e-c010-d4a8-ba36-4f43169465d9 |
Set a date reminder 30 days from now and remind me daily of the upcoming date. | # test data
data_model = DataModel(reset=True)
data_date_time30 = DateTime(text="30 days from now")
data_model.append(data_date_time30)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_date_time1 = DateTime(text="daily", value="day 1")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="daily", value="day 2")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="daily", value="day 3")
data_model.append(data_date_time3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"date_time": data_date_time30,
}
] + [
{
"person_reminded": data_person_reminded,
"date_time": data_date_time,
"content": Content(value=reminder),
}
for data_date_time in [
data_date_time1,
data_date_time2,
data_date_time3,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| b3c0730c-f3f5-0613-e405-61e67c871fdb |
Is there a Radiohead concert in August, October, or November? | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="a Radiohead concert")
data_model.append(data_event_name)
data_date_time1 = DateTime(text="August, October, or November", value="August")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="August, October, or November", value="October")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="August, October, or November", value="November")
data_model.append(data_date_time3)
data_date_time4 = DateTime(text="December", value="December")
data_model.append(data_date_time4)
data_event1 = EventEntity(event_name=data_event_name, date_time=data_date_time2)
data_model.append(data_event1)
data_event2 = EventEntity(event_name=data_event_name, date_time=data_date_time3)
data_model.append(data_event2)
data_event_neg = EventEntity(event_name=data_event_name, date_time=data_date_time4)
data_model.append(data_event_neg)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([EventEntity]))
actual = next(iterator, None)
expected = [data_event1, data_event2]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 536fb693-4062-440c-464c-a2eef82b0be8 |
Check the email to see that I received an email from Bob and reply to him. | # test data
data_model = DataModel(reset=True)
data_recipient = Contact(text="I")
data_model.append(data_recipient)
data_message_content_type = MessageContentType(text="the email")
data_model.append(data_message_content_type)
data_sender = Contact(text="Bob")
data_model.append(data_sender)
data_sender_neg = Contact(text="Joe")
data_model.append(data_sender_neg)
data_message = MessageEntity(
recipient=data_recipient,
message_content_type=data_message_content_type,
sender=data_sender,
)
data_model.append(data_message)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"recipient": data_recipient,
"sender": data_sender,
},
{
"message_content_type": data_message_content_type,
"recipient": data_sender,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 01f51895-d4a1-91db-add7-737720cd3043 |
Check the email to see that I received an email from Bob and reply to him. | # test data
data_model = DataModel(reset=True)
data_recipient = Contact(text="I")
data_model.append(data_recipient)
data_message_content_type = MessageContentType(text="the email")
data_model.append(data_message_content_type)
data_sender = Contact(text="Bob")
data_model.append(data_sender)
data_sender_neg = Contact(text="Joe")
data_model.append(data_sender_neg)
data_message = MessageEntity(
recipient=data_recipient,
message_content_type=data_message_content_type,
sender=data_sender_neg,
)
data_model.append(data_message)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"recipient": data_recipient,
"sender": data_sender_neg,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 9921caad-cf00-ec7d-4735-d7c63f32a04b |
Check what the temperature is right now and set a reminder for me to grab my jacket. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="right now")
data_model.append(data_date_time)
data_temperature = WeatherTemperature(text="above 90")
data_model.append(data_temperature)
data_weather_forecast = WeatherForecastEntity(
date_time=data_date_time, weather_temperature=data_temperature
)
data_model.append(data_weather_forecast)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_content = Content(text="grab my jacket")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([WeatherForecastEntity]))
actual = next(iterator, None)
expected = [data_weather_forecast]
response_assertions(expected, actual, test_results)
actual = data_model.get_data(ReminderEntity)
expected = [
{
"person_reminded": data_person_reminded,
"content": data_content,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 06349be7-0bd2-d5dd-98d3-6b9b8dba0a05 |
Check mail to check that Gemma messaged me and send a reply to her that I am doing ok. | # test data
data_model = DataModel(reset=True)
data_sender = Contact(text="Gemma")
data_model.append(data_sender)
data_recipient = Contact(text="me")
data_model.append(data_recipient)
data_message = MessageEntity(sender=data_sender, recipient=data_recipient)
data_model.append(data_message)
data_content = Content(text="I am doing ok")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"sender": data_sender,
},
{
"recipient": data_sender,
"content": data_content,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| f840f27e-91cd-02c5-6063-6d956dda5aa1 |
Check mail to check that Gemma messaged me and send a reply to her that I am doing ok. | # test data
data_model = DataModel(reset=True)
data_sender = Contact(text="Gemma")
data_model.append(data_sender)
data_sender_neg = Contact(text="Bono")
data_model.append(data_sender_neg)
data_recipient = Contact(text="me")
data_model.append(data_recipient)
data_message = MessageEntity(sender=data_sender_neg, recipient=data_recipient)
data_model.append(data_message)
data_content = Content(text="I am doing ok")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"sender": data_sender_neg,
"recipient": data_recipient,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 8eaa3b2a-77f8-0b9e-d9bf-268d1dd53f67 |
Play music at 3AM and play music again at 4AM. | # test data
data_model = DataModel(reset=True)
data_date_time3 = DateTime(text="at 3AM")
data_model.append(data_date_time3)
data_date_time4 = DateTime(text="at 4AM")
data_model.append(data_date_time4)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MusicEntity)
expected = [
{
"date_time": data_date_time,
}
for data_date_time in [data_date_time3, data_date_time4]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| ae1e7198-bc30-74ff-1b2e-9ff520c30bc1 |
Add Nutpods and coffee to my shopping list and email mom to ask her to stop by for coffee any day this week. | # test data
data_model = DataModel(reset=True)
data_product_name1 = ProductName(text="Nutpods and coffee", value="Nutpods")
data_model.append(data_product_name1)
data_product_name2 = ProductName(text="Nutpods and coffee", value="coffee")
data_model.append(data_product_name2)
data_shopping_list_name = ShoppingListName(text="my shopping list")
data_model.append(data_shopping_list_name)
data_message_content_type = MessageContentType(text="email")
data_model.append(data_message_content_type)
data_recipient = Contact(text="mom")
data_model.append(data_recipient)
data_content = Content(text="ask her to stop by for coffee any day this week")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ShoppingListEntity)
expected = [
{
"shopping_list_name": data_shopping_list_name,
"product_name": data_product_name,
}
for data_product_name in [data_product_name1, data_product_name2]
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"content": data_content,
"message_content_type": data_message_content_type,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| fd937516-49ac-3ea8-f877-2ba49c8c1fe0 |
Find the closest Walmart and get directions to there. | # test data
data_model = DataModel(reset=True)
data_location1 = Location(
text="the closest Walmart", value="Walmart midtown", closest=120
)
data_model.append(data_location1)
data_location2 = Location(
text="the closest Walmart", value="Walmart downtown", closest=35
)
data_model.append(data_location2)
data_location3 = Location(
text="the closest Walmart", value="Walmart uptown", closest=100
)
data_model.append(data_location3)
data_navigation_direction1 = NavigationDirectionEntity(destination=data_location1)
data_model.append(data_navigation_direction1)
data_navigation_direction2 = NavigationDirectionEntity(destination=data_location2)
data_model.append(data_navigation_direction2)
data_navigation_direction3 = NavigationDirectionEntity(destination=data_location3)
data_model.append(data_navigation_direction3)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([NavigationDirectionEntity]))
actual = next(iterator, None)
expected = [data_navigation_direction2]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 74cbd2c2-15c2-c13c-4b61-10ada96de889 |
See reminders and delete all reminders that are old. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="old")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="new")
data_model.append(data_date_time_neg)
reminder1 = ReminderEntity(date_time=data_date_time)
data_model.append(reminder1)
reminder2 = ReminderEntity(date_time=data_date_time_neg)
data_model.append(reminder2)
reminder3 = ReminderEntity(date_time=data_date_time)
data_model.append(reminder3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"date_time": data_date_time_neg,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 717b2f3d-8816-8305-4909-7908c134e172 |
Check there are messages from Jane and reply to her messages with "I am busy!" | # test data
data_model = DataModel(reset=True)
data_sender = Contact(text="Jane")
data_model.append(data_sender)
data_message1 = MessageEntity(sender=data_sender)
data_model.append(data_message1)
data_message2 = MessageEntity(sender=data_sender)
data_model.append(data_message2)
data_content = Content(text="I am busy!")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"sender": data_sender,
},
{
"sender": data_sender,
},
{
"recipient": data_sender,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| d9c2ee4f-7df3-f92d-0200-312c8c36181d |
Check there are messages from Jane and reply to her messages with "I am busy!" | # test data
data_model = DataModel(reset=True)
data_sender = Contact(text="Jane")
data_model.append(data_sender)
data_sender_neg = Contact(text="Carla")
data_model.append(data_sender_neg)
data_message1 = MessageEntity(sender=data_sender_neg)
data_model.append(data_message1)
data_message2 = MessageEntity(sender=data_sender_neg)
data_model.append(data_message2)
data_content = Content(text="I am busy!")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"sender": data_sender_neg,
},
{
"sender": data_sender_neg,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| aeeabe75-a2b0-ddf3-a64f-f5e3916d148f |
Check that I received a mail from Jason or cancel my meeting later. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="a mail")
data_model.append(data_message_content_type)
data_sender = Contact(text="Jason")
data_model.append(data_sender)
data_sender_neg = Contact(text="Carla")
data_model.append(data_sender_neg)
data_message1 = MessageEntity(sender=data_sender)
data_model.append(data_message1)
data_message2 = MessageEntity(sender=data_sender_neg)
data_model.append(data_message2)
data_event_name = EventName(text="my meeting")
data_model.append(data_event_name)
data_date_time = DateTime(text="later")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="now")
data_model.append(data_date_time_neg)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time)
data_model.append(data_event)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time_neg)
data_model.append(data_event)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = [
{"event_name": data_event_name, "date_time": data_date_time},
{"event_name": data_event_name, "date_time": data_date_time_neg},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 8afbd3ee-3a9b-2d80-dbf8-f8a169610c43 |
Check that I received a mail from Jason or cancel my meeting later. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="a mail")
data_model.append(data_message_content_type)
data_sender = Contact(text="Jason")
data_model.append(data_sender)
data_sender_neg = Contact(text="Carla")
data_model.append(data_sender_neg)
data_message1 = MessageEntity(sender=data_sender_neg)
data_model.append(data_message1)
data_message2 = MessageEntity(sender=data_sender_neg)
data_model.append(data_message2)
data_event_name = EventName(text="my meeting")
data_model.append(data_event_name)
data_date_time = DateTime(text="later")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="now")
data_model.append(data_date_time_neg)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time)
data_model.append(data_event)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time_neg)
data_model.append(data_event)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = [
{"event_name": data_event_name, "date_time": data_date_time_neg},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 8b32434d-ec46-8160-1d5b-dd404cb72c27 |
Set navigation for walking to the park, show me how long it took me to get there. | # test data
data_model = DataModel(reset=True)
data_nav_travel_method = NavigationTravelMethod(text="by walking")
data_model.append(data_nav_travel_method)
data_destination = Location(text="to the park")
data_model.append(data_destination)
data_navigation_direction = NavigationDirectionEntity(
nav_travel_method=data_nav_travel_method, destination=data_destination
)
data_model.append(data_navigation_direction)
data_navigation_duration = NavigationDurationEntity(
nav_travel_method=data_nav_travel_method, destination=data_destination
)
data_model.append(data_navigation_duration)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([NavigationDirectionEntity]))
actual = next(iterator, None)
expected = [data_navigation_direction]
response_assertions(expected, actual, test_results)
iterator = iter(data_model.get_response([NavigationDurationEntity]))
actual = next(iterator, None)
expected = [data_navigation_duration]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 04f1241e-d2b1-b531-c2c8-53ce1eeff952 |
Message Jessica to see what time she can go to the movies Saturday and get tickets for any horror movie playing at that time. | # test data
data_model = DataModel(reset=True)
data_recipient = Contact(text="Jessica")
data_model.append(data_recipient)
data_content = Content(text="see what time she can go to the movies Saturday")
data_model.append(data_content)
data_event_name1 = EventName(
text="any horror movie playing", value="Nightmare on Elm Street"
)
data_model.append(data_event_name1)
data_event_name2 = EventName(text="any horror movie playing", value="Hostel")
data_model.append(data_event_name2)
data_date_time = DateTime(text="at that time")
data_model.append(data_date_time)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{"recipient": data_recipient, "content": data_content},
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(EventTicketEntity)
expected = [
{"event_name": data_event_name1, "date_time": data_date_time},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| aee544ce-ddfe-7ab6-9a02-f82bdf8ce6ea |
Is it going to be cold on Tue, Wed at 5 PM? | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="cold")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="hot")
data_model.append(data_weather_attribute_neg)
data_date_time1 = DateTime(text="on Tue, Wed at 5 PM", value="Tuesday")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="on Tue, Wed at 5 PM", value="Wednesday")
data_model.append(data_date_time2)
data_weather_forecast1 = WeatherForecastEntity(
weather_attribute=data_weather_attribute, date_time=data_date_time1
)
data_model.append(data_weather_forecast1)
data_weather_forecast2 = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg, date_time=data_date_time2
)
data_model.append(data_weather_forecast2)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([WeatherForecastEntity]))
actual = next(iterator, None)
expected = [data_weather_forecast1]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| bcf814ab-4150-6290-ab1b-8158ebda6ee6 |
Search for pillows on Amazon under $40, show me the highest rated one. | # test data
data_model = DataModel(reset=True)
data_product_name = ProductName(text="pillows")
data_model.append(data_product_name)
data_location = Location(text="on Amazon")
data_model.append(data_location)
data_location_neg = Location(text="Target")
data_model.append(data_location_neg)
data_product_attribute = ProductAttribute(text="under $40")
data_model.append(data_product_attribute)
data_product1 = ProductEntity(
product_name=data_product_name,
location=data_location,
product_attribute=data_product_attribute,
rated=1,
)
data_model.append(data_product1)
data_product2 = ProductEntity(
product_name=data_product_name,
location=data_location,
product_attribute=data_product_attribute,
rated=10,
)
data_model.append(data_product2)
data_product3 = ProductEntity(
product_name=data_product_name,
location=data_location_neg,
product_attribute=data_product_attribute,
rated=100,
)
data_model.append(data_product3)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response(ProductEntity))
actual = next(iterator, None)
expected = data_product1
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| cfa2ed2a-ac6d-61f4-4ca9-cba73e1e8946 |
Remind me of the ball game later on, set a reminder every 30 minutes before the game. | # test data
data_model = DataModel(reset=True)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_content = Content(text="of the ball game later on")
data_model.append(data_content)
data_date_time1 = DateTime(text="every 30 minutes before the game", value="16:30")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="every 30 minutes before the game", value="17:00")
data_model.append(data_date_time2)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"person_reminded": data_person_reminded,
"content": data_content,
"date_time": data_date_time,
}
for data_date_time in [data_date_time1, data_date_time2]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| acf1fffc-01dc-0193-aa07-d0b1de723c29 |
Set a reminder every weekday at 5PM to take the bus home. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="every weekday at 5PM", value="17:00 Mon")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="every weekday at 5PM", value="17:00 Tue")
data_model.append(data_date_time2)
data_content = Content(text="take the bus home")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"content": data_content,
"date_time": data_date_time,
}
for data_date_time in [data_date_time1, data_date_time2]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| e54183e2-a040-e6c0-9e61-eb22d542e3d5 |
Set an alarm the day before each of my appointments in May, June, July. | # test data
data_model = DataModel(reset=True)
data_event_name1 = EventName(text="each of my appointments", value="A")
data_model.append(data_event_name1)
data_event_name2 = EventName(text="each of my appointments", value="B")
data_model.append(data_event_name2)
data_date_time1 = DateTime(text="in May, June, July", value="May")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="in May, June, July", value="June")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="in May, June, July", value="July")
data_model.append(data_date_time3)
data_event1 = EventEntity(event_name=data_event_name1, date_time=data_date_time2)
data_model.append(data_event1)
data_event2 = EventEntity(event_name=data_event_name2, date_time=data_date_time1)
data_model.append(data_event2)
data_date_time_event1 = DateTime(value=data_event1)
data_model.append(data_date_time_event1)
data_date_time_event2 = DateTime(value=data_event2)
data_model.append(data_date_time_event2)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{
"date_time": data_date_time,
}
# for data_date_time in [data_date_time_event1, data_date_time_event2]
for data_date_time in [data_date_time1, data_date_time2]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3a2dc677-d8e8-5ac8-5654-1744e288d504 |
Set timer to wake me up in 3 hours at 5, 6, 7 AM. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="in 3 hours at 5, 6, 7 AM", value="5:00")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="in 3 hours at 5, 6, 7 AM", value="6:00")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="in 3 hours at 5, 6, 7 AM", value="7:00")
data_model.append(data_date_time3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(TimerEntity)
expected = [
{
"date_time": data_date_time,
}
for data_date_time in [data_date_time1, data_date_time2, data_date_time3]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 2fcc820f-c1d9-5b1e-8a3a-219c7e3689bb |
Set an alarm to remind me of my meeting at 4 PM between 5PM every 10 minutes. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(
text="at 4 PM between 5PM every 10 minutes", value="16:00"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="at 4 PM between 5PM every 10 minutes", value="16:10"
)
data_model.append(data_date_time2)
data_date_time3 = DateTime(
text="at 4 PM between 5PM every 10 minutes", value="16:20"
)
data_model.append(data_date_time3)
data_date_time4 = DateTime(
text="at 4 PM between 5PM every 10 minutes", value="16:30"
)
data_model.append(data_date_time4)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{
"date_time": data_date_time,
}
for data_date_time in [
data_date_time1,
data_date_time2,
data_date_time3,
data_date_time4,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 19a448c0-1aa2-e7d5-5979-473b647e2824 |
Set navigation to the the airport, text Susie I will meet her there at 8 a.m. | # test data
data_model = DataModel(reset=True)
data_destination = Location(text="the airport")
data_model.append(data_destination)
data_navigation_direction = NavigationDirectionEntity(destination=data_destination)
data_model.append(data_navigation_direction)
data_recipient = Contact(text="Susie")
data_model.append(data_recipient)
data_content = Content(text="I will meet her there at 8 a.m")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([NavigationDirectionEntity]))
actual = next(iterator, None)
expected = [data_navigation_direction]
response_assertions(expected, actual, test_results)
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 14bb99f8-1147-d270-5f53-a1d75337b2ec |
Blast music at 5AM, 6AM, 7AM until I wake up | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="at 5AM, 6AM, 7AM", value="5Am")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="at 5AM, 6AM, 7AM", value="6Am")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="at 5AM, 6AM, 7AM", value="7Am")
data_model.append(data_date_time3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MusicEntity)
expected = [
{
"date_time": data_date_time,
}
for data_date_time in [data_date_time1, data_date_time2, data_date_time3]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 2a79f141-2094-5873-482b-7823caabe2fc |
Check that it's hot on Tues, Weds, Thu and set a reminder for the zoo on any day it's hot. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="hot")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="cold")
data_model.append(data_weather_attribute_neg)
data_date_time1 = DateTime(text="on Tues, Weds, Thu", value="Tuesday")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="on Tues, Weds, Thu", value="Wedneday")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="on Tues, Weds, Thu", value="Thursday")
data_model.append(data_date_time3)
data_weather_forecast1 = WeatherForecastEntity(
date_time=data_date_time1, weather_attribute=data_weather_attribute_neg
)
data_model.append(data_weather_forecast1)
data_weather_forecast2 = WeatherForecastEntity(
date_time=data_date_time2, weather_attribute=data_weather_attribute
)
data_model.append(data_weather_forecast2)
data_weather_forecast3 = WeatherForecastEntity(
date_time=data_date_time3, weather_attribute=data_weather_attribute
)
data_model.append(data_weather_forecast3)
# data_date_time1 = DateTime(value=data_weather_forecast1)
# data_model.append(data_date_time1)
# data_date_time2 = DateTime(value=data_weather_forecast2)
# data_model.append(data_date_time2)
# data_date_time3 = DateTime(value=data_weather_forecast3)
# data_model.append(data_date_time3)
data_content = Content(text="the zoo")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([WeatherForecastEntity]))
actual = next(iterator, None)
expected = [data_weather_forecast2, data_weather_forecast3]
response_assertions(expected, actual, test_results)
actual = data_model.get_data(ReminderEntity)
expected = [
{
"content": data_content,
"date_time": data_date_time,
}
for data_date_time in [data_date_time2, data_date_time3]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 752ae7bd-bb96-bf25-280b-55990570beab |
Order 1 green beans, 2 chickens, and broth from the store. | # test data
data_model = DataModel(reset=True)
data_product_name1 = ProductName(
text="1 green beans, 2 chickens, and broth", value="1 green beans"
)
data_model.append(data_product_name1)
data_product_name2 = ProductName(
text="1 green beans, 2 chickens, and broth", value="2 chickens"
)
data_model.append(data_product_name2)
data_product_name3 = ProductName(
text="1 green beans, 2 chickens, and broth", value="broth"
)
data_model.append(data_product_name3)
data_location = Location(text="the store")
data_model.append(data_location)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = [
{
"product_name": data_product_name,
"location": data_location,
}
for data_product_name in [
data_product_name1,
data_product_name2,
data_product_name3,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 2952aeca-0fe1-5cf3-10ed-e96c437acb94 |
Set alarm in 30 minutes and repeat alarm every 40 minutes for the next 2 hours. | # test data
data_model = DataModel(reset=True)
data_date_time0 = DateTime(text="in 30 minutes")
data_model.append(data_date_time0)
data_date_time1 = DateTime(
text="every 40 minutes for the next 2 hours", value="02:40"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="every 40 minutes for the next 2 hours", value="03:20"
)
data_model.append(data_date_time2)
data_date_time3 = DateTime(
text="every 40 minutes for the next 2 hours", value="03:40"
)
data_model.append(data_date_time3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{
"date_time": data_date_time,
}
for data_date_time in [
data_date_time0,
data_date_time1,
data_date_time2,
data_date_time3,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 5f1cd7c3-fb68-ae7c-679f-8c3396661067 |
Remind me on the 10th to reserve airline tickets and message Ashleigh with the confirmation. | # test data
data_model = DataModel(reset=True)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_date_time = DateTime(text="the 10th")
data_model.append(data_date_time)
data_content = Content(
text="reserve airline tickets and message Ashleigh with the confirmation"
)
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"person_reminded": data_person_reminded,
"date_time": data_date_time,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3be76cc0-16a8-c850-6619-56c5f71d14c6 |
Will there be any free events downtown this weekend or next weekend? | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="free events")
data_model.append(data_event_name)
data_location = Location(text="downtown")
data_model.append(data_location)
data_date_time1 = DateTime(
text="this weekend or next weekend", value="this weekend"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="this weekend or next weekend", value="next weekend"
)
data_model.append(data_date_time2)
data_event = EventEntity(
event_name=data_event_name, location=data_location, date_time=data_date_time2
)
data_model.append(data_event)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([EventEntity]))
actual = next(iterator, None)
expected = [data_event]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| baab3401-8148-3924-63ef-4c49b5a92440 |
Set the alarm at 6 a.m. should it be a rainy day. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="at 6 a.m.")
data_model.append(data_date_time)
data_weather_attribute = WeatherAttribute(text="a rainy day")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="sunny")
data_model.append(data_weather_attribute_neg)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute
)
data_model.append(data_weather_forecast)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{
"date_time": data_date_time,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3391f3b4-5039-4209-a4d6-951673361f2b |
Set the alarm at 6 a.m. should it be a rainy day. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="at 6 a.m.")
data_model.append(data_date_time)
data_weather_attribute = WeatherAttribute(text="a rainy day")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="sunny")
data_model.append(data_weather_attribute_neg)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg
)
data_model.append(data_weather_forecast)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| fc3e5a4d-f197-0f41-579a-0533d82fd2f8 |
Check my calendar to see what time the board meeting is on Wednesday and set an alarm when the meeting is supposed to start. | # test data
data_model = DataModel(reset=True)
data_event_calendar = EventCalendar(text="my calendar")
data_model.append(data_event_calendar)
data_event_name = EventName(text="the board meeting")
data_model.append(data_event_name)
data_date_time = DateTime(text="on Wednesday")
data_model.append(data_date_time)
data_event = EventEntity(
event_calendar=data_event_calendar,
event_name=data_event_name,
date_time=data_date_time,
)
data_model.append(data_event)
# data_date_time_alarm = DateTime(
# # text="30 minutes before the meeting is supposed to start",
# value=[data_event]
# )
# data_model.append(data_date_time_alarm)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{
"date_time": data_date_time,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 1b4a364f-76e9-fa80-7351-6100ed65590c |
Move any text messages that mention dinner and are between two weeks and one month old to the trash folder. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="text messages")
data_model.append(data_message_content_type)
data_content = Content(text="mention dinner")
data_model.append(data_content)
data_content_neg = Content(text="breakfast")
data_model.append(data_content_neg)
data_date_time1 = DateTime(
text="between two weeks and one month old", value="3 weeks"
)
data_model.append(data_date_time1)
data_date_time2 = DateTime(
text="between two weeks and one month old", value="4 weeks"
)
data_model.append(data_date_time2)
data_message1 = MessageEntity(
message_content_type=data_message_content_type,
content=data_content,
date_time=data_date_time1,
)
data_model.append(data_message1)
data_message2 = MessageEntity(
message_content_type=data_message_content_type,
content=data_content,
date_time=data_date_time2,
)
data_model.append(data_message2)
data_message3 = MessageEntity(
message_content_type=data_message_content_type,
content=data_content_neg,
date_time=data_date_time2,
)
data_model.append(data_message3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"content": data_content_neg,
"date_time": data_date_time2,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 19187dc9-8dce-52fa-4c4e-8e05b341a9b7 |
Purchase tickets for the NFL game Friday and text all my friends that I am going to be busy that day. | # test data
data_model = DataModel(reset=True)
data_event_name = EventName(text="the NFL game")
data_model.append(data_event_name)
data_date_time = DateTime(text="Friday")
data_model.append(data_date_time)
data_message_content_type = MessageContentType(text="text")
data_model.append(data_message_content_type)
data_contact1 = Contact(text="all my friends", value="John")
data_model.append(data_contact1)
data_contact2 = Contact(text="all my friends", value="Abigail")
data_model.append(data_contact2)
data_content = Content(text="I am going to be busy that day")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventTicketEntity)
expected = [
{
"event_name": data_event_name,
"date_time": data_date_time,
}
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"content": data_content,
}
for data_recipient in [
data_contact1,
data_contact2,
]
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 9a15f42d-1c52-4c30-6eb9-1c3df1216db2 |
Check my email to see whether Soeurette has RSVPed for this evening's party; assuming she's planning to come, send her the directions to the venue. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="my email")
data_model.append(data_message_content_type)
data_sender = Contact(text="Soeurette")
data_model.append(data_sender)
data_sender_neg = Contact(text="Sam")
data_model.append(data_sender_neg)
data_content = Content(text="has RSVPed for this evening's party")
data_model.append(data_content)
data_content_neg = Content(text="decline")
data_model.append(data_content_neg)
data_message1 = MessageEntity(
message_content_type=data_message_content_type,
sender=data_sender,
content=data_content,
)
data_model.append(data_message1)
data_message2 = MessageEntity(
message_content_type=data_message_content_type,
sender=data_sender_neg,
content=data_content_neg,
)
data_model.append(data_message2)
data_destination = Location(text="the venue")
data_model.append(data_destination)
data_content_directions = Content()
data_model.append(data_content_directions)
data_navigation_direction = NavigationDirectionEntity(destination=data_destination, data_content_directions=data_content_directions)
data_model.append(data_navigation_direction)
# data_content_directions = Content(value=[data_navigation_direction])
# data_model.append(data_content_directions)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"sender": data_sender,
"content": data_content,
},
{
"message_content_type": data_message_content_type,
"sender": data_sender_neg,
"content": data_content_neg,
},
{
"recipient": data_sender,
"content": data_content_directions,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| b3edb1ac-97de-2de2-3977-a7a1655c37af |
Check my email to see whether Soeurette has RSVPed for this evening's party; assuming she's planning to come, send her the directions to the venue. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="my email")
data_model.append(data_message_content_type)
data_sender = Contact(text="Soeurette")
data_model.append(data_sender)
data_sender_neg = Contact(text="Sam")
data_model.append(data_sender_neg)
data_content = Content(text="has RSVPed for this evening's party")
data_model.append(data_content)
data_content_neg = Content(text="decline")
data_model.append(data_content_neg)
data_message1 = MessageEntity(
message_content_type=data_message_content_type,
sender=data_sender,
content=data_content_neg,
)
data_model.append(data_message1)
data_message2 = MessageEntity(
message_content_type=data_message_content_type,
sender=data_sender_neg,
content=data_content_neg,
)
data_model.append(data_message2)
data_destination = Location(text="the venue")
data_model.append(data_destination)
data_content_directions = Content()
data_model.append(data_content_directions)
data_navigation_direction = NavigationDirectionEntity(destination=data_destination, data_content_directions=data_content_directions)
data_model.append(data_navigation_direction)
# data_content_directions = Content(value=[data_navigation_direction])
# data_model.append(data_content_directions)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"sender": data_sender,
"content": data_content_neg,
},
{
"message_content_type": data_message_content_type,
"sender": data_sender_neg,
"content": data_content_neg,
},
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 230afd15-ee19-82eb-2bf9-048b76db67f7 |
Set an alarm for 6 AM and set a reminder to go shopping at 4 PM Wednesday. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="for 6 AM")
data_model.append(data_date_time)
data_content = Content(text="go shopping")
data_model.append(data_content)
data_date_time_reminder = DateTime(text="at 4 PM Wednesday")
data_model.append(data_date_time_reminder)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(AlarmEntity)
expected = [
{
"date_time": data_date_time,
}
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(ReminderEntity)
expected = [
{
"date_time": data_date_time_reminder,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3d5bdf10-7de5-96ce-77e8-ce48a61b585f |
On evenings the temperature drops below 50F, turn the family room heat to 70F. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="evenings", value="Monday evening")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="evenings", value="Tuesday evening")
data_model.append(data_date_time2)
data_weather_temperature = WeatherTemperature(text="below 50F")
data_model.append(data_weather_temperature)
data_weather_temperature_neg = WeatherTemperature(text="48F")
data_model.append(data_weather_temperature_neg)
data_weather_forecast1 = WeatherForecastEntity(
date_time=data_date_time1, weather_temperature=data_weather_temperature
)
data_model.append(data_weather_forecast1)
data_weather_forecast2 = WeatherForecastEntity(
date_time=data_date_time2, weather_temperature=data_weather_temperature_neg
)
data_model.append(data_weather_forecast2)
# data_date_time_weather1 = DateTime(value=data_weather_forecast1)
# data_model.append(data_date_time_weather1)
# data_date_time_weather2 = DateTime(value=data_weather_forecast2)
# data_model.append(data_date_time_weather2)
data_home_device_action = HomeDeviceAction(text="turn")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the family room heat")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="to 70F")
data_model.append(data_home_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = [
{
"date_time": data_date_time1,
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
}
]
entity_assertions(expected, actual, test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 5b7d26c4-d99b-9229-29b7-c30ce06be0fd |
Buy 4 movie tickets for Strange World (2022) for this Friday anytime from 4 to 6 pm at AMC in Naperville | # test data
data_model = DataModel(reset=True)
data_amount = Amount(text="4")
data_model.append(data_amount)
data_product_attribute = ProductAttribute(text="movie tickets")
data_model.append(data_product_attribute)
data_product_name = ProductName(text="Strange World (2022)")
data_model.append(data_product_name)
data_date_time = DateTime(text="this Friday anytime from 4 to 6 pm")
data_model.append(data_date_time)
data_location = Location(text="AMC in Naperville")
data_model.append(data_location)
data_product = ProductEntity(
product_name=data_product_name,
date_time=data_date_time,
location=data_location,
product_attribute=data_product_attribute,
)
data_model.append(data_product)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = [
{
"product_name": data_product_name,
"product_attribute": data_product_attribute,
"location": data_location,
"date_time": data_date_time,
"amount": data_amount,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 9ffd1ae1-21c4-f26f-e7f0-c45ecdc85fa6 |
Order 1 chicken, 2 turkeys and a box of stuffing from Amazon Fresh store. | # test data
data_model = DataModel(reset=True)
data_amount_1 = Amount(text="1")
data_model.append(data_amount_1)
data_amount_2 = Amount(text="2")
data_model.append(data_amount_2)
data_amount_box = Amount(text="a box")
data_model.append(data_amount_box)
data_product_name_chicken = ProductName(text="chicken")
data_model.append(data_product_name_chicken)
data_product_name_turkey = ProductName(text="turkeys")
data_model.append(data_product_name_turkey)
data_product_name_stuffing = ProductName(text="stuffing")
data_model.append(data_product_name_stuffing)
data_location = Location(text="Amazon Fresh store")
data_model.append(data_location)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = [
{
"product_name": data_product_name,
"amount": data_amount,
"location": data_location,
}
for data_product_name, data_amount in zip(
[data_product_name_chicken, data_product_name_turkey, data_product_name_stuffing],
[data_amount_1, data_amount_2, data_amount_box],
)
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| b4ef7df1-7d3d-c747-20cd-2a8fe98a173f |
Remind me to close the windows at 7 am should it be a cloudy day | # test data
data_model = DataModel(reset=True)
data_content = Content(text="close the windows")
data_model.append(data_content)
data_date_time = DateTime(text="7 am")
data_model.append(data_date_time)
data_weather_attr_cloudy = WeatherAttribute(text="cloudy day")
data_model.append(data_weather_attr_cloudy)
data_weather_attribute_neg = WeatherAttribute(text="sunny day")
data_model.append(data_weather_attribute_neg)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attr_cloudy
)
data_model.append(data_weather_forecast)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"date_time": data_date_time,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| e340ebcf-28df-ba3c-3783-5054905004fa |
Remind me to close the windows at 7 am should it be a cloudy day | # test data
data_model = DataModel(reset=True)
data_content = Content(text="close the windows")
data_model.append(data_content)
data_date_time = DateTime(text="7 am")
data_model.append(data_date_time)
data_weather_attr_cloudy = WeatherAttribute(text="cloudy day")
data_model.append(data_weather_attr_cloudy)
data_weather_attribute_neg = WeatherAttribute(text="sunny day")
data_model.append(data_weather_attribute_neg)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg
)
data_model.append(data_weather_forecast)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 4b7240be-8c01-bb9d-40da-2e7ae87582b6 |
Assuming that I have a Zoom call on my calendar for Friday morning, send an email to my doctor asking whether my Friday morning appointment can be moved to Friday at 2pm. | data_model = DataModel(reset=True)
data_event_name = EventName(text="Zoom call")
data_model.append(data_event_name)
data_event_name_neg = EventName(text="Tennis match")
data_model.append(data_event_name_neg)
data_calendar = EventCalendar(text="my calendar")
data_model.append(data_calendar)
data_date_time = DateTime(text="Friday morning")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="Thursday morning")
data_model.append(data_date_time_neg)
data_event = EventEntity(
event_name=data_event_name,
event_calendar=data_calendar,
date_time=data_date_time,
)
data_model.append(data_event)
data_message_content_type = MessageContentType(text="email")
data_model.append(data_message_content_type)
data_recipient = Content(text="my doctor")
data_model.append(data_recipient)
data_content = Content(text="asking whether my Friday morning appointment can be moved to Friday at 2pm")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"content": data_content,
"recipient": data_recipient,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| aae02b6e-27dc-d13d-19f3-8311b7f58d1c |
Assuming that I have a Zoom call on my calendar for Friday morning, send an email to my doctor asking whether my Friday morning appointment can be moved to Friday at 2pm. | data_model = DataModel(reset=True)
data_event_name = EventName(text="Zoom call")
data_model.append(data_event_name)
data_calendar = EventCalendar(text="my calendar")
data_model.append(data_calendar)
data_date_time = DateTime(text="Friday morning")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="Thursday morning")
data_model.append(data_date_time_neg)
data_event = EventEntity(
event_name=data_event_name,
event_calendar=data_calendar,
date_time=data_date_time_neg,
)
data_model.append(data_event)
data_message_content_type = MessageContentType(text="email")
data_model.append(data_message_content_type)
data_recipient = Content(text="my doctor")
data_model.append(data_recipient)
data_content = Content(text="asking whether my Friday morning appointment can be moved to Friday at 2pm")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 824a8c23-0167-a3a4-bb79-ce9aba2dff8e |
Please ensure that my house's front door is locked and turn on the front porch light. | # test data
data_model = DataModel(reset=True)
data_home_device_action_door = HomeDeviceAction(text="ensure")
data_model.append(data_home_device_action_door)
data_home_device_name_door = HomeDeviceName(text="my house's front door")
data_model.append(data_home_device_name_door)
data_home_device_value_door = HomeDeviceValue(text="locked")
data_model.append(data_home_device_value_door)
data_home_device_action_porch = HomeDeviceAction(text="turn")
data_model.append(data_home_device_action_porch)
data_home_device_name_porch = HomeDeviceName(text="the front porch light")
data_model.append(data_home_device_name_porch)
data_home_device_value_porch = HomeDeviceValue(text="on")
data_model.append(data_home_device_value_porch)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = []
for data_home_device_action, data_home_device_name, data_home_device_value in zip(
[data_home_device_action_door, data_home_device_action_porch],
[data_home_device_name_door, data_home_device_name_porch],
[data_home_device_value_door, data_home_device_value_porch]
):
expected.append(
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
}
)
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| ba30fd97-b412-7db5-6e9f-4d3d9c030d71 |
Remind me to get apples next week unless they are on sale this week, in that case remind to stop after the game and get them. | # test data
data_model = DataModel(reset=True)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_content = Content(text="get apples")
data_model.append(data_content)
data_content2 = Content(text="get them")
data_model.append(data_content2)
data_date_time_reminder = DateTime(text="next week")
data_model.append(data_date_time_reminder)
data_date_time_sale = DateTime(text="this week")
data_model.append(data_date_time_sale)
data_product_name = ProductName(text="apples")
data_model.append(data_product_name)
data_product_attribute = ProductAttribute(text="on sale")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="fully priced")
data_model.append(data_product_attribute_neg)
data_product = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute,
)
data_model.append(data_product)
data_event_name = EventName(text="the game")
data_model.append(data_event_name)
data_date_time_game = DateTime(text="after the game")
data_model.append(data_date_time_game)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time_game)
data_model.append(data_event)
# start code block to test
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 9d4e8784-5a6c-02ab-bd38-835983d06f67 |
Remind me to get apples next week unless they are on sale this week, in that case remind to stop after the game and get them. | # test data
data_model = DataModel(reset=True)
data_person_reminded = Contact(text="me")
data_model.append(data_person_reminded)
data_content = Content(text="get apples")
data_model.append(data_content)
data_content2 = Content(text="get them")
data_model.append(data_content2)
data_date_time_reminder = DateTime(text="next week")
data_model.append(data_date_time_reminder)
data_date_time_sale = DateTime(text="this week")
data_model.append(data_date_time_sale)
data_product_name = ProductName(text="apples")
data_model.append(data_product_name)
data_product_attribute = ProductAttribute(text="on sale")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="fully priced")
data_model.append(data_product_attribute_neg)
data_product = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute_neg,
)
data_model.append(data_product)
data_event_name = EventName(text="the game")
data_model.append(data_event_name)
data_date_time_game = DateTime(text="after the game")
data_model.append(data_date_time_game)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time_game)
data_model.append(data_event)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"person_reminded": data_person_reminded,
"content": data_content,
"date_time": data_date_time_reminder,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 20a87392-0b77-1533-e6aa-8d01e9c3ff15 |
Search for hiking backpacks in yellow color under $40 in other shopping sites in case there is none in Amazon | # test data
data_model = DataModel(reset=True)
data_product_name = ProductName(text="hiking backpacks")
data_model.append(data_product_name)
data_product_attribute = ProductAttribute(text="yellow color under $40")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="green")
data_model.append(data_product_attribute_neg)
data_location_amazon = Location(text="Amazon")
data_model.append(data_location_amazon)
data_location_walmart = Location(text="other shopping sites", value="Walmart")
data_model.append(data_location_walmart)
data_location_target = Location(text="other shopping sites", value="Target")
data_model.append(data_location_target)
data_product1 = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute_neg,
location=data_location_walmart,
)
data_model.append(data_product1)
data_product2 = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute,
location=data_location_walmart,
)
data_model.append(data_product2)
data_product3 = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute,
location=data_location_target,
)
data_model.append(data_product3)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([ProductEntity]))
actual = next(iterator, None)
expected = [
data_product2,
data_product3,
]
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 845019fa-e804-90a3-7765-e83f21b63c41 |
Search for hiking backpacks in yellow color under $40 in other shopping sites in case there is none in Amazon | # test data
data_model = DataModel(reset=True)
data_product_name = ProductName(text="hiking backpacks")
data_model.append(data_product_name)
data_product_attribute = ProductAttribute(text="yellow color under $40")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="green")
data_model.append(data_product_attribute_neg)
data_location_amazon = Location(text="Amazon")
data_model.append(data_location_amazon)
data_location_walmart = Location(text="other shopping sites", value="Walmart")
data_model.append(data_location_walmart)
data_location_target = Location(text="other shopping sites", value="Target")
data_model.append(data_location_target)
data_product1 = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute,
location=data_location_amazon,
)
data_model.append(data_product1)
data_product2 = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute,
location=data_location_walmart,
)
data_model.append(data_product2)
data_product3 = ProductEntity(
product_name=data_product_name,
product_attribute=data_product_attribute,
location=data_location_target,
)
data_model.append(data_product3)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([ProductEntity]))
actual = next(iterator, None)
expected = []
response_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| a716c671-0515-2635-8d6d-e4b77e0cc85c |
Assuming that the temperature outdoors is under 60 degrees right now, crank up the thermostat in the living room to 75 degrees. | # test data
data_model = DataModel(reset=True)
data_location = Location(text="outdoors")
data_model.append(data_location)
data_weather_temperature = WeatherTemperature(text="under 60 degrees")
data_model.append(data_weather_temperature)
data_date_time = DateTime(text="right now")
data_model.append(data_date_time)
data_weather_forecast = WeatherForecastEntity(
date_time=data_date_time,
weather_temperature=data_weather_temperature,
location=data_location,
)
data_model.append(data_weather_forecast)
data_home_device_action = HomeDeviceAction(text="crank up")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the thermostat in the living room")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="75 degrees")
data_model.append(data_home_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = [
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 6d18941b-3af0-60a0-138e-1e171804d52e |
Assuming that the temperature outdoors is under 60 degrees right now, crank up the thermostat in the living room to 75 degrees. | # test data
data_model = DataModel(reset=True)
data_location = Location(text="outdoors")
data_model.append(data_location)
data_weather_temperature = WeatherTemperature(text="under 60 degrees")
data_model.append(data_weather_temperature)
data_weather_temperature_neg = WeatherTemperature(text="82")
data_model.append(data_weather_temperature_neg)
data_date_time = DateTime(text="right now")
data_model.append(data_date_time)
data_weather_forecast = WeatherForecastEntity(
date_time=data_date_time,
weather_temperature=data_weather_temperature_neg,
location=data_location,
)
data_model.append(data_weather_forecast)
data_home_device_action = HomeDeviceAction(text="crank up")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the thermostat in the living room")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="75 degrees")
data_model.append(data_home_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3641e997-a47e-b549-bed0-7206b35c1730 |
Open up my email and delete anything from March before setting a reminder to go to John's school Friday at 10 AM. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="email")
data_model.append(data_message_content_type)
data_date_time1 = DateTime(text="February")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="March")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="March")
data_model.append(data_date_time3)
data_message1 = MessageEntity(
message_content_type=data_message_content_type, date_time=data_date_time1
)
data_model.append(data_message1)
data_message2 = MessageEntity(
message_content_type=data_message_content_type, date_time=data_date_time2
)
data_model.append(data_message2)
data_message3 = MessageEntity(
message_content_type=data_message_content_type, date_time=data_date_time3
)
data_model.append(data_message3)
data_content_reminder = Content(text="go to John's school")
data_model.append(data_content_reminder)
data_date_time_reminder = DateTime(text="Friday at 10 AM")
data_model.append(data_date_time_reminder)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{"message_content_type": data_message_content_type, "date_time": data_date_time1},
]
entity_assertions(expected, actual, test_results)
actual = data_model.get_data(ReminderEntity)
expected = [
{
"date_time": data_date_time_reminder,
"content": data_content_reminder,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| c439c60b-7bf0-0fc6-d80b-76312309f8dc |
Set a reminder for next Thursday to bring an umbrella in the case of rain. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="next Thursday")
data_model.append(data_date_time)
data_content = Content(text="bring an umbrella")
data_model.append(data_content)
data_weather_attribute = WeatherAttribute(text="rain")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="sunny")
data_model.append(data_weather_attribute_neg)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute
)
data_model.append(data_weather_forecast)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = [
{
"date_time": data_date_time,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| dad3ce83-2f11-b2db-4fea-1ce034cc0676 |
Set a reminder for next Thursday to bring an umbrella in the case of rain. | # test data
data_model = DataModel(reset=True)
data_date_time = DateTime(text="next Thursday")
data_model.append(data_date_time)
data_content = Content(text="bring an umbrella")
data_model.append(data_content)
data_weather_attribute = WeatherAttribute(text="rain")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="sunny")
data_model.append(data_weather_attribute_neg)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg
)
data_model.append(data_weather_forecast)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ReminderEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 1cf920c9-d5cb-05d2-57c3-137b8d59c2ae |
As long as it's snowing outside, turn up the temperature of the living room to 78 degrees. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="snowing")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="raining")
data_model.append(data_weather_attribute_neg)
data_location = Location(text="outside")
data_model.append(data_location)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute,
location=data_location,
)
data_model.append(data_weather_forecast)
data_home_device_action = HomeDeviceAction(text="turn up")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the temperature of the living room")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="78 degrees")
data_model.append(data_home_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = [
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 176c8f83-358a-e89d-a83a-5fc318a10665 |
As long as it's snowing outside, turn up the temperature of the living room to 78 degrees. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="snowing")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="raining")
data_model.append(data_weather_attribute_neg)
data_location = Location(text="outside")
data_model.append(data_location)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg,
location=data_location,
)
data_model.append(data_weather_forecast)
data_home_device_action = HomeDeviceAction(text="turn up")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the temperature of the living room")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="78 degrees")
data_model.append(data_home_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_260():
"""
Send a text to Mom letting her know I'll be late on the occasion that she texts me during a meeting.
"""
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 1a996bd8-1ab2-d41e-f59f-1322cc173a21 |
Assuming it snows on Wednesday as forecasted, cancel my lunch date with Andrew. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="snows")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="rains")
data_model.append(data_weather_attribute_neg)
data_date_time = DateTime(text="Wednesday")
data_model.append(data_date_time)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute,
date_time=data_date_time,
)
data_model.append(data_weather_forecast)
data_event_name = EventName(text="lunch date with Andrew")
data_model.append(data_event_name)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time)
data_model.append(data_event)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 1f75bdea-ac46-84bf-ebb1-b8e3ee5888ee |
Assuming it snows on Wednesday as forecasted, cancel my lunch date with Andrew. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="snows")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="rains")
data_model.append(data_weather_attribute_neg)
data_date_time = DateTime(text="Wednesday")
data_model.append(data_date_time)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg,
date_time=data_date_time,
)
data_model.append(data_weather_forecast)
data_event_name = EventName(text="lunch date with Andrew")
data_model.append(data_event_name)
data_event = EventEntity(event_name=data_event_name, date_time=data_date_time)
data_model.append(data_event)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = [
{
"event_name": data_event_name,
"date_time": data_date_time,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| f30f67f1-8a88-f022-cded-11cb011b4327 |
Check Elizabeth's calendar to see whether she has any availability for lunch on Friday at noon; assuming she is free, send an email to Roberta's Restaurant to see whether they have a table for two at that time. | # test data
data_model = DataModel(reset=True)
data_event_calendar = EventCalendar(text="Elizabeth's calendar")
data_model.append(data_event_calendar)
data_date_time = DateTime(text="Friday at noon")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="Saturday morning")
data_model.append(data_date_time_neg)
data_event = EventEntity(
date_time=data_date_time_neg, event_calendar=data_event_calendar
)
data_model.append(data_event)
data_contact = Contact(text="Roberta's Restaurant")
data_model.append(data_contact)
data_content = Content(text="table for two")
data_model.append(data_content)
data_message_content_type = MessageContentType(text="an email")
data_model.append(data_message_content_type)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_contact,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| ebc514f3-73a5-da2e-8cea-a67db312f76c |
Check Elizabeth's calendar to see whether she has any availability for lunch on Friday at noon; assuming she is free, send an email to Roberta's Restaurant to see whether they have a table for two at that time. | # test data
data_model = DataModel(reset=True)
data_event_calendar = EventCalendar(text="Elizabeth's calendar")
data_model.append(data_event_calendar)
data_date_time = DateTime(text="Friday at noon")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="Saturday morning")
data_model.append(data_date_time_neg)
data_event = EventEntity(
date_time=data_date_time, event_calendar=data_event_calendar
)
data_model.append(data_event)
data_contact = Contact(text="Roberta's Restaurant")
data_model.append(data_contact)
data_content = Content(text="table for two")
data_model.append(data_content)
data_message_content_type = MessageContentType(text="an email")
data_model.append(data_message_content_type)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_266():
"""
Buy Taylor Swift tickets for her June concert, but only ones that are under 50$.
"""
pass
f test_268():
"""
Whenever the temperature gets below 60 degrees next week, turn on my heater and set the temperature to 70 degrees.
"""
pass
f test_269():
"""
Send me a weekly reminder to buy the coat on my Amazon wish list unless it has already been marked as purchased.
"""
pass
f test_270_a():
"""
Send me a message on days a concert is scheduled on the same day I am scheduled to be off work.
"""
# test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="Tuesday")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="Sunday")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="Saturday")
data_model.append(data_date_time3)
data_event_name_concert = EventName(text="a concert")
data_model.append(data_event_name_concert)
data_event_concert1 = EventEntity(
event_name=data_event_name_concert, date_time=data_date_time2
)
data_model.append(data_event_concert1)
data_event_concert2 = EventEntity(
event_name=data_event_name_concert, date_time=data_date_time3
)
data_model.append(data_event_concert2)
data_recipient = Contact(text="me")
data_model.append(data_recipient)
data_message_content_type = MessageContentType(text="a message")
data_model.append(data_message_content_type)
data_event_name_off = EventName(text="off work")
data_model.append(data_event_name_off)
data_event_off1 = EventEntity(
event_name=data_event_name_off, date_time=data_date_time_off1
)
data_model.append(data_event_off1)
data_event_off2 = EventEntity(
event_name=data_event_name_off, date_time=data_date_time_off2
)
data_model.append(data_event_off2)
# start code block to test
event_name = EventName.resolve_from_text("a concert")
event_concerts = Calendar.find_events(event_name=event_name)
for event_concert in event_concerts:
event_name = EventName.resolve_from_text("off work")
date_time = DateTime.resolve_from_entity(entity=event_concert)
event_offs = Calendar.find_events(event_name=event_name, date_time=date_time)
for event_off in event_offs:
recipient = Contact.resolve_from_text("me")
message_content_type = MessageContentType.resolve_from_text("a message")
Messages.send_message(
recipient=recipient, message_content_type=message_content_type
)
for event_concert in event_concerts:
for event_off in event_offs:
if event_concert.date_time == event_off.date_time:
recipient = Contact.resolve_from_text("me")
Messages.send_message(
recipient=recipient, content_type=MessageContentType.resolve_from_text("a message")
)
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_recipient,
"content_type": data_message_content_type,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_270_b():
"""
Send me a message on days a concert is scheduled on the same day I am scheduled to be off work.
"""
# test data
data_model = DataModel(reset=True)
data_date_time_work = DateTime(text="Tuesday")
data_model.append(data_date_time_off1)
data_date_time_off1 = DateTime(text="Sunday")
data_model.append(data_date_time_off1)
data_date_time_off2 = DateTime(text="Saturday")
data_model.append(data_date_time_off2)
data_event_name_off = EventName(text="off work")
data_model.append(data_event_name_off)
data_event_off1 = EventEntity(
event_name=data_event_name_off, date_time=data_date_time_off1
)
data_model.append(data_event_off1)
data_event_off2 = EventEntity(
event_name=data_event_name_off, date_time=data_date_time_off2
)
data_model.append(data_event_off2)
data_event_name_concert = EventName(text="a concert")
data_event_concert2 = EventEntity(
event_name=data_event_name_concert, date_time=data_date_time_work
)
data_model.append(data_event_concert2)
data_recipient = Contact(text="me")
data_model.append(data_recipient)
data_message_content_type = MessageContentType(text="a message")
data_model.append(data_message_content_type)
# start code block to test
event_name = EventName.resolve_from_text("a concert")
event_concerts = Calendar.find_events(event_name=event_name)
event_name = EventName.resolve_from_text("off work")
event_offs = Calendar.find_events(event_name=event_name)
for event_concert in event_concerts:
for event_off in event_offs:
if event_concert.date_time == event_off.date_time:
recipient = Contact.resolve_from_text("me")
Messages.send_message(
recipient=recipient, content_type=MessageContentType.resolve_from_text("a message")
)
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_271():
"""
ll the babysitter that I have to change time and ask that she could please come in on Wednesday instead of Thursday.
"
pass
f test_272():
"""
long as my calendar has a free slot on Thursday at noon, book a one-hour meeting with Michaela at that time.
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 979ddcc6-8ddd-225b-7d27-eddd42b3d444 |
Adjust the thermostat up five degrees on days snow is forecasted. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="snow")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="rain")
data_model.append(data_weather_attribute_neg)
data_date_time1 = DateTime(text="Wednesday")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="Thursday")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="Friday")
data_model.append(data_date_time3)
data_weather_forecast1= WeatherForecastEntity(
weather_attribute=data_weather_attribute,
date_time=data_date_time1,
)
data_model.append(data_weather_forecast1)
data_weather_forecast2= WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg,
date_time=data_date_time2,
)
data_model.append(data_weather_forecast2)
data_weather_forecast3 = WeatherForecastEntity(
weather_attribute=data_weather_attribute,
date_time=data_date_time3,
)
data_model.append(data_weather_forecast3)
data_home_device_action = HomeDeviceAction(text="adjust up")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the thermostat")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="five degrees")
data_model.append(data_home_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = [
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
"date_time": DateTime(value=data_weather_forecast1),
},
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
"date_time": DateTime(value=data_weather_forecast3),
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_274():
"""
at tickets are available for the Winter Jam concert in Birmingham and how long will the drive take from my current location at home?
"
pass
f test_275():
"""
long as Matt emails me back before 5pm to confirm his availability, book the restaurant reservation for 7pm this evening.
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 733b57ae-9e45-bae7-4222-1b555c15e97f |
Delete any emails in my archived folder that are 2 years or older. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="emails in my archived folder")
data_model.append(data_message_content_type)
data_date_time = DateTime(text="2 years or older")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="yestreday")
data_model.append(data_date_time_neg)
data_message1 = MessageEntity(
message_content_type=data_message_content_type, date_time=data_date_time
)
data_model.append(data_message1)
data_message2 = MessageEntity(
message_content_type=data_message_content_type, date_time=data_date_time
)
data_model.append(data_message2)
data_message3 = MessageEntity(
message_content_type=data_message_content_type, date_time=data_date_time_neg
)
data_model.append(data_message3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"date_time": data_date_time_neg
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 6d363479-c974-39b9-21ad-2bcba054992d |
Check the store for burger availability and purchase a burger for pickup later. | # test data
data_model = DataModel(reset=True)
data_store = Location(text="the store")
data_model.append(data_store)
data_store_neg = Location(text="Costco")
data_model.append(data_store_neg)
data_model.append(data_store)
data_product_name_burger = ProductName(text="burger")
data_model.append(data_product_name_burger)
data_product_name_fries = ProductName(text="fries")
data_model.append(data_product_name_fries)
data_product_burger = ProductEntity(
product_name=data_product_name_burger, location=data_store
)
data_model.append(data_product_burger)
data_product_fries = ProductEntity(
product_name=data_product_name_fries, location=data_store
)
data_model.append(data_product_fries)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = [
{
"product_name": data_product_name_burger,
"location": data_store,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 48d65085-5be6-909f-e80e-8d7c0611ce47 |
Check the store for burger availability and purchase a burger for pickup later. | # test data
data_model = DataModel(reset=True)
data_store = Location(text="the store")
data_model.append(data_store)
data_store_neg = Location(text="Costco")
data_model.append(data_store_neg)
data_model.append(data_store)
data_product_name_burger = ProductName(text="burger")
data_model.append(data_product_name_burger)
data_product_name_fries = ProductName(text="fries")
data_model.append(data_product_name_fries)
data_product_burger = ProductEntity(
product_name=data_product_name_burger, location=data_store_neg
)
data_model.append(data_product_burger)
data_product_fries = ProductEntity(
product_name=data_product_name_fries, location=data_store
)
data_model.append(data_product_fries)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| b920a38c-0c58-7390-b716-9996f4f88bdd |
So long as the front row Taylor Swift concert tickets aren't higher than $400, purchase five tickets by charging my credit card ending in 4012. | # test data
data_model = DataModel(reset=True)
data_product_name = ProductName(text="front row Taylor Swift concert tickets")
data_model.append(data_product_name)
data_product_attribute = ProductAttribute(text="higher than $400")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="$599")
data_model.append(data_product_attribute_neg)
data_product = ProductEntity(
product_name=data_product_name, product_attribute=data_product_attribute
)
data_model.append(data_product)
data_amount = Amount(text="five")
data_model.append(data_amount)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = [
{
"product_name": data_product_name,
"product_attribute": data_product_attribute,
"amount": data_amount,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| b8d1ad2e-e7d6-c1b6-c126-7a3b1ed49102 |
So long as the front row Taylor Swift concert tickets aren't higher than $400, purchase five tickets by charging my credit card ending in 4012. | # test data
data_model = DataModel(reset=True)
data_product_name = ProductName(text="front row Taylor Swift concert tickets")
data_model.append(data_product_name)
data_product_attribute = ProductAttribute(text="higher than $400")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="$599")
data_model.append(data_product_attribute_neg)
data_product = ProductEntity(
product_name=data_product_name, product_attribute=data_product_attribute_neg
)
data_model.append(data_product)
data_amount = Amount(text="five")
data_model.append(data_amount)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(OrderEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_279():
"""
the occasion that my 6:00 am alarm is snoozed three times anytime in the next week, play any Queen song to wake me up.
"
pass
f test_280():
"""
need the Christmas lights on the tree and outside turned on at 6pm any day this week I am still at work past 5:30pm.
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 670d424a-6927-4210-4a16-38cbb8006729 |
In case it's raining at 11am on Thursday, text Pete to reschedule our lunch date. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="raining")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="snowing")
data_model.append(data_weather_attribute_neg)
data_date_time = DateTime(text="Thursday at 11am")
data_model.append(data_date_time)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute,
date_time=data_date_time,
)
data_model.append(data_weather_forecast)
data_contact = Contact(text="Pete")
data_model.append(data_contact)
data_content = Content(text="reschedule our lunch date")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_contact,
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 51c72142-ed34-1e7c-def4-e8375b2d28f8 |
In case it's raining at 11am on Thursday, text Pete to reschedule our lunch date. | # test data
data_model = DataModel(reset=True)
data_weather_attribute = WeatherAttribute(text="raining")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="snowing")
data_model.append(data_weather_attribute_neg)
data_date_time = DateTime(text="Thursday at 11am")
data_model.append(data_date_time)
data_weather_forecast = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg,
date_time=data_date_time,
)
data_model.append(data_weather_forecast)
data_contact = Contact(text="Pete")
data_model.append(data_contact)
data_content = Content(text="reschedule our lunch date")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = []
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_282():
"""
eck how hot it is today and depending on whether it's hot or cold, set a timer for AC or Heating in my car.
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| afc6b918-8a04-60f4-b3f6-6dd228f15c7d |
Schedule a 7am run everyday this week the temperature is supposed to be 70 degrees by 7am. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="7am")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="7am")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="7am")
data_model.append(data_date_time3)
data_event_name = EventName(text="run")
data_model.append(data_event_name)
data_weather_attribute = WeatherAttribute(text="70 degrees")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="60 fahrenheit")
data_model.append(data_weather_attribute_neg)
data_weather_forecast1 = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg, date_time=data_date_time1
)
data_model.append(data_weather_forecast1)
data_weather_forecast2 = WeatherForecastEntity(
weather_attribute=data_weather_attribute, date_time=data_date_time2
)
data_model.append(data_weather_forecast2)
data_weather_forecast3 = WeatherForecastEntity(
weather_attribute=data_weather_attribute, date_time=data_date_time3
)
data_model.append(data_weather_forecast3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(EventEntity)
expected = [
{
"event_name": data_event_name,
"date_time": DateTime(value=data_weather_forecast2),
},
{
"event_name": data_event_name,
"date_time": DateTime(value=data_weather_forecast3),
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 3032a4be-ba0c-c85b-a637-566923b54c9a |
Check mail, delete spam in all folders so I can read my messages more clearly. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="mail")
data_model.append(data_message_content_type)
data_content1 = Content(text="spam")
data_model.append(data_content1)
data_content2 = Content(text="Important mail")
data_model.append(data_content2)
data_content3 = Content(text="spam")
data_model.append(data_content3)
data_message1 = MessageEntity(
message_content_type=data_message_content_type, content=data_content1
)
data_model.append(data_message1)
data_message2 = MessageEntity(
message_content_type=data_message_content_type, content=data_content2
)
data_model.append(data_message2)
data_message3 = MessageEntity(
message_content_type=data_message_content_type, content=data_content3
)
data_model.append(data_message3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"content": data_content2,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 7f35419a-058e-19d2-b75e-962dba149bdd |
Please make me a grocery list with organic foods. | # test data
data_model = DataModel(reset=True)
data_product_attribute = ProductAttribute(text="organic")
data_model.append(data_product_attribute)
data_product_attribute_neg = ProductAttribute(text="junk food")
data_model.append(data_product_attribute_neg)
data_product_name1 = ProductName(text="organic apple")
data_model.append(data_product_name1)
data_product_name2 = ProductName(text="organic milk")
data_model.append(data_product_name2)
data_product_name3 = ProductName(text="hot dog")
data_model.append(data_product_name3)
data_product1 = ProductEntity(
product_name=data_product_name1, product_attribute=data_product_attribute
)
data_model.append(data_product1)
data_product2 = ProductEntity(
product_name=data_product_name2, product_attribute=data_product_attribute
)
data_model.append(data_product2)
data_product3 = ProductEntity(
product_name=data_product_name3, product_attribute=data_product_attribute_neg
)
data_model.append(data_product3)
data_shopping_list_name = ShoppingListName(text="grocery list")
data_model.append(data_shopping_list_name)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(ShoppingListEntity)
expected = [
{
"shopping_list_name": data_shopping_list_name,
"product_name": data_product_name1,
},
{
"shopping_list_name": data_shopping_list_name,
"product_name": data_product_name2,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_286():
"""
nfirm what the prices of white t-shirts are at Walmart in addition to Target.
"
pass
f test_287():
"""
nd Courtney the address of the Mexican restaurant in Topeka that has the best ratings.
"
pass
f test_288():
"""
nd a message to Paul once a day for the next three days with the list of events with tickets available for the weekend.
"
pass
f test_289():
"""
der one ream of printer paper on the first business day of each month for the next year.
"
pass
f test_290():
"""
move all my appointments after I complete them on any day following today.
"
pass
f test_291():
"""
eck the chances for rain on the days of all meetings on my calendar for next week.
"
pass
f test_292():
"""
mind me to confirm with Nick whether he plans to come to the holiday party on Friday, in addition to confirming with Madeline whether she plans to be there.
"
pass
f test_293():
"""
need a pair of blue dress shoes for my cousins wedding that can be delivered before I leave for vacation.
"
pass
f test_294():
"""
want to order multiple items of chicken stuffing from the grocery store, about 5 items please.
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 367ac64a-16d1-9e2a-fefc-f7c5fab8666d |
Send a text to Marianna as well as Juliet to see whether either of them can pick up the pizza for the party. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="a text")
data_model.append(data_message_content_type)
data_contact1 = Contact(text="Marianna as well as Juliet")
data_model.append(data_contact1)
data_contact2 = Contact(text="Marianna as well as Juliet")
data_model.append(data_contact2)
data_content = Content(text="pick up the pizza for the party")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"recipient": data_contact1,
"content": data_content,
"message_content_type": data_message_content_type
},
{
"recipient": data_contact2,
"content": data_content,
"message_content_type": data_message_content_type
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| a02b857f-2eff-73e8-e188-f35529dd91f8 |
Set the porch light to come on at 6:00 am on any day that rain is called for in the forecast. | # test data
data_model = DataModel(reset=True)
data_home_device_action = HomeDeviceAction(text="set")
data_model.append(data_home_device_action)
data_home_device_name = HomeDeviceName(text="the porch light")
data_model.append(data_home_device_name)
data_home_device_value = HomeDeviceValue(text="come on")
data_model.append(data_home_device_value)
data_weather_attribute = WeatherAttribute(text="rain")
data_model.append(data_weather_attribute)
data_weather_attribute_neg = WeatherAttribute(text="sun")
data_model.append(data_weather_attribute_neg)
data_date_time1 = DateTime(text="Wednesday")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="Thursday")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="Friday")
data_model.append(data_date_time3)
data_weather_forecast1 = WeatherForecastEntity(
weather_attribute=data_weather_attribute, date_time=data_date_time1
)
data_model.append(data_weather_forecast1)
data_weather_forecast2 = WeatherForecastEntity(
weather_attribute=data_weather_attribute, date_time=data_date_time2
)
data_model.append(data_weather_forecast2)
data_weather_forecast3 = WeatherForecastEntity(
weather_attribute=data_weather_attribute_neg, date_time=data_date_time3
)
data_model.append(data_weather_forecast3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = [
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
"date_time": DateTime(value=data_weather_forecast1),
},
{
"device_action": data_home_device_action,
"device_name": data_home_device_name,
"device_value": data_home_device_value,
"date_time": DateTime(value=data_weather_forecast2),
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_297():
"""
t a reminder to do my physical therapy exercises every 6 hours during waking hours every day for 2 weeks.
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| cc8cd1ce-ed58-e175-5b28-acffa45c3d0a |
Send a Happy Birthday text to anyone listed on my calendar as having a birthday this week. | # test data
data_model = DataModel(reset=True)
data_content = Content(text="Happy Birthday")
data_model.append(data_content)
data_message_content_type = MessageContentType(text="text")
data_model.append(data_message_content_type)
data_date_time1 = DateTime(text="this week")
data_model.append(data_date_time1)
data_event_name = EventName(text="birthday")
data_model.append(data_event_name)
data_event_name_neg = EventName(text="dentist appointment")
data_model.append(data_event_name_neg)
data_event1 = EventEntity(
event_name=data_event_name, date_time=data_date_time1
)
data_model.append(data_event1)
data_event2 = EventEntity(
event_name=data_event_name_neg, date_time=data_date_time1
)
data_model.append(data_event2)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"content": data_content,
"recipient": Contact(value=data_event1),
"message_content_type": data_message_content_type
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_299():
"""
arch messages by Jessica in the day of Wednesday between 2010-2015 so I can review them.
"
pass
f test_300():
"""
there any Seahawk home games in October to December?
"
pass
f test_301():
"""
there a coupon for bread in Meijer, Jewel in addition to Aldi?
"
pass
f test_302():
"""
eck the forecast for Saturday as well as Sunday to let me know which day has warmer temperatures.
"
pass
f test_303():
"""
eck how many movie tickets are left for Thor as well as Black Panther; book whichever movie is more in demand.
"
pass
f test_304():
"""
w many work lunches do I have scheduled on Monday over the next three weeks?
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| eb65e208-b715-d3b4-2fc5-35aebcd8d3e7 |
Send a message to everyone who I have meetings scheduled this week asking for confirmation of the time of the appointment. | # test data
data_model = DataModel(reset=True)
data_message_content_type = MessageContentType(text="a message")
data_model.append(data_message_content_type)
data_date_time = DateTime(text="this week")
data_model.append(data_date_time)
data_date_time_neg = DateTime(text="yestreday")
data_model.append(data_date_time_neg)
data_event1 = EventEntity(date_time=data_date_time)
data_model.append(data_event1)
data_event2 = EventEntity(date_time=data_date_time)
data_model.append(data_event2)
data_event3 = EventEntity(date_time=data_date_time_neg)
data_model.append(data_event3)
data_content = Content(text="confirmation of the time of the appointment")
data_model.append(data_content)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MessageEntity)
expected = [
{
"message_content_type": data_message_content_type,
"recipient": Contact(value=data_event1),
"content": data_content,
},
{
"message_content_type": data_message_content_type,
"recipient": Contact(value=data_event2),
"content": data_content,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 9a3d6127-374a-f09c-2201-5bf3ede3ac00 |
Play "Eye of the Tiger" 15 minutes before every one of my scheduled basketball games. | # test data
data_model = DataModel(reset=True)
data_song = Song(text="Eye of the Tiger")
data_model.append(data_song)
data_event_name = EventName(text="basketball games")
data_model.append(data_event_name)
data_event_name_neg = EventName(text="Dentist appointment")
data_model.append(data_event_name_neg)
data_date_time1 = DateTime(text="Wednesday at 6pm")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="Thursday at 6pm")
data_model.append(data_date_time2)
data_date_time3 = DateTime(text="Friday at 6pm")
data_model.append(data_date_time3)
data_event1 = EventEntity(
event_name=data_event_name, date_time=data_date_time1
)
data_model.append(data_event1)
data_event2 = EventEntity(
event_name=data_event_name, date_time=data_date_time2
)
data_model.append(data_event2)
data_event3 = EventEntity(
event_name=data_event_name_neg, date_time=data_date_time3
)
data_model.append(data_event3)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(MusicEntity)
expected = [
{
"song": data_song,
"date_time": DateTime(value=data_event1),
},
{
"song": data_song,
"date_time": DateTime(value=data_event2),
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
f test_307():
"""
t reminders about my doctors visit the day before, also 5 hours before the appointment.
"
pass
f test_308():
"""
Check whether I have any new emails; afterwards, go back to mark all reviewed emails as "read." After that, confirm whether all new emails have received a response.
"""
# test data
data_model = DataModel(reset=True)
data_message_status = MessageStatus(text="new")
data_model.append(data_message_status)
data_message_content_type = MessageContentType(text="emails")
data_model.append(data_message_content_type)
f test_309():
"""
eck the price of PlayStation 5s on Amazon for six hours today starting at 12 pm.
"
pass
f test_310():
"""
I get a sweater, a pair of sneakers in addition to yoga pants in my Amazon shopping cart?
"
pass
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| 72c1975b-93f0-fff1-3952-a520575f947c |
Every day for 1 week enable my car auto start at 5am. | # test data
data_model = DataModel(reset=True)
data_date_time_recurring1 = DateTime(text="Every day for 1 week at 5am", value="Monday")
data_model.append(data_date_time_recurring1)
data_date_time_recurring2 = DateTime(text="Every day for 1 week at 5am", value="Tuesday")
data_model.append(data_date_time_recurring2)
data_date_time_recurring3 = DateTime(text="Every day for 1 week at 5am", value="Wednesday")
data_model.append(data_date_time_recurring3)
data_device_action = HomeDeviceAction(text="my car auto start")
data_model.append(data_device_action)
data_device_name = HomeDeviceName(text="my car")
data_model.append(data_device_name)
data_device_value = HomeDeviceValue(text="enable")
data_model.append(data_device_value)
# start code block to test
# end code block to test
# assertions
test_results = {}
actual = data_model.get_data(HomeDeviceEntity)
expected = [
{
"device_action": data_device_action,
"device_name": data_device_name,
"device_value": data_device_value,
"date_time": data_date_time_recurring1,
},
{
"device_action": data_device_action,
"device_name": data_device_name,
"device_value": data_device_value,
"date_time": data_date_time_recurring2,
},
{
"device_action": data_device_action,
"device_name": data_device_name,
"device_value": data_device_value,
"date_time": data_date_time_recurring3,
}
]
entity_assertions(expected, actual, test_results)
assert_test(test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| eb94d5c2-be91-b5d6-dd99-5dbadd5ac0c3 |
Check what the temperature is for Monday as well as each day of the weekend. | # test data
data_model = DataModel(reset=True)
data_date_time1 = DateTime(text="Monday as well as each day of the weekend", value="Monday")
data_model.append(data_date_time1)
data_date_time2 = DateTime(text="Monday as well as each day of the weekend", value="Tuesday")
data_model.append(data_date_time2)
data_date_time_neg = DateTime(text="Next week")
data_model.append(data_date_time_neg)
data_weather_forecast1 = WeatherForecastEntity(
date_time=data_date_time1
)
data_model.append(data_weather_forecast1)
data_weather_forecast2 = WeatherForecastEntity(
date_time=data_date_time2
)
data_model.append(data_weather_forecast2)
data_weather_forecast3 = WeatherForecastEntity(
date_time=data_date_time_neg
)
data_model.append(data_weather_forecast3)
# start code block to test
# end code block to test
# assertions
test_results = {}
iterator = iter(data_model.get_response([WeatherForecastEntity]))
actual = next(iterator, None)
expected = [
data_weather_forecast1,
data_weather_forecast2,
]
response_assertions(expected, actual, test_results)
| from entities.generic import *
from entities.calendar import *
from entities.home import *
from entities.map import *
from entities.message import *
from entities.music import *
from entities.navigation import *
from entities.reminder import *
from entities.shopping import *
from entities.weather import *
from actions.calendar import *
from actions.clock import *
from actions.calendar import *
from actions.home import *
from actions.map import *
from actions.messages import *
from actions.music import *
from actions.navigation import *
from actions.reminders import *
from actions.responder import *
from actions.shopping import *
from actions.weather import *
from providers.data_model import DataModel
from datetime import datetime, timedelta
import utils.api_utils as utils
from utils.test_utils import *
| ef7de0b7-dedd-e0a2-7223-80a752fece7a |