def __init__(self):
self.state = StateMachine()
self.blockchain = Blockchain()
self.transaction_pool = []
self.executed_transactions = []
self.nodes = []
self.lock = Lock()
def getStates(self):
# add states to the game
self.states = StateMachine()
self.states.addState('mainScreen', MainScreen(self))
self.states.addState('gameScreen', GameScreen(self))
self.states.addState('pauseScreen', PauseMenu(self))
self.states.change('mainScreen')
def test_proceed_while_allowed(self):
"Proceed returns False reaching a state with no allowed exits."
sm = StateMachine("ABCGH")
sm["A"].add_exit("C")
sm["C"].add_exit("G", self.truecond)
sm["G"].add_exit("B", self.falsecond)
sm["B"].add_exit("H")
self.assertFalse(sm.proceed())
self.assertEquals(sm.history.keys(), list("ACG"))
def test_proceed(self):
"Proceed steps through all states and then returns True"
sm = StateMachine("ABCGH")
sm.A.add_exit(sm.C)
sm.C.add_exit(sm.G)
sm.G.add_exit(sm.B)
sm.B.add_exit(sm.H)
self.assertTrue(sm.proceed())
self.assertEquals(sm.history.keys(), list("ACGBH"))
def test_chained_syntax(self):
"States can be defined using chainable calls."
sm = StateMachine("ABCD")
action = Mock()
state_action = Mock()
sm.A.when(self.truecond).do(action).goto(sm.B)
sm.A.when(self.falsecond).goto(sm.D)
sm.B.set_action(state_action).when(self.truecond).goto(sm.C)
sm.proceed()
self.assertEquals(sm.state, "C")
action.assert_called_with()
state_action.assert_called_with()
def __init__(self, channels):
"""
:param channels: a list of Channel object
"""
self._channels = channels
self._statemachine = {}
self.__savestartdate = {}
self.__saveenddate = {}
self._currentstate = {}
self._timer = {}
for ch in self._channels:
self._statemachine[ch.nb] = StateMachine()
self._statemachine[ch.nb].register("NotRunning", self._not_running, [ch])
self._statemachine[ch.nb].register("Running", self._running, [ch])
self._statemachine[ch.nb].register("ManualOn", self._manual_on, [ch])
self._statemachine[ch.nb].register("ManualOff", self._manual_off, [ch])
self._statemachine[ch.nb].setState("NotRunning")
self._currentstate[ch.nb] = {'nb': ch.nb, 'state': "NotRunning"}
self._timer[ch.nb] = timer.Timer()
self._oldstate = self._currentstate.copy()
self._sched = Scheduler(self.run)
self._logger = logging.getLogger('sprinkler')
self._event_new_state = asyncio.Event()
def sm_eval(self, plan, input_state):
def be_task(prim_name, fn, api, **kwargs):
def wrapped(input_state, **outer_args):
kwargs.update(outer_args)
return self.backend_wrapper(input_state, prim_name, fn, api, **kwargs)
return wrapped
self.logger.info("building state machine for %s" % plan)
sm = StateMachine(input_state)
sm.set_state("state_0")
for state_index, state in enumerate(plan):
parameters = state["ns"]
primitive = state["primitive"]
timeout = state.get("timeout", 30)
self.logger.debug("padding globals %s" % self.adventure_globals)
parameters["globals"] = self.adventure_globals
parameters["globals"]["parent_task_id"] = self.parent_task_id
self.logger.debug("Wrapping %s primitive" % primitive)
if "." in primitive:
# this primitive comes from backends
backend_fn = opencenter.backends.primitive_by_name(primitive)
if not backend_fn:
msg = 'cannot find backend primitive "%s"' % primitive
self.logger.debug(msg)
input_state["fails"] = input_state["nodes"]
input_state["nodes"] = []
return ({"result_code": 1, "result_str": msg, "result_data": {}}, input_state)
fn = be_task(primitive, backend_fn, self.api, **parameters)
else:
# this primitive comes from node tasks.
parameters["timeout"] = timeout
run_task = "agent.run_task"
backend_fn = opencenter.backends.primitive_by_name(run_task)
fn = be_task("agent.run_task", backend_fn, self.api, **{"action": primitive, "payload": parameters})
# we have the backend fn, now wrap it up.
# solver plans are linear, so we'll jump to next step always
# plus, we'll assume that failure goes to default failure case
next_state = state_index + 1
success_state = "state_%d" % next_state
if (next_state) == len(plan):
success_state = "success"
sm.add_state("state_%d" % state_index, StateMachineState(advance=fn, on_success=success_state))
result_data, end_state = sm.run_to_completion()
return (result_data, end_state)
class Game():
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREEN_DIM)
pygame.display.set_caption(TITLE)
self.clock = pygame.time.Clock()
self.allSprites = pygame.sprite.Group()
self.player = Player(self, 10, 10)
self.camera = None
self.running = True
self.getStates()
def getStates(self):
# add states to the game
self.states = StateMachine()
self.states.addState('mainScreen', MainScreen(self))
self.states.addState('gameScreen', GameScreen(self))
self.states.addState('pauseScreen', PauseMenu(self))
self.states.change('mainScreen')
def loop(self):
print(self.states.currentState.name)
while self.running:
# update the delta time variable
self.dt = self.clock.tick(FPS) / CLOCK_TICK
# events
self.running = mainGameEvents(self.running)
self.states.events()
# updates
self.update()
# rendering
self.render()
self.quit()
def quit(self):
self.running = False
pygame.quit()
sys.exit()
def update(self):
self.allSprites.update()
self.states.update()
def render(self):
self.states.render()
pygame.display.flip()
def init_from_db(self):
state_data = db.states.find( { 'sm_village': self.village.village_id } )
for data in state_data:
sm = StateMachine.create_from_db(self.village, data)
sm.current_state.transition()
self.state_machines.append( sm )
class Consensus:
def __init__(self):
self.state = StateMachine()
self.blockchain = Blockchain()
self.transaction_pool = []
self.executed_transactions = []
self.nodes = []
self.lock = Lock()
def set_port(self, port):
ports = [port] #5000, 5001, 5002]
for p in ports:
self.nodes.append(f'127.0.0.1:{p}')
self.me = f'127.0.0.1:{port}'
neighbours = list(self.nodes)
neighbours.remove(self.me)
self.network = Network(self.me, neighbours)
def new_transaction(self, transaction):
self.lock.acquire()
# drive consensus over the transaction
transaction.set_registrer(self.me)
self.add_transaction(transaction)
self.lock.release()
return True
def report_transaction(self, transaction):
self.lock.acquire()
self.add_transaction(transaction)
self.lock.release()
def add_transaction(self, transaction):
if transaction not in self.executed_transactions and transaction not in self.transaction_pool:
self.transaction_pool.append(transaction)
self.network.broadcast_transaction(transaction)
if self.my_turn():
self.sign()
def my_turn(self):
last_signer = self.blockchain.last_signer()
last_index = self.nodes.index(last_signer) if last_signer else -1
next = 0 if last_index + 1 == len(self.nodes) else last_index + 1
return self.nodes[next] == self.me
def execute_block(self, block):
for transaction in block.transactions:
self.state.execute_transaction(transaction)
def sign(self):
block = Block(self.transaction_pool, self.me,
self.blockchain.last_hash())
self.blockchain.add(block)
self.transaction_pool = []
self.network.broadcast_block(block)
self.execute_block(block)
def report_block(self, transactions, signer, previous):
self.lock.acquire()
if self.blockchain.last_hash() == previous:
block = Block(transactions, signer, previous)
self.blockchain.add(block)
for transaction in transactions:
if transaction in self.transaction_pool:
self.transaction_pool.remove(transaction)
self.executed_transactions.append(transaction)
self.network.broadcast_block(block)
self.execute_block(block)
self.lock.release()
def sm_eval(self, plan, input_state):
def be_task(prim_name, fn, api, **kwargs):
def wrapped(input_state, **outer_args):
kwargs.update(outer_args)
return self.backend_wrapper(input_state, prim_name,
fn, api, **kwargs)
return wrapped
self.logger.info('building state machine for %s' % plan)
sm = StateMachine(input_state)
sm.set_state('state_0')
for state_index, state in enumerate(plan):
parameters = state['ns']
primitive = state['primitive']
timeout = state.get('timeout', 30)
self.logger.debug('padding globals %s' % self.adventure_globals)
parameters['globals'] = self.adventure_globals
parameters['globals']['parent_task_id'] = self.parent_task_id
self.logger.debug('Wrapping %s primitive' % primitive)
if '.' in primitive:
# this primitive comes from backends
backend_fn = opencenter.backends.primitive_by_name(primitive)
if not backend_fn:
msg = 'cannot find backend primitive "%s"' % primitive
self.logger.debug(msg)
input_state['fails'] = input_state['nodes']
input_state['nodes'] = []
return({'result_code': 1,
'result_str': msg,
'result_data': {}}, input_state)
fn = be_task(primitive, backend_fn, self.api, **parameters)
else:
# this primitive comes from node tasks.
parameters['timeout'] = timeout
run_task = 'agent.run_task'
backend_fn = opencenter.backends.primitive_by_name(run_task)
fn = be_task('agent.run_task', backend_fn, self.api,
**{'action': primitive,
'payload': parameters})
# we have the backend fn, now wrap it up.
# solver plans are linear, so we'll jump to next step always
# plus, we'll assume that failure goes to default failure case
next_state = state_index + 1
success_state = 'state_%d' % next_state
if(next_state) == len(plan):
success_state = 'success'
sm.add_state(
'state_%d' % state_index, StateMachineState(
advance=fn,
on_success=success_state))
result_data, end_state = sm.run_to_completion()
return (result_data, end_state)
def sm_eval(self, plan, input_state):
def be_task(prim_name, fn, api, **kwargs):
def wrapped(input_state, **outer_args):
kwargs.update(outer_args)
return self.backend_wrapper(input_state, prim_name, fn, api,
**kwargs)
return wrapped
self.logger.info('building state machine for %s' % plan)
sm = StateMachine(input_state)
sm.set_state('state_0')
for state_index, state in enumerate(plan):
parameters = state['ns']
primitive = state['primitive']
timeout = state.get('timeout', 30)
self.logger.debug('padding globals %s' % self.adventure_globals)
parameters['globals'] = self.adventure_globals
parameters['globals']['parent_task_id'] = self.parent_task_id
self.logger.debug('Wrapping %s primitive' % primitive)
if '.' in primitive:
# this primitive comes from backends
backend_fn = opencenter.backends.primitive_by_name(primitive)
if not backend_fn:
msg = 'cannot find backend primitive "%s"' % primitive
self.logger.debug(msg)
input_state['fails'] = input_state['nodes']
input_state['nodes'] = []
return ({
'result_code': 1,
'result_str': msg,
'result_data': {}
}, input_state)
fn = be_task(primitive, backend_fn, self.api, **parameters)
else:
# this primitive comes from node tasks.
parameters['timeout'] = timeout
run_task = 'agent.run_task'
backend_fn = opencenter.backends.primitive_by_name(run_task)
fn = be_task('agent.run_task', backend_fn, self.api, **{
'action': primitive,
'payload': parameters
})
# we have the backend fn, now wrap it up.
# solver plans are linear, so we'll jump to next step always
# plus, we'll assume that failure goes to default failure case
next_state = state_index + 1
success_state = 'state_%d' % next_state
if (next_state) == len(plan):
success_state = 'success'
sm.add_state(
'state_%d' % state_index,
StateMachineState(advance=fn, on_success=success_state))
result_data, end_state = sm.run_to_completion()
return (result_data, end_state)
from state import StateMachine
import config
import pyaudio
import time
machine = StateMachine()
p = pyaudio.PyAudio()
def callback(data, frame_count, time_info, status):
out = machine.process(data)
return (out, pyaudio.paContinue)
stream = p.open(format=p.get_format_from_width(config.WIDTH),
channels=config.CHANNELS,
rate=config.RATE,
frames_per_buffer=config.CHUNK,
input=True,
output=True,
stream_callback=callback)
stream.start_stream()
while True:
time.sleep(0.1)
stream.stop_stream()
stream.close()
p.terminate()
