def main(myAddr, clAddr):
myDisplay = Display()
myDisplay.init()
backSender = BackSender(clAddr)
# start threads
displayThread = threading.Thread(None, displayMain, 'display', (myDisplay, ))
displayThread.start()
serverThread = threading.Thread(None, displayServerMain, 'displayserver', (myDisplay, myAddr))
serverThread.start()
connectTread = threading.Thread(None, connectMain, 'connection', (myAddr, backSender))
connectTread.start()
inputThread = threading.Thread(None, inputMain, 'input', (myDisplay, backSender))
inputThread.start()
# wait till threads end
while displayThread.is_alive() and serverThread.is_alive():
try:
littlePause = 0.1
displayThread.join(littlePause)
except KeyboardInterrupt:
logging.info('exit on keyboard interrupt')
myDisplay.quit = True
except Exception as err:
logging.error('unhandled exception in main thread:')
logging.error(str(err))
logging.debug(traceback.format_exc())
class Test:
def __init__(self, stream):
self.display = Display()
self.stream = Stream(stream)
def parse(self):
if not self.stream.line:
return False
parse = self.stream.line.split('#')
if len(parse) == 2:
try:
self.result = int(parse[0].rstrip(' '))
self.message = parse[1].rstrip(' ')
except:
return False
if self.result != 0 and self.result != 1:
return False
return True
return False
def launch(self):
sucess = 0
total = 0
while self.stream.read():
if self.parse():
if self.result == 1:
sucess += 1
else:
self.display.error("Error on" + self.message)
total += 1
self.display.summary(sucess, total)
def run_game(size):
gol = GameOfLife(size)
display = Display()
while True:
display.show_board(gol.get_board())
time.sleep(1)
class Simulator(object):
def __init__(self, num_tokens=5, size=(8, 8), frames_per_second=30):
self.arena = Arena()
for i in range(num_tokens):
token = Token(self.arena, i)
token.location = (random() * 4 - 2, random() * 4 - 2)
self.arena.objects.append(token)
self.display = Display(self.arena)
self._loop_thread = threading.Thread(target=self._main_loop, args=(frames_per_second,))
self._loop_thread.start()
def _main_loop(self, frames_per_second):
clock = pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
self.display.tick(1/frames_per_second)
clock.tick(frames_per_second)
def __del__(self):
pygame.quit()
class OutputHandler(object):
def __init__(self, outputs, pars, neuron2NoteConversion=4):
self.pars = pars
super(OutputHandler, self).__init__()
self.display = Display(pars['N_col'], pars['N_row'],\
['Ne', 'Ni', 's_e', 's_i', 'tau_e', 'tau_i', 'midi_ext_e', 'midi_ext_i',
'cam_ext', 'cam_external_max'], 'lines', screenSize=pars['screen_size'])
pm.init()
self.__output = outputs
if Visuals.NAME in self.__output:
self.__output[Visuals.NAME].note_on(1)
# self.__membraneViewer = Test()
self.__now = time.time()
self.__activeNotes = set()
self.__neuron2NoteConversion = neuron2NoteConversion
def __setupInputs(self, inputList):
self.__input = {}
for name in inputList:
self.__input[name] = \
self.__getDevice(self.__name2Identifier[name], type = 'input')
def update(self,fired):
# print 'es feuern', fired
neuron_ids = intersect1d(fired, self.pars['note_ids'])
self.__checkKeyChange(neuron_ids)
n_fired = neuron_ids.__len__()
if n_fired > 0:
for neuron_id in neuron_ids:
for name, output in self.__output.iteritems():
output.note_on(neuron_id)
# self.__membraneViewer.move()
# display spikes and update display
self.display.update_fired(fired)
self.display.update_pars(
['cam_ext', 'midi_ext_e', 'midi_ext_i', 's_e', 's_i',
'tau_e', 'tau_i', 'cam_external_max'])
pygame.display.update()
def turnOff(self):
for outputName in self.__output.iterkeys():
if outputName == NeuronNotes.NAME:
self.__output[outputName].turnAllOff()
def __checkKeyChange(self, neuron_ids):
if len(neuron_ids)>20:
self.__neuron2NoteConversion = (1 if self.__neuron2NoteConversion==7 else 7)
self.__output[NeuronNotes.NAME].setNeuron2NoteConversion(
self.__neuron2NoteConversion
)
# [output.setNeuron2NoteConversion(self.__neuron2NoteConversion) for
# name, output in self.__output.iteritems()]
print '----------------------------------------key change'
def run():
dis = Display()
start_time = arrow.now()
while True:
td = fmt_timedelta(start=start_time)
print td
dis.simple_static_message(td)
sleep(1)
def example1():
coefficients = np.array([[1, 1],
[1, -1]], dtype='float')
constraints = np.array([[4],
[2]], dtype='float')
objective = np.array([3, 2])
simplex = Simplex(coefficients=coefficients, constraints=constraints, objective=objective)
display = Display(simplex_init=simplex)
display.run_simplex()
def example2():
coefficients = np.array([[4.1, 2],
[2, 4]], dtype='float')
constraints = np.array([[40],
[32]], dtype='float')
objective = np.array([80, 55])
simplex = Simplex(coefficients=coefficients, constraints=constraints, objective=objective)
display = Display(simplex_init=simplex)
display.run_simplex()
class Session:
"""
for stand-alone usage by the ox-user.
?for collaborative sessions see CoSession
"""
print("DEL import Session")
def __init__(self, name, window):
self._name = name
self._dis = Display(window)
self._co = Coach()
self._co.register(self, self._dis)
self._dis.register(self, self._co)
self._co.create_exercises() #TODO.WN091101 replace by storing Exerc.s
self._calcs = None #pop !
def run(self):
"""as long as user does exercises"""
#print("in Session.run")
self._co.request_exercise()
self._dis.init_calc() #TODOWN091101 take Exercise as argument
def notify(self, (msg, data)):
'''called by the observed objects'''
#print('in Session.notify: msg=,data=', msg, data)
if msg == 'setting-done': # from Coach
self._ex = data
self._calcs = data._generate_calcs()
self._key = data.get_topic()
(self._calcs).reverse()
_calc = (self._calcs).pop()
#print('in Session.notify: calc=', _calc)
_lines, self._input = data.format(_calc)
self._dis.display_calc(_lines)
self._curr_in = self._input.pop() #need _curr_in in notify
self._dis.create_entryline(self._curr_in)
# create_entryline sets the callback from gtk to Display
if msg == 'digit-done': # from Display
#print('in Session.notify, digit-done: _input=', self._input)
(lino, pos, dig, proterr, protok, li) = self._curr_in
self._dis.create_entryline((lino, -1, dig, proterr, protok, li))
if len(self._input) > 0:
self._curr_in = self._input.pop()
self._dis.create_entryline(self._curr_in)
else: # start new calc
self._dis.show_progress()
if len(self._calcs) > 0:
_calc = (self._calcs).pop()
print('in Session.notify: calc=', _calc)
_lines, self._input = self._ex.format(_calc)
self._dis.display_calc(_lines)
self._curr_in = self._input.pop() #need _curr_in in notify
self._dis.create_entryline(self._curr_in)
# create_entryline sets the callback from gtk to Display
else:
self._dis.finish_calc()
class Browser(object):
display = None
browser = None
def __init__(self, downloaded_data_dir=None, implicitly_wait_seconds=10, is_visible=False, profile_directory=None):
if not is_visible:
self.display = Display()
self.downloaded_data_dir = downloaded_data_dir
self.start_browser(downloaded_data_dir, implicitly_wait_seconds, profile_directory)
def __enter__(self):
return self
def __exit__(self, type, value, trace):
if type and self.downloaded_data_dir:
try:
save_to = join(self.downloaded_data_dir, 'error_screenshot_' + datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S"))
self.browser.save_screenshot(save_to)
except:
pass
self.close()
def start_browser(self, downloaded_data_dir=None, implicitly_wait_seconds=10, profile_directory=None):
profile = webdriver.FirefoxProfile(profile_directory)
if downloaded_data_dir:
'''start browser with profile'''
profile.set_preference("browser.download.folderList", 2)
profile.set_preference("browser.download.manager.showWhenStarting", False)
profile.set_preference("browser.download.dir", downloaded_data_dir)
profile.set_preference("browser.helperApps.neverAsk.saveToDisk", "application/csv,text/csv")
profile.set_preference("browser.download.manager.scanWhenDone", False)
profile.set_preference("browser.download.manager.showAlertOnComplete", True)
profile.set_preference("browser.download.manager.useWindow", False)
profile.set_preference("browser.helperApps.alwaysAsk.force", False)
self.browser = webdriver.Firefox(firefox_profile=profile)
self.browser.implicitly_wait(implicitly_wait_seconds)
def get_browser(self):
if self.browser:
return self.browser
raise Exception("browser don't exist")
def close_browser(self):
'''browser.quit() closes the browser & deleted the temp files'''
if self.browser:
try:
self.browser.quit()
except Exception as e:
log.error("error closing browser, reason: " + str(e))
self.browser = None
def close(self):
self.close_browser()
if self.display:
self.display.stop_display()
def run_from_txt():
with open("lp.txt") as file:
content = file.read()
kw = {}
exec(content, globals(), kw)
A = np.array(kw['A'])
b = np.array(kw['b'])
c = np.array(kw['c'])
d = Display(Simplex(coefficients=A, constraints=b, objective=c))
d.run_simplex()
def complex_camera(camera, target_rect):
l, t, _, _ = target_rect
_, _, w, h = camera
l, t, _, _ = -l+Display.getHalfWidth(), -t+Display.getHalfHeight(), w, h
#l = min(0, l) # stop scrolling at the left edge
#l = max(-(camera.width-WIN_WIDTH), l) # stop scrolling at the right edge
#t = max(-(camera.height-WIN_HEIGHT), t) # stop scrolling at the bottom
#t = min(0, t) # stop scrolling at the top
return Rect(l, t, w, h)
def run(self):
self.setup_logging()
scheduler = BlockingScheduler()
weather = Weather(scheduler, zip=self._args['zip'], station=self._args['station'])
dimmer = Dimmer(scheduler)
display = Display(weather, dimmer)
display.start()
scheduler.start()
def example3():
coefficients = np.array([[2, 1, 0],
[1, 2, -2],
[0, 1, 2]], dtype='float')
constraints = np.array([[10],
[20],
[ 5]], dtype='float')
objective = np.array([2, -1, 2])
simplex = Simplex(coefficients=coefficients, constraints=constraints, objective=objective)
display = Display(simplex_init=simplex)
display.run_simplex()
class Simulator(object):
def __init__(self, config={}, size=(8, 8), frames_per_second=30, foreground=False):
try:
game_name = config["game"]
del config["game"]
except KeyError:
game_name = DEFAULT_GAME
game = GAMES[game_name]
self.GAME_CODE = GAME_CODES[game_name]
self.arena = game(**config)
self.display = Display(self.arena, self.GAME_CODE)
self.foreground = foreground
self.frames_per_second = frames_per_second
if not self.foreground:
self._loop_thread = threading.Thread(target=self._main_loop, args=(frames_per_second,))
self._loop_thread.setDaemon(True)
self._loop_thread.start()
def run(self):
if not self.foreground:
raise RuntimeError("Simulator runs in the background. Try passing foreground=True")
self._main_loop(self.frames_per_second)
def set_robots(self, robots):
self.robots = robots
def _main_loop(self, frames_per_second):
clock = pygame.time.Clock()
while True:
if any(
event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE)
for event in pygame.event.get()
):
break
self.display.tick(1 / frames_per_second)
clock.tick(frames_per_second)
for robot in self.robots:
try:
robot.raiseExc(KeyboardInterrupt)
except threading.ThreadError:
pass
pygame.quit()
sys.exit(0)
class Game(object):
def __init__(self):
self.clock = pygame.time.Clock()
self.display = Display()
self.game_state = GameState()
self.control_state = ControlState()
def run(self):
pygame.init()
while True:
self.control_state.update()
self.game_state.update(self.control_state)
self.display.update(self.game_state)
self.clock.tick(60)
class Life(object):
__display = None
grid_size = [100, 100]
def __init__(self):
self.__display = Display(title='PyLife', grid_size=self.grid_size, width=800, height=800)
def initial_seed(self):
cells = {}
for x in range(self.grid_size[0]):
for y in range(self.grid_size[1]):
if random.randint(0, 1) == 1:
cells[(x, y)] = 1
return cells
def get_cell_neighbours(self, item, cells):
neighbours = 0
for x in range(-1, 2):
for y in range(-1, 2):
cell = (item[0] + x, item[1] + y)
if cell[0] in range(0, self.grid_size[0]) and cell[1] in range(0, self.grid_size[1]) and cell in cells:
if (x == 0 and y == 0) is False:
neighbours += 1
return neighbours
def get_cells(self, cells):
new_cells = {}
for x in range(self.grid_size[0]):
for y in range(self.grid_size[1]):
neighbours = self.get_cell_neighbours((x, y), cells)
if ((x, y) in cells) and (neighbours == 2 or neighbours == 3):
new_cells[(x, y)] = 1
elif ((x, y) in cells) is False and neighbours == 3:
new_cells[(x, y)] = 1
del cells
return new_cells
def run(self):
cells = self.initial_seed()
while True:
if self.__display.update() is False:
self.__display.quit()
sys.exit(0)
cells = self.get_cells(cells)
for cell in cells:
self.__display.draw(cell[0], cell[1])
def __init__(self, args):
""" BoomBoomClient constructor.
@param host: Server hostname.
@type host: C{str}
@param display_port: Server port for "display"/"view" connection.
@type display_port: C{int}
@param input_port: Server port for "input" connection.
@type input_port: C{int}
@param verbose: Verbose mode flag.
@type verbose: C{bool}
@param debug: Debug mode flag.
@type debug: C{bool}
@param max_fps: Maximal number of frames per second, for optimization.
@type max_fps: C{int}
"""
args["protocol"] = protocol.loadProtocol("protocol.xml")
args["features"] = ["game"] # Constant features
Happyboom.__init__(self, args)
EventListener.__init__(self, prefix="evt_")
self.display = Display(args)
self.input = Input(args)
self.__verbose = args.get("verbose", False)
self.registerEvent("happyboom")
self.registerEvent("game")
def __init__(self, width=800, height=600):
(self.__width, self.__height) = (width, height)
self.__display = Display(width, height)
self.__bts = {}
self.__ms = set()
self.__color_index = 0
self.__filename = None
self.__speed = 1.
self.__freqs_color = {}
log.nb_handover = 0
self.__display.action_load.triggered.connect(self.load_file)
self.__display.action_reload.triggered.connect(self.reload_file)
self.__display.action_play.triggered.connect(self.__update_moving_ms)
self.__display.action_incSpeed.triggered.connect(
lambda: self.change_speed(1))
self.__display.action_decSpeed.triggered.connect(
lambda: self.change_speed(-1))
self.__display.speed_lineedit.editingFinished.connect(
lambda: self.set_speed(float(self.__display.speed_lineedit.text())))
self.__move_timer = QtCore.QTimer()
self.__move_timer.timeout.connect(self.movems)
self.set_speed(1)
self.__display.show()
def __init__(self):
self.logger = Logger(level='debug')
self.logger.debug("Create display")
self.display = Display()
self.logger.debug(" + size: %sx%s" % (self.display.width, self.display.height))
## Config
self.blocks_width = 5
self.aliens_width = 10
self.aliens_height = 4
self.aliens_margin = 2
self.torpedos = []
self.max_speed = 10
self.frame_rate = 25
self.speed_down = 3
self.score = 0
# Build Aliens
self.aliens = self.build_aliens()
# Build Blocks
self.blocks = self.build_blocks()
# Build ship
self.ship = Ship(
logger=self.logger,
display=self.display,
game=self
)
def __enter__(self):
# init curses and it's wrapper
self.screen = curses.initscr()
self.display = Display(self.screen, self.encoding)
# create keyhandler
self.keyhandler = key.KeyHandler(self.screen)
# create view
self.view = SelectorView(percol = self)
# create command
self.command_candidate = SelectorCommand(self.model_candidate, self.view)
self.command_action = SelectorCommand(self.model_action, self.view)
# suppress SIGINT termination
signal.signal(signal.SIGINT, lambda signum, frame: None)
# handle special keys like <f1>, <down>, ...
self.screen.keypad(True)
curses.raw()
curses.noecho()
curses.cbreak()
return self
def __init__(self):
self.display = Display()
self.player = Charactor(self)
self.level = Level(self)
self.hud = Hud()
self.prepare_stage()
def initialize_interface(self):
self.display = Display(self.game_data)
self.uis = UIState(self.game_data)
#Building buttons callbacks
self.uis.button_homes.callback = self.generate_building_callback('houses')
self.uis.button_fields.callback = self.generate_building_callback('field')
self.uis.button_woodcutter.callback = self.generate_building_callback('woodcutter')
self.uis.button_road.callback = self.generate_building_callback('road')
self.uis.button_port.callback = self.generate_building_callback('port')
self.uis.button_stockpile.callback = self.generate_building_callback('stockpile')
self.uis.button_stone_carrier.callback = self.generate_building_callback('stone_carrier')
self.uis.button_workshop.callback = self.generate_building_callback('workshop')
self.uis.button_iron_mine.callback = self.generate_building_callback('iron_mine')
self.uis.button_destruct.callback = self.generate_building_callback('destruct')
self.display.uis = self.uis
self.game_data.uis = self.uis
self.uis.display = self.display
self.uis.save_button.callback = self.save_game
self.uis.load_button.callback = self.load_game
#Listeners
event_manager.event_manager.add_listener(event_manager.MESSAGE_MOUSE_UP, self.uis.mouse_button_up_callback)
event_manager.event_manager.add_listener(event_manager.MESSAGE_KEY_UP, self.keyup_callback)
event_manager.event_manager.add_listener(event_manager.MESSAGE_KEY_DOWN, self.keydown_callback)
event_manager.event_manager.add_listener(event_manager.MESSAGE_MOUSE_MOTION, self.mouse_move)
event_manager.event_manager.add_listener(event_manager.MESSAGE_MOUSE_DOWN, self.mouse_key_down_callback)
event_manager.event_manager.add_listener(event_manager.MESSAGE_KEY_UP, self.uis.check_button_up)
def __init__(self):
""" connect hardware, initialize state dir """
self.trigger = Trigger()
self.display = Display()
self.current_address = None
self.cost = 0
self.set_state(Vend.STARTUP)
def create_displays2(self, fullscreen): #create display objects for each projector image
self.create_images()
self.shadows = []
self.display = Display()
self.display.setup(fullscreen)
self.draw()
def __init__(self, verbose = False, scan_interval_timeout = constants.SCAN_INTERVAL_TIMEOUT):
self.scan_interval_timeout = scan_interval_timeout
self.last_tag = None
self.last_tag_type = None
self.current_tag_type = None
self.last_read_tstamp = -1
self.display = Display()
def __init__(self):
self.config = {} # dict to contain combined list of config file options and commandline parameters
self.email_list = [] # list of email targets
self.webserver = None # web server process
# initialize some config options
self.config["domain_name"] = ""
self.config["company_name"] = ""
self.config["config_filename"] = ""
self.config["email_list_filename"] = ""
# default all bool values to False
self.config["verbose"] = False
self.config["gather_emails"] = False
self.config["enable_externals"] = False
self.config["enable_web"] = False
self.config["enable_email"] = False
self.config["enable_email_sending"] = False
self.config["simulate_email_sending"] = False
self.config["daemon_web"] = False
self.config["always_yes"] = False
# get current IP
self.config['ip'] = Utils.getIP()
# set a few misc values
self.pid_path = os.path.dirname(os.path.realpath(__file__)) + "/../"
self.display = Display()
self.email_templates = defaultdict(list)
def load(self):
self._map = {}
self._tiles = {}
self._attributes = {}
file = Files.openFile(self._file)
self._attributes = self.loadAttributes('attribs', file)
self._enemies = self.loadAttributes('enemies', file)
self.w = self.getAttr("w") * const.res
self.h = self.getAttr("h") * const.res
self._display = Display(Surface((self.w, self.h)), klass=self, transparent=True)
file = re.search("map: {(.*?)}", file, flags=re.DOTALL).group(1)
for tile in re.finditer(r"\((.*?):(.*?)\)", file):
rect, right = tile.group(1), tile.group(2)
rect = re.match(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", rect)
if not rect:
raise Exception("Unrecognized pattern: {}".format(rect))
details = re.match(r"(\d+),(\d+)$", right)
if not details:
raise Exception("Unrecognized pattern: {}".format(right))
i, e = int(rect.group(1)), int(rect.group(2))
x, y, w, h = rect.group(3), rect.group(4), rect.group(5), rect.group(6)
x, y, w, h = int(x), int(y), int(w), int(h)
typ, tile = int(details.group(1)), int(details.group(2))
attrib = {}
wall = Wall((x, y, w, h), typ, tile, attrib)
wall.subscribe("map", self._updateMap)
self._map[(i, e)] = wall
self._tiles.setdefault(wall.getType(), []).append(wall)
def start(self, ip, port):
self.sock.connect((ip, port))
self.sendline("name {}".format(self.name))
for line in readline_from_socket(self.sock):
data = json.loads(line)
if "status" in data:
self.handle_status_message(data)
continue
if not self.display:
self.board = GameBoardClient(*data["map_size"])
self.players = [Player(None, name="Player"+str(i)) for i in range(data["num_players"])]
self.my_id = data["player_id"]
self.players[self.my_id].name = self.name
self.display = Display(600, 600, self.board.width, self.board.height)
self.display.init()
self.board.update(data["map"])
self.display.clear()
self.display.draw_board(self.board, self.players)
self.display.update(fps=0)
self.resolve_round()
for event in pygame.event.get():
if event.type == pygame.QUIT:
print("Game terminated by host.")
sys.exit(0)
def case2(self):
filepath = os.path.dirname(os.path.abspath(__file__)) + '/sample/sample5.json'
layout = GreedyLayout(filepath, 1500, 1000)
self.display = Display(layout)
self.display.show()
self.score(layout)
try:
import boot2
except:
pass
import ckcc
import uasyncio.core as asyncio
loop = asyncio.get_event_loop()
print("---\nColdcard Wallet from Coinkite Inc. (c) 2018.\n")
# Setup OLED and get something onto it.
from display import Display, FontFixed, FontSmall, FontLarge
dis = Display()
dis.splash()
if version.is_mark2():
# Setup membrane numpad (mark 2)
from mempad import MembraneNumpad
numpad = MembraneNumpad(loop)
else:
# Setup touch numpad (mark 1 hardware)
from touchpad import TouchNumpad
numpad = TouchNumpad(loop)
# Serial Flash memory
from sflash import SPIFlash
sf = SPIFlash()
class GameServer:
def __init__(self, port, mapfile, rounds_per_second, w, h, observers):
self._port = port
self.players = []
self.observers = []
self.numObservers = observers
self.numPlayers = 0 # Will be overwritten by loadmap. (but included here to make PyCharm happy)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind(('', port))
self.socket.listen(3)
self.loadmap(mapfile)
self.display = Display(w, h, self.board.width, self.board.height)
self.rounds_per_second = rounds_per_second
def start(self):
print("Server started on port {}.".format(self._port))
self.wait_for_observsers()
self.wait_for_players()
print("All players are ready, game is now starting.")
self.send_gamestate_to_observers(unfiltered=True)
self.display.init()
first_round = True
while True:
self.display.clear()
self.start_next_turn()
self.resolve_food_harvest()
self.move_and_spawn_units()
self.resolve_fights()
self.destroy_spawners()
if random.randrange(0, 100) < 17:
self.board.spawn_food()
self.send_gamestate_to_players()
self.send_gamestate_to_observers()
self.display.draw_board(self.board, self.players)
if first_round:
self.wait_for_next_round(1)
first_round = False
if self.wait_for_next_round(self.rounds_per_second):
return True
def wait_for_next_round(self, rounds_per_seconds):
num_updates = int(20 / rounds_per_seconds)
for _ in range(num_updates):
self.display.update(20)
for event in pygame.event.get():
if event.type == pygame.QUIT:
print("Game terminated by host.")
return True
return False
def wait_for_observsers(self):
print("Waiting for {} observer(s) to connect...".format(
self.numObservers))
for _ in range(self.numObservers):
observer = self.get_player_from_socket()
observer.name = "Observer"
self.observers.append(observer)
def wait_for_players(self):
print("Waiting for {} player(s) to connect...".format(self.numPlayers))
for _ in range(self.numPlayers):
player = self.get_player_from_socket()
player.start()
self.players.append(player)
while not self.check_players_ready():
time.sleep(0.5)
def start_next_turn(self):
for player in self.players:
player.start_next_turn()
def get_player_from_socket(self):
conn, addr = self.socket.accept()
print("Recieved new connection from {}:{}".format(*addr))
return Player(conn)
def check_players_ready(self):
for player in self.players:
if not player.ready:
return False
return True
def move_and_spawn_units(self):
for playerNum, player in enumerate(self.players):
# Set new spawning mode for the player
mode = player.command.get("mode", "standard")
if mode == "standard":
player.mode = Unit
elif mode == "harvester":
player.mode = Harvester
elif mode == "soldier":
player.mode = Soldier
# move all the units he sent a command for
legal_moves = [
] # Used so we do not send loads of illegal-moves to the observers
for move in player.command.get("moves", []):
try:
x, y, direction = move
if self.board.move_unit(x, y, playerNum, direction):
legal_moves.append(move)
except (IndexError, ValueError, TypeError) as e:
print(
"{} sent an invalid move-command: '{}' Exception: {}".
format(player.name, move, e.message))
player.command["moves"] = legal_moves
self.board.resolve_moves()
# Spawn new units
spawners = copy(self.board.spawners)
random.shuffle(spawners)
for spawner in filter(lambda s: not s.dead, spawners):
owner = self.players[spawner.owner]
if owner.food > 0:
if not self.board.any_units_on_position(spawner.position):
self.board.add_unit(spawner.position[0],
spawner.position[1], owner.mode,
spawner.owner)
owner.food -= 1
def resolve_fights(self):
self.board.calculate_attack_strengths(5)
deadUnits = []
for unit in self.board.units:
x, y = unit.position
for enemy in self.board.get_neighbour_enemy_units(
x, y, 5, unit.owner):
if unit.attackStrength >= enemy.attackStrength:
unit.dead = True
if unit not in deadUnits:
deadUnits.append(unit)
self.display.draw_attack(enemy, unit)
for unit in deadUnits:
x, y = unit.position
self.board[x][y].unit = None
self.board.units.remove(unit)
def destroy_spawners(self):
for spawner in filter(lambda s: not s.dead, self.board.spawners):
x, y = spawner.position
if self.board[x][y].unit is not None:
if self.board[x][y].unit.owner != spawner.owner:
spawner.dead = True
def resolve_food_harvest(self):
removedCells = []
for foodcell in self.board.foodcells:
players = set()
harvest = 0
neighbourCells = self.board.get_neighbour_cells(
foodcell.x, foodcell.y, 1)
for cell in filter(
lambda c: c.unit is not None and c.unit.type != "soldier",
neighbourCells):
players.add(cell.unit.owner)
if cell.unit.harvest > harvest:
harvest = cell.unit.harvest
foodcell.hasFood = False
removedCells.append(foodcell)
break
if len(players) == 1:
self.players[players.pop()].food += harvest
for cell in removedCells:
self.board.foodcells.remove(cell)
def loadmap(self, mapfile_path):
with open(mapfile_path) as mapfile:
line = mapfile.readline().rstrip().split(" ")
width, height, numPlayers = int(line[0]), int(line[1]), int(
line[2])
self.numPlayers = numPlayers
self.board = GameBoard(width, height)
for y in range(height):
line = mapfile.readline().rstrip()
for x in range(width):
if line[x] == "#":
self.board.add_wall(x, y)
if line[x].isdigit():
self.board.add_spawner(x, y, int(line[x]))
def send_gamestate_to_players(self):
visibility_board = self.get_unit_visibility()
for player_id, player in enumerate(self.players):
state = {
"map_size": (self.board.width, self.board.height),
"player_id": player_id,
"num_players": self.numPlayers
}
state["map"] = []
for x in range(len(visibility_board)):
for y in range(len(visibility_board[x])):
if player_id in visibility_board[x][y]:
state["map"].append(self.board[x][y].as_dict())
player.send_gamestate(state)
def get_unit_visibility(self):
cell_visibility_mask = [[[] for _ in range(self.board.height)]
for _ in range(self.board.width)]
for unit in self.board.units:
x, y = unit.position
if unit.owner not in cell_visibility_mask[x][y]:
cell_visibility_mask[x][y].append(unit.owner)
for cell in filter(lambda cell: not cell.empty(),
self.board.get_neighbour_cells(x, y, 55)):
if unit.owner not in cell_visibility_mask[cell.x][cell.y]:
cell_visibility_mask[cell.x][cell.y].append(unit.owner)
return cell_visibility_mask
def send_gamestate_to_observers(self, unfiltered=False):
if self.numObservers == 0:
return
players = []
for i, player in enumerate(self.players):
players.append({
"id": i,
"name": player.name,
"food": player.food,
"command": player.command
})
state = dict(map_size=(self.board.width, self.board.height),
players=players)
cells = filter(
lambda c: (not c.empty()) and (unfiltered or not c.isWall),
chain.from_iterable(self.board))
state["map"] = [cell.as_dict() for cell in cells]
for observer in self.observers:
observer.send_gamestate(state)
class Core:
def __init__(self):
pass
'''
@name initiate
@description start core services
'''
def initiate(self):
format = "%(asctime)s: %(message)s"
logging.basicConfig(format=format,
level=logging.INFO,
datefmt="%H:%M:%S")
logging.info("Core: creating run_scheduler_job thread")
######run scheduler
self.run_scheduler_job()
logging.warning("Core: creating get_display_information thread")
#reset display storage
self.run_display_information_job()
# get a model
logging.info("Core: creating fetch_model_library thread")
self.run_fetch_model_job()
#begin flask server, after initiation tasks
server.run()
'''
@name run_scheduler_job
@description start scheduler on a new thread.
scheduler runs:
- process engine,
- risk engine
- model engine,
- anomaly engine
'''
def run_scheduler_job(self):
x = threading.Thread(target=scheduler_run,
args=("Test parameter to scheduler_run", ))
logging.info("core: before running thread")
x.start()
logging.info("core: wait for the thread to finish")
'''
@name run_display_information_job
@description run display information job
'''
def run_display_information_job(self):
print("Getting display information")
self.display = Display()
self.display.get_system_display()
'''
@name run_fetch_model
@description get model
'''
def run_fetch_model_job(self):
print("Getting model")
ModelLibrary.fetch_model()
def run(self):
"初始值设置"
IDs = [1, 2, 3, 4, 5, 6]
pointMap = {}
act_flocks = []
pot_flocks = []
curid = 0
colorlist = np.zeros((2, 3))
for j in range(3):
colorlist[0][j] = 1
for j in range(3):
colorlist[1][j] = 0.9
onedata = np.zeros((0, 0))
lasttype = []
assigned = [0, 0, 0, 0, 0, 0]
flockmap = {}
cmap = {}
maxid = -2
start = 0
end = 0
# XAXISSIZE = 1000
WIN = 100
left = ''
# fig, ax = plt.subplots()
# plt.axis([0, XAXISSIZE, 0, 10])
# ax = plt.axis()
Display.drawFlock(colorlist, onedata, IDs, self.ax, start)
while True:
data = self.client.recv(BUFSIZE)
if data:
string = bytes.decode(data, encoding)
# print(string)
self.client.send("ok".encode(encoding='utf-8'))
IDs, pointMap, left = decodeMsg(string, left, IDs, pointMap)
# print(IDs)
# if string.startswith('#'):
# ts, points = dePositionMsg(string)
# if ts not in pointMap:
# pointMap[ts] = []
# pointMap[ts] = points
# elif string.startswith('%'):
# IDs = deIdMsg(string)
# print(IDs)
if len(pointMap) == WIN:
pointmap = pointMap
pointMap = {}
end = start + WIN
start = end
"画图"
draw_array, flockmap, act_flocks, pot_flocks, curid = FD.rtFlockDetect(
IDs, self.gama, self.delta, pointmap, self.eps,
self.minPts, 0, 0.4, act_flocks, pot_flocks, flockmap,
curid, self.spatialType)
draw_array1 = np.transpose(draw_array)
onedata = Display.combinedata(onedata, draw_array1)
"获得色彩数组"
colorlist, lasttype, assigned, cmap, maxid = color.chooseColor(
colorlist, draw_array, lasttype, assigned, cmap, maxid)
# print(list(colorlist))
"画图"
plt.clf()
Display.drawFlock(colorlist, onedata, IDs, self.ax, start)
else:
print('no data')
break
# plt.show()
print("close:", self.client.getpeername())
class Client(Happyboom, EventListener):
""" The main class of the client of BoomBoom.
@ivar display: Display manager of the game.
@type display: C{L{BoomBoomDisplay}}
@ivar input: Input manager of the game.
@type input: C{L{BoomBoomInput}}
@ivar __verbose: Verbose mode flag.
@type __verbose: C{bool}
@ivar __stopped: Stopped game flag.
@type __stopped: C{bool}
@ivar __stoplock: Mutex for synchronizing __stopped.
@type __stoplock: C{thread.lock}
"""
def __init__(self, args):
""" BoomBoomClient constructor.
@param host: Server hostname.
@type host: C{str}
@param display_port: Server port for "display"/"view" connection.
@type display_port: C{int}
@param input_port: Server port for "input" connection.
@type input_port: C{int}
@param verbose: Verbose mode flag.
@type verbose: C{bool}
@param debug: Debug mode flag.
@type debug: C{bool}
@param max_fps: Maximal number of frames per second, for optimization.
@type max_fps: C{int}
"""
args["protocol"] = protocol.loadProtocol("protocol.xml")
args["features"] = ["game"] # Constant features
Happyboom.__init__(self, args)
EventListener.__init__(self, prefix="evt_")
self.display = Display(args)
self.input = Input(args)
self.__verbose = args.get("verbose", False)
self.registerEvent("happyboom")
self.registerEvent("game")
def start(self):
""" Starts the game client."""
if self.__verbose:
log.info("[BOOMBOOM] Starting client...")
Happyboom.start(self)
# Create thread for display
thread.start_new_thread(self.displayThread, ())
quit = False
while not quit:
self.input.process()
time.sleep(0.100)
quit = self.stopped
def stop(self):
""" Stops the game client."""
if self.__verbose:
log.info("[BOOMBOOM] Stopping client...")
Happyboom.stop(self)
self.launchEvent("happyboom", "disconnection", self._io, u"Quit.")
self.display.stop()
def evt_game_stop(self):
self.stop()
def evt_happyboom_stop(self):
""" Stop event handler.
"""
self.stop()
def displayThread(self):
""" Thread handler for the "display" part."""
try:
self.display.start()
except Exception, msg:
bt = getBacktrace()
log.error("EXCEPTION IN DISPLAY THREAD:\n%s\n%s" % (msg, bt))
try:
self.stop()
except Exception, msg:
bt = getBacktrace()
log.error("EXCEPTION (2) IN DISPLAY THREAD:\n%s\n%s" % (msg, bt))
"""
CS550 Project: Solitaire
Due September 24, 2018
@author: Ethan Chapman
Dependencies:
termcolor - package for changing the console colors
pyparsing - parsing colored strings
"""
from display import Display
from game import Game
game = Game()
while sum([len(i) for i in game.piles]) > 0:
Display.clear()
Display.display(game)
game.do_turn()
print("You Win!")
async def display_task(display_queue, config):
num_leds = config['num_leds']
led_display = Display(config['pin_l'], config['pin_r'], num_leds)
update_rate = config['update_rate']
last_msg = None
last_percent = 0.0
pulse_rate = 60
try:
while True:
msg = await display_queue.get()
if msg != last_msg:
last_msg = msg
data = msg[1]
if msg[0] == 'percent_smooth':
if data >= 1.0:
for i in range(pulse_rate/2):
led_display.display_pulse((-0.8/(pulse_rate/2))*i+1)
time.sleep(update_rate/pulse_rate)
await asyncio.sleep(0)
for i in range(pulse_rate/2):
led_display.display_pulse((0.8/(pulse_rate/2))*i+0.2)
time.sleep(update_rate/pulse_rate)
await asyncio.sleep(0)
else:
percent = data
num_prev_leds = ceil(last_percent*num_leds)
num_active_leds = ceil(percent*num_leds)
leds_to_update = abs(num_prev_leds-num_active_leds)
if leds_to_update > 0:
if percent > last_percent:
for i in range(num_prev_leds, num_active_leds):
led_display.display_values(i/num_leds)
await asyncio.sleep(update_rate/leds_to_update)
else:
for i in range(num_prev_leds-1, num_active_leds-1, -1):
led_display.display_values(i/num_leds)
await asyncio.sleep(update_rate/leds_to_update)
last_percent = data
elif msg[0] == 'percent':
led_display.display_config(data)
else:
print('unkown message in display task ' + str(msg))
except asyncio.CancelledError:
return
class DroneManager:
def __init__(self):
self.pids = DronePIDs()
self.orbslam = OrbSlam()
self.display = Display()
self.marker_vision = CopterMarkerVision()
self.drone_rc_controller = DroneRCController()
self.shared_state = {}
#self.joystick = JoystickInput()
def process_loop(self):
# Get Telemetry
# self.shared_state['marker_telemetry'] = self.marker_vision.process()
self.shared_state['slam_telemetry'] = self.orbslam.process(
self.shared_state)
# Scan keyboard
self.shared_state['cv_keyboard'] = self.handle_opencv_keyboard_input()
self.shared_state[
'pygame_keyboard'] = self.display.get_keyboard_events()
# Tune yaw on spacebar
if 'space' in self.shared_state.get('pygame_keyboard'):
self.pids.pids['yaw'].begin_tuning()
# Lock in setpoints on 'S' key
if 's' in self.shared_state.get(
'pygame_keyboard'
) and 'last_known_pose' in self.shared_state['slam_telemetry']:
self.pids.hold_current_position(
self.shared_state['slam_telemetry']['last_known_pose'])
# Only update PIDs if new telemetry pose data is available
if self.shared_state['slam_telemetry'].get('pose_update'):
self.shared_state['pid_output'] = self.pids.update(
self.shared_state['slam_telemetry']['pose_update'])
self.drone_rc_controller.update_channels(
self.shared_state['pid_output']['aileron'],
self.shared_state['pid_output']['pitch'],
self.shared_state['pid_output']['throttle'],
self.shared_state['pid_output']['yaw'],
)
# Kill throttle if telemetry is lost
if self.shared_state['slam_telemetry'].get('telemetry_lost'):
self.drone_rc_controller.pause_stream()
self.display.rerender(self.shared_state)
sleep(.05)
def cleanup(self):
self.drone_rc_controller.kill_throttle()
self.drone_rc_controller.pause_stream()
self.marker_vision.cleanup()
self.orbslam.cleanup()
self.display.cleanup()
@staticmethod
def handle_opencv_keyboard_input():
k = cv2.waitKey(30) & 0xff
if k == 27:
raise Exception('Shutdown')
def screen_timeout(timer):
Disp.enable(False)
timer.deinit()
def draw_menu():
for prog in PROGRAMS:
Disp.add_link(prog.name, SCR_PROG)
Disp.set_highlighted(Config.cur_program())
#!/usr/bin/env python3
import cv2
import time
from display import Display
W = 1920 // 2
H = 1080 // 2
disp = Display(W, H)
class FeatureExtractor(object):
GX = 16
GY = 12
def __init__(self):
self.orb = cv2.ORB_create()
def extract(self, img):
# run detect in grid
sy = img.shape[0] // self.GY
sx = img.shape[1] // self.GX
for ry in range(0, img.shape[0], sy):
for rx in range(0, img.shape[1], sx):
img_chunk = img[ry:ry + sy, rx:rx + sx]
kp = self.orb.detect(img_chunk, None)
for p in kp:
print(p)
fe = FeatureExtractor()
parser.add_argument('--labels', type=str, nargs='+', default=[])
args = parser.parse_args()
args.temp_dir_root = os.path.expanduser(args.temp_dir_root)
args.repo_cache_dir = os.path.expanduser(args.repo_cache_dir)
args.trash_dir_root = os.path.expanduser(args.trash_dir_root)
db = connection = pymysql.connect(
host=args.host,
user=args.user,
password=args.password,
database=args.database,
cursorclass=pymysql.cursors.DictCursor,
autocommit=True,
)
available_gpu_ids = ''
if args.gpus:
available_gpu_ids = list(map(int, args.gpus.split(',')))
with Display() as display:
ExecutorManager(
display,
db,
available_gpu_ids,
args.temp_dir_root,
args.repo_cache_dir,
args.trash_dir_root,
args.max_parallel,
args.labels,
).run()
class Environment(object):
"""
Represents the virtual environment -- the 'OS'
behind Tal, which manages all other running apps and services,
and centrally monitors and dispatches updates to Tals
peripherals.
"""
ENABLED_APPS = [
ReaderApp,
TracerApp,
]
ENABLED_SERVICES = [
NetworkService,
]
activeHandlers = [
LuxControlHandler,
]
activeSession = None
runningServices = []
message = ''
tiltSensorRight = None
tiltSensorLeft = None # for now
display = None
def __init__(self):
self.beforeStartUp()
self.startUp()
self.afterStartUp()
def beforeStartUp(self):
self.message = 'Starting up ...'
def startUp(self):
if YAPI.RegisterHub('usb', YRefParam()) != YAPI.SUCCESS:
sys.exit('Connection error: connection through USB failed')
self.tiltSensorRight = Sensor()
self.display = Display()
# bootstrap handlers
for h in self.activeHandlers:
self.tiltSensorRight.attachHandler(h())
self.tiltSensorRight.startWatching()
# start display update loop
def loop():
threading.Timer(.10, loop).start()
self.display.updateStatus()
# for debugging, show data in the message row for now
self.display.updateMessage('P:{} R:{}'.format(
str(pitch), str(roll)))
loop()
def afterStartUp(self):
self.message = 'Idle'
def beforeStartApp(self, app):
if app not in self.ENABLED_APPS:
return False
self.message = 'Starting {}...'.format(app.name)
def startApp(self, app):
if app in self.ENABLED_APPS:
self.activeSession = app(environment=self)
else:
return False
def afterStartApp(self, app):
self.message = 'Running {}'.format(app.name)
def beforeCloseApp(self, app):
if not self.activeSession:
return False
self.activeSession.beforeClose()
def closeApp(self, app):
if not self.activeSession:
return False
self.activeSession = None
def afterCloseApp(self, app):
return
def registerHandler(self, handlerInstance):
self.activeHandlers.append(handlerInstance)
def unregisterHandler(self, handlerInstance):
self.activeHandlers.remove(handlerInstance)
self.sSocket.send(bMensagem)
except BrokenPipeError:
self.mataThread()
# definicao das variaveis e funções
serverName = '' # ip do servidor (em branco)
serverPort = 65000 # porta a se conectar
serverSocket = socket(AF_INET, SOCK_STREAM) # criacao do socket TCP
# bind do ip do servidor com a porta
serverSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
serverSocket.bind((serverName, serverPort))
serverSocket.listen(1) # socket pronto para 'ouvir' conexoes
# Inicia o diplay
display = Display()
display.start()
listaDeUsuarios = []
# Manda a mensagem recebida para todos os usuários logados e para o display do servidor
def sendBroadcast(bMensagem):
for usuario in listaDeUsuarios:
try:
usuario.sSocket.send(bMensagem)
except OSError:
usuario.mataThread()
# Tenta mandar a mensagem recebida para o usuário especificado no comando privado()
class Monitor(object):
def __init__(self):
self._name = 'Monitor/{}'.format(str(uuid.uuid4()))
self._logger = self._make_logger(self._name)
self._logger.debug('Initialized Logger')
observer = log.PythonLoggingObserver()
observer.start()
self._last_query = None
self._tasks = []
self._display = Display()
self._notifiers = {
'display': self._notify_display,
'thingspeak': self._notify_thingspeak,
}
self._logger.info('Initialized {}'.format(self._name))
self.start_tasks()
def __del__(self):
if self._display:
self._display.clear()
GPIO.cleanup()
def start_tasks(self):
update_display = LoopingCall(self._update_display_last_query)
update_display.start(UPDATE_DISPLAY_INTERVAL)
self._tasks.append(update_display)
query = LoopingCall(self._query_sensors_and_notify)
query.start(QUERY_INTERVAL)
self._tasks.append(query)
def stop_tasks(self):
for task in self._tasks:
task.stop()
@staticmethod
def _make_logger(name):
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
sh = logging.StreamHandler()
sh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s %(levelname)s\t- %(message)s',
datefmt='%d/%m/%y %H:%M:%S')
sh.setFormatter(formatter)
logger.addHandler(sh)
return logger
def _notify_thingspeak(self, sensor_readings):
self._logger.debug('Sending update...')
fields = {
TEMPRATURE_FIELD_INDEX: sensor_readings['temprature'],
HUMIDITY_FIELD_INDEX: sensor_readings['humidity']
}
fields_url_part = '&'.join(
['{}={}'.format(f, d) for f, d in fields.items()])
uri = '{}?api_key={}&{}'.format(BASE_URL, API_KEY, fields_url_part)
agent = Agent(reactor)
d = agent.request(
bytes('GET', 'ascii'), bytes(uri, 'ascii'), None, None
) #Headers({'User-Agent': ['Twisted Web Client Example']}), None)
def response(ctx):
self._logger.debug('Update Sent')
d.addCallback(response)
def _notify_display(self, sensor_readings):
self._display.write_line(self._format_sensor_readings(sensor_readings),
SENSOR_DISPLAY_LINE)
def _update_display_last_query(self):
if not self._last_query:
return
self._display.write_line(timeago.format(self._last_query),
TIME_AGO_DISPLAY_LINE)
def _read_dht22(self):
self._logger.debug('Started reading from DHT22')
humidity, temp = Adafruit_DHT.read_retry(Adafruit_DHT.DHT22,
DHT22_DATA_PIN)
self._logger.debug('Read from DHT22')
return humidity, temp
def _query_sensors(self):
sensors = {}
humidity, temp = self._read_dht22()
if humidity is not None:
sensors['humidity'] = round(humidity, 2)
if temp is not None:
sensors['temprature'] = round(temp, 2)
self._last_query = datetime.datetime.now()
return sensors
def _format_sensor_readings(self, sensor_readings):
if sensor_readings['humidity'] is None or sensor_readings[
'temprature'] is None:
self._logger.error(
'humidity/temp received are incorrect ({}.{})'.format(
humidity, temp))
return DEFAULT_DATA_DISPLAY
text = 'T/H: {:.1f}c {:.1f}%'.format(sensor_readings['temprature'],
sensor_readings['humidity'])
return text
def _query_sensors_and_notify(self):
sensor_readings = self._query_sensors()
text = self._format_sensor_readings(sensor_readings)
self._logger.info(text)
for notifier in self._notifiers.values():
reactor.callWhenRunning(notifier, sensor_readings)
def run(self):
reactor.run()
class Game(object):
"""
This class represents an individual game, and contains the main game logic.
"""
defaults = {
"curses": True, # whether to use ncurses for map display
"color": True, # whether to use color with ncurses
"delay": 0.1, # seconds to sleep after each (ncurses) display update
"connect": CONNECT, # the territory connection graph (see world.py)
"areas": AREAS, # the territory->continent mapping, and values
"cmap": MAP, # the ASCII art map to use
"ckey": KEY, # the territority->char mapping key for the map
"screen": None, # a curses.window (for use with the curses.wrapper function)
"round": None, # the round number
"wait": False, # whether to pause and wait for a keypress after each event
"history": {}, # the win/loss history for each player, for multiple rounds
"deal": False # deal out territories rather than let players choose
}
def __init__(self, **options):
self.options = self.defaults.copy()
self.options.update(options)
self.world = World()
self.world.load(self.options['areas'], self.options['connect'])
self.players = {}
self.turn = 0
self.turn_order = []
if self.options['curses']:
self.display = CursesDisplay(self.options['screen'], self,
self.options['cmap'], self.options['ckey'],
self.options['color'], self.options['wait'])
else:
self.display = Display()
def add_player(self, name, ai_class, **ai_kwargs):
assert name not in self.players
player = Player(name, self, ai_class, ai_kwargs)
self.players[name] = player
@property
def player(self):
"""Property that returns the correct player object for this turn."""
return self.players[self.turn_order[self.turn % len(self.players)]]
def aiwarn(self, *args):
"""Generate a warning message when an AI player tries to break the rules."""
logging.getLogger("pyrisk.player.%s" % self.player.ai.__class__.__name__).warn(*args)
def event(self, msg, territory=None, player=None):
"""
Record any game action.
`msg` is a tuple describing what happened.
`territory` is a list of territory objects to be highlighted, if any
`player` is a list of player names to be highlighted, if any
Calling this method triggers the display to be updated, and any AI
players that have implemented event() to be notified.
"""
self.display.update(msg, territory=territory, player=player)
LOG.info([str(m) for m in msg])
for p in self.players.values():
p.ai.event(msg)
def play(self):
assert 2 <= len(self.players) <= 5
self.turn_order = list(self.players)
random.shuffle(self.turn_order)
for i, name in enumerate(self.turn_order):
self.players[name].color = i + 1
self.players[name].ord = ord('\/-|+*'[i])
self.players[name].ai.start()
self.event(("start",))
live_players = len(self.players)
self.initial_placement()
while live_players > 1:
if self.player.alive:
choices = self.player.ai.reinforce(self.player.reinforcements)
assert sum(choices.values()) == self.player.reinforcements
for tt, ff in choices.items():
t = self.world.territory(tt)
f = int(ff)
if t is None:
self.aiwarn("reinforce invalid territory %s", tt)
continue
if t.owner != self.player:
self.aiwarn("reinforce unowned territory %s", t.name)
continue
if f < 0:
self.aiwarn("reinforce invalid count %s", f)
continue
t.forces += f
self.event(("reinforce", self.player, t, f), territory=[t], player=[self.player.name])
for src, target, attack, move in self.player.ai.attack():
st = self.world.territory(src)
tt = self.world.territory(target)
if st is None:
self.aiwarn("attack invalid src %s", src)
continue
if tt is None:
self.aiwarn("attack invalid target %s", target)
continue
if st.owner != self.player:
self.aiwarn("attack unowned src %s", st.name)
continue
if tt.owner == self.player:
self.aiwarn("attack owned target %s", tt.name)
continue
if tt not in st.connect:
self.aiwarn("attack unconnected %s %s", st.name, tt.name)
continue
initial_forces = (st.forces, tt.forces)
opponent = tt.owner
victory = self.combat(st, tt, attack, move)
final_forces = (st.forces, tt.forces)
self.event(("conquer" if victory else "defeat", self.player, opponent, st, tt, initial_forces,
final_forces), territory=[st, tt], player=[self.player.name, tt.owner.name])
freemove = self.player.ai.freemove()
if freemove:
src, target, count = freemove
st = self.world.territory(src)
tt = self.world.territory(target)
f = int(count)
valid = True
if st is None:
self.aiwarn("freemove invalid src %s", src)
valid = False
if tt is None:
self.aiwarn("freemove invalid target %s", target)
valid = False
if st.owner != self.player:
self.aiwarn("freemove unowned src %s", st.name)
valid = False
if tt.owner != self.player:
self.aiwarn("freemove unowned target %s", tt.name)
valid = False
if not 0 <= f < st.forces:
self.aiwarn("freemove invalid count %s", f)
valid = False
if valid:
st.forces -= count
tt.forces += count
self.event(("move", self.player, st, tt, count), territory=[st, tt], player=[self.player.name])
live_players = len([p for p in self.players.values() if p.alive])
self.turn += 1
winner = [p for p in self.players.values() if p.alive][0]
self.event(("victory", winner), player=[self.player.name])
for p in self.players.values():
p.ai.end()
return winner.name
def combat(self, src, target, f_atk, f_move):
n_atk = src.forces
n_def = target.forces
if f_atk is None:
f_atk = lambda a, d: True
if f_move is None:
f_move = lambda a: a - 1
while n_atk > 1 and n_def > 0 and f_atk(n_atk, n_def):
atk_dice = min(n_atk - 1, 3)
atk_roll = sorted([random.randint(1, 6) for i in range(atk_dice)], reverse=True)
def_dice = min(n_def, 2)
def_roll = sorted([random.randint(1, 6) for i in range(def_dice)], reverse=True)
for a, d in zip(atk_roll, def_roll):
if a > d:
n_def -= 1
else:
n_atk -= 1
if n_def == 0:
move = f_move(n_atk)
min_move = min(n_atk - 1, 3)
max_move = n_atk - 1
if move < min_move:
self.aiwarn("combat invalid move request %s (%s-%s)", move, min_move, max_move)
move = min_move
if move > max_move:
self.aiwarn("combat invalid move request %s (%s-%s)", move, min_move, max_move)
move = max_move
src.forces = n_atk - move
target.forces = move
target.owner = src.owner
return True
else:
src.forces = n_atk
target.forces = n_def
return False
def initial_placement(self):
empty = list(self.world.territories.values())
available = 35 - 2 * len(self.players)
remaining = {p: available for p in self.players}
if self.options['deal']:
random.shuffle(empty)
while empty:
t = empty.pop()
t.forces += 1
remaining[self.player.name] -= 1
t.owner = self.player
self.event(("deal", self.player, t), territory=[t], player=[self.player.name])
self.turn += 1
else:
while empty:
choice = self.player.ai.initial_placement(empty, remaining[self.player.name])
t = self.world.territory(choice)
if t is None:
self.aiwarn("invalid territory choice %s", choice)
self.turn += 1
continue
if t not in empty:
self.aiwarn("initial invalid empty territory %s", t.name)
self.turn += 1
continue
t.forces += 1
t.owner = self.player
remaining[self.player.name] -= 1
empty.remove(t)
self.event(("claim", self.player, t), territory=[t], player=[self.player.name])
self.turn += 1
while sum(remaining.values()) > 0:
if remaining[self.player.name] > 0:
choice = self.player.ai.initial_placement(None, remaining[self.player.name])
t = self.world.territory(choice)
if t is None:
self.aiwarn("initial invalid territory %s", choice)
self.turn += 1
continue
if t.owner != self.player:
self.aiwarn("initial unowned territory %s", t.name)
self.turn += 1
continue
t.forces += 1
remaining[self.player.name] -= 1
self.event(("reinforce", self.player, t, 1), territory=[t], player=[self.player.name])
self.turn += 1
# Give external devs a way to start stuff early
try:
import boot2
except: pass
import ckcc
import uasyncio.core as asyncio
loop = asyncio.get_event_loop()
print("---\nColdcard Wallet from Coinkite Inc. (c) 2020.\n")
# Setup OLED and get something onto it.
from display import Display
dis = Display()
dis.splash()
# Setup membrane numpad (mark 2+)
from mempad import MembraneNumpad
numpad = MembraneNumpad(loop)
# Serial Flash memory
from sflash import SPIFlash
sf = SPIFlash()
# NV settings
from nvstore import SettingsObject
settings = SettingsObject(loop)
# global ptr to HSM policy, if any (supported on Mk3 only)
import re
from button import Button
from tagreader import TagReader
from player import Player
from display import Display
from os import listdir
from os.path import isdir, join
import RPi.GPIO as GPIO
# Initialize display first to write Hello
print("Initializing Display")
d = Display()
d.draw_text("Hallo!", 32)
library_path = "/srv/library"
GPIO.setmode(GPIO.BCM)
print("Initializing Player")
p = Player(24)
def on_tag_discovered(tag):
# Check if there is a album with this name
try:
selected_album = (join(library_path, f) for f in listdir(library_path)
if isdir(join(library_path, f))
and bool(re.search(tag + "$", f, re.I))).next()
p.play_album(selected_album)
except StopIteration:
d.draw_text(tag, 12)
#!/usr/bin/env python3
import cv2
import time
from display import Display
from extractor import Extractor
import numpy as np
W = 1920 / 2
H = 1020 / 2
F = 1
display = Display(W, H)
K = np.array([[F, 0, W // 2], [0, F, H // 2], [0, 0, 1]])
fe = Extractor(K)
def process_frame(img):
# too much resolution so will have to resize
img = cv2.resize(img, (W, H))
matches = fe.extract(img)
print("%d matches" % (len(matches)))
for pt1, pt2 in matches:
u1, v1 = fe.denormalize(pt1)
u2, v2 = fe.denormalize(pt2)
cv2.circle(img, (u1, v1), color=(0, 255, 0), radius=3)
cv2.line(img, (u1, v1), (u2, v2), color=(255, 0, 0))
display.paint(img)
class Tracker:
def __init__(self):
# Strava client to hold information for tracker.
self.client = Client()
# Time token expires at.
self.token_expires_at_ = None
# Client information.
self.client_id = None
self.client_secret = None
# Time in seconds between refreshes.
self.sleep_time_ = 300
# Number of target activities per week.
self.target_ = 4
# Private display object.
self.display_ = Display()
# Activity tracking variables.
self.start_date = datetime.datetime.utcnow().date()
self.next_week = self.start_date + datetime.timedelta(weeks=1)
self.week_streak = 0
self.num_activities = 0
# Filename of save file.
self.save_file_ = 'streak.yaml'
def set_expiration(self, token_expires_at):
self.token_expires_at_ = token_expires_at
def set_client_info(self, client_id, client_secret):
self.client_id = client_id
self.client_secret = client_secret
def save_status(self):
save_obj = {'start_date' : self.start_date, 'next_week' : self.next_week,
'week_streak' : self.week_streak, 'num_activities' : self.num_activities}
with open(self.save_file_, 'wb') as save_file:
pickle.dump(save_obj, save_file)
def load_status(self):
save_obj = None
try:
with open(self.save_file_, 'rb') as save_file:
save_obj = pickle.load(save_file)
self.start_date = save_obj['start_date']
self.next_week = save_obj['next_week']
self.week_streak = save_obj['week_streak']
self.num_activities = save_obj['num_activities']
except (OSError, IOError, EOFError) as e:
print('Nothing in this save file, going to save defaults.')
self.save_status()
def update(self):
self.save_status()
self.display_.show(self.week_streak, self.target_ - self.num_activities, self.target_)
def run(self):
# Save start date/time
# Ask Strava for activities since 1 week ago
# If len(activities) >= goal increment streak
# Check that token won't expire in 12 hours
# If token needs refreshing, refresh it
# Sleep for sleep_time
self.load_status()
self.update()
while(True):
# Refresh token if necessary.
if time.time() > self.token_expires_at_:
refresh_response = self.client.refresh_access_token(client_id=self.client_id,
client_secret=self.client_secret,
refresh_token=self.client.refresh_token)
self.token_expires_at_ = refresh_response['expires_at']
print('Refreshing token, new one expires at {}'
.format(str(refresh_response['expires_at'])))
new_activities = len(list(self.client.get_activities(after = self.start_date.isoformat())))
# Handle null return from Strava servers.
if not new_activities:
new_activities = 0
print(new_activities)
if new_activities != self.num_activities:
print("New activities detected!")
self.num_activities = new_activities
self.update()
for activity in self.client.get_activities(after = self.start_date.isoformat()):
print("{0.name} {0.moving_time}".format(activity))
# Check if we've hit the target for this week.
if self.num_activities >= self.target_:
self.week_streak += 1
self.update()
cur_date = datetime.datetime.utcnow().date()
# Check if it's next week.
if cur_date == self.next_week:
# Check if we haven't hit our target and reset.
if self.num_activities < self.target_:
self.week_streak = 0
# Advance the date to a week from now.
self.start_date = cur_date
self.next_week = cur_date + datetime.timedelta(weeks=1)
self.update()
time.sleep(self.sleep_time_)
class Game_board:
# constructeur
def __init__(self):
self.nb_maison_dispo = 32
self.nb_hotel_dispo = 12
self.dice = Dice()
# instanciation des cartes
self.carte_chance = Carte_chance()
self.carte_communaute = Carte_communaute()
# instanciation des cases propriété
self.proprietes = []
for i in proprietes_data:
self.proprietes.append(Propriete(i))
# for p in self.proprietes: p.fiche()
# instanciation des cases gare
self.gares = []
for i in gares_data:
self.gares.append(Gare(i))
# for g in self.gares: g.fiche()
# instanciation des cases compagnie
self.compagnies = []
for i in compagnies_data:
self.compagnies.append(Compagnie(i))
# for c in self.compagnies: c.fiche()
# instanciation de la prison
self.prison = Prison()
# tableau des joueurs
self.joueurs = []
# initialisation graphique du plateau
self.display = Display()
def init_game(self):
print("************************************\n" +
"* BIENVENUE A LA TABLE DE MONOPOLY *\n" +
"************************************\n")
j = Joueur()
self.joueurs.append(j)
j = Joueur()
self.joueurs.append(j)
print("Il y a", len(self.joueurs), "joueurs à la table\n")
while len(self.joueurs) < 5 and input(
"Souhaitez-vous ajouter un nouveau joueur (max = 5) (o/N) ? "
).lower() == "o":
j = Joueur()
self.joueurs.append(j)
print("Il y a", len(self.joueurs), "joueurs à la table\n")
print("\nDébut de la partie\n")
# affichage des pions des joueurs sur le plateau
self.display.display_players(self.joueurs)
def play(self):
for j in self.joueurs:
j.fiche()
if j.position == 40: #joueur en prison
self.prison.libere(j, self.carte_chance, self.carte_communaute)
if j.position != 40:
self.case_arrivee(j) # le joueur a été libéré
else: # si joueur n'est pas en prison
self.go(j, self.dice.lancer(j))
self.case_arrivee(j)
while j.nb_double > 0: # tant le joueur a fait un double, il rejoue
print(j.nom, "rejoue")
self.go(j, self.dice.lancer(j))
self.case_arrivee(j)
# analyse de la case d'arrivée
def case_arrivee(self, j): # joueur j
if j.position == 0: # case départ = 0
j.cash += 200
print("Vous avez reçu 200 € !")
elif j.position in [7, 22, 36]:
self.carte_chance.tirer_carte(j) # carte chance
if j.replay:
j.replay = False
self.case_arrivee(j) # en cas de carte de déplacement
elif j.position in [2, 17, 33]:
self.carte_communaute.tirer_carte(
j, self.joueurs) # carte caisse de communauté
if j.replay:
j.replay = False
self.case_arrivee(j) # en cas de carte de déplacement
if j.retire_chance:
j.retire_chance = False
self.carte_chance.tirer_carte(
j) # si ne paye pas l'amende et préfere tirer chance
elif j.position in proprietes_data: # terrain
p = Propriete(j.position)
p.fiche()
p.visite(j, self.joueurs)
elif j.position in compagnies_data: # électricité/eau
c = Compagnie(j.position)
c.fiche()
c.visite(j, self.joueurs)
elif j.position in gares_data: # gare
g = Gare(j.position)
g.fiche()
g.visite(j, self.joueurs)
elif j.position in [0, 10,
20]: # case départ, simple visite, parc gratuit
if j.position == 0: print("Case départ")
elif j.position == 10: print("Simple visite")
elif j.position == 20: print("Parc gratuit")
elif j.position == 30: # allez en prison
print("Allez directement en prison")
j.position = 40
j.nb_double = 0 # cas du joueur qui arrive ici par un double => ne rejoue pas
elif j.position == 4: # impôts
print("Taxe sur le revenu: 200 €")
j.payer(200)
elif j.position == 38: # taxe luxe
print("Taxe de luxe: 100 €")
j.payer(100)
else: # pour debug
print("Erreur de case")
exit()
# déplacement du joueur j et maj graphique du plateau
def go(self, j, dice):
progress = dice # le joueur progresse de la valeur du lancé de dés
self.display.update_board(
j, progress,
self.joueurs) # visualisation du déplacement sur le plateau
j.position += progress # avance de la valeur de dice
if j.position > 39: j.position -= 40 # case départ = 0
#############################################################################
########################### FONCTIONS POUR DEBUG ###########################
#############################################################################
def list_all(self):
print("****************\nListing complet")
for i in range(1, 40):
print("\ncase:", i)
if i in self.proprietes:
p = Propriete(i)
p.fiche()
elif i in self.compagnies:
c = Compagnie(i)
c.fiche()
elif i in self.gares:
g = Gare(i)
g.fiche()
def list_proprietes(self):
print("****************\nListing propriétés")
for i in range(1, 40):
if i in self.proprietes:
print("\ncase:", i)
p = Propriete(i)
p.fiche()
def list_gares(self):
print("****************\nListing gares")
for i in range(1, 40):
if i in self.gares:
print("\ncase:", i)
g = Gare(i)
g.fiche()
def list_compagnies(self):
print("****************\nListing compagnies")
for i in range(1, 40):
if i in self.compagnies:
print("\ncase:", i)
c = Compagnie(i)
c.fiche()
# listing des cartes chance
def list_chance(self):
print("****************\nListing cartes chance")
# for i in range(len(self.carte_chance.jeu_carte)): print(self.carte_chance.jeu_carte.pop(len(self.carte_chance.jeu_carte)-1)[0])
for c in self.carte_chance.jeu_carte:
print(self.carte_chance.jeu_carte[c])
# listing des cartes caisse de communauté
def list_communaute(self):
print("****************\nListing cartes caisse de communauté")
# for i in range(len(self.carte_communaute.jeu_carte)): print(self.carte_communaute.jeu_carte.pop(len(self.carte_communaute.jeu_carte)-1)[0])
for c in self.carte_communaute.jeu_carte:
print(self.carte_communaute.jeu_carte[c])
class App(object):
""" The regression application.
The application accepts input from the command line and visualizes
results in a display window.
noise E -- set standard deviation representing measurement noise.
spacing O -- select spacing option (regular/random)
sample N -- sample N points on the sine function.
"""
def __init__(self, root):
""" Initializes the sine and standard display object and setup a loop
to continuously process the user input provided via the command line.
"""
# construct two frames
frame1 = tk.Frame(root)
frame1.place(relx=0, rely=0, relheight=1, relwidth=0.75)
frame2 = tk.Frame(root)
frame2.place(relx=0.75, rely=0, relheight=1, relwidth=0.25)
self.sine = Sine()
self.display = Display(frame1)
# Place scrollbar
s = tk.Scrollbar(frame2)
s.place(relx=0.95, rely=0, relwidth=0.05, relheight=0.5)
# Place text box to display previous commands
self.hist = tk.Text(frame2)
self.hist.config(yscrollcommand=s.set)
self.hist.place(relx=0, rely=0, relwidth=0.95, relheight=0.5)
# entry box to display new commands
self.cmd_var = tk.StringVar()
cmd = tk.Entry(frame2, textvariable=self.cmd_var)
cmd.bind('<Return>', self._execute_command)
cmd.place(relx=0, rely=0.5, relwidth=1, relheight=0.2)
# text box to display output messages
self.out_var = tk.StringVar()
out = tk.Entry(frame2, textvariable=self.out_var)
out.place(relx=0, rely=0.7, relwidth=1, relheight=0.3)
self.display.sine_function(self.sine.df_sine)
self.root = root
def _execute_command(self, event):
""" Interpret command line arguments.
args:
command -- str, input string provided via command line.
"""
command = self.cmd_var.get()
self.cmd_var.set('')
if 'quit' in command:
self.root.quit()
# interpret command
try:
if 'noise' in command:
self.sine.set_std(command.split()[1])
elif 'spacing' in command:
self.sine.set_spacing(command.split()[1])
elif 'sample' in command:
self.sine.training_data(command.split()[1])
self.display.training_data(self.sine.df_data)
except Message as m:
self.out_var.set(m.message)
hist = self.hist.insert(tk.END, command + '\n')
default=300, help='Width of the frames in the video stream.')
parser.add_argument('-ht', '--height', dest='height', type=int,
default=200, help='Height of the frames in the video stream.')
parser.add_argument('-ds', '--display', dest='display', type=int,
default=0, help='Display the detected images using OpenCV. This reduces FPS')
parser.add_argument('-num-w', '--num-workers', dest='num_workers', type=int,
default=3, help='Number of workers.')
parser.add_argument('-q-size', '--queue-size', dest='queue_size', type=int,
default=5, help='Size of the queue.')
args = parser.parse_args()
input_q = Queue(maxsize=args.queue_size)
output_q = Queue(maxsize=args.queue_size)
display_q = Queue(maxsize=args.queue_size)
d = Display()
video_capture = WebcamVideoStream(src=args.video_source,
width=args.width,
height=args.height).start()
cap_params = {}
frame_processed = 0
cap_params['im_width'], cap_params['im_height'] = video_capture.size()
cap_params['score_thresh'] = score_thresh
# max number of hands we want to detect/track
cap_params['num_hands_detect'] = args.num_hands
print(cap_params, args)
class Main:
def __init__(self):
self.results = get_args()
self.name = self.results.target
# Check if requested target exists
if not utils.is_target(self.name, neural=True):
return
if self.results.camera == 'pi':
camera_provider = PICamera()
logging.info('Using PI Camera provider')
elif self.results.camera == 'realsense':
logging.info('Using RealSense camera provider')
camera_provider = RealSense()
elif self.results.camera == 'cv':
camera_provider = CVCamera(self.results.port)
else:
logging.error('Invalid camera provider, this shouldn\'t happen')
sys.exit(1)
self.display = Display(provider=camera_provider)
if self.results.web:
self.web = Web(self)
self.web.start_thread() # Run web server
if self.results.networktables:
self.nt = nt_handler.NT(self.name)
self.stop = False
self.session = None
def change_name(self, name):
"""
Changes the name and starts a new loop.
:param name:
"""
if not utils.is_target(name, neural=True):
return
logging.info('Changing target to {}'.format(name))
self.name = name
self.stop = True
def loop(self):
printed = False
# Check if requested target exists
if not utils.is_target(self.name, False, True):
return
logging.info('Starting loop with target {}'.format(self.name))
self.stop = False
# We dynamically load classes in order to provide a modular base
target = import_module('neural_targets.{}'.format(
self.name)).Target(self)
self.display.change_exposure(target.exposure)
# Timer for FPS counter
timer = time.time()
avg = 0
while True:
frame = self.display.get_frame()
if frame is None:
if not printed:
logging.warning('Couldn\'t read from camera')
printed = True
continue
else:
printed = False
# Get bounding boxes
boxes = target.boxes(frame)
# Draw on frame
target.draw(frame, boxes)
angle, distance, bounding_box = target.measurements(frame, boxes)
# Show FPS
avg = utils.calculate_fps(frame, time.time(), timer, avg)
timer = time.time()
# Web
self.web.frame = frame
# Display
self.display.process_frame(frame, 'image', self.results.local)
if self.results.networktables:
if distance:
self.nt.set_item('distance', distance)
if angle:
self.nt.set_item('angle', angle)
if self.stop:
# If stop signal was sent we call loop again to start with new name
logging.warning('Restarting...')
self.loop()
break
k = cv2.waitKey(1) & 0xFF # large wait time to remove freezing
if k in (27, 113):
logging.warning('Q pressed, stopping...')
self.display.release()
self.session.close()
break
def run_display_information_job(self):
print("Getting display information")
self.display = Display()
self.display.get_system_display()
def __init__(self):
self.root = tk.Tk()
self.windowManager = WindowManager(Globals.NumCols, Globals.NumRows)
self.display = Display(self.root, self.windowManager)
self.inputHandler = InputHandler(self.display.getWidget())
def main():
screen1 = Display(1200, 600, 20)
screen1.create_display()
# Devices
##
import timer
from timer import Timer
from dac import DAC
from lcd import LCD
from bp import BP
from power import Power
###############################################################################
# DISPLAY
##########
# You shall modify pygame to True or False if you want or not to use pygame (True by default)
# You shall modify screen if you want to change screen dimensions ([800, 600] by default)
###############################################################################
dispatch_display = Display(pygame=True, screen=[560, 320])
###############################################################################
# SCHEDULER
##########
# You shall modify speedCoeff only
###############################################################################
scheduler = Scheduler(speedCoeff=1)
###############################################################################
# REGISTERS
##########
# Add registers like that : reg = Register("NAME")
###############################################################################
###############################################################################
def key_menu(key, count):
if key == KEY_NEXT:
Disp.key_next(count)
elif key == KEY_PREV:
Disp.key_prev(count)
elif key == KEY_ENTER:
if Disp.highlighted() != Disp.selected():
Disp.set_highlighted(Disp.selected())
Config.cur_program(Disp.highlighted())
# Config.save()
else:
Disp.key_enter()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--sentences', help='path to sentences file', type=str)
args = parser.parse_args()
sentences_file = args.sentences
try:
db = Db(FileIO.read(sentences_file))
except Exception:
Display.error('Error occurred while processing sentences file.')
sys.exit()
wa = WordAssociation(FileIO.read_optional(WORD_ASSOCIATION_DEFAULT_FILE))
error_lines = db.get_error_lines()
if len(error_lines) > 0:
Display.error(
'Keyword was not properly marked in the following line(s):')
for line in error_lines:
Display.display(line)
sys.exit()
twc = db.get_total_word_count()
kwc = db.get_known_word_count()
Display.display_header(twc, kwc)
try:
error = False
next_word = True
k, v = None, None
prompt = InputMapper.get_main_prompt()
while True:
if not error and next_word:
k, v = db.get_next_key_value()
disp = k
associations = wa.get_associations_for_word(Db.strip_key(k))
if len(associations) > 0:
disp = Db.mark_key(k, EmojiMapper.get(EmojiTypes.EYES))
Display.display(disp, True)
error = False
next_word = False
inp = raw_input(prompt).lower()
commands = InputMapper.get_commands(inp)
word = Db.strip_key(k)
for command in commands:
if command == Command.KNOW_IT:
db.mark(k, EmojiMapper.get(EmojiTypes.THUMBS_UP))
next_word = True
elif command == Command.SKIP:
db.unmark(k)
next_word = True
elif command == Command.OPEN_DICTIONARY:
Display.info('Opening dictionary for ' +
Display.bold_replace(word))
os.system('open dict://{}'.format(word))
elif command == Command.SHOW_CONTEXT:
Display.display(v)
elif command == Command.DISPLAY_ALL_WORDS:
Display.display_all_words(db.get_data(),
db.get_total_word_count(),
db.get_known_word_count())
elif command == Command.ASSOCIATE:
word_prompt = Display.get_association_prompt(word)
associations = raw_input(word_prompt).split()
associations = [w.lower() for w in associations]
associations.append(word)
wa.associate(associations)
elif command == Command.DISPLAY_ASSOCIATED_WORDS:
Display.display_associated_words(associations)
elif command == Command.DISPLAY_ALL_ASSOCIATIONS:
Display.display_all_associations(wa.get_all_associations(),
wa.get_num_associations())
elif command == Command.CONFLICTING:
Display.error('Conflicting command')
error = True
else:
Display.error('Unknown command')
error = True
Display.new_line()
except KeyboardInterrupt:
pass
finally:
FileIO.write_db(sentences_file, db.get_data())
FileIO.write_associations(WORD_ASSOCIATION_DEFAULT_FILE,
wa.get_all_associations())
