text
stringlengths
43
210
test
stringlengths
532
6.45k
imports
stringclasses
2 values
guid
stringlengths
36
36
Check the availability of Pepsi at Walmart and also check it at Walgreens.
# test data data_model = DataModel(reset=True) data_product_name_pepsi = ProductName(text="Pepsi") data_model.append(data_product_name_pepsi) data_product_name_coca = ProductName(text="coca cola") data_model.append(data_product_name_coca) data_location1 = Location(text="Walmart") data_model.append(data_location1) data_location2 = Location(text="Walgreens") data_model.append(data_location2) data_location3 = Location(text="CVS") data_model.append(data_location3) data_product1 = ProductEntity( product_name=data_product_name_pepsi, location=data_location1 ) data_model.append(data_product1) data_product2 = ProductEntity( product_name=data_product_name_pepsi, location=data_location2 ) data_model.append(data_product2) data_product3 = ProductEntity( product_name=data_product_name_coca, location=data_location1 ) data_model.append(data_product3) data_product4 = ProductEntity( product_name=data_product_name_coca, location=data_location2 ) data_model.append(data_product4) data_product5 = ProductEntity( product_name=data_product_name_pepsi, location=data_location3 ) data_model.append(data_product5) data_product6 = ProductEntity( product_name=data_product_name_pepsi, location=data_location1 ) data_model.append(data_product6) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([ProductEntity])) expected = [data_product1, data_product6] actual = next(iterator, None) response_assertions(expected, actual, test_results) expected = [data_product2] actual = next(iterator, None) 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
b6589fc6-ab0d-c82c-f120-99d1c2d40ab9
If it's raining tomorrow morning, set my alarm for 7:30, if it's not, set my alarm for 8.
# test data data_model = DataModel(reset=True) data_date_time = DateTime( text="tomorrow morning", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time) data_weather_attribute = WeatherAttribute(text="raining", value="rain") data_model.append(data_weather_attribute) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute, date_time=data_date_time ) ) data_date_time730 = DateTime(text="7:30", value=datetime(2022, 11, 13, 7, 30)) data_model.append(data_date_time730) data_date_time800 = DateTime(text="8", value=datetime(2022, 11, 13, 8, 00)) data_model.append(data_date_time800) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(AlarmEntity) expected = [{"date_time": data_date_time730}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
97dacd70-dd76-5bb8-c19a-adbe64119028
If it's raining tomorrow morning, set my alarm for 7:30, if it's not, set my alarm for 8.
# test data data_model = DataModel(reset=True) data_date_time = DateTime( text="tomorrow morning", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time) data_weather_attribute = WeatherAttribute(text="raining", value="rain") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="sunny", value="sun") data_model.append(data_weather_attribute_neg) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute_neg, date_time=data_date_time ) ) data_date_time730 = DateTime(text="7:30", value=datetime(2022, 11, 13, 7, 30)) data_model.append(data_date_time730) data_date_time800 = DateTime(text="8", value=datetime(2022, 11, 13, 8, 00)) data_model.append(data_date_time800) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(AlarmEntity) expected = [{"date_time": data_date_time800}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
a34bbe61-27c5-3447-4a6a-f1d7fd15f092
Play the new Taylor Swift album and pull up my shopping list for today.
# test data data_model = DataModel(reset=True) data_album = Album(text="the new Taylor Swift album") data_model.append(data_album) data_date_time_today = DateTime(text="today", value=datetime.now()) data_model.append(data_date_time_today) data_shopping_list1 = ShoppingListEntity(date_time=data_date_time_today) data_model.append(data_shopping_list1) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time_tomorrow) data_shopping_list2 = ShoppingListEntity(date_time=data_date_time_tomorrow) data_model.append(data_shopping_list2) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(MusicEntity) expected = [{"album": data_album}] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([ShoppingListEntity])) actual = next(iterator, None) expected = [data_shopping_list1] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
da4b9237-bacc-cdf1-9c07-60cab7aec4a8
Send a message to dad if it rains tomorrow.
# test data data_model = DataModel(reset=True) data_recipient = Contact(text="dad", value="Father") data_model.append(data_recipient) data_date_time = DateTime(text="tomorrow", value=datetime.now() + timedelta(days=1)) data_model.append(data_date_time) data_weather_attribute = WeatherAttribute(text="rains", value="rain") data_model.append(data_weather_attribute) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute, date_time=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}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
dffff454-5ba0-c6ab-a9aa-6ff950bddc82
Send a message to dad if it rains tomorrow.
# test data data_model = DataModel(reset=True) data_recipient = Contact(text="dad", value="Father") data_model.append(data_recipient) data_date_time = DateTime(text="tomorrow", value=datetime.now() + timedelta(days=1)) data_model.append(data_date_time) data_weather_attribute = WeatherAttribute(text="rains", value="rain") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="sunny", value="sun") data_model.append(data_weather_attribute_neg) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute_neg, date_time=data_date_time ) ) # 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
94a27c17-ef51-adc0-db1f-85e1a20519fc
Give me directions to Navy pier in Chicago and tell me what the current traffic is looking like.
# test data data_model = DataModel(reset=True) data_location = Location(text="Navy pier in Chicago", value="Navy pier in Chicago") data_model.append(data_location) data_directions = NavigationDirectionEntity(destination=data_location) data_model.append(data_directions) data_traffic_info = NavigationTrafficInfoEntity(destination=data_location) data_model.append(data_traffic_info) # 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_directions] response_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationTrafficInfoEntity])) actual = next(iterator, None) expected = [data_traffic_info] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
1b645389-2473-a467-d073-72d45eb05abc
Check the next time Blink 182 will be in Chicago and tell me the ticket prices.
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="Blink 182") data_model.append(data_event_name) data_location = Location(text="in Chicago") data_model.append(data_location) data_event = EventEntity(event_name=data_event_name, location=data_location) data_model.append(data_event) data_tickets = EventTicketEntity(event_name=data_event_name, location=data_location) data_model.append(data_tickets) # 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) iterator = iter(data_model.get_response([EventTicketEntity])) actual = next(iterator, None) expected = [data_tickets] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
ac3478d6-9a3c-81fa-62e6-0f5c3696165a
Remind me tomorrow to email Jim about lunch and schedule a reservation for noon at the cafe.
# test data data_model = DataModel(reset=True) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime(2022, 11, 14, 00, 00) ) data_model.append(data_date_time_tomorrow) data_contact = Contact(text="me", value="Asaf") data_model.append(data_contact) data_content = Content(text="email Jim about lunch", value="email Jim about lunch") data_model.append(data_content) data_date_time_noon = DateTime(text="noon", value=datetime(2022, 11, 13, 12, 00)) data_model.append(data_date_time_noon) data_location = Location(text="the cafe", value="the cafe") data_model.append(data_location) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(ReminderEntity) expected = [ { "person_reminded": data_contact, "date_time": data_date_time_tomorrow, "content": data_content, } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(EventEntity) expected = [{"date_time": data_date_time_noon, "location": data_location}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c1dfd96e-ea8c-c2b6-2785-275bca38ac26
Can you place an order for two turkeys to arrive the 22nd, and remind me about it on the 21st?
# test data data_model = DataModel(reset=True) data_amount = Amount(text="two", value=2) data_model.append(data_amount) data_product_name = ProductName(text="turkeys") data_model.append(data_product_name) data_date_time_22 = DateTime(text="22nd", value=datetime(2022, 11, 22)) data_model.append(data_date_time_22) data_contact = Contact(text="me", value="me") data_model.append(data_contact) data_date_time_21 = DateTime(text="21st", value=datetime(2022, 11, 21)) data_model.append(data_date_time_21) # 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, "date_time": data_date_time_22, } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(ReminderEntity) expected = [ { "date_time": data_date_time_21, "person_reminded": data_contact, "content": Content(value=order), } for order in data_model.get_data(OrderEntity) ] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
902ba3cd-a188-3801-594b-6e1b452790cc
How long will it take to get to AMC theater at 8pm tonight and tell me what tonight's weather outlook is.
# test data data_model = DataModel(reset=True) data_location = Location(text="AMC theater", value="AMC theater") data_model.append(data_location) data_date_time_8pm = DateTime( text="at 8pm tonight", value=datetime(2022, 11, 13, 20, 00) ) data_model.append(data_date_time_8pm) data_estimated_arrival = NavigationEstimatedArrivalEntity( destination=data_location, arrival_date_time=data_date_time_8pm ) data_model.append(data_estimated_arrival) data_date_time_tonight = DateTime( text="tonight", value=datetime(2022, 11, 13, 18, 00) ) data_model.append(data_date_time_tonight) data_weather_forecast = WeatherForecastEntity(date_time=data_date_time_tonight) data_model.append(data_weather_forecast) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([NavigationEstimatedArrivalEntity])) actual = next(iterator, None) expected = [data_estimated_arrival] response_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([WeatherForecastEntity])) actual = next(iterator, None) expected = [data_weather_forecast] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
fe5dbbce-a5ce-7e29-88b8-c69bcfdfde89
Check the weather for the 4th of July and send a text to Grandpa to invite him over and tell him the weather.
# test data data_model = DataModel(reset=True) data_date_time = DateTime(text="the 4th of July", value=datetime(2022, 7, 4)) data_model.append(data_date_time) data_weather_forecast = WeatherForecastEntity(date_time=data_date_time) data_model.append(data_weather_forecast) data_recipient = Contact(text="Grandpa", value="Grandpa") data_model.append(data_recipient) data_content1 = Content(text="invite him over", value="invite him over") data_model.append(data_content1) data_content2 = Content(value=[data_weather_forecast]) data_model.append(data_content2) # 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(MessageEntity) expected = [ { "recipient": data_recipient, "content": content, } for content in [ data_content1, 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
0ade7c2c-f97f-75d0-0997-5f4d720d1fa6
Set a timer for one hour and text Stacy that dinner will be ready in one hour.
# test data data_model = DataModel(reset=True) data_duration = DateTime(text="one hour", value=datetime(2022, 11, 14, 1, 0)) data_model.append(data_duration) data_contact = Contact(text="Stacy", value="Stacy") data_model.append(data_contact) data_content = Content(text="dinner will be ready in one hour") data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(TimerEntity) expected = [ { "duration": data_duration, } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(MessageEntity) expected = [ { "recipient": data_contact, "content": data_content, } ] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
b1d57811-11d8-4f7b-3fe4-5a0852e59758
If the weather is cold tomorrow please remind me to grab my winter jacket.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="cold", value="cold") data_model.append(data_weather_attribute) data_date_time = DateTime(text="tomorrow", value=datetime(2022, 11, 15)) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( date_time=data_date_time, weather_attribute=data_weather_attribute ) ) data_person_reminded = Contact(text="me", value="I") data_model.append(data_person_reminded) data_content = Content( text="grab my winter jacket.", value="grab my winter jacket.", ) data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} data_reminder_list = data_model.get_data(ReminderEntity) assert_equal(len(data_reminder_list), 1, test_results) data_reminder = data_reminder_list[0] assert_equal(data_reminder.person_reminded, data_person_reminded, test_results) assert_equal(data_reminder.content, data_content, 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
71b18005-4c28-b40b-7600-ccc90b3fa123
If the weather is cold tomorrow please remind me to grab my winter jacket.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="cold", value="cold") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="hot", value="hot") data_model.append(data_weather_attribute_neg) data_date_time = DateTime(text="tomorrow", value=datetime.now() + timedelta(days=1)) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( date_time=data_date_time, weather_attribute=data_weather_attribute_neg ) ) data_person_reminded = Contact(text="me", value="I") data_model.append(data_person_reminded) data_content = Content( text="grab my winter jacket.", value="grab my winter jacket.", ) 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 = [] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
ef0d89d0-7160-68b2-1b63-833c6a28d0e9
What is the weather going to be at 5:00 PM today and navigate destination set to home after 5:00 PM.
# test data data_model = DataModel(reset=True) data_date_time = DateTime(text="5:00 PM today", value=datetime(2022, 11, 14, 17, 0)) data_model.append(data_date_time) data_weather_attribute = WeatherAttribute(text="cold", value="cold") data_model.append(data_weather_attribute) data_weather_forecast = WeatherForecastEntity( date_time=data_date_time, weather_attribute=data_weather_attribute ) data_model.append(data_weather_forecast) data_destination = Location(text="home", value="23e 8th st, new york, ny") data_model.append(data_destination) data_departure_date_time = DateTime( text="after 5:00 PM", value=datetime(2022, 11, 14, 17, 1) ) data_model.append(data_departure_date_time) data_direction = NavigationDirectionEntity( destination=data_destination, departure_date_time=data_departure_date_time ) data_model.append(data_direction) # 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) iterator = iter(data_model.get_response([NavigationDirectionEntity])) actual = next(iterator, None) expected = [data_direction] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
fa35e192-121e-abf3-dabf-9f5ea6abdbcb
If it's snowing in Boulder, Colorado by 6pm, text Lauren to tell her to let the dog inside.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="snowing", value="snow") data_model.append(data_weather_attribute) data_location = Location(text="Boulder, Colorado") data_model.append(data_location) data_date_time = DateTime(text="by 6pm", value=datetime(2022, 11, 15, 18, 00)) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute, location=data_location, date_time=data_date_time, ) ) data_recipient = Contact(text="Lauren", value="Lauren Hill") data_model.append(data_recipient) data_content = Content( text="let the dog inside", value="let the dog inside", ) 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}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
04a7d094-9ee7-0c56-808a-83b79b41bdc9
If it's snowing in Boulder, Colorado by 6pm, text Lauren to tell her to let the dog inside.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="snowing", value="snow") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="rain", value="rain") data_model.append(data_weather_attribute_neg) data_location = Location(text="Boulder, Colorado") data_model.append(data_location) data_date_time = DateTime(text="by 6pm", value=datetime(2022, 11, 15, 18, 00)) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute_neg, location=data_location, date_time=data_date_time, ) ) data_recipient = Contact(text="Lauren", value="Lauren Hill") data_model.append(data_recipient) data_content = Content( text="let the dog inside", value="let the dog inside", ) 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
92dec2ef-9ba6-4fdc-36d6-33d5e4cd189f
Text my brother I am on my way and also tell me the current traffic conditions.
# test data data_model = DataModel(reset=True) data_recipient = Contact(text="my brother", value="Jim Hill") data_model.append(data_recipient) data_content_omw = Content( text="I am on my way", value="I am on my way", ) data_model.append(data_content_omw) data_navigation_traffic_info = NavigationTrafficInfoEntity() data_model.append(data_navigation_traffic_info) # 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_omw}] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationTrafficInfoEntity])) actual = next(iterator, None) expected = [data_navigation_traffic_info] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
1574bddb-75c7-8a6f-d225-1d61e2993b51
Start my shower playlist and text Lucas that I'm just now getting in the shower and it will be 15 or 20 minutes until I'm out.
# test data data_model = DataModel(reset=True) data_playlist = Playlist(text="shower playlist") data_model.append(data_playlist) data_recipient = Contact(text="Lucas") data_model.append(data_recipient) data_content = Content( text="I'm just now getting in the shower and it will be 15 or 20 minutes until I'm out", ) data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(MusicEntity) expected = [{"playlist": data_playlist}] entity_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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
0716d970-8d32-1ffb-6a00-818614779e77
Tell Abe to pick up bread on his way home and set a timer for 60 minutes.
# test data data_model = DataModel(reset=True) data_recipient = Contact(text="Abe") data_model.append(data_recipient) data_content = Content( text="pick up bread on his way home", ) data_model.append(data_content) data_duration = TimeDuration(text="60 minutes") data_model.append(data_duration) # 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(TimerEntity) expected = [{"duration": data_duration}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
9e6a55b6-b456-3e65-2a23-be9d623ca505
Check the weather in Indianapolis, and if it's sunny, text Bob to remind him about the concert today.
# test data data_model = DataModel(reset=True) data_location = Location(text="Indianapolis") data_model.append(data_location) data_weather_attribute = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute, location=data_location, ) data_model.append(data_weather_forecast) data_recipient = Contact(text="Bob") data_model.append(data_recipient) data_content = Content( text="remind him about the concert today", ) 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(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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
378a41e7-1462-4e55-0f24-34847a1bdfe8
Check the weather in Indianapolis, and if it's sunny, text Bob to remind him about the concert today.
# test data data_model = DataModel(reset=True) data_location = Location(text="Indianapolis") data_model.append(data_location) data_weather_attribute = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="rain") data_model.append(data_weather_attribute_neg) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute_neg, location=data_location, ) data_model.append(data_weather_forecast) data_recipient = Contact(text="Bob") data_model.append(data_recipient) data_content = Content( text="remind him about the concert today", ) 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(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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c41c37ed-1f36-a5c0-2692-99ffe45f64ae
Give me directions to the nearest movie theater and text Mike to meet me there in a half hour.
# test data data_model = DataModel(reset=True) data_destination1 = Location( text="movie theater", value="movie theater 1", nearest=100 ) data_model.append(data_destination1) data_destination2 = Location( text="movie theater", value="movie theater 2", nearest=1 ) data_model.append(data_destination2) data_destination3 = Location( text="movie theater", value="movie theater 3", nearest=30 ) data_model.append(data_destination3) data_directions = NavigationDirectionEntity( destination=data_destination2, ) data_model.append(data_directions) data_recipient = Contact(text="Mike") data_model.append(data_recipient) data_content = Content( text="meet me there in a half hour", ) 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_directions] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
91032ad7-bbcb-6cf7-2875-e8e8207dcfba
Check my calendar for when my aunt's birthday is this month and then set a reminder for three days before, so I can remember to buy a gift.
# test data data_model = DataModel(reset=True) data_calendar = EventCalendar(text="my calendar") data_model.append(data_calendar) data_event_name = EventName( text="my aunt's birthday", value="Auntie Rachel's Birthday" ) data_model.append(data_event_name) data_date_time = DateTime(text="this month", value=datetime(2022, 11, 8, 00, 00)) data_model.append(data_date_time) data_event = EventEntity( event_name=data_event_name, date_time=data_date_time, event_calendar=data_calendar, ) data_model.append(data_event) data_date_time2 = DateTime( text="three days before", value=datetime(2022, 11, 5, 00, 00) ) data_model.append(data_date_time2) data_content = Content(text="remember to buy a gift") data_model.append(data_content) # 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) actual = data_model.get_data(ReminderEntity) expected = [{"date_time": data_date_time2, "content": data_content}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
472b07b9-fcf2-c245-1e87-81e944bf5f77
Set alarm for 6 AM and set the bedroom lights to turn on at 6 AM.
# test data data_model = DataModel(reset=True) data_date_time = DateTime(text="6 AM", value="6 AM") data_model.append(data_date_time) data_home_device_action = HomeDeviceAction(text="turn on", value="turn on") data_model.append(data_home_device_action) data_home_device_name = HomeDeviceName(text="the bedroom lights") data_model.append(data_home_device_name) data_home_device_value = HomeDeviceValue(text="turn on") data_model.append(data_home_device_value) data_date_time2 = DateTime(text="at 6 AM") data_model.append(data_date_time2) # 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(HomeDeviceEntity) expected = [ { "device_name": data_home_device_name, "device_action": data_home_device_action, "device_value": data_home_device_value, "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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
12c6fc06-c99a-4623-75ee-b3f43dfd832b
If the weather is nice tomorrow, text Jenny if she would like to go to the park
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="nice") data_model.append(data_weather_attribute) data_date_time = DateTime(text="tomorrow") data_model.append(data_date_time) data_model.append( WeatherForecastEntity( date_time=data_date_time, weather_attribute=data_weather_attribute ) ) data_recipient = Contact(text="Jenny") data_model.append(data_recipient) data_content = Content( text="if she would like to go to the park", ) 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}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
442dde44-84c9-2e73-a121-7a610a64dfd6
If the weather is nice tomorrow, text Jenny if she would like to go to the park
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="nice", value="nice") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="stormy", value="storm") data_model.append(data_weather_attribute_neg) data_date_time = DateTime(text="tomorrow", value="tomorrow") data_model.append(data_date_time) data_model.append( WeatherForecastEntity( date_time=data_date_time, weather_attribute=data_weather_attribute_neg ) ) data_recipient = Contact(text="Jenny", value="Jennifer Lopez") data_model.append(data_recipient) data_content = Content( text="if she would like to go to the park", value="if she would like to go to the park", ) 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
fa09371c-f935-550e-7f9f-04329f07bd64
Send Tyler a text saying hi and send one to Susan too.
# test data data_model = DataModel(reset=True) data_tyler = Contact(text="Tyler") data_model.append(data_tyler) data_susan = Contact(text="Susan") data_model.append(data_susan) data_content = Content( text="hi", ) 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_tyler, "content": data_content}, {"recipient": data_susan, "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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
bc33ea4e-26e5-e1af-1408-321416956113
Set timer for one hour labeled workout and start playing my music playlist titled workout tunes.
# test data data_model = DataModel(reset=True) data_duration = TimeDuration(text="one hour") data_model.append(data_duration) data_playlist = Playlist(text="workout tunes") data_model.append(data_playlist) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(TimerEntity) expected = [{"duration": data_duration}] entity_assertions(expected, actual, test_results) actual = data_model.get_data(MusicEntity) expected = [{"playlist": data_playlist}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
22d200f8-670d-bdb3-e253-a90eee509847
Turn on the living room lights and navigate Home.
# test data data_model = DataModel(reset=True) data_home_device_action = HomeDeviceAction(text="Turn") data_model.append(data_home_device_action) data_home_device_value = HomeDeviceValue(text="on", value="on") data_model.append(data_home_device_value) data_home_device_name = HomeDeviceName( text="the living room lights", value="the living room lights" ) data_model.append(data_home_device_name) data_destination = Location(text="Home", value="Home") data_model.append(data_destination) data_navigation_direction = NavigationDirectionEntity(destination=data_destination) data_model.append(data_navigation_direction) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(HomeDeviceEntity) expected = [ { "device_name": data_home_device_name, "device_action": data_home_device_action, "device_value": data_home_device_value, } ] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationDirectionEntity])) actual = next(iterator, None) expected = [data_navigation_direction] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
63266754-7e7c-d3e0-4665-47863e1207a8
Look up directions to the Sushi House and text my mom, telling her that I'm leaving soon
# test data data_model = DataModel(reset=True) data_destination = Location(text="the Sushi House", value="the Sushi House") data_model.append(data_destination) data_directions = NavigationDirectionEntity(destination=data_destination) data_model.append(data_directions) data_recipient = Contact(text="my mom") data_model.append(data_recipient) data_content = Content(text="I'm leaving soon") 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_directions] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
cb4e5208-b4cd-8726-8b20-8e49452ed6e8
Add eggs to my shopping list and text Steve to please buy eggs at the grocery store.
# test data data_model = DataModel(reset=True) data_product_name = ProductName(text="eggs") data_model.append(data_product_name) data_shopping_list_name = ShoppingListName(text="my shopping list") data_model.append(data_shopping_list_name) data_recipient = Contact(text="Steve") data_model.append(data_recipient) data_content = Content(text="please buy eggs at the grocery store") 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 = [ { "product_name": data_product_name, "shopping_list_name": data_shopping_list_name, } ] entity_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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
b6692ea5-df92-0cad-691c-20319a6fffd7
If I receive a text from Ruby tonight, change my alarm to 7am.
# test data data_model = DataModel(reset=True) data_sender_ruby = Contact(text="Ruby", value="Ruby Chen") data_model.append(data_sender_ruby) data_sender_steve = Contact(text="Steve", value="Steven Smith") data_model.append(data_sender_steve) data_date_time_tonight = DateTime(text="tonight", value=datetime.now()) data_model.append(data_date_time_tonight) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time_tomorrow) data_model.append( MessageEntity(sender=data_sender_ruby, date_time=data_date_time_tonight) ) data_model.append( MessageEntity(sender=data_sender_ruby, date_time=data_date_time_tomorrow) ) data_model.append( MessageEntity(sender=data_sender_steve, date_time=data_date_time_tonight) ) data_alarm_date_time_9 = DateTime( text="9am", value=datetime.now().replace(hour=9, minute=0, second=0, microsecond=0), ) data_model.append(data_alarm_date_time_9) data_alarm_date_time_7 = DateTime( text="7am", value=datetime.now().replace(hour=7, minute=0, second=0, microsecond=0), ) data_model.append(data_alarm_date_time_7) data_alarm_name = AlarmName(text="my alarm") data_model.append(data_alarm_name) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(AlarmEntity) expected = [{"alarm_name": data_alarm_name, "date_time": data_alarm_date_time_7}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
490b5c96-9899-b6b8-b49c-095559958c3f
If I receive a text from Ruby tonight, change my alarm to 7am.
# test data data_model = DataModel(reset=True) data_sender_ruby = Contact(text="Ruby") data_model.append(data_sender_ruby) data_sender_steve = Contact(text="Steve") data_model.append(data_sender_steve) data_date_time_tonight = DateTime(text="tonight") data_model.append(data_date_time_tonight) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time_tomorrow) data_model.append( MessageEntity(sender=data_sender_ruby, date_time=data_date_time_tomorrow) ) data_model.append( MessageEntity(sender=data_sender_steve, date_time=data_date_time_tonight) ) data_alarm_date_time_9 = DateTime( text="9am", value=datetime.now().replace(hour=9, minute=0, second=0, microsecond=0), ) data_model.append(data_alarm_date_time_9) # 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c17b63c6-672e-d06f-f0e1-b1667f035bd6
Add Jake's birthday party to the calendar for 7pm Saturday then send an email to Tom are you going to the party?
# test data data_model = DataModel(reset=True) data_date_time_sat7pm = DateTime( text="7pm Saturday", value=( datetime.now() + timedelta( days=((12 - datetime.now().weekday()) % 7) ) # find next Sat https://stackoverflow.com/a/16770463/1609802 ).replace(hour=19, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time_sat7pm) data_event_name = EventName(text="Jake's birthday party") data_model.append(data_event_name) data_recipient = Contact(text="Tom") data_model.append(data_recipient) data_content = Content(text="are you going to 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(EventEntity) expected = [{"event_name": data_event_name, "date_time": data_date_time_sat7pm}] entity_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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
fc074d50-1302-eb2b-93e2-554793fcaf50
Buy tickets to Black Adam and email the time of the show to Carlos.
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="Black Adam") data_model.append(data_event_name) data_date_time = DateTime(text="the time of the show") data_model.append(data_date_time) data_event = EventEntity(event_name=data_event_name, date_time=data_date_time) data_model.append(data_event) data_recipient = Contact(text="Carlos") data_model.append(data_recipient) data_message_content_type = MessageContentType(text="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(EventTicketEntity) expected = [ { "event": data_event } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(MessageEntity) expected = [ { "recipient": data_recipient, "content": Content(value=event),#, text="the time of the show"), "message_content_type": message_content_type, } for event in data_model.get_data(EventEntity) ] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
5b384ce3-2d8c-def0-2bc3-a139d4cac0a2
Look up what the weather will be like tomorrow, if it's not raining, message my sister saying we should go out for lunch tomorrow.
# test data data_model = DataModel(reset=True) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time_tomorrow) data_weather_attribute = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute) data_weather_attribute_raining = WeatherAttribute(text="raining") data_model.append(data_weather_attribute_raining) data_weather_forecast = WeatherForecastEntity( date_time=data_date_time_tomorrow, weather_attribute=data_weather_attribute ) data_model.append(data_weather_forecast) data_message_content_type = MessageContentType(text="message") data_model.append(data_message_content_type) data_recipient = Contact(text="my sister") data_model.append(data_recipient) data_content = Content( text="we should go out for lunch tomorrow", ) 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(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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c9b4f6f9-d2ab-0719-de56-dc4e63623c51
Look up what the weather will be like tomorrow, if it's not raining, message my sister saying we should go out for lunch tomorrow.
# test data data_model = DataModel(reset=True) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time_tomorrow) data_weather_attribute = WeatherAttribute(text="raining") data_model.append(data_weather_attribute) data_weather_forecast = WeatherForecastEntity( date_time=data_date_time_tomorrow, weather_attribute=data_weather_attribute ) data_model.append(data_weather_forecast) data_message_content_type = MessageContentType(text="message") data_model.append(data_message_content_type) data_recipient = Contact(text="my sister") data_model.append(data_recipient) data_content = Content( text="we should go out for lunch tomorrow", ) 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(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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
a39f8dcb-b77e-ec1a-9801-8791939859bf
If I don't have anything scheduled on the 20th of this month on my calendar, message Alice and ask if she wants to go dinner.
# test data data_model = DataModel(reset=True) data_date_time_20 = DateTime( text="20th of this month", value=datetime.now().replace(day=20) ) data_model.append(data_date_time_20) data_date_time_19 = DateTime( text="19th of this month", value=datetime.now().replace(day=19) ) data_model.append(data_date_time_19) data_calendar = EventCalendar(text="my calendar") data_model.append(data_calendar) data_event_name = EventName(text="dinner") data_model.append( EventEntity( date_time=data_date_time_19, event_calendar=data_calendar, event_name=data_event_name, ) ) data_recipient = Contact(text="Alice") data_model.append(data_recipient) data_content = Content(text="she wants to go dinner") 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}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
071c725c-ab7a-ecba-6ded-15f5e6079061
If I don't have anything scheduled on the 20th of this month on my calendar, message Alice and ask if she wants to go dinner.
# test data data_model = DataModel(reset=True) data_date_time_20 = DateTime( text="20th of this month", value=datetime.now().replace(day=20) ) data_model.append(data_date_time_20) data_date_time_19 = DateTime( text="19th of this month", value=datetime.now().replace(day=19) ) data_model.append(data_date_time_19) data_calendar = EventCalendar(text="my calendar") data_model.append(data_calendar) data_event_name = EventName(text="dinner") data_model.append( EventEntity( date_time=data_date_time_20, event_calendar=data_calendar, event_name=data_event_name, ) ) data_recipient = Contact(text="Alice") data_model.append(data_recipient) data_content = Content(text="she wants to go dinner") 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c7c54e7b-425b-7a0c-9790-53c6633eec5b
Set the A/C to 72 degrees and set a timer for 30 minutes.
# 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 A/C", value="A/C") data_model.append(data_home_device_name) data_home_device_value = HomeDeviceValue(text="72 degrees", value=72) data_model.append(data_home_device_value) data_duration_30 = TimeDuration(text="30 minutes") data_model.append(data_duration_30) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(HomeDeviceEntity) expected = [ { "device_name": data_home_device_name, "device_action": data_home_device_action, "device_value": data_home_device_value, } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(TimerEntity) expected = [{"duration": data_duration_30}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
761f22b2-c159-3d0b-b87e-0b606f990ba4
Buy a ticket for the new Wakanda movie, What is Friday's weather going to be like?
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="the new Wakanda movie") data_model.append(data_event_name) data_event = EventEntity(event_name=data_event_name) data_model.append(data_event) data_date_time = DateTime( text="Friday", value=datetime.now() + timedelta(days=((7 + 4 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time) data_weather_forecast = WeatherForecastEntity(date_time=data_date_time) data_model.append(data_weather_forecast) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(EventTicketEntity) expected = [{"event": data_event}] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([WeatherForecastEntity])) actual = next(iterator, None) expected = [data_weather_forecast] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
98fbc42f-aedc-0249-2397-cb5962ea3a3f
Set a timer for 5 minutes and then when the timer is up send a message to Justin, telling him I am finished with the job.
# test data data_model = DataModel(reset=True) data_duration = TimeDuration(text="5 minutes") data_model.append(data_duration) data_date_time_5m = DateTime( text="5 minutes", value=datetime.now() + timedelta(minutes=5) ) data_model.append(data_date_time_5m) data_recipient = Contact(text="Justin", value="Justin Bieber") data_model.append(data_recipient) data_content = Content( text="I am finished with the job", value="I am finished with the job" ) data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(TimerEntity) expected = [{"duration": data_duration}] entity_assertions(expected, actual, test_results) actual = data_model.get_data(MessageEntity) expected = [ { "recipient": data_recipient, "content": data_content, "date_time": data_date_time_5m, } ] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
fb644351-560d-8296-fe6d-a332236b1f8d
Find the nearest In N Out and send a text to Bryan asking for his order.
# test data data_model = DataModel(reset=True) data_location1 = Location(text="In N Out", nearest=10) data_model.append(data_location1) data_location2 = Location(text="In N Out", nearest=2) data_model.append(data_location2) data_location3 = Location(text="In N Out", nearest=5) data_model.append(data_location3) data_map_entity1 = MapEntity(location=data_location1) data_model.append(data_map_entity1) data_map_entity2 = MapEntity(location=data_location2) data_model.append(data_map_entity2) data_map_entity3 = MapEntity(location=data_location3) data_model.append(data_map_entity3) data_recipient = Contact(text="Bryan") data_model.append(data_recipient) data_content = Content(text="his order") data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([MapEntity])) actual = next(iterator, None) expected = [data_map_entity2] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
fe2ef495-a115-2561-5729-49784c16bf23
Set a timer for 6 AM to wake up, also set the thermostat to turn up the temperature by 5 degrees at 6 AM.
# test data data_model = DataModel(reset=True) data_date_time_6am = DateTime( text="6 AM", value=datetime.now().replace(hour=6, minute=0) ) data_model.append(data_date_time_6am) data_home_device_name = HomeDeviceName( text="the thermostat", ) data_model.append(data_home_device_name) data_home_device_action = HomeDeviceAction( text="turn up the temperature", ) data_model.append(data_home_device_action) data_home_device_value = HomeDeviceValue(text="by 5 degrees", value=25) 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(TimerEntity) expected = [{"date_time": data_date_time_6am}] entity_assertions(expected, actual, test_results) actual = data_model.get_data(HomeDeviceEntity) expected = [ { "device_name": data_home_device_name, "device_value": data_home_device_value, "device_action": data_home_device_action, } ] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
827bfc45-8708-f0b4-4200-9c9c9836f7e4
Turn on the lights in the hallway at 7 pm and start playing my playlist at 8 pm.
# test data data_model = DataModel(reset=True) data_home_device_action = HomeDeviceAction(text="turn on") data_model.append(data_home_device_action) data_home_device_value = HomeDeviceValue(text="on") data_model.append(data_home_device_value) data_home_device_name = HomeDeviceName(text="the lights in the hallway") data_model.append(data_home_device_name) data_date_time_7pm = DateTime( text="at 7 pm", value=datetime.now().replace(hour=6, minute=0) ) data_model.append(data_date_time_7pm) data_playlist = Playlist(text="my playlist") data_model.append(data_playlist) data_date_time_8pm = DateTime( text="at 8 pm", value=datetime.now().replace(hour=8, minute=0) ) data_model.append(data_date_time_8pm) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(HomeDeviceEntity) expected = [ { "device_name": data_home_device_name, "device_action": data_home_device_action, "device_value": data_home_device_value, "date_time": data_date_time_7pm, } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(MusicEntity) expected = [{"playlist": data_playlist, "date_time": data_date_time_8pm}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
64e095fe-763f-c624-1837-8753f9402623
Set a reminder at 3:00 PM that I will need to pick up my items from the store, and text Jason to meet me at the store at 2:50 PM.
# test data data_model = DataModel(reset=True) data_date_time = DateTime(text="at 3 PM") data_model.append(data_date_time) data_content = Content( text="I will need to pick up my items from the store", ) data_model.append(data_content) data_message_content_type = MessageContentType(text="text") data_model.append(data_message_content_type) data_recipient = Contact(text="Jason") data_model.append(data_recipient) data_content_message = Content(text="meet me at the store at 2:50 PM") data_model.append(data_content_message) # 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) actual = data_model.get_data(MessageEntity) expected = [ { "recipient": data_recipient, "content": data_content_message, "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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
a9334987-ece7-8b6f-e8bf-130ef00b7484
Set the thermostat to 70 degrees and play my romantic playlist.
# 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 thermostat") data_model.append(data_home_device_name) data_home_device_value = HomeDeviceValue(text="70 degrees") data_model.append(data_home_device_value) data_playlist = Playlist(text="my romantic playlist", value="my romantic playlist") data_model.append(data_playlist) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(HomeDeviceEntity) expected = [ { "device_name": data_home_device_name, "device_action": data_home_device_action, "device_value": data_home_device_value, } ] entity_assertions(expected, actual, test_results) actual = data_model.get_data(MusicEntity) expected = [{"playlist": data_playlist}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
80e28a51-cbc2-6fa4-bd34-938c5e593b36
Remind me to send an email to Mom and Dad tomorrow and delete the appointment in my calendar for Tuesday.
# test data data_model = DataModel(reset=True) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_content = Content(text="send an email to Mom and Dad") data_model.append(data_content) data_date_time = DateTime(text="Tuesday") data_model.append(data_date_time) data_date_time2 = DateTime(text="Wednesday") data_model.append(data_date_time2) data_calendar = EventCalendar(text="my calendar") data_model.append(data_calendar) data_event1 = EventEntity(date_time=data_date_time, event_calendar=data_calendar) data_model.append(data_event1) data_event2 = EventEntity(date_time=data_date_time2, event_calendar=data_calendar) data_model.append(data_event2) # 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}] entity_assertions(expected, actual, test_results) actual = data_model.get_data(EventEntity) expected = [{"date_time": data_date_time2, "event_calendar": data_calendar}] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
8effee40-9c62-5e1a-2d8f-5033631840e6
If Walmart has Jurassic World on bluray, buy it so I can pick it up tomorrow morning.
# test data data_model = DataModel(reset=True) data_store = Location(text="Walmart") data_model.append(data_store) data_product_name = ProductName(text="Jurassic World on bluray") data_model.append(data_product_name) data_product = ProductEntity(location=data_store, product_name=data_product_name) 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, "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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
a19f469a-ee1c-af42-afcd-6dfd2aa9d4e2
If Walmart has Jurassic World on bluray, buy it so I can pick it up tomorrow morning.
# test data data_model = DataModel(reset=True) data_store1 = Location(text="Amazon") data_model.append(data_store1) data_store2 = Location(text="Walmart") data_model.append(data_store2) data_product_name = ProductName(text="Jurassic World on bluray") data_model.append(data_product_name) data_product = ProductEntity(location=data_store1, product_name=data_product_name) 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 = [] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
1fa6447b-3a56-084e-2a72-22e3fe725f53
Get directions to Portland, and tell me if it will snow along the route in the next hour
# test data data_model = DataModel(reset=True) data_destination = Location(text="Portland") data_model.append(data_destination) data_direction = NavigationDirectionEntity(destination=data_destination) data_model.append(data_direction) data_weather_attribute = WeatherAttribute(text="snow") data_model.append(data_weather_attribute) data_date_time = DateTime( text="in the next hour", ) data_model.append(data_date_time) data_location = Location(value=data_direction) data_model.append(data_location) data_weather_forecast = WeatherForecastEntity( location=data_location, weather_attribute=data_weather_attribute, date_time=data_date_time, ) data_model.append(data_weather_forecast) # 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_direction] response_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([WeatherForecastEntity])) actual = next(iterator, None) expected = [data_weather_forecast] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
5a5b0f9b-7d3f-8fc8-4c3c-ef8fd8efaaa6
Check the weather and text Mike that I will meet them later if it's hot.
# test data data_model = DataModel(reset=True) data_weather_attribute1 = WeatherAttribute(text="hot") data_model.append(data_weather_attribute1) data_weather_attribute2 = WeatherAttribute(text="cold") data_model.append(data_weather_attribute2) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute1 ) data_model.append(data_weather_forecast) data_recipient = Contact(text="Mike") data_model.append(data_recipient) data_content = Content(text="I will meet them later") 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(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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
933ebca0-b2ae-a422-dbad-d84726497721
Check the weather and text Mike that I will meet them later if it's hot.
# test data data_model = DataModel(reset=True) data_weather_attribute1 = WeatherAttribute(text="hot") data_model.append(data_weather_attribute1) data_weather_attribute2 = WeatherAttribute(text="cold") data_model.append(data_weather_attribute2) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute2 ) data_model.append(data_weather_forecast) data_recipient = Contact(text="Mike") data_model.append(data_recipient) data_content = Content(text="I will meet them later") 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(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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
9a1f1f6d-833a-ad81-c985-670c3647353f
If the weather is going to be sunny Saturday morning, send an email to Ashley asking if she wants to go for a hike.
# test data data_model = DataModel(reset=True) data_weather_attribute1 = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute1) data_weather_attribute2 = WeatherAttribute(text="cloudy") data_model.append(data_weather_attribute2) data_date_time_sat = DateTime( text="Saturday morning", value=datetime.now() + timedelta(days=((7 + 5 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time_sat) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute1, date_time=data_date_time_sat ) data_model.append(data_weather_forecast) data_message_content_type = MessageContentType(text="email") data_model.append(data_message_content_type) data_recipient = Contact(text="Ashley", value="Ashley Smith") data_model.append(data_recipient) data_content = Content(text="she wants to go for a hike") 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, } ] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c0c42ffc-8bb3-e3e9-89f5-9e5dfd2b7ae7
If the weather is going to be sunny Saturday morning, send an email to Ashley asking if she wants to go for a hike.
# test data data_model = DataModel(reset=True) data_weather_attribute1 = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute1) data_weather_attribute2 = WeatherAttribute(text="cloudy") data_model.append(data_weather_attribute2) data_date_time_sat = DateTime( text="Saturday morning", value=datetime.now() + timedelta(days=((7 + 5 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time_sat) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute2, date_time=data_date_time_sat ) data_model.append(data_weather_forecast) data_message_content_type = MessageContentType(text="email") data_model.append(data_message_content_type) data_recipient = Contact(text="Ashley", value="Ashley Smith") data_model.append(data_recipient) data_content = Content(text="she wants to go for a hike") 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
dabfe7ab-2862-4f70-7a38-3cb0a847c10a
Send a message to my friends list on Monday telling them to remember to vote and set a reminder to me too.
# test data data_model = DataModel(reset=True) data_message_content_type = MessageContentType(text="a message") data_model.append(data_message_content_type) data_recipients = [] for text, value in [ ("my friends list", "Tom"), ("my friends list", "Jerry"), ("my friends list", "Mike"), ("my friends list", "Ashley"), ]: data_recipient = Contact(text=text, value=value) data_model.append(data_recipient) data_recipients.append(data_recipient) data_date_time_mon = DateTime( text="on Monday", value=datetime.now() + timedelta(days=((7 + 0 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time_mon) data_content = Content(text="remember to vote") data_model.append(data_content) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(MessageEntity) expected = list( map( lambda data_recipient: { "recipient": data_recipient, "content": data_content, "message_content_type": data_message_content_type, }, data_recipients, ) ) entity_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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
2a459380-709e-2fe4-ac2d-ae5733c73225
Show me all of the musical events within 10 miles of me.
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="all of the musical events") data_model.append(data_event_name) data_location = Location(text="within 10 miles of me") data_model.append(data_location) data_expected_events = [] for _ in range(3): data_event = EventEntity( event_name=data_event_name, location=data_location, ) data_model.append(data_event) data_expected_events.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_expected_events 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
59129aac-fb6c-ebbe-2c52-f30ef3424209
Play my favorite music playlist and tell John I am running late and will be there soon.
# test data data_model = DataModel(reset=True) data_playlist = Playlist(text="my favorite music playlist") data_model.append(data_playlist) data_recipient = Contact(text="John") data_model.append(data_recipient) data_content = Content(text="I am running late and will be there soon") data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(MusicEntity) expected = [{"playlist": data_playlist}] entity_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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
b4c96d80-854d-d27e-76d8-cc9e21960eeb
Look up current prices for Chicago Blackhawks tickets for tomorrow's game and tell me what the traffic conditions will be like around 5 PM
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="Chicago Blackhawks") data_model.append(data_event_name) data_date_time_tomorrow = DateTime( text="tomorrow", value=datetime.now() + timedelta(days=1) ) data_model.append(data_date_time_tomorrow) data_event_ticket = EventTicketEntity( event_name=data_event_name, date_time=data_date_time_tomorrow ) data_model.append(data_event_ticket) data_date_time_5pm = DateTime(text="5 PM", value=datetime.now().replace(hour=17)) data_model.append(data_date_time_5pm) data_nav_traffic_info = NavigationTrafficInfoEntity(date_time=data_date_time_5pm) data_model.append(data_nav_traffic_info) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([EventTicketEntity])) actual = next(iterator, None) expected = [data_event_ticket] response_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationTrafficInfoEntity])) actual = next(iterator, None) expected = [data_nav_traffic_info] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
b7103ca2-78a7-5cad-8f7d-065acda0c2e8
Set timer to 30 mins and remind me to take the fish out of the oven.
# test data data_model = DataModel(reset=True) data_time_duration = TimeDuration(text="30 mins") data_model.append(data_time_duration) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_content = Content(text="take the fish out of the oven") data_model.append(data_content) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(TimerEntity) expected = [{"duration": data_time_duration}] entity_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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
d02560dd-9d7d-b446-7627-745bd6701e80
Check the weather and if it's above 80 degrees, set a reminder on my calendar for "Go to the park later"
# test data data_model = DataModel(reset=True) data_weather_temperature1 = WeatherTemperature(text="above 80 degrees") data_model.append(data_weather_temperature1) data_weather_temperature2 = WeatherTemperature(text="79 degrees") data_model.append(data_weather_temperature2) data_weather_forecast = WeatherForecastEntity( weather_temperature=data_weather_temperature1 ) data_model.append(data_weather_forecast) data_calendar = EventCalendar(text="my calendar") data_model.append(data_calendar) data_content = Content(text="Go to the park later") 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 = [{"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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
c8a43ea6-1fb6-4fb1-e2f8-af24a3cc9814
Check the weather and if it's above 80 degrees, set a reminder on my calendar for "Go to the park later"
# test data data_model = DataModel(reset=True) data_weather_temperature1 = WeatherTemperature(text="above 80 degrees") data_model.append(data_weather_temperature1) data_weather_temperature2 = WeatherTemperature(text="79 degrees") data_model.append(data_weather_temperature2) data_weather_forecast = WeatherForecastEntity( weather_temperature=data_weather_temperature2 ) data_model.append(data_weather_forecast) data_calendar = EventCalendar(text="my calendar") data_model.append(data_calendar) data_content = Content(text="Go to the park later") 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 = [] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
3c4fcdc0-45f4-f9df-6394-352a8b4a10bd
Remind me on Sunday about my doctor's appointment next Monday and give me directions to the doctor's office.
# test data data_model = DataModel(reset=True) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_date_time_sunday = DateTime( text="on Sunday", value=datetime.now() + timedelta(days=((7 + 6 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time_sunday) data_content = Content(text="my doctor's appointment next Monday") data_model.append(data_content) data_destination = Location(text="the doctor's office") data_model.append(data_destination) data_navigation_direction = NavigationDirectionEntity(destination=data_destination) data_model.append(data_navigation_direction) # 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_sunday, "content": data_content, } ] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationDirectionEntity])) actual = next(iterator, None) expected = [data_navigation_direction] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
35e995c1-07a7-1cae-b833-bb3b79f9f547
For Shakey Graves' upcoming summer tour, what will be the closest show to me and how many miles away is the venue?
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="Shakey Graves' upcoming summer tour") data_model.append(data_event_name) data_event1 = EventEntity(event_name=data_event_name, closest=10) data_model.append(data_event1) data_event2 = EventEntity(event_name=data_event_name, closest=25) data_model.append(data_event2) data_event3 = EventEntity(event_name=data_event_name, closest=3) data_model.append(data_event3) data_destination = Location(value=data_event3) data_model.append(data_destination) data_navigation_distance = NavigationDistanceEntity(destination=data_destination) data_model.append(data_navigation_distance) # 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_event3] response_assertions(expected, [actual], test_results) iterator = iter(data_model.get_response([NavigationDistanceEntity])) actual = next(iterator, None) expected = [data_navigation_distance] 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
450ddec8-dd20-6c2e-2ab1-aeeaa90e85e5
If is is raining at 8pm turn the heat up 5 degrees.
# test data data_model = DataModel(reset=True) data_weather_attribute1 = WeatherAttribute(text="raining") data_model.append(data_weather_attribute1) data_weather_attribute2 = WeatherAttribute(text="clear blue sky") data_model.append(data_weather_attribute2) data_date_time = DateTime( text="8pm", value=datetime.now().replace(hour=20, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute1, date_time=data_date_time ) ) data_home_device_name = HomeDeviceName(text="the heat") data_model.append(data_home_device_name) data_home_device_action = HomeDeviceAction(text="turn") data_model.append(data_home_device_action) data_home_device_value = HomeDeviceValue(text="up 5 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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
4b0f78fa-63de-2412-141b-f387999591d5
If is is raining at 8pm turn the heat up 5 degrees.
# test data data_model = DataModel(reset=True) data_weather_attribute1 = WeatherAttribute(text="raining") data_model.append(data_weather_attribute1) data_weather_attribute2 = WeatherAttribute(text="clear blue sky") data_model.append(data_weather_attribute2) data_date_time = DateTime( text="8pm", value=datetime.now().replace(hour=20, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute2, date_time=data_date_time ) ) data_home_device_name = HomeDeviceName(text="the heat") data_model.append(data_home_device_name) data_home_device_action = HomeDeviceAction(text="turn") data_model.append(data_home_device_action) data_home_device_value = HomeDeviceValue(text="up 5 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)
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 ( assert_equal, response_assertions, assert_test, entity_assertions, )
f2dc1d5d-2333-a6e0-f759-49ce45e6234d
If I get a text message from my boss Tony, then check my mail to see if I have any emails from work.
# test data data_model = DataModel(reset=True) data_message_content_type = MessageContentType(text="a text message") data_model.append(data_message_content_type) data_sender_boss = Contact(text="my boss Tony") data_model.append(data_sender_boss) data_sender_work1 = Contact(text="work", value="worker 1") data_model.append(data_sender_work1) data_sender_work2 = Contact(text="work", value="worker 2") data_model.append(data_sender_work2) data_message = MessageEntity( message_content_type=data_message_content_type, sender=data_sender_boss ) data_model.append(data_message) data_recipient = Contact(text="I") data_model.append(data_recipient) data_message_content_type_email = MessageContentType(text="any emails") data_model.append(data_message_content_type_email) data_message2 = MessageEntity( sender=data_sender_work1, recipient=data_recipient, message_content_type=data_message_content_type_email, ) data_model.append(data_message2) data_message3 = MessageEntity( sender=data_sender_work2, recipient=data_recipient, message_content_type=data_message_content_type_email, ) data_model.append(data_message3) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([MessageEntity])) actual = next(iterator, None) expected = [data_message2, data_message3] 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 *
adcb15ca-c578-a73b-db5b-bf2d9bc6a664
If I get a text message from my boss Tony, then check my mail to see if I have any emails from work.
# test data data_model = DataModel(reset=True) data_message_content_type = MessageContentType(text="a text message") data_model.append(data_message_content_type) data_sender_boss = Contact(text="my boss Tony") data_model.append(data_sender_boss) data_sender_work1 = Contact(text="work", value="worker 1") data_model.append(data_sender_work1) data_sender_work2 = Contact(text="work", value="worker 2") data_model.append(data_sender_work2) data_message = MessageEntity( message_content_type=data_message_content_type, sender=data_sender_work1 ) data_model.append(data_message) data_recipient = Contact(text="I") data_model.append(data_recipient) data_message_content_type_email = MessageContentType(text="any emails") data_model.append(data_message_content_type_email) data_message2 = MessageEntity( sender=data_sender_work1, recipient=data_recipient, message_content_type=data_message_content_type, ) data_model.append(data_message2) data_message3 = MessageEntity( sender=data_sender_work2, recipient=data_recipient, message_content_type=data_message_content_type, ) data_model.append(data_message3) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([MessageEntity])) 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 *
5d58cb96-cbb5-72fd-10ac-239fbab8a52b
Check the weather for next tuesday and create a beach day event on my calendar if the temperature is above 90 degrees.
# test data data_model = DataModel(reset=True) data_date_time_tuesday = DateTime( text="next tuesday", value=datetime.now() + timedelta(days=((7 + 1 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time_tuesday) data_weather_temperature = WeatherTemperature(text="above 90 degrees") data_model.append(data_weather_temperature) data_weather_temperature_neg = WeatherTemperature(text="below 80") data_model.append(data_weather_temperature_neg) data_weather_forecast = WeatherForecastEntity( date_time=data_date_time_tuesday, weather_temperature=data_weather_temperature ) data_model.append(data_weather_forecast) data_event_name = EventName(text="beach day") data_model.append(data_event_name) data_event_calendar = EventCalendar(text="my calendar") data_model.append(data_event_calendar) # 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(EventEntity) expected = [{"event_name": data_event_name, "event_calendar": data_event_calendar}] 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 *
b959b88c-8828-d389-5203-748f64704555
Check the weather for next tuesday and create a beach day event on my calendar if the temperature is above 90 degrees.
# test data data_model = DataModel(reset=True) data_date_time_tuesday = DateTime( text="next tuesday", value=datetime.now() + timedelta(days=((7 + 1 - datetime.now().weekday()) % 7)), ) data_model.append(data_date_time_tuesday) data_weather_temperature = WeatherTemperature(text="above 90 degrees") data_model.append(data_weather_temperature) data_weather_temperature_neg = WeatherTemperature(text="below 80") data_model.append(data_weather_temperature_neg) data_weather_forecast = WeatherForecastEntity( date_time=data_date_time_tuesday, weather_temperature=data_weather_temperature_neg, ) data_model.append(data_weather_forecast) data_event_name = EventName(text="beach day") data_model.append(data_event_name) data_event_calendar = EventCalendar(text="my calendar") data_model.append(data_event_calendar) # 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(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 *
6989c50b-d2e0-8e7e-0423-aad5428a545e
Message my brother I will not be able to make it to his house for dinner because of a flat tire, also look up tire repair places nearby.
# test data data_model = DataModel(reset=True) data_message_content_type = MessageContentType(text="message") data_model.append(data_message_content_type) data_recipient = Contact(text="my brother") data_model.append(data_recipient) data_content = Content( text="I will not be able to make it to his house for dinner because of a flat tire" ) data_model.append(data_content) data_location1 = Location(text="tire repair places", nearby=12) data_model.append(data_location1) data_location2 = Location(text="tire repair places", nearby=11) data_model.append(data_location2) data_location3 = Location(text="tire repair places", nearby=10) data_model.append(data_location3) data_map_entity1 = MapEntity(location=data_location1) data_model.append(data_map_entity1) data_map_entity2 = MapEntity(location=data_location2) data_model.append(data_map_entity2) data_map_entity3 = MapEntity(location=data_location3) data_model.append(data_map_entity3) # 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, } ] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([MapEntity])) actual = next(iterator, None) expected = [data_map_entity3] 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 *
b888b298-26bb-53dc-5314-37e723738383
Set a timer for 3:00 PM then enable home security alarm system to stay on until 8:00 PM
# test data data_model = DataModel(reset=True) data_date_time_3pm = DateTime( text="3:00 PM", value=datetime.now().replace(hour=15, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time_3pm) data_home_device_action = HomeDeviceAction(text="enable") data_model.append(data_home_device_action) data_home_device_name = HomeDeviceName(text="home security alarm") data_model.append(data_home_device_name) data_home_device_value = HomeDeviceValue(text="stay on") data_model.append(data_home_device_value) data_date_time_8pm = DateTime( text="until 8:00 PM", value=datetime.now().replace(hour=20, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time_8pm) # 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_3pm}] entity_assertions(expected, actual, 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": data_date_time_8pm, } ] 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 *
1d513c0b-cbe3-3b2e-7440-e5e14d0b22ef
If it starts raining between 3pm-5pm, turn the thermostat up to 73 degrees.
# 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="sunny") data_model.append(data_weather_attribute_neg) data_date_time = DateTime( text="between 3pm-5pm", value=datetime.now().replace(hour=15, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute, date_time=data_date_time ) ) data_home_device_action = HomeDeviceAction(text="turn") 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="up tp 73 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 *
58a59665-c255-17a7-d64e-05943bb63614
If it starts raining between 3pm-5pm, turn the thermostat up to 73 degrees.
# 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="sunny") data_model.append(data_weather_attribute_neg) data_date_time = DateTime( text="between 3pm-5pm", value=datetime.now().replace(hour=15, minute=0, second=0, microsecond=0), ) data_model.append(data_date_time) data_model.append( WeatherForecastEntity( weather_attribute=data_weather_attribute_neg, date_time=data_date_time ) ) data_home_device_action = HomeDeviceAction(text="turn") 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="up tp 73 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 *
c0f00a63-0854-ea1e-cc43-c1f53dfdb559
Show me a map of downtown Phoenix and give me directions to the airport.
# test data data_model = DataModel(reset=True) data_location = Location(text="downtown Phoenix") data_model.append(data_location) data_place = MapEntity(location=data_location) data_model.append(data_place) data_destination = Location(text="airport") data_model.append(data_destination) data_navigation_direction = NavigationDirectionEntity(destination=data_destination) data_model.append(data_navigation_direction) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response([MapEntity])) actual = next(iterator, None) expected = [data_place] response_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationDirectionEntity])) actual = next(iterator, None) expected = [data_navigation_direction] 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 *
3c26dffc-8a2e-8804-dfe2-c8a1195cfaa5
Play my lofi Spotify playlist and buy tickets to the upcoming Joji show.
# test data data_model = DataModel(reset=True) data_playlist = Playlist(text="my lofi Spotify playlist") data_model.append(data_playlist) data_event_name = EventName(text="the upcoming Joji show") data_model.append(data_event_name) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(MusicEntity) expected = [{"playlist": data_playlist}] entity_assertions(expected, actual, test_results) actual = data_model.get_data(EventTicketEntity) expected = [{"event_name": data_event_name}] 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 *
e62d7f1e-b43d-87c2-02d2-f164ba61297e
Check if it's supposed to rain tonight and if it's not text Brian that I want to go out tonight
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="rain") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="not rain") data_model.append(data_weather_attribute_neg) data_date_time = DateTime(text="tonight") 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_message_content_type = MessageContentType(text="text") data_model.append(data_message_content_type) data_contact_brian = Contact(text="Brian") data_model.append(data_contact_brian) data_content = Content(text="I want to go out tonight") 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 = [] response_assertions(expected, actual, test_results) actual = data_model.get_data(MessageEntity) expected = [ { "message_content_type": data_message_content_type, "recipient": data_contact_brian, "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 *
fca81add-6423-fd6d-e07b-86a7f22eb161
Check if it's supposed to rain tonight and if it's not text Brian that I want to go out tonight
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="rain") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="not rain") data_model.append(data_weather_attribute_neg) data_date_time = DateTime(text="tonight") 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_message_content_type = MessageContentType(text="text") data_model.append(data_message_content_type) data_contact_brian = Contact(text="Brian") data_model.append(data_contact_brian) data_content = Content(text="I want to go out tonight") 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(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 *
271462c2-cebd-512e-1c20-f9e8409b2e70
Look up free events for this weekend and let me know what the weather will be.
# test data data_model = DataModel(reset=True) data_event_name1 = EventName(text="free events", value="art show") data_model.append(data_event_name1) data_event_name2 = EventName(text="free events", value="community event") data_model.append(data_event_name2) data_date_time1 = DateTime( text="this weekend", value=datetime.now() + timedelta(days=0) ) data_model.append(data_date_time1) data_date_time2 = DateTime( text="this weekend", value=datetime.now() + timedelta(days=0) ) data_model.append(data_date_time2) data_model.append( data_event1 := EventEntity( event_name=data_event_name1, date_time=data_date_time1 ) ) data_model.append( data_event2 := EventEntity( event_name=data_event_name1, date_time=data_date_time2 ) ) data_model.append( data_event3 := EventEntity( event_name=data_event_name2, date_time=data_date_time2 ) ) data_model.append( data_weather_forecast1 := WeatherForecastEntity(date_time=data_date_time1) ) data_model.append( data_weather_forecast2 := WeatherForecastEntity(date_time=data_date_time2) ) # 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, data_event3] response_assertions(expected, actual, 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) 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 *
8ee51caa-a2c2-f4ee-2e5b-4b7ef5a89db7
When rain is forecasted for tomorrow? remind me at 9pm the night before to put out Quinten's boots by the front door.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="rain") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="not rain") data_model.append(data_weather_attribute_neg) data_date_time_tomorrow = DateTime( text="tomorrow", ) data_model.append(data_date_time_tomorrow) data_model.append( data_weather_forecast1 := WeatherForecastEntity( weather_attribute=data_weather_attribute, date_time=data_date_time_tomorrow ) ) data_model.append( data_weather_forecast2 := WeatherForecastEntity( weather_attribute=data_weather_attribute_neg, date_time=data_date_time_tomorrow, ) ) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_date_time_9pm = DateTime( text="9pm the night before", ) data_model.append(data_date_time_9pm) data_content = Content(text="put out Quinten's boots by the front door") 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_forecast1] response_assertions(expected, actual, test_results) actual = data_model.get_data(ReminderEntity) expected = [ { "person_reminded": data_person_reminded, "date_time": data_date_time_9pm, "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 *
215bb47d-a8fa-c334-2b85-8ac3db09b033
Add almond milk, pomegranate seeds, and granola to my shopping list and set a reminder for Saturday morning at 9am that I need to be home from the store by noon.
# test data data_model = DataModel(reset=True) data_product_name1 = ProductName( text="almond milk, pomegranate seeds, and granola", value="almond milk" ) data_model.append(data_product_name1) data_product_name2 = ProductName( text="almond milk, pomegranate seeds, and granola", value="pomegranate seeds" ) data_model.append(data_product_name2) data_product_name3 = ProductName( text="almond milk, pomegranate seeds, and granola", value="granola" ) data_model.append(data_product_name3) data_shopping_list_name = ShoppingListName(text="my shopping list") data_model.append(data_shopping_list_name) data_date_time = DateTime(text="Saturday morning at 9am") data_model.append(data_date_time) data_content = Content(text="I need to be home from the store by noon") 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 = [ { "product_name": data_product_name, "shopping_list_name": data_shopping_list_name, } for data_product_name in [ data_product_name1, data_product_name2, data_product_name3, ] ] entity_assertions(expected, actual, 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 *
6fb84aed-32fa-cd12-99ee-1e77c8fd2b1a
Check my calendar for this weekend and message Ashley to invite her to lunch for whichever day I have free time in the afternoon.
# test data data_model = DataModel(reset=True) data_event_calendar = EventCalendar(text="my calendar") data_model.append(data_event_calendar) data_date_time1 = DateTime(text="this weekend", value="Saturday") data_model.append(data_date_time1) data_date_time2 = DateTime(text="this weekend", value="Sunday") data_model.append(data_date_time2) data_event1 = EventEntity( event_calendar=data_event_calendar, date_time=data_date_time1 ) data_model.append(data_event1) data_event2 = EventEntity( event_calendar=data_event_calendar, date_time=data_date_time2 ) data_model.append(data_event2) data_recipient = Contact(text="Ashley") data_model.append(data_recipient) data_content = Content( text="invite her to lunch for whichever day I have free time in the afternoon" ) data_model.append(data_content) # 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) 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 *
31bd9b9f-5f7b-338e-41b5-6183a2f3008b
Go shopping and buy multiples of items on my shopping list and prompt me after you buy it, as well as set a reminder of the time it will be delivered.
# test data data_model = DataModel(reset=True) data_shopping_list_name = ShoppingListName(text="my shopping list") data_model.append(data_shopping_list_name) # start code block to test # end code block to test # assertions test_results = {} iterator = iter(data_model.get_response(OrderEntity)) actual = next(iterator, None) expected = OrderEntity(shopping_list_name=data_shopping_list_name) response_assertions([expected], [actual], test_results) actual = data_model.get_data(ReminderEntity) expected = [ { "date_time": DateTime(value=order), } for order in data_model.get_data(OrderEntity) ] 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 *
9a79be61-1e02-67e1-d943-da0737c6c51b
Set an alarm for 7:30am and notify me with a reminder 2 hours later that I need to message Vincent with an update on our work project.
# test data data_model = DataModel(reset=True) data_date_time = DateTime(text="7:30am") data_model.append(data_date_time) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_date_time2 = DateTime(text="2 hours later") data_model.append(data_date_time2) data_content = Content( text="I need to message Vincent with an update on our work project" ) data_model.append(data_content) # 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 = [ { "person_reminded": data_person_reminded, "date_time": data_date_time2, "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 *
c8306ae1-39ac-98f4-3293-2286151dc0ec
In the event that Jessica messages with road closure information downtown, create a 3pm alarm, so I can leave earlier.
# test data data_model = DataModel(reset=True) data_sender = Contact(text="Jessica") data_model.append(data_sender) data_content = Content(text="road closure information downtown") data_model.append(data_content) data_content_neg = Content(text="all roads are clear") data_model.append(data_content_neg) data_date_time = DateTime(text="3pm") data_model.append(data_date_time) data_message = MessageEntity(sender=data_sender, content=data_content) data_model.append(data_message) # 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 *
9e50a4e6-2ab0-01f0-149a-144043d83e14
In the event that Jessica messages with road closure information downtown, create a 3pm alarm, so I can leave earlier.
# test data data_model = DataModel(reset=True) data_sender = Contact(text="Jessica") data_model.append(data_sender) data_content = Content(text="road closure information downtown") data_model.append(data_content) data_content_neg = Content(text="all roads are clear") data_model.append(data_content_neg) data_date_time = DateTime(text="3pm") data_model.append(data_date_time) data_message = MessageEntity(sender=data_sender, content=data_content_neg) data_model.append(data_message) # 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 *
36ba6496-dd1a-39ce-aa44-babed71ee5ea
Order tickets for the art festival this weekend and add the address to my navigation.
# test data data_model = DataModel(reset=True) data_event_name = EventName(text="the art festival") data_model.append(data_event_name) data_date_time1 = DateTime(text="this weekend", value="Saturday") data_model.append(data_date_time1) data_date_time2 = DateTime(text="this weekend", value="Sunday") data_model.append(data_date_time2) 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_destination1 = Location(value=data_event1) data_model.append(data_destination1) data_destination2 = Location(value=data_event2) data_model.append(data_destination2) data_navigation_direction1 = NavigationDirectionEntity( destination=data_destination1 ) data_model.append(data_navigation_direction1) data_navigation_direction2 = NavigationDirectionEntity( destination=data_destination2 ) data_model.append(data_navigation_direction2) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(EventTicketEntity) expected = [ { "event": data_event1, }, { "event": data_event2, }, ] entity_assertions(expected, actual, test_results) iterator = iter(data_model.get_response([NavigationDirectionEntity])) actual = next(iterator, None) expected = [data_navigation_direction1, 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 *
e114c448-f4ab-8554-ad14-eff3d66dfeb3
The temperature at home should be set to 82 degrees after texting Bob about picking the kids up from soccer practice.
# test data data_model = DataModel(reset=True) data_device_name = HomeDeviceName(text="The temperature at home") data_model.append(data_device_name) data_device_action = HomeDeviceAction(text="set") data_model.append(data_device_action) data_device_value = HomeDeviceValue(text="82 degrees") data_model.append(data_device_value) data_recipient = Contact(text="Bob") data_model.append(data_recipient) data_content = Content(text="picking the kids up from soccer practice") 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}] entity_assertions(expected, actual, test_results) actual = data_model.get_data(HomeDeviceEntity) expected = [ { "device_name": data_device_name, "device_action": data_device_action, "device_value": data_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 *
17503a6b-2326-f09f-bc4e-3a7c03874c73
Send an email to manager Steve after I get a text confirmation for the meeting from Jennie.
# test data data_model = DataModel(reset=True) data_message_content_type = MessageContentType(text="an email") data_model.append(data_message_content_type) data_recipient_steve = Contact(text="manager Steve") data_model.append(data_recipient_steve) data_recipient_i = Contact(text="I") data_model.append(data_recipient_i) data_content = Content(text="a text confirmation for the meeting") data_model.append(data_content) data_content_neg = Content(text="cannot attend") data_model.append(data_content_neg) data_sender = Contact(text="Jennie") data_model.append(data_sender) data_message = MessageEntity( sender=data_sender, content=data_content, recipient=data_recipient_i ) 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 = [ { "recipient": data_recipient_i, "content": data_content, "sender": data_sender, }, { "message_content_type": data_message_content_type, "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 *
905db08d-9573-60d6-e196-bf45a4d2faec
Send an email to manager Steve after I get a text confirmation for the meeting from Jennie.
# test data data_model = DataModel(reset=True) data_message_content_type = MessageContentType(text="an email") data_model.append(data_message_content_type) data_recipient_steve = Contact(text="manager Steve") data_model.append(data_recipient_steve) data_recipient_i = Contact(text="I") data_model.append(data_recipient_i) data_content = Content(text="a text confirmation for the meeting") data_model.append(data_content) data_content_neg = Content(text="cannot attend") data_model.append(data_content_neg) data_sender = Contact(text="Jennie") data_model.append(data_sender) data_message = MessageEntity( sender=data_sender, content=data_content_neg, recipient=data_recipient_i ) 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 = [ { "recipient": data_recipient_i, "content": data_content_neg, "sender": 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 *
d9feafdf-bf25-eb20-c728-39939e099837
In the case that I receive an email from Kaiser Permanente, remind me to read it after 10 minutes.
# test data data_model = DataModel(reset=True) data_recipient = Contact(text="I") data_model.append(data_recipient) data_message_content_type = MessageContentType(text="an email") data_model.append(data_message_content_type) data_message_content_type_neg = MessageContentType(text="an email") data_model.append(data_message_content_type_neg) data_sender = Contact(text="Kaiser Permanente") data_model.append(data_sender) data_message = MessageEntity( recipient=data_recipient, sender=data_sender, message_content_type=data_message_content_type, ) data_model.append(data_message) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_content = Content(text="read it") data_model.append(data_content) data_date_time = DateTime(text="after 10 minutes") data_model.append(data_date_time) # start code block to test # end code block to test # assertions test_results = {} actual = data_model.get_data(ReminderEntity)[-1:] expected = [ { "person_reminded": data_person_reminded, "content": data_content, "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 *
e20df7f3-a964-3dbf-bd6d-08947ba6a1f8
In the case that I receive an email from Kaiser Permanente, remind me to read it after 10 minutes.
# test data data_model = DataModel(reset=True) data_recipient = Contact(text="I") data_model.append(data_recipient) data_message_content_type = MessageContentType(text="an email") data_model.append(data_message_content_type) data_message_content_type_neg = MessageContentType(text="a text") data_model.append(data_message_content_type_neg) data_sender = Contact(text="Kaiser Permanente") data_model.append(data_sender) data_message = MessageEntity( recipient=data_recipient, sender=data_sender, message_content_type=data_message_content_type_neg, ) data_model.append(data_message) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_content = Content(text="read it") data_model.append(data_content) data_date_time = DateTime(text="after 10 minutes") data_model.append(data_date_time) # 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 *
9be4efbc-d24f-a97e-4d47-8cb3279b55ca
On the 2nd of November set a reminder that I will be going out with friends and to remind me every 3 days before the event.
# test data data_model = DataModel(reset=True) data_date_time = DateTime(text="On the 2nd of November") data_model.append(data_date_time) data_content = Content(text="I will be going out with friends") data_model.append(data_content) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_date_times1 = DateTime(text="every 3 days before the event", value="day 1") data_model.append(data_date_times1) data_date_times2 = DateTime(text="every 3 days before the event", value="day 2") data_model.append(data_date_times2) # 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, }, { "person_reminded": data_person_reminded, "date_time": data_date_times1, }, { "person_reminded": data_person_reminded, "date_time": data_date_times2, }, ] 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 *
e993215b-fdaa-515f-6ea0-0fafc1918f54
In the case that the rain projection is above 90%, text my golf group and say that I am going to today's game.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="rain projection is above 90%") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="hot and sunny") data_model.append(data_weather_attribute_neg) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute ) data_model.append(data_weather_forecast) data_message_content_type = MessageContentType(text="text") data_model.append(data_message_content_type) data_recipient1 = Contact(text="my golf group", value="Joe") data_model.append(data_recipient1) data_recipient2 = Contact(text="my golf group", value="Brian") data_model.append(data_recipient2) data_content = Content(text="I am going to today's 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 *
64d4aef8-ef29-e1b9-9231-647b6d5d73e3
In the case that the rain projection is above 90%, text my golf group and say that I am going to today's game.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="rain projection is above 90%") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="hot and sunny") data_model.append(data_weather_attribute_neg) data_weather_forecast = WeatherForecastEntity( weather_attribute=data_weather_attribute_neg ) data_model.append(data_weather_forecast) data_message_content_type = MessageContentType(text="text") data_model.append(data_message_content_type) data_recipient1 = Contact(text="my golf group", value="Joe") data_model.append(data_recipient1) data_recipient2 = Contact(text="my golf group", value="Brian") data_model.append(data_recipient2) data_content = Content(text="I am going to today's 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 = [] 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 *
f8b254e1-7328-7422-fc59-9017be0503d2
Remind me to buy apples, dates, and cheese at the grocery store, and also remind me to text Nathan about Grandma's birthday party.
# test data data_model = DataModel(reset=True) data_person_reminded = Contact(text="me") data_model.append(data_person_reminded) data_content1 = Content(text="buy apples, dates, and cheese at the grocery store") data_model.append(data_content1) data_content2 = Content(text="text Nathan about Grandma's birthday party") data_model.append(data_content2) # 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_content1}, {"person_reminded": data_person_reminded, "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 *
8bd7954c-40c1-e59a-900f-71ea3a266732
Check for potential snowfall this weekend in Denver, and should the forecast say we're getting at least 6 inches, email Jason to invite him to go snowboarding.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="snowfall") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute_neg) data_date_time = DateTime(text="this weekend") data_model.append(data_date_time) data_location = Location(text="in Denver") data_model.append(data_location) data_weather = WeatherForecastEntity( date_time=data_date_time, location=data_location, weather_attribute=data_weather_attribute, ) data_model.append(data_weather) data_message_content_type = MessageContentType(text="email") data_model.append(data_message_content_type) data_recipient = Contact(text="Jason") data_model.append(data_recipient) data_content = Content(text="invite him to go snowboarding") 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, }, ] 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 *
c2d5e5ae-30e3-3f57-15ce-6ad5a4d93675
Check for potential snowfall this weekend in Denver, and should the forecast say we're getting at least 6 inches, email Jason to invite him to go snowboarding.
# test data data_model = DataModel(reset=True) data_weather_attribute = WeatherAttribute(text="snowfall") data_model.append(data_weather_attribute) data_weather_attribute_neg = WeatherAttribute(text="sunny") data_model.append(data_weather_attribute_neg) data_date_time = DateTime(text="this weekend") data_model.append(data_date_time) data_location = Location(text="in Denver") data_model.append(data_location) data_weather = WeatherForecastEntity( date_time=data_date_time, location=data_location, weather_attribute=data_weather_attribute_neg, ) data_model.append(data_weather) data_message_content_type = MessageContentType(text="email") data_model.append(data_message_content_type) data_recipient = Contact(text="Jason") data_model.append(data_recipient) data_content = Content(text="invite him to go snowboarding") 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 *
8fbf3d1b-29c4-9aa9-0769-775ebc7610e5