def bot(): replyStack = list() msg_in_json = request.get_json() msg_in_string = json.dumps(msg_in_json) replyToken = msg_in_json["events"][0]['replyToken'] userID = msg_in_json["events"][0]['source']['userId'] msgType = msg_in_json["events"][0]['message']['type'] if msgType != 'text': reply(replyToken, ['Only text is allowed.']) return 'OK', 200 sent = msg_in_json["events"][0]['message']['text'].lower().strip() if sent == 'reset': filebase.remove_user(userID) reply(replyToken, ['ลบข้อมูล State Machine บน firebase แล้ว']) return 'OK', 200 if sent in ['สวัสดี','สวัสดีจ้า','สวัสดีครับ','สวัสดีค่ะ','สวัสดีค้าบ','hello','hi','ทัก']: reply(replyToken, ['สวัสดีจ้า :)']) return 'OK', 200 state = StateMachine(push, token=userID) all_data = compute(sent) this_intention = all_data['intent'] this_information = all_data['frame'] state.get_input(this_intention, this_information) print("Intent:", this_intention) print("IR:", this_information) return 'OK', 200
def test_is_child_final_true(self): m = StateMachine() s = m.create_state('final', CompositeState) f = s.create_state('sfinal', FinalState) s.set_state(f) e = Event() self.assertTrue(guards.is_child_final(e, s))
def checkState1(self, value, info): if value['sendNum'] > 5: text = u"今天已经给你发送太多的短信了,明天再来吧" StateMachine.end(info.user) elif self.checkPhoneNum(info.text): try: user = WeixinUser.objects.get(phone=info.text) text = "这个手机号已经被使用了,请使用其他号码" except: user = None if user == None: verifyCode = str(random.randint(100000, 1000000)) ret = send_sms(info.text, u"验证码是%s,15分钟内有效" % verifyCode) logger.debug("send sms return %s" % ret) value = { 'state': 2, 'phone': info.text, 'verifyCode': verifyCode, "sendTime": time.time(), 'sendNum': value['sendNum'] + 1 } self.store(info.user, value) text = u'我们已经将验证码发送到%s,请将收到的验证码发送给我们就完成验证,如果2分钟内没有收到短信就请输入“重新发送”,我们将重新给你发送新的验证码,如果想换手机号,就请输入“换手机号”' % info.text else: text = u"请输入正确的手机号" return text
def test_state_machine_init_method(): """Basic testing for the State Machine init method """ # Setup state_machine = StateMachine() # Setup def decision(): return 'state2' def decision2(): return 'state3' state1 = State(name="state1", routine_function=fun_routine, decision_function=decision, entry_function=fun_entry, exit_function=fun_exit, is_async=False) state2 = State(name="state2", routine_function=fun_routine, decision_function=decision2, entry_function=fun_entry, exit_function=fun_exit, is_async=False) state3 = State(name="state3", routine_function=fun_routine, decision_function=decision, is_async=False) state_machine.add_states(state3, state2, state1) state_machine.initial_state = "state1"
def test_is_child_final_false(self): m = StateMachine() s = m.create_state('final', CompositeState) c = s.create_state('s') s.set_state(c) e = Event() self.assertFalse(guards.is_child_final(e, s))
class MainNode(): def __init__(self): rospy.init_node('default_offboard', anonymous=True) self.rate = rospy.Rate(20) self.mav1 = Mav("mavros") self._command_sub = rospy.Subscriber("pose_command", String, self._pose_command_callback) # wait for FCU connection self.mav1.wait_for_connection() print("mavs connected") self.sm = StateMachine() self.sm.set_params(self.mav1) self.sm.set_current_state(self.sm.States.TAKE_OFF) def loop(self): # enter the main loop while (True): # print "Entered whiled loop" self.sm.execute() self.rate.sleep() def _pose_command_callback(self, topic=String()): text = topic.data textarr = np.array(text.split(";")) arr = textarr.astype(np.float) print("new target pose: " + str(arr.tolist())) pose = create_setpoint_message_xyz_yaw(arr[0], arr[1], arr[2], arr[3]) self.mav1.set_target_pose(pose) self.mav1.max_speed = 1 self.sm.set_next_state(self.sm.States.IDLE) self.sm.set_current_state(self.sm.States.WAITING_TO_ARRIVE) pass
class Wife(BaseGameEntity): def __init__(self, val): super().__init__(val) self.location = "Home" self.peeNeed = 5 self.cookingStew = False self.fsm = StateMachine(self) self.fsm.globalState = WifeGlobalState() self.fsm.currentState = WifeClean() def Update(self): self.fsm.Update() def NeedToRelief(self): return self.peeNeed >= 10 def CookingStew(self): return self.cookingStew def HandleMessage(self, telegram): return self.fsm.HandleMessage(telegram) def logStates(self): log(str(self) + " global state: " + str(self.fsm.globalState)) log(str(self) + " current state: " + str(self.fsm.currentState)) log(str(self) + " previous state: " + str(self.fsm.previousState)) log(str(self) + " location: " + self.location) log(str(self) + " peeNeed: " + str(self.peeNeed)) log(str(self) + " cookingStew: " + str(self.cookingStew))
def test_trivial_case(self): grammar = 'rulename = abc "def"\nabc = "abc"' rulename = 'rulename' edge = Edge('abc', 'abc') edge2 = Edge('def', 'def') final_edge = Edge('', FINAL_STATE) state = State('abc', edge2, is_automata=True) state2 = State('def', final_edge) start_state = State(START_STATE, edge) final_state = State(FINAL_STATE) states = [start_state, state, state2, final_state] expected = StateMachine(rulename, states) rulename = 'abc' sub_edge = Edge('abc', 'abc') sub_final_edge = Edge('', FINAL_STATE) sub_state = State('abc', sub_final_edge) sub_start_state = State(START_STATE, sub_edge) sub_final_state = State(FINAL_STATE) states = [sub_start_state, sub_state, sub_final_state] submachine = StateMachine(rulename, states) expected.register_automata(submachine) actual = choices_parser.parse_from_string(grammar) logger.debug(f'Actual: {actual}') logger.debug(f'Expected: {expected}') assert_state_machines_equal(actual, expected)
def test_is_child_final_false(self): m=StateMachine() s=m.create_state('final', CompositeState) c=s.create_state('s') s.set_state(c) e=Event() self.assertFalse( guards.is_child_final(e, s))
def __init__(self): # Setting the screen self.screen = pygame.display.set_mode( (settings.WINDOW_WIDTH, settings.WINDOW_HEIGHT)) pygame.display.set_caption('Bird') # Creating the virtual screen self.surface = pygame.Surface( (settings.VIRTUAL_WIDTH, settings.VIRTUAL_HEIGHT)) self.background_x = 0 self.ground_x = 0 self.clock = pygame.time.Clock() self.state_machine = StateMachine({ 'start': states.StartState, 'count': states.CountState, 'play': states.PlayState, 'score': states.ScoreState, }) self.state_machine.change('start') pygame.mixer.music.load('sounds/choco_birds_run.mp3') pygame.mixer.music.play(loops=-1) settings.GAME_SOUNDS['jump'].set_volume(0.5) settings.GAME_SOUNDS['death'].set_volume(0.5)
class Wife(BaseGameEntity): def __init__(self, name, global_state=None, current_state=None): BaseGameEntity.__init__(self) self._name = name self.state_machine = StateMachine(self) self.location = None self.cooking = False self.husband = None self.state_machine.global_state = global_state self.state_machine.current_state = current_state @property def name(self): return self._name def update(self): self.state_machine.update() def handle_message(self, t): self.state_machine.handle_message(t) def change_location(self, new_location): self.location = new_location def say(self, s): print('\x1b[0;31;40m' + '{0} : '.format(self.name) + s + '\x1b[0m')
def test_is_child_final_true(self): m=StateMachine() s=m.create_state('final', CompositeState) f=s.create_state('sfinal', FinalState) s.set_state(f) e=Event() self.assertTrue( guards.is_child_final(e, s))
class TestTransitionErrorStateMachine(unittest.TestCase): def setUp(self): self.sm = StateMachine("test_state_machine", ["exit", "__preempted__"]) self.state1 = TestStateLoop("test1", ["s2", "s3"]) self.state2 = TestStateLoop("test2", ["s1", "s1"]) self.state3 = TestStateLoop("test3", ["s1", "exit"]) self.sm.add_state(self.state1, {"s2": "test2", "s3": "test3"}, initial=True) self.sm.add_state(self.state2, {"s1": "test1"}) self.sm.add_state(self.state3, {"s1": "test1"}) def test_no_states(self): error = None try: StateMachine("test_state_machine", [])._run() except TransitionError as e: error = e assert error is not None def test_transition_doesnt_exist(self): error = None sm = StateMachine("test_state_machine", ["exit", "__preempted__"]) state1 = TestState("test1", ["s2"]) sm.add_state(self.state1, {}, initial=True) try: sm._run() except TransitionError as e: error = e print(error) assert error is not None
def setup_state_machine(self): # This is where we will initialize states, create a state machine, add # state transitions to the state machine, and start the state machine. hungup_state = HungUpState(self) recording_state = RecordingState(self) ending_state = EndingState(self) reviewing_state = ReviewingState(self) greeting_state = GreetingState(self) self.state_machine = StateMachine() self.state_machine.add_transition(recording_state, Event.DTMF_OCTOTHORPE, reviewing_state) self.state_machine.add_transition(recording_state, Event.HANGUP, hungup_state) self.state_machine.add_transition(recording_state, Event.DTMF_STAR, recording_state) self.state_machine.add_transition(reviewing_state, Event.HANGUP, hungup_state) self.state_machine.add_transition(reviewing_state, Event.DTMF_OCTOTHORPE, ending_state) self.state_machine.add_transition(reviewing_state, Event.DTMF_STAR, recording_state) self.state_machine.add_transition(greeting_state, Event.HANGUP, hungup_state) self.state_machine.add_transition(greeting_state, Event.PLAYBACK_COMPLETE, recording_state) self.state_machine.start(greeting_state)
def __init__(self, val): super().__init__(val) self.location = "Home" self.peeNeed = 5 self.cookingStew = False self.fsm = StateMachine(self) self.fsm.globalState = WifeGlobalState() self.fsm.currentState = WifeClean()
def setUp(self): self.sm = StateMachine("test_state_machine", ["exit", "__preempted__"]) self.state1 = TestStateLoop("test1", ["s2", "s3"]) self.state2 = TestStateLoop("test2", ["s1", "s1"]) self.state3 = TestStateLoop("test3", ["s1", "exit"]) self.sm.add_state(self.state1, {"s2": "test2", "s3": "test3"}, initial=True) self.sm.add_state(self.state2, {"s1": "test1"}) self.sm.add_state(self.state3, {"s1": "test1"})
def test_is_final_state_using_subclass(self): class AnotherFinalState(FinalState): pass m = StateMachine() s = m.create_state('final', AnotherFinalState) e = Event() self.assertTrue(guards.is_final_state(e, s))
def test_add_transition_to(self): m = StateMachine() s1 = m.create_state(name='s1') s2 = m.create_state(name='s2') s1.add_transition_to(s2, 'test event...') self.assertEqual( s2, s1.transitions_by_trigger['test event...'][0].target )
def setUp(self): chatbot = StateMachine('chatbot') active_state = chatbot.create_state('active', CompositeState) sleeping_state = chatbot.create_state('sleeping', State) final_state = chatbot.create_state('final', FinalState) chatbot.initial_state=active_state active_state.add_transition_to(sleeping_state, 'sunset') active_state.add_transition_to(final_state, 'bandwidth exceeded') sleeping_state.add_transition_to(active_state, 'sunrise') sleeping_state.add_transition_to(final_state, 'power off') def become_happy( event, state ): state.logger.info('Becoming Happy') def happy_message(event, state): if event.name=='msg': state.logger.info('Hello %s, I am happy', event.payload['from']) def become_sad(event, state): state.logger.info('Becoming Sad') def sad_message(event, state): if event.name=='msg': state.logger.info('Hello %s, I am sad', event.payload['from']) def sun_is_shining(event, state): return True def clouds_are_looming(event, state): return True def do_happy_dance(event, state): return True def hang_head_in_shame(event, state): return True happy_state = active_state.create_state('happy') happy_state.on_start = become_happy happy_state.on_run = happy_message sad_state = active_state.create_state('sad') sad_state.on_start = become_sad sad_state.on_run = sad_message final_state = active_state.create_state( 'depressed', FinalState ) happy_state.add_transition_to(sad_state, 'criticism', guard=clouds_are_looming, action=hang_head_in_shame) sad_state.add_transition_to(happy_state, 'praise', guard=sun_is_shining, action=do_happy_dance) sad_state.add_transition_to(final_state, 'excessive criticism') active_state.initial_state=happy_state active_state.initialise() self.chatbot = chatbot
class MainNode(): def __init__(self): rospy.init_node('default_offboard', anonymous=True) self.rate = rospy.Rate(20) self.mav1 = Mav("uav1/mavros") self.mav2 = Mav("uav2/mavros") self.sm = StateMachine() self.sm.set_params((self.mav1, self.mav2)) self._command_sub = rospy.Subscriber("pose_command", String, self._pose_command_callback) # wait for FCU connection self.mav1.wait_for_connection() self.mav2.wait_for_connection() self.last_request = rospy.Time.now() - rospy.Duration(5.0) self.sm.set_current_state(self.sm.States.TAKE_OFF) def loop(self): # enter the main loop while (True): # print "Entered whiled loop" self.arm_and_set_mode() self.sm.execute() self.rate.sleep() def arm_and_set_mode(self): if rospy.Time.now() - self.last_request > rospy.Duration(1.0): if self.mav1.UAV_state.mode != "OFFBOARD": self.mav1.set_mode(0, 'OFFBOARD') print("enabling offboard mode") self.last_request = rospy.Time.now() if not self.mav1.UAV_state.armed: if self.mav1.set_arming(True): print("Vehicle armed") self.last_request = rospy.Time.now() if self.mav2.UAV_state.mode != "OFFBOARD": self.mav2.set_mode(0, 'OFFBOARD') print("enabling offboard mode") self.last_request = rospy.Time.now() if not self.mav2.UAV_state.armed: if self.mav2.set_arming(True): print("Vehicle armed") self.last_request = rospy.Time.now() def _pose_command_callback(self, topic=String()): text = topic.data textarr = np.array(text.split(";")) arr = textarr.astype(np.float) print("new target pose: " + str(arr.tolist())) pose = create_setpoint_message_xyz_yaw(arr[0], arr[1], arr[2], arr[3]) self.mav1.set_target_pose(pose) self.mav2.set_target_pose(pose) self.sm.set_next_state(self.sm.States.IDLE) self.sm.set_current_state(self.sm.States.WAITING_TO_ARRIVE) pass
def test_start_stores_event(self): m = StateMachine() s = m.create_state(name='test state') e = Event() s.start(e) self.assertEqual(e, s.start_event)
def test_without_test_bank(self): state_machine = StateMachine() search = Mock() state_machine._search = search response = state_machine._handle(0, new_question_message) assert response is None search.get_search_results.assert_called_with(question)
def setUp(self): self.iterations_num = 3 self.sm = StateMachine("test_state_machine", ["exit", "__preempted__"]) self.state1 = TestState("test1", ["s2", "s3"], execute_iterations=self.iterations_num) self.state2 = TestState("test2", ["s3", "s1"], execute_iterations=self.iterations_num) self.state3 = TestState("test3", ["exit", "s1"], execute_iterations=self.iterations_num) self.sm.add_state(self.state1, {"s2": "test2", "s3": "test3"}, initial=True) self.sm.add_state(self.state2, {"s1": "test1", "s3": "test3"}) self.sm.add_state(self.state3, {"s2": "test2", "s1": "test1"})
def test_is_final_state_using_subclass(self): class AnotherFinalState(FinalState): pass m = StateMachine() s = m.create_state('final', AnotherFinalState) e = Event() self.assertTrue( guards.is_final_state(e, s) )
def test_add_transition_to(self): m = StateMachine() s1 = m.create_state(name='s1') s2 = m.create_state(name='s2') s1.add_transition_to(s2, 'test event...') self.assertEqual(s2, s1.transitions_by_trigger['test event...'][0].target)
def __init__(self): # getting access to elements in DroneVideo and FlightstatsReciever super(DroneMaster, self).__init__() self.objectName = "Test Object" self.startingAngle = 0 self.circleRadius = 1 #meters self.circlePoints = 8 #numbers of points equally spaced along circle self.startTime = 0 # backpack: 120/-55/95 # +100 for big objects, +50 for shorter objects. (Modifies how close drone is to object; smaller # > closer) # +10 for very small objects. self.yOffset = 0 # -30 for big objects, -15 for shorter objects. (Modifies how close drone is to object; larger # > closer) self.ySizeOffset = -30 # +75 for tall objects or using cube, 0 for shorter objects. (Modifies how high the drone should fly; smaller # > lower self.zOffset = 25 # Seting up a timestamped folder inside Flight_Info that will have the pictures & log of this flight self.droneRecordPath = ( expanduser("~") + "/drone_ws/src/SVCL_ardrone_automation/src/Flight_Info/" + self.objectName + "_Flight_" + datetime.datetime.now().strftime("%m-%d-%Y__%H:%M:%S, %A") + "/") if not os.path.exists(self.droneRecordPath): os.makedirs(self.droneRecordPath) #self.logger = Logger(self.droneRecordPath, "AR Drone Flight") #self.logger.Start() #import PID and color constants self.settingsPath = expanduser( "~" ) + "/drone_ws/src/SVCL_ardrone_automation/src/resources/calibrater_settings.txt" # initalizing the state machine that will handle which algorithms to run at which time; # the results of the algorithms will be used to control the drone self.stateMachine = StateMachine() # drone starts without any machine loaded, so that it can be controlled using the keyboard self.currMachine = None # i1nitalizing helper objects self.pictureManager = PictureManager(self.droneRecordPath) self.controller = BasicDroneController("TraceCircle") self.startTimer = time.clock() # max height of drone, in mm; any higher and the drone will auto-land self.maxHeight = 2530 self.emergency = False self.captureRound = 0.5 self.oldBattery = -1 self.photoDirective = CapturePhotoDirective(self.droneRecordPath, 30, 0.014, self.objectName, self.circlePoints, 1000, 0) self.keySub = rospy.Subscriber('/controller/keyboard', ROSString, self.keyPress)
def test_add_transition_to_without_params(self): m = StateMachine() m.logger.info(m.states) s1 = m.create_state(name='s1') s2 = m.create_state(name='s2') s1.add_transition_to(s2) self.assertEqual( 0, len( s1.transitions_by_trigger ) ) self.assertEqual( s2, s1.default_transition.target )
def test_notify_observers(self): m = StateMachine() m.notify_observers = MagicMock() s = State('test state', m) e = Event() s.notify_observers(e) self.assertEqual(1, m.notify_observers.call_count) self.assertEqual(e, m.notify_observers.call_args[0][0])
def test_add_transition_to(self): m = StateMachine() ps = m.create_state('ps', PseudoState) tgt1 = m.create_state('tgt1') g1 = lambda event, state: True ps.add_transition_to(tgt1, guard=g1) self.assertEqual(1, len(ps.transitions)) self.assertEqual(tgt1, ps.transitions[0].target)
def test_add_transition_to_without_params(self): m = StateMachine() m.logger.info(m.states) s1 = m.create_state(name='s1') s2 = m.create_state(name='s2') s1.add_transition_to(s2) self.assertEqual(0, len(s1.transitions_by_trigger)) self.assertEqual(s2, s1.default_transition.target)
def __init__(self, val): super().__init__(val) self.location = "Mine" self.moneyInBank = 10 self.goldCarried = 19 self.thirst = 0 self.fatigue = 10 self.fsm = StateMachine(self) self.fsm.globalState = MinerGlobalState() self.fsm.currentState = MineForGold()
def test_undispach_event(self): sm_test = StateMachine() sm_test.sm['load'] = {1: print("test")} sm_test.inicia_tread() sm_test.on_event(event=1, args=None) sm_test.finaliza_tread() assert 1 == sm_test.events_queue.getLenth()
def test_notify_child(self): m = StateMachine() composite_state = m.create_state('composite', CompositeState) target_state = m.create_state('target') composite_state.add_transition_to(target_state, 'tick') substate_source = composite_state.create_state('substate1') substate_target = composite_state.create_state('substate2') substate_source.add_transition_to(substate_target, 'tick') substate_source.on_end = MagicMock() substate_target.on_start = MagicMock() composite_state.initial_state = substate_source composite_state.initialise() m.initial_state = composite_state m.initialise() # Test, expecting the composite state's machine to transition e = Event('tick') m.notify(e) # Verify self.assertEqual(composite_state, m.current_state) self.assertEqual(substate_target, composite_state.current_state) self.assertEqual(1, substate_source.on_end.call_count) self.assertEqual(1, substate_target.on_start.call_count)
class Game(object): """ This is where the main gameloop runs. :param machine = Creates an instance of StateMachine.""" def __init__(self): pygame.init() self.machine = StateMachine() self.display_w = 800 self.display_h = 600 def run(self): self.display = pygame.display.set_mode((self.display_w,self.display_h)) pygame.display.set_caption('The DiceGame') self.clock = pygame.time.Clock() self.machine.load(intro_state.IntroState(self.machine, self.display)) while self.machine.isRunning(): self.machine.nextState() self.machine.update() self.machine.draw() self.clock.tick(30) # Debug if (len(self.machine.states) > 1): print("Machinestates: '{}'".format(self.machine.states)) print("") print("----------------") print("DiceGame succesfully terminated.") print("Now clearing pygame.") print("") pygame.quit()
def test_to_str(self): m = StateMachine() s = m.create_state(name='test state') s2 = m.create_state(name='s2') s.add_transition_to( s2, 'trigger' ) r = s.transitions[0].to_str() self.assertEqual('trigger', r)
def test_to_str(self): m = StateMachine() s = m.create_state(name='test state') s2 = m.create_state(name='s2') s.add_transition_to(s2, 'trigger') r = s.transitions[0].to_str() self.assertEqual('trigger', r)
def __init__(self, *args, **kwargs): super(TestStringPattern, self).__init__(*args, **kwargs) self.m = StateMachine() self.m.add_state("start_state", state_zero) self.m.add_state("first_state", state_one) self.m.add_state("second_state", state_two) self.m.add_state("third_state", state_three) self.m.add_state("last_state", None, end_state=1) self.m.add_state("error_state", None, end_state=1) self.m.set_start("start_state")
def __init__(self, name, global_state=None, current_state=None): BaseGameEntity.__init__(self) self._name = name self.state_machine = StateMachine(self) self.location = None self.cooking = False self.husband = None self.state_machine.global_state = global_state self.state_machine.current_state = current_state
def __init__(self, name='motion', context=None, speed=100.): ''' Parameters: name : str Name of the underlying Object. context : Context instance Attach the underlying StateMachine to this context. speed : float Speed in world-coordinate metric per seconds. ''' StateMachine.__init__(self, name, context) self._speed = speed
def __init__(self, name='sprite', context=None, layer=1): ''' name: name of the sprite layer: (default: 1 since 0 is reserved for background) ''' StateMachine.__init__(self, name, context) if context is None: context = Config.get_default_context() context.add_visible_data(self, layer) self._layer = layer self._location = np.zeros(2) self._size = np.zeros(2) self._bb_center = np.zeros(2) self.set_motion(no_motion)
def test_transitions(self): m = StateMachine() s = m.create_state(name='test state') s2 = m.create_state(name='s2') s3 = m.create_state(name='s3') s.add_transition_to( s2, 'ignore' ) s.add_transition_to( s3, 'trigger' ) transitions = s.transitions self.assertIsInstance( transitions, list ) self.assertEqual(2, len( transitions ))
def test_transition_to_default(self): m = StateMachine() s = m.create_state(name='test state') s2 = m.create_state(name='should get here') s3 = m.create_state(name='should not get here') s.add_transition_to(s3, 'test event') s.add_transition_to(s2) event = Event('any event') t = s.next_transition(event) self.assertEqual(s2, t.target)
def test_next_transition(self): m = StateMachine() s = m.create_state(name='test state') s2 = m.create_state(name='s2') s3 = m.create_state(name='s3') s.add_transition_to( s2, 'ignore' ) s.add_transition_to( s3, 'trigger' ) event = Event('trigger') result = s.next_transition( event ) self.assertEqual(s3, result.target )
def test_next_transition(self): m = StateMachine() ps = m.create_state('ps', PseudoState) tgt1 = m.create_state('tgt1') tgt2 = m.create_state('tgt2') g1 = lambda event, state: True ps.add_transition_to(tgt1, guard=g1) g2 = lambda event, state: False ps.add_transition_to(tgt2, guard=g2) e = Event() t = ps.next_transition(e) self.assertEqual(tgt1, t.target)
def setup_state_machine(self): """ setup the states and start the initial state """ main_menu = DtmfMenuState(self, 'sound:/telewall/sounds/de/mainmenu', allowed_keys=['1', '2', '3']) playback = PlaybackRefusedState(self) recording_instruction = GenericPlaybackState(self, 'sound:/telewall/sounds/de/record-announcement-instruction') recording = RecordingState(self) recording_reset = ResetRecordingState(self) recording_reset_done = GenericPlaybackState(self, 'sound:/telewall/sounds/de/reset-announcement-done') hungup_state = HungUpState(self) ending_state = EndingState(self) self.state_machine = StateMachine() self.state_machine.add_transition(main_menu, Event.DTMF_1, playback) self.state_machine.add_transition(main_menu, Event.DTMF_2, recording_instruction) self.state_machine.add_transition(main_menu, Event.DTMF_3, recording_reset) # 1: playback self.state_machine.add_transition(playback, Event.PLAYBACK_COMPLETE, ending_state) # 2: recording self.state_machine.add_transition(recording_instruction, Event.PLAYBACK_COMPLETE, recording) # 3: reset recording self.state_machine.add_transition(recording_reset, Event.ACTION_COMPLETE, recording_reset_done) self.state_machine.add_transition(recording_reset_done, Event.PLAYBACK_COMPLETE, main_menu) # hangup event is in every state for state in [main_menu, playback, recording_instruction, recording, recording_reset, recording_reset_done]: self.state_machine.add_transition(state, Event.HANGUP, hungup_state) self.state_machine.start(main_menu)
def setup_state_machine(self): """ setup the states and start the initial state """ check_caller = CheckCallerState(self) call_handset = CallHandsetState(self) playback_refused = PlaybackRefusedState(self, hangup_caller_when_hangup_handset=False) call_connected = CallConnectedState(self) hungup_state = HungUpState(self) ending_state = EndingState(self) self.state_machine = StateMachine() # identification self.state_machine.add_transition(check_caller, Event.CALLER_ALLOWED, call_handset) self.state_machine.add_transition(check_caller, Event.CALLER_REFUSED, playback_refused) # allowed self.state_machine.add_transition(call_handset, Event.ANSWER, call_connected) self.state_machine.add_transition(call_handset, Event.BUSY, ending_state) self.state_machine.add_transition(call_connected, Event.CALLER_REFUSED, playback_refused) # refused self.state_machine.add_transition(playback_refused, Event.PLAYBACK_COMPLETE, ending_state) # hangup event is in every state (except the final states hangup and ending) for state in [check_caller, call_handset, playback_refused, playback_refused, call_connected]: self.state_machine.add_transition(state, Event.HANGUP, hungup_state) self.state_machine.start(check_caller)
def __init__(self, header_row_fn=None, body_row_fn=None, footer_row_fn=None): HTMLParser.__init__(self) self.state_machine = StateMachine() self.header_row_fn = header_row_fn self.body_row_fn = body_row_fn self.footer_row_fn = footer_row_fn self.cells = []
class FindBallState(State): def __init__(self, worldWrapper): # Create our internal state machine self.stateMachine = StateMachine(DriveStraightState(worldWrapper)) def step(self, worldWrapper): world = worldWrapper.world # Do the global checks # newState, changed = self.checkGlobal(worldWrapper) # if changepd == STATE_CHANGE_FLAG: # return newState, changed # If we see any balls # Step the state machine self.stateMachine.step(worldWrapper) return self, self.stateMachine.goal
def test_to_str2(self): def guard_fn(event, state): return True def action_fn(event, state): pass m = StateMachine() s = m.create_state(name='test state') s2 = m.create_state(name='s2') s.add_transition_to( s2, 'trigger', guard=guard_fn, action=action_fn ) r = s.transitions[0].to_str() self.assertEqual('trigger[guard_fn]/action_fn', r)
class TableParser(HTMLParser): VALID_TAGS = ['table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td'] def __init__(self, header_row_fn=None, body_row_fn=None, footer_row_fn=None): HTMLParser.__init__(self) self.state_machine = StateMachine() self.header_row_fn = header_row_fn self.body_row_fn = body_row_fn self.footer_row_fn = footer_row_fn self.cells = [] def handle_starttag(self, tag, attrs): if tag not in TableParser.VALID_TAGS: return self.state_machine.transition(tag, StateMachine.START_TAG) def handle_endtag(self, tag): if tag not in TableParser.VALID_TAGS: return self.state_machine.transition(tag, StateMachine.END_TAG) if tag == 'tr': if self.state_machine.in_header() and self.header_row_fn: self.header_row_fn(self.cells) elif self.state_machine.in_footer() and self.footer_row_fn: self.footer_row_fn(self.cells) elif self.body_row_fn: self.body_row_fn(self.cells) self.cells = [] def handle_data(self, data): if self.state_machine.in_cell(): self.cells.append(data)
def checkState1(self, value, info): if value['sendNum'] > 5: text = u"今天已经给你发送太多的短信了,明天再来吧" StateMachine.end(info.user) elif self.checkPhoneNum(info.text): try: user = WeixinUser.objects.get(phone=info.text) text = "这个手机号已经被使用了,请使用其他号码" except: user = None if user == None: verifyCode = str(random.randint(100000, 1000000)) ret = send_sms(info.text, u"验证码是%s,15分钟内有效" % verifyCode) logger.debug("send sms return %s" % ret) value = {'state':2, 'phone':info.text, 'verifyCode':verifyCode, "sendTime":time.time(), 'sendNum':value['sendNum'] + 1} self.store(info.user, value) text = u'我们已经将验证码发送到%s,请将收到的验证码发送给我们就完成验证,如果2分钟内没有收到短信就请输入“重新发送”,我们将重新给你发送新的验证码,如果想换手机号,就请输入“换手机号”' % info.text else: text = u"请输入正确的手机号" return text
class BallAcquisitionState(State): TIMEOUT = 10 def __init__(self, worldWrapper): # Create and keep track of our state machine self.stateMachine = StateMachine(SeekBallState(worldWrapper)) # Keep track of time for a timeout self.lastTime = time.time() def step(self, worldWrapper): world = worldWrapper.world # Check globals newState, changed = self.checkGlobal(worldWrapper) if changed == STATE_CHANGE_FLAG: return newState, changed # Check for a timeout if time.time() - self.lastTime > self.TIMEOUT: return EscapeState(worldWrapper), STATE_CHANGE_FLAG # Check for having lost all the balls if len(world.balls) == 0: return FindBallState(worldWrapper), STATE_CHANGE_FLAG # TODO: run the Ferrous # Otherwise, step the state machine oldState = self.stateMachine.state self.stateMachine.step(worldWrapper) # Update our timer if self.stateMachine.state != oldState: self.lastTime = time.time() # Step the state machine self.stateMachine.step(worldWrapper) return self, self.stateMachine.goal
def checkState2(self, value, info): if info.text == str(value['verifyCode']): StateMachine.end(info.user) user = WeixinUser.objects.filter(uid=info.user)[0] user.phone = value['phone'] user.save() text = u'恭喜您,已经完成了验证,赶快回复“礼品”去积分商城选择礼品吧' elif info.text == u"重新发送": if time.time() < value['sendTime'] + 2 * 60: text = u"刚给您发送了短信,请耐心等候" elif value['sendNum'] > 5: text = u"今天已经给您发送了太多短信了,请明天再来吧" self.timeout = 12 * 3600 self.store(info.user, value) else: verifyCode = str(random.randint(100000, 1000000)) value['verifyCode'] = verifyCode ret = send_sms(value['phone'], u"验证码是%s,15分钟内有效" % verifyCode) logger.debug("send sms return %s" % ret) value['sendTime'] = time.time() value['sendNum'] += 1 self.store(info.user, value) text = u"已经给您发送了一条短信,请查收" elif info.text == u"换手机号" or info.text == u"换手机": if time.time() < value['sendTime'] + 2 * 60: text = u'刚给你发送了短信,请2分钟后没收到,再“换手机号”' elif value['sendNum'] > 5: text = u'今天已经给你发送了太多短信了,请明天再来吧' self.timeout = 12 * 3600 self.store(info.user, value) else: value['state'] = 1 self.store(info.user, value) text = u"请输入新的手机号" else: text = u"您输入的验证码有误,请再看一下" return text
def __init__(self, testblock_name, metrics): self.testblock_name = testblock_name rospy.Subscriber("/atf/" + self.testblock_name + "/Trigger", Trigger, self.trigger_callback) self.transition = None self.metrics = metrics self.m = StateMachine(self.testblock_name) self.m.add_state(Status.PURGED, self.purged_state) self.m.add_state(Status.ACTIVE, self.active_state) self.m.add_state(Status.PAUSED, self.paused_state) self.m.add_state(Status.FINISHED, self.finished_state, end_state=True) self.m.add_state(Status.ERROR, self.error_state, end_state=True) self.m.set_start(Status.PURGED) self.m.run()
def setup_state_machine(self): """ setup the states and start the initial state """ unblock = UnblockState(self, self.dialed_extension) done = GenericPlaybackState(self, 'sound:/telewall/sounds/de/unblock-done') invalid = GenericPlaybackState(self, 'sound:/telewall/sounds/de/phonenumber-invalid') hungup_state = HungUpState(self) ending_state = EndingState(self) self.state_machine = StateMachine() self.state_machine.add_transition(unblock, Event.ACTION_COMPLETE, done) self.state_machine.add_transition(unblock, Event.INVALID_INPUT, invalid) self.state_machine.add_transition(done, Event.PLAYBACK_COMPLETE, ending_state) self.state_machine.add_transition(invalid, Event.PLAYBACK_COMPLETE, ending_state) # hangup event is in every state for state in [unblock, done, invalid]: self.state_machine.add_transition(state, Event.HANGUP, hungup_state) self.state_machine.start(unblock)
def main(): sm = StateMachine() sm.register(state_no_match) sm.register(state_one_match) sm.register(state_both_match) some_string = "hello and welcome to you" initial_state = State() print sm.evaluate(initial_state, some_string) current_state = State() some_string_2 = "you and welcome to hello" print sm.evaluate(current_state, some_string_2)
class UnblockCall(BaseAsteriskAppCall): """ unblockes a caller using asterisk. A new instance is created for each call. """ def __init__(self, ari_client, channel, asterisk_app_name, dialed_extension): """ :param ari_client: the ari client instance :param channel: the active channel with the handset """ super(UnblockCall, self).__init__(ari_client, channel, asterisk_app_name) self.dialed_extension = dialed_extension self.state_machine = None self.setup_state_machine() def setup_state_machine(self): """ setup the states and start the initial state """ unblock = UnblockState(self, self.dialed_extension) done = GenericPlaybackState(self, 'sound:/telewall/sounds/de/unblock-done') invalid = GenericPlaybackState(self, 'sound:/telewall/sounds/de/phonenumber-invalid') hungup_state = HungUpState(self) ending_state = EndingState(self) self.state_machine = StateMachine() self.state_machine.add_transition(unblock, Event.ACTION_COMPLETE, done) self.state_machine.add_transition(unblock, Event.INVALID_INPUT, invalid) self.state_machine.add_transition(done, Event.PLAYBACK_COMPLETE, ending_state) self.state_machine.add_transition(invalid, Event.PLAYBACK_COMPLETE, ending_state) # hangup event is in every state for state in [unblock, done, invalid]: self.state_machine.add_transition(state, Event.HANGUP, hungup_state) self.state_machine.start(unblock)