def __init__(self, trivia_question_repository, user_repository): Command.__init__(self) self._trivia_question_repository = trivia_question_repository self._user_repository = user_repository self._game_started = False self._current_question = None
def apply_command(matches: Collection, query: str) -> List[Message]: match_id = query check: Union[Message, ObjectId] = Command.check_match_id(match_id, "spectate") if isinstance(check, Message): return [check] object_id = check match = matches.find_one({"_id": object_id}) if match is None: return [Command.error_msg("Match not found", "spectate", match_id)] if match["gameState"] == GameState.ENDED.value: return [Command.error_msg("Game ended", "spectate", match_id)] return [ Message({ "messageType": "spectate", "matchId": match_id }, True, match_id, True), Message( Command.generate_state_dict( matches.find_one({"_id": object_id})), # type: ignore False, match_id) ]
def test_set_action_overrides_with_lambda(self): # Assemble c1 = Command() # Action c1.set_action(lambda x, y: x + y) # Assert self.assertEqual(3, c1.__do__(1, 2))
def __init__(self, args): Command.__init__(self, args) self.apkFile = args.apk # print(type(args.perm)) self.show_permission = args.perm self.show_signature = args.sign self.components = args.comp
def test_set_action_overrides_with_function(self): c1 = Command() def my_action(): return 1 c1.set_action(my_action) self.assertEqual(1, c1.__do__())
def test_when_executing_then_handle(mocker): on_handle_stub = mocker.stub(name='on_handle_stub') on_unregister_stub = mocker.stub(name='on_unregister_stub') command = Command([StubHandler(on_handle_stub, on_unregister_stub)]) command.execute(HANDLED_DATA) on_handle_stub.assert_called_once_with(None) on_unregister_stub.assert_called_once()
def extract_command(message_text) -> Command: logging.info("Message Text:: {}".format(message_text)) if len(message_text.split('me')) == 1: logging.info('Command Not Found ' + message_text) return Command(None, None) else: return Command( message_text.split('me')[0], message_text.split('me')[1])
def test_set_action_overrides_with_function_and_allows_params(self): # Assemble c1 = Command() def my_action(x, y): return x + y # Action c1.set_action(my_action) # Assert self.assertEqual(3, c1.__do__(1, 2))
def test_given_multiple_handlers_when_executing_then_handle(mocker): on_handle_stub = mocker.stub(name='on_handle_stub') on_unregister_stub = mocker.stub(name='on_unregister_stub') command = Command([ StubHandler(on_handle_stub, on_unregister_stub), StubHandler(on_handle_stub, on_unregister_stub) ]) command.execute(HANDLED_DATA) on_handle_stub.assert_has_calls([call(None), call(ONCE_HANDLED_DATA)]) assert on_unregister_stub.call_count == 2
def test_set_previous_sets_node_correctly(self): # Assemble c1 = Command() c2 = Command() # Action c2.set_previous(c1) # Assert self.assertEqual(c1.get_next(), c2) self.assertEqual(c1.get_previous(), None) self.assertEqual(c2.get_next(), None) self.assertEqual(c2.get_previous(), c1)
class Client(Updater): COMMANDS = [ Command('hello', funs.hello), Command('start', funs.start), Command('morning', funs.morning), Command('weather', funs.weather), Command('help', funs.help), Command('income', funs.income), Command('outflow', funs.outflow), Command('balance', funs.balance) ] def __init__(self, **kwargs): super().__init__(token=os.environ.get('TELEGRAM_KEY', 'XXX'), **kwargs) self.__init_client() def __init_client(self): for command in self.COMMANDS: self.__add_command(command()) def __add_command(self, command): self.dispatcher.add_handler(command) def run(self): self.start_polling() self.idle()
def test_given_next_command_when_executing_then_pass_handled_data(mocker): on_handle_stub = mocker.stub(name='on_handle_stub') on_unregister_stub = mocker.stub(name='on_unregister_stub') commands = [ Command([StubHandler(on_handle_stub, on_unregister_stub)]), Command([StubHandler(on_handle_stub, on_unregister_stub)]) ] handled_data = HANDLED_DATA for command in commands: handled_data = command.execute(handled_data) on_handle_stub.assert_has_calls([call(None), call(ONCE_HANDLED_DATA)]) assert on_unregister_stub.call_count == 2
def game_socket(ws: WebSocket) -> None: while not ws.closed: query = ws.receive() if query is None: continue print(f"Received:`{query}`") messages: List[Message] for command in commands: if command.command_matches(query): messages = command.apply_command( matches, query[len(command.STARTS_WITH):]) break else: messages = [Command.error_msg("Invalid command sent", query)] pass for message in messages: if message.add_sender_to_spectate_map: add_client_to_map(message.match_id, ws) msg_to_send_str = to_json_str(message.message) if message.reply_to_only_sender: ws.send(msg_to_send_str) else: removed_clients: List[WebSocket] = [] for client in game_clients[message.match_id]: try: client.send(msg_to_send_str) except WebSocketError: removed_clients.append(client) for client in removed_clients: game_clients[message.match_id].remove(client)
def test_dispatches_to_hardware(self): with MockHardware() as hardware_service: dispatcher = Dispatcher(hardware_service) current_state = State(color=Color(100, 100, 100), buzzer_pattern=BuzzerPattern.NONE) command = Command(color=Color(110, 110, 110), duration=100, buzzer_pattern=BuzzerPattern.NONE) now = 0 next_state = dispatcher.dispatch(current_state, command, now) self.assertEqual(next_state.color.r, 100) self.assertEqual(next_state.color.g, 100) self.assertEqual(next_state.color.b, 100) self.assertEqual(hardware_service.color_last_called_with.r, 100) self.assertEqual(hardware_service.color_last_called_with.g, 100) self.assertEqual(hardware_service.color_last_called_with.b, 100) self.assertEqual(hardware_service.color_called_count, 1) now = 10 next_state = dispatcher.dispatch(next_state, command, now) self.assertEqual(next_state.color.r, 101) self.assertEqual(next_state.color.g, 101) self.assertEqual(next_state.color.b, 101) self.assertEqual(hardware_service.color_last_called_with.r, 101) self.assertEqual(hardware_service.color_last_called_with.g, 101) self.assertEqual(hardware_service.color_last_called_with.b, 101) self.assertEqual(hardware_service.color_called_count, 2) now = 90 next_state = dispatcher.dispatch(next_state, command, now) self.assertEqual(next_state.color.r, 109) self.assertEqual(next_state.color.g, 109) self.assertEqual(next_state.color.b, 109) self.assertEqual(hardware_service.color_last_called_with.r, 109) self.assertEqual(hardware_service.color_last_called_with.g, 109) self.assertEqual(hardware_service.color_last_called_with.b, 109) self.assertEqual(hardware_service.color_called_count, 3) now = 100 next_state = dispatcher.dispatch(next_state, command, now) self.assertEqual(next_state.color.r, 110) self.assertEqual(next_state.color.g, 110) self.assertEqual(next_state.color.b, 110) self.assertEqual(hardware_service.color_last_called_with.r, 110) self.assertEqual(hardware_service.color_last_called_with.g, 110) self.assertEqual(hardware_service.color_last_called_with.b, 110) self.assertEqual(hardware_service.color_called_count, 4)
def load_commands(message_sender, tg_logger = None): global logger global commands logger = tg_logger commands = [] for cls in Command.__subclasses__(): command = cls(logger, message_sender) commands.append(command)
def apply_command(matches: Collection, query: str) -> List[Message]: match_id = query check: Union[Message, ObjectId] = Command.check_match_id(match_id, "state") if isinstance(check, Message): return [check] object_id = check match = matches.find_one({"_id": object_id}) if match is None: return [Command.error_msg("Match not found", "state", match_id)] return [ Message( Command.generate_state_dict(match), True, match_id ) ]
def command(self, coro: Callable ) -> Callable[[fortnitepy.FriendMessage], Any]: if not asyncio.iscoroutinefunction(coro): raise TypeError("Function must be a coroutine") self.register_command(coro.__name__, Command(coro, self.command_prefix) ) def inner(*args, **kwargs): return coro(*args, **kwargs) return inner
def test_all_execute_when_no_errors_are_thrown(self): # Setup command chain with mocked __do__ functions c2 = Command() c1 = Command(next=c2) c1.__do__ = Mock() c2.__do__ = Mock() # Action c1.run() # Assert all functions called c1.__do__.assert_called_once() c2.__do__.assert_called_once()
def test_child_command_rolls_back_self_on_exception(self): # Assemble command chain with mocked __do__ functions # Initial command triggered will throw exception c1 = Command() c2 = Command(previous=c1) c2.__do__ = Mock(side_effect=Exception('Oh No!')) c2.__undo__ = Mock() # Action c1.run() # Assert command 2 was rolled back c2.__undo__.assert_called_once()
def test_chained_command_does_not_execute_if_parent_throws_exception(self): # Assemble command chain with mocked __do__ functions # Initial command triggered will throw exception c1 = Command() c2 = Command(previous=c1) c1.__do__ = Mock(side_effect=Exception('Oh No!')) c2.__do__ = Mock() # Action c1.run() # Assert command one was called (Threw an exception) and c2 was not called c1.__do__.assert_called_once() c2.__do__.assert_not_called()
def test_constructor_links_next_node_when_passed_in_constructor(self): # Assemble c2 = Command() c1 = Command(next=c2) # Assert self.assertEqual(c1.get_next(), c2) self.assertEqual(c2.get_previous(), c1)
def __init__(self): self.prompt = "➜ " self.banner = """ n0framework Powered by n0b0dy@Eur3kA """ self.session = None self.commandReg = CommandRegister() self.serviceReg = ServiceRegister() self.history = FileHistory("/framelog/history.txt") for cmd in Command.find_all(): self.commandReg.register(cmd()) for service in Service.find_all(): self.serviceReg.register(service())
def __init__(self, parent, frame, **kwargs): """ Constructor must be called after objects_container is set!!! Because of notebook wanting itself to be parent, we pass frame as another variable """ super(ObjectsCanvas, self).__init__(parent, **kwargs) self.frame = frame self.SetDoubleBuffered(True) self.size = 0, 0 self.SetName("ObjectCanvas") self.commands = Command() self.saved_command = self.commands self.canvas_size = [1, 1] # w, h self.view_point = [0, 0] # x, y self.filepath = None self.zoom = 1 self.update_bounds() self.do_bindings()
def main(): admin = os.getenv('ADMIN_USER') telegram_token = os.getenv('TELEGRAM_TOKEN') with open('version', 'r') as v: version = v.read().rstrip() with open('handlers/greeters.yml') as f: gs = f.read() handlers = [] for g in yaml.full_load_all(gs): handlers.append(g) handlers.append( Command('versio', 'La meva versió és {}', [version], Filters.chat(username=admin))) handlers.append(Roller('roll', '', '', None)) r = Rostollador(admin, telegram_token, handlers) r.start()
def test_dispatches_to_hardware_with_buzzer(self): with MockHardware() as hardware_service: dispatcher = Dispatcher(hardware_service) current_state = State(color=Color(100, 100, 100), buzzer_pattern=BuzzerPattern.NONE) command = Command(color=Color.no_change(), duration=100, buzzer_pattern=BuzzerPattern(duration=10, strength=1)) now = 0 next_state = dispatcher.dispatch(current_state, command, now) self.assertEqual(next_state.color.r, 100) self.assertEqual(next_state.color.g, 100) self.assertEqual(next_state.color.b, 100) self.assertEqual(next_state.buzzer_pattern.strength, 1) self.assertEqual(hardware_service.motor_called_count, 1) self.assertEqual(hardware_service.motor_state, 1) now = 10 next_state = dispatcher.dispatch(next_state, command, now) self.assertEqual(next_state.color.r, 100) self.assertEqual(next_state.color.g, 100) self.assertEqual(next_state.color.b, 100) self.assertEqual(next_state.buzzer_pattern.strength, 1) self.assertEqual(hardware_service.motor_called_count, 2) self.assertEqual(hardware_service.motor_state, 1) now = 90 next_state = dispatcher.dispatch(next_state, command, now) self.assertEqual(next_state.color.r, 100) self.assertEqual(next_state.color.g, 100) self.assertEqual(next_state.color.b, 100) self.assertEqual(next_state.buzzer_pattern.strength, 0) self.assertEqual(hardware_service.motor_stop_called_count, 1) self.assertEqual(hardware_service.motor_state, 0)
def apply_command(matches: Collection, query: str) -> List[Message]: # Command format: move [match_id] [token] [card] [move] # Example: move 5f9c394ee71e1740c218587b iq2V39W9WNm0EZpDqEcqzoLRhSkdD3lY boar a1a2 split = query.split(" ") match_id, token, card_name, move = split check: Union[Message, ObjectId] = Command.check_match_id(match_id, "move") if isinstance(check, Message): return [check] object_id = check match = matches.find_one({"_id": object_id}) if match is None: return [Command.error_msg("Match not found", "move", match_id)] if match["gameState"] == GameState.ENDED.value: return [Command.error_msg("Game ended", "move", match_id)] if token == match["tokenBlue"]: color = "blue" elif token == match["tokenRed"]: color = "red" else: return [Command.error_msg("Token is incorrect", "move", match_id)] if move[0] not in "abdce" or move[1] not in "12345" or move[ 2] not in "abcde" or move[3] not in "12345": move = "none" if card_name not in ALL_BASE_CARD_NAMES: card_name = "none" if move == "none" or card_name == "none": return [ Command.error_msg("'move' or 'card' not given properly", "move", match_id) ] board = str_to_board(match["board"]) piece_pos = notation_to_pos(move[:2]) if match["currentTurn"] != color: return [ Command.error_msg("Cannot move when it is not your turn", "move", match_id) ] if board[piece_pos.y][piece_pos.x].color.value != color: return [ Command.error_msg( "Cannot move opponent's pieces or empty squares", "move", match_id) ] move_pos = notation_to_pos(move[2:]) move_card = get_card_from_name(card_name) cards = get_cards_from_names(match["cards"][color]) new_board: Optional[Board] = apply_move(piece_pos, move_pos, move_card, cards, board) if new_board is None: return [Command.error_msg("Invalid move", "move", match_id)] winner = check_win_condition(new_board) state = GameState.ENDED.value if winner != Player.NONE else GameState.IN_PROGRESS.value moves = match["moves"] moves.append(f"{card_name}:{move}") side_card: str = match["cards"]["side"] new_cards: List[str] = match["cards"][color] new_cards[new_cards.index(card_name)] = side_card enemy = "red" if color == "blue" else "blue" enemy_cards = match["cards"][enemy] matches.find_one_and_update({"_id": object_id}, { "$set": { "board": board_to_str(new_board), "moves": moves, "currentTurn": "blue" if color == "red" else "red", "cards": { enemy: enemy_cards, color: new_cards, "side": card_name }, "gameState": state, "winner": winner.value } }) return [ Message({ "messageType": "move", "matchId": match_id }, True, match_id), Message( Command.generate_state_dict( matches.find_one({"_id": object_id})), # type: ignore False, match_id) ]
def __init__(self): Command.__init__(self) self._request_uri = "http://api.urbandictionary.com/v0/define?term={}"
def __init__(self): Command.__init__(self, "set")
def __init__(self, quote_repository): Command.__init__(self) self._quote_repository = quote_repository
def __init__(self): Command.__init__(self) self._request_uri = "http://api.giphy.com/v1/gifs/random?tag={}&api_key={}" self._api_key = "dc6zaTOxFJmzC"
def __init__(self): Command.__init__(self, "compile")
def apply_command(matches: Collection, query: str) -> List[Message]: split = query.split(" ") match_id = split[0] check: Union[Message, ObjectId] = Command.check_match_id(match_id, "join") if isinstance(check, Message): return [check] object_id = check username = "******".join(split[1:]) match = matches.find_one({"_id": object_id}) if match is None: return [Command.error_msg("Match not found", "join", match_id)] if match["gameState"] != GameState.WAITING_FOR_PLAYER.value: return [Command.error_msg("Not allowed to join", "join", match_id)] token: str = token_hex(32) color: str = "red" if match["tokenRed"] == "" else "blue" board, blue_cards, red_cards, side_card = init_game() usernames = match["usernames"] usernames[color] = username indices = match["indices"] indices[color] = 1 matches.find_one_and_update({"_id": object_id}, { "$set": { f"token{color.title()}": token, "usernames": usernames, "indices": indices, "gameState": GameState.IN_PROGRESS.value, "board": board_to_str(board), "moves": [], "currentTurn": side_card.color.value, "cards": { "blue": [i.name for i in blue_cards], "red": [i.name for i in red_cards], "side": side_card.name }, "startingCards": { "blue": [i.name for i in blue_cards], "red": [i.name for i in red_cards], "side": side_card.name }, "winner": Player.NONE.value } }) return [ Message( { "messageType": "join", "matchId": match_id, "token": token, "index": 1 }, True, match_id), Message( Command.generate_state_dict( matches.find_one({"_id": object_id})), # type: ignore False, match_id) ]
def __init__(self): Command.__init__(self) self._request_uri = "http://api.fixer.io/latest?base={}&symbols={}"
def __init__(self): Command.__init__(self, "add")
def __init__(self, loud=False): Command.__init__(self) self.volume = 8 if not loud else 16
def __init__(self, **kwargs): Command.__init__(self, **kwargs) if type(self).params is None: type(self).params = ParamPipe() self.setup()
class ObjectsCanvas(wx.ScrolledWindow): def __init__(self, parent, frame, **kwargs): """ Constructor must be called after objects_container is set!!! Because of notebook wanting itself to be parent, we pass frame as another variable """ super(ObjectsCanvas, self).__init__(parent, **kwargs) self.frame = frame self.SetDoubleBuffered(True) self.size = 0, 0 self.SetName("ObjectCanvas") self.commands = Command() self.saved_command = self.commands self.canvas_size = [1, 1] # w, h self.view_point = [0, 0] # x, y self.filepath = None self.zoom = 1 self.update_bounds() self.do_bindings() def zoom_out(self): if self.zoom >=0.25: self.zoom -= 0.1 self.update_bounds() self.Refresh() def zoom_in(self): self.zoom += 0.1 self.update_bounds() self.Refresh() def zoom_restore(self): self.zoom = 1 self.update_bounds() self.Refresh() @property def strategy(self): return self.frame.strategy def do_bindings(self): self.Bind(wx.EVT_PAINT, self.on_paint_event) self.Bind(wx.EVT_SIZE, self.on_size_event) self.Bind(wx.EVT_LEFT_DOWN, self.on_left_button_down) self.Bind(wx.EVT_LEFT_UP, self.on_left_button_up) self.Bind(wx.EVT_MOTION, self.on_mouse_motion) self.Bind(wx.EVT_LEFT_DCLICK, self.on_left_button_dclick) self.Bind(wx.EVT_RIGHT_DOWN, self.on_right_button_down) self.Bind(wx.EVT_RIGHT_UP, self.on_right_button_up) self.Bind(wx.EVT_SCROLLWIN, self.on_scroll) @property def is_changed(self): return self.commands is not self.saved_command @property def has_unsaved_changes(self): if self.is_changed: return True if self.filepath is None: if self.petri.places or self.petri.transitions: return True return False def GetObjectsInRect(self, lx, ly, tx, ty): for obj in self.get_objects_iter(): if not obj.is_selectable(): continue obj.unselect_temporary() if obj.in_rect(lx, ly, tx, ty): yield obj def get_name(self): result = self.GetName() if self.has_unsaved_changes: result = '*'+result return result def load_from_file(self, filepath, format): net = None with open(filepath, 'rb') as f: data = f.read() net = format.import_net(data) self.update_title(filepath) self.filepath = filepath self.petri = net def update_title(self, filepath): basename = osp.basename(filepath) title = osp.splitext(basename)[0] self.SetName(title) def save_to_file(self, filepath, net, format): if format.persistent: self.update_title(filepath) data = format.export_net(net) with open(filepath, 'wb') as f: f.write(data) if format.persistent: self.filepath = filepath self.saved_command = self.commands def on_scroll(self, event): orientation = event.GetOrientation() event.Skip() wx.CallAfter(self.process_scroll_event, orientation) def process_scroll_event(self, orientation): if not self.strategy.is_moving_objects: pos = self.GetScrollPos(orientation) rng = self.GetScrollRange(orientation) - self.GetScrollThumb(orientation) if rng==0: self.Refresh() return ind = 1 if orientation == wx.VERTICAL else 0 new_vp = (float(pos) / rng) * (self.canvas_size[ind] - self.size[ind]) self.view_point[ind] = int(new_vp) self.Refresh() def append_command(self, command): if command.does_nothing: return self.commands = self.commands.add_command(command) self.frame.on_command_append() def update_frame_menu(self): self.frame.update_menu() def undo(self): if self.can_undo(): self.commands = self.commands.go_prev() self.Refresh() def can_undo(self): return self.strategy.allow_undo_redo and self.commands.has_prev() def redo(self): if self.can_redo(): self.commands = self.commands.go_next() self.Refresh() def can_redo(self): return self.strategy.allow_undo_redo and self.commands.has_next() def can_select(self): return self.strategy.can_select can_cut = can_delete = can_paste = can_copy = can_select def copy(self): if self.can_copy(): self.on_copy() def on_copy(self): raise NotImplementedError def paste(self): if self.can_paste(): self.on_paste() def on_paste(self): raise NotImplementedError def cut(self): if self.can_cut(): self.on_cut() def on_cut(self): raise NotImplementedError def delete(self): if self.can_delete(): self.on_delete() def on_delete(self): raise NotImplementedError def select_all(self): if self.can_select(): self.strategy.on_select_all() def save(self, format): return self.save_as(filepath=self.filepath, format=format) def save_as(self, format, filepath=None): if filepath is None: while True: print format dlg = wx.FileDialog( self, message="Save file as ...", defaultFile="", wildcard=format.get_wildcard(), style=wx.SAVE ) if dlg.ShowModal() == wx.ID_OK: filepath = dlg.GetPath() else: return if not osp.exists(filepath): break if not osp.isfile(filepath): continue dlg = wx.MessageDialog(self, message='File (%s) already exists. Overwrite it?'%filepath, style=wx.YES_NO|wx.CANCEL|wx.CENTER) result = dlg.ShowModal() dlg.Destroy() if result == wx.ID_YES: break elif result == wx.ID_NO: continue elif result == wx.ID_CANCEL: return if not filepath: return self.save_to_file(filepath, self.petri, format=format) return True def on_size_event(self, event): self.size = event.GetSize() self.update_bounds() self.Refresh() def on_paint_event(self, event): dc = SmartDC(self) w, h = self.size dc.SetPen(wx.WHITE_PEN) dc.SetBrush(wx.WHITE_BRUSH) dc.DrawRectangleOnScreen(0,0,w,h) self.draw(dc, w, h) def on_left_button_down(self, event): if self.strategy.need_capture_mouse: self.mouse_in = True self.on_lbutton_timer() self.strategy.on_left_down(event) self.SetFocus() def on_right_button_down(self, event): self.strategy.on_right_down(event) def on_right_button_up(self, event): self.strategy.on_right_up(event) def on_left_button_dclick(self, event): self.strategy.on_left_dclick(event) self.SetFocus() def on_key_down(self, event): self.strategy.on_key_down(event) def on_lbutton_timer(self, *args, **kwargs): """ Dirty hack to catch the moment when mouse leaves window and capture it. wx.EVT_LEAVE_WINDOW is not always sent. """ x, y, w, h = self.GetScreenRect() w -= constants.VSCROLL_X h -= constants.HSCROLL_Y mx, my = wx.GetMousePosition() state = wx.GetMouseState() if not state.LeftDown(): if self.HasCapture(): self.ReleaseMouse() return mouse_in = x <= mx <= x+w and y <= my <= y+h if mouse_in and not self.mouse_in: if self.HasCapture(): self.ReleaseMouse() elif not mouse_in and self.mouse_in: self.CaptureMouse() self.mouse_in = mouse_in wx.CallLater(20, self.on_lbutton_timer) def get_object_at(self, x, y): """ Gets object under given virtual position """ # Check in reverse order so the topmost object will be selected for obj in self.get_objects_reversed_iter(): if obj.contains_point(x, y): return obj def on_mouse_motion(self, event): self.strategy.on_motion(event) def on_left_button_up(self, event): self.strategy.on_left_up(event) def get_objects_iter(self): raise NotImplementedError def get_objects_reversed_iter(self): raise NotImplementedError def update_bounds(self): """ Update canvas size and adjust scrollbars to it """ if self.strategy.is_moving_objects: # Do not update when user is moving something, because it will cause mess. return max_x, max_y = 0, 0 for obj in self.get_objects_iter(): x,y = obj.get_position() w,h = obj.get_size() max_x = max(max_x, x+w) max_y = max(max_y, y+h) max_x = max_x * self.zoom max_y = max_y * self.zoom max_x = max(max_x+constants.RIGHT_OFFSET, self.size[0]-constants.VSCROLL_X) max_y = max(max_y+constants.BOTTOM_OFFSET, self.size[1]-constants.HSCROLL_Y) self.canvas_size[0], self.canvas_size[1] = max_x, max_y prev_x, prev_y = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL) self.SetScrollbars(1, 1, max_x, max_y) self.Scroll(prev_x, prev_y) self.process_scroll_event(wx.VERTICAL) self.process_scroll_event(wx.HORIZONTAL) def screen_to_canvas_coordinates(self, point): x, y = point vx, vy = self.view_point x = x / self.zoom y = y / self.zoom return (x+vx, y+vy) def canvas_to_screen_coordinates(self, point): x, y = point x = (x - self.view_point[0])*self.zoom y = (y - self.view_point[1])*self.zoom return (x, y) def draw(self, dc, w, h): for obj in self.get_objects_iter(): obj.draw(dc, self.zoom) self.strategy.draw(dc, self.zoom)
def __init__(self): Command.__init__(self)
def __init__(self): Command.__init__(self, "list")
def __init__(self, message_repository, message=None): Command.__init__(self) self._message_repository = message_repository self.message = message
def __init__(self): Command.__init__(self) self._request_uri = "http://api.openweathermap.org/data/2.5/weather?q={}&appid={}" self._api_key = os.getenv("WEATHER_API_KEY")
def __init__(self): Command.__init__(self, "clone")
def __init__(self): Command.__init__(self, "deps")
import random from constants import game as gc from commands.command import Command from commands.move_command import MoveCommand from constants import command as cc COMMAND_LIST = Command.__subclasses__() random.seed(gc.RAND_SEED) # GODS PLAN def create_a_choice(parents=None): command_generation_function = { MoveCommand: _create_move_command, } next_choice = random.choice(COMMAND_LIST) command, command_kwargs = command_generation_function.get(next_choice)( parents) return command, command_kwargs def _create_move_command(parents): if parents: # TODO: Parent 50/50 here pass else: return MoveCommand, { cc.DIRECTION: random.choice(list(cc.DIRECTION_MAP.values())) }
from commands.command import Command from linker.linker import Linker action1 = Command() action1.set_action(lambda: print("Hello from Action 1!")) action2 = Command() action2.set_action(lambda: print("Hello from Action 2!")) action1.run() linker = Linker() linker.load('./flow.yml') linker.validate() linker.link()
def __init__(self, message_repository, message = None): Command.__init__(self) self._message_repository = message_repository self.message = message
def __init__(self, client, api_key): Command.__init__(self) self.client = client self.api_key = api_key