def test_prompt_interactions(self, _):
        """
        Note that the steps goals and numbers get in a weird positive feedback loop because of how I
        monkey patched the fitbit reader
        """

        num_days = param_db.get(param_db.Keys.WEEKS_WITH_ROBOT)*7

        initial_datetime = datetime.datetime(
            year=2019, month=1, day=1, hour=8, minute=6, second=3
        )
        with freeze_time(initial_datetime) as frozen_datetime:
            state_db.reset()
            self.abm_interaction = AbmInteraction()

            self.update_after_first_meeting()

            pm_checkin_datetime = self.get_pm_checkin_datetime(0, initial_datetime)
            frozen_datetime.move_to(pm_checkin_datetime)
            self.update_day_steps()
            self.abm_interaction.set_prompt_to_handle()
            self.abm_interaction.run_scheduler_once()
            self.update_after_am_checkin()

            self.assertTrue(state_db.is_set(state_db.Keys.FIRST_MEETING))
            self.assertTrue(state_db.get(state_db.Keys.IS_DONE_AM_CHECKIN_TODAY))
            self.assertTrue(state_db.get(state_db.Keys.IS_DONE_PM_CHECKIN_TODAY))
            self.assertTrue(state_db.get(state_db.Keys.IS_MET_GOAL))

            for day in range(1, num_days + 2):

                am_checkin_datetime = self.get_am_checkin_datetime(day, initial_datetime)
                frozen_datetime.move_to(am_checkin_datetime)
                self.abm_interaction._new_day_update()
                self.abm_interaction.set_prompt_to_handle()
                self.abm_interaction.run_scheduler_once()
                self.update_after_am_checkin()

                # Run non consequential off-checkin
                for _ in range(2):
                    self.abm_interaction.set_prompt_to_handle()
                    self.abm_interaction.run_scheduler_once()

                self.assertTrue(state_db.get(state_db.Keys.IS_DONE_AM_CHECKIN_TODAY))
                self.assertFalse(state_db.get(state_db.Keys.IS_DONE_PM_CHECKIN_TODAY))

                pm_checkin_datetime = self.get_pm_checkin_datetime(day, initial_datetime)
                frozen_datetime.move_to(pm_checkin_datetime)
                self.update_day_steps()
                self.abm_interaction.set_prompt_to_handle()
                self.abm_interaction.run_scheduler_once()

                self.assertTrue(state_db.get(state_db.Keys.IS_DONE_AM_CHECKIN_TODAY))
                self.assertTrue(state_db.get(state_db.Keys.IS_DONE_PM_CHECKIN_TODAY))
                self.assertTrue(state_db.get(state_db.Keys.IS_MET_GOAL))

                # Run non consequential off-checkin
                for _ in range(2):
                    self.abm_interaction._build_and_run_plan()
    def setUp(self) -> None:

        fitbit_patcher = mock.patch('abm_grant_interaction.abm_interaction.AbmFitbitClient')
        self._mock_fitbit = fitbit_patcher.start()
        self._mock_fitbit.return_value.get_last_sync.side_effect = lambda: datetime.datetime.now()
        self.set_steps_per_day(300)

        run_once_patcher = mock.patch('abm_grant_interaction.abm_interaction.AbmInteraction._build_and_run_plan')
        self._mock_run_once = run_once_patcher.start()
        self._mock_run_once.side_effect = self.build_and_simulate_plan

        state_db.reset()
        self.abm_interaction = AbmInteraction()
        self.mins_before_allowed = param_db.get(param_db.Keys.MINS_BEFORE_ALLOW_CHECKIN)
        self.mins_after_allowed = param_db.get(param_db.Keys.MINS_AFTER_ALLOW_CHECKIN)
Exemple #3
0
    def setUp(self) -> None:

        state_db.reset()

        self.true_plan = MessagerPlanner(possible_plans)
        self.builder = builder.PlanBuilder()
    def __init__(
        self,
        credentials_file_path="fitbit_credentials.yaml",
        redirect_url="http://localhost",
        is_data_recording_topic='data_capture/is_record',
        automaticity_topic='abm/automaticity',
        is_go_to_sleep_topic='cordial/sleep',
        interface=None,
        is_reset_state_db=False,
        goal_setter=None,
    ):

        if is_reset_state_db:
            logging.info("Reseting database")
            state_db.reset()

        self._plan_builder = PlanBuilder()
        if interface is None:
            interface = TerminalClientAndServerInterface(state_db)
        self._interface = interface
        self._fitbit = AbmFitbitClient(
            credentials_file_path=credentials_file_path,
            redirect_url=redirect_url,
        )

        start_days_before_first_meeting = datetime.timedelta(days=7)
        if state_db.is_set(state_db.Keys.FIRST_MEETING):
            start_date = state_db.get(
                state_db.Keys.FIRST_MEETING) - start_days_before_first_meeting
        else:
            start_date = datetime.datetime.now(
            ) - start_days_before_first_meeting

        if goal_setter is None:
            logging.info('Creating goal setter')
            goal_setter = GoalSetter(
                fitbit_active_steps_fn=self._fitbit.get_total_steps,
                start_date=start_date,
                num_weeks=param_db.get(param_db.Keys.WEEKS_WITH_ROBOT) +
                1,  # +1 for week with just fitbit
                final_week_goal=param_db.get(param_db.Keys.FINAL_STEPS_GOAL),
                min_weekly_steps_goal=param_db.get(
                    param_db.Keys.MIN_WEEKLY_STEPS_GOAL),
                week_goal_min_improvement_ratio=1.1,
                week_goal_max_improvement_ratio=2.0,
                daily_goal_min_to_max_ratio=2.5,
            )
        self._goal_setter = goal_setter

        self._is_recording_publisher = rospy.Publisher(is_data_recording_topic,
                                                       Bool,
                                                       queue_size=1)
        self._automaticity_publisher = rospy.Publisher(automaticity_topic,
                                                       Float32,
                                                       queue_size=1)
        self._is_go_to_sleep_publisher = rospy.Publisher(is_go_to_sleep_topic,
                                                         Bool,
                                                         queue_size=1)

        self._update_week_steps_and_goals()
        self._update_todays_steps()

        self._checkin_scheduler = schedule.Scheduler()

        self._update_scheduler = schedule.Scheduler()
        self._update_scheduler.every(15).seconds.do(self._new_day_update)

        self._is_prompt_to_run = False
        if state_db.is_set(state_db.Keys.FIRST_MEETING):
            self._build_checkin_schedule()
            state_db.set(state_db.Keys.IS_REDO_SCHEDULE, False)
        else:
            self._init_vars()