def respond_role_menu(call, user): role = Role.get(Role.role_name == call.data) prev_value = RoleSelectionTracker.get( RoleSelectionTracker.user == user, RoleSelectionTracker.role == role).checked new_value = not prev_value RoleSelectionTracker.update(checked=new_value).where( RoleSelectionTracker.user == user, RoleSelectionTracker.role == role).execute() if new_value: answer_callback(f"نقش {role.role_name} اضافه شد.", call.id) else: answer_callback(f"نقش {role.role_name} حذف شد.", call.id) # update role team keyboard if role.team == "مافیا": message_id = Tracker.get(Tracker.id == user.id).mafia_message_id else: message_id = Tracker.get(Tracker.id == user.id).citizen_message_id # edit reply keyboard with new values edit_message_reply_markup( create_role_selection_menu(user, role.team), chat_id=user.id, message_id=message_id, ) # send the new list of roles to every player players = get_players(user, include_god=True) num_players = len(players) - 1 for player in players: send_current_roles(player, num_players, edit=True)
async def add_shape(sid: int, data: Dict[str, Any]): pr: PlayerRoom = game_state.get(sid) if "temporary" not in data: data["temporary"] = False floor = pr.active_location.floors.select().where( Floor.name == data["shape"]["floor"])[0] layer = floor.layers.where(Layer.name == data["shape"]["layer"])[0] if pr.role != Role.DM and not layer.player_editable: logger.warning( f"{pr.player.name} attempted to add a shape to a dm layer") return if data["temporary"]: game_state.add_temp(sid, data["shape"]["uuid"]) else: with db.atomic(): data["shape"]["layer"] = layer data["shape"]["index"] = layer.shapes.count() # Shape itself shape = Shape.create(**reduce_data_to_model(Shape, data["shape"])) # Subshape type_table = get_table(shape.type_) type_table.create( shape=shape, **type_table.pre_create( **reduce_data_to_model(type_table, data["shape"])), ) # Owners for owner in data["shape"]["owners"]: ShapeOwner.create( shape=shape, user=User.by_name(owner["user"]), edit_access=owner["edit_access"], movement_access=owner["movement_access"], vision_access=owner["vision_access"], ) # Trackers for tracker in data["shape"]["trackers"]: Tracker.create(**reduce_data_to_model(Tracker, tracker), shape=shape) # Auras for aura in data["shape"]["auras"]: Aura.create(**reduce_data_to_model(Aura, aura), shape=shape) for room_player in pr.room.players: is_dm = room_player.role == Role.DM for psid in game_state.get_sids(player=room_player.player, active_location=pr.active_location): if psid == sid: continue if not is_dm and not layer.player_visible: continue if not data["temporary"]: data["shape"] = shape.as_dict(room_player.player, is_dm) await sio.emit("Shape.Add", data["shape"], room=psid, namespace=GAME_NS)
def GetTracker(key): """Get a tracker, or create one if it dosent exist""" tracker = Tracker.all().filter('name =',key).get() if tracker==None: tracker = Tracker(name=key) tracker.put() return tracker
def next_tracking(): global _tracker if not session.get('vid'): abort(401) previous_frame = request.args.get('previous_frame', 0, type=int) current_frame = request.args.get('current_frame', 0, type=int) left = request.args.get('left', 0, int) top = request.args.get('top', 0, int) width = request.args.get('width', 0, int) height = request.args.get('height', 0, int) is_new_box = request.args.get('new_box', 0, int) if not _tracker: _tracker = Tracker(Video.query.get(session.get('vid')).json, previous_frame, left, top, width, height) elif is_new_box: _tracker.start_new_tracking(previous_frame, [(left, top, left+width, top+height)]) new_left, new_top, new_width, new_height = _tracker.get_next_box(current_frame) return jsonify(left=new_left, top=new_top, width=new_width, height=new_height)
async def add_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] if "temporary" not in data: data["temporary"] = False floor = location.floors.select().where( Floor.name == data["shape"]["floor"])[0] layer = floor.layers.where(Layer.name == data["shape"]["layer"])[0] if room.creator != user and not layer.player_editable: logger.warning(f"{user.name} attempted to add a shape to a dm layer") return if data["temporary"]: state.add_temp(sid, data["shape"]["uuid"]) else: with db.atomic(): data["shape"]["layer"] = layer data["shape"]["index"] = layer.shapes.count() # Shape itself shape = Shape.create(**reduce_data_to_model(Shape, data["shape"])) # Subshape type_table = get_table(shape.type_) type_table.create(shape=shape, **reduce_data_to_model(type_table, data["shape"])) # Owners ShapeOwner.create(shape=shape, user=user) # Trackers for tracker in data["shape"]["trackers"]: Tracker.create(**reduce_data_to_model(Tracker, tracker), shape=shape) # Auras for aura in data["shape"]["auras"]: Aura.create(**reduce_data_to_model(Aura, aura), shape=shape) if layer.player_visible: for room_player in room.players: for psid in state.get_sids(user=room_player.player, room=room): if psid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room_player.player, False) await sio.emit("Shape.Add", data["shape"], room=psid, namespace="/planarally") for csid in state.get_sids(user=room.creator, room=room): if csid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room.creator, True) await sio.emit("Shape.Add", data["shape"], room=csid, namespace="/planarally")
def __init__(self, update_facebank=False, show_results=True, dataset_path=None, save=False): """ :param update_facebank: Calculate new facebank or use old one :param show_results: Draw bboxes and ident info at frame :param videoPath: Path for processing the video :param save: Save processed video """ self.dataset_path = dataset_path self.video_path = f'{self.dataset_path}/{self.find_video()}' self.face_identificator = FaceIdentificator( update_facebank, f'{os.getcwd()}/{self.dataset_path}') self.tracker = Tracker() self.unique_facebank_names = list( self.face_identificator.saved_embeddings.keys()) # TODO Create smth more smarter for scores initialization self.saved_scores = dict( zip(self.unique_facebank_names, [ self.face_identificator.threshold for name in self.unique_facebank_names ])) self.mapped_tracks = {} self.show_results = show_results self.treshold = 0.4 self.save = save
def get(self): if os.environ.get('HTTP_HOST'): url = os.environ['HTTP_HOST'] else: url = os.environ['SERVER_NAME'] self.response.headers['Content-Type'] = 'text/plain' self.response.out.write( """OpenTrack\n Extreamly Basic tracking system, for use with p2p programs To use the tracker visit http://%s/trk/<tracker name> The tracker does not need to be setup beforhand It will return a list of IP adresses that have visited that tracker and add yours to the list Optionally add "?tick=<seconds>" to the url where seconds is how recently it has been visited the default tick is 60 seconds NEW: http://%s/tick/<tracker name> provides a way of refreshing yourself in a tracker without retrieveing a list \nCurrent Trackers (activity last 24 hours)\n"""%(url,url)) trackers = Tracker.all() for tracker in trackers: self.response.out.write(" - %s\n"%tracker.name)
async def create_tracker(sid: str, data: TrackerDelta): pr: PlayerRoom = game_state.get(sid) shape = get_shape_or_none(pr, data["shape"], "Tracker.Create") if shape is None: return model = reduce_data_to_model(Tracker, data) tracker = Tracker.create(**model) tracker.save() owners = [*get_owner_sids(pr, shape, skip_sid=sid)] for psid in owners: await sio.emit( "Shape.Options.Tracker.Create", data, room=psid, namespace=GAME_NS, ) if tracker.visible: for psid in game_state.get_sids( active_location=pr.active_location, skip_sid=sid ): if psid in owners: continue await sio.emit( "Shape.Options.Tracker.Create", data, room=psid, namespace=GAME_NS, )
def register_user(message): user = User.get_or_none(User.id == message.chat.id) if user is not None: game = Game.get_or_none(Game.user == user) if game is None: send_message(message.chat.id, f"Hi again <b>{user.name}</b>!", reply_markup=keyboards.main) else: text = f"Hi again <b>{user.name}</b>!\n\n" text += ":game_die: Note that you're in the middle of a game." send_message( message.chat.id, text, ) return False send_message(message.chat.id, f"Hi <b>{message.chat.first_name}</b>!", reply_markup=keyboards.main) # tracker and user information Tracker.replace(id=message.chat.id).on_conflict_replace().execute() User.replace( id=message.chat.id, name=message.chat.first_name, username=message.chat.username, ).on_conflict_replace().execute() # default game settings for each user user = User.get(User.id == message.chat.id) GameSettings.insert(user=user).execute() # insert selected roles tracker roles = Role.select().where(Role.is_default == True) data = [] for r in roles: data.append((r, user, False)) RoleSelectionTracker.insert_many(data, fields=[ RoleSelectionTracker.role, RoleSelectionTracker.user, RoleSelectionTracker.checked ]).execute() return True
def get_user_location(self, request): """Get tracker location of user""" entity = User.get_by_id(request.id) if entity: entity = Tracker.get_trackers(request) return entity else: raise endpoints.NotFoundException()
def update_user_location(self, request): """Update current location of user""" entity = User.get_by_id(request.id) if entity: entity = Tracker.put_from_message(request) return entity else: raise endpoints.NotFoundException()
async def update_tracker(sid: str, data: TrackerDelta): pr: PlayerRoom = game_state.get(sid) shape = get_shape_or_none(pr, data["shape"], "Tracker.Update") if shape is None: return tracker = Tracker.get_by_id(data["uuid"]) changed_visible = tracker.visible != data.get("visible", tracker.visible) update_model_from_dict(tracker, data) tracker.save() owners = [*get_owner_sids(pr, shape, skip_sid=sid)] for psid in owners: await sio.emit( "Shape.Options.Tracker.Update", data, room=psid, namespace=GAME_NS, ) for psid in game_state.get_sids(active_location=pr.active_location, skip_sid=sid): if psid in owners: continue if changed_visible: if tracker.visible: await sio.emit( "Shape.Options.Tracker.Create", { "shape": shape.uuid, **tracker.as_dict() }, room=psid, namespace=GAME_NS, ) else: await sio.emit( "Shape.Options.Tracker.Remove", { "shape": shape.uuid, "value": tracker.uuid }, room=psid, namespace=GAME_NS, ) else: await sio.emit( "Shape.Options.Tracker.Update", data, room=psid, namespace=GAME_NS, )
async def remove_tracker(sid: str, data: ShapeSetStringValue): pr: PlayerRoom = game_state.get(sid) shape = get_shape_or_none(pr, data["shape"], "Tracker.Remove") if shape is None: return tracker: Tracker = Tracker.get_by_id(data["value"]) tracker.delete_instance(True) await sio.emit( "Shape.Options.Tracker.Remove", data, skip_sid=sid, room=pr.active_location.get_path(), namespace=GAME_NS, )
async def update_shape_tracker(sid: str, data: TrackerUpdateData): pr: PlayerRoom = game_state.get(sid) if data["_type"] == "tracker": tracker = Tracker.get_by_id(data["uuid"]) else: tracker = Aura.get_by_id(data["uuid"]) tracker.value = data["value"] tracker.save() await sio.emit( "Shapes.Trackers.Update", data, room=pr.active_location.get_path(), skip_sid=sid, namespace=GAME_NS, )
async def move_tracker(sid: str, data: TrackerMove): pr: PlayerRoom = game_state.get(sid) new_shape = get_shape_or_none(pr, data["new_shape"], "Tracker.Options.Tracker.Move") if new_shape is None: return tracker = Tracker.get_by_id(data["tracker"]) tracker.shape = new_shape tracker.save() await sio.emit( "Shape.Options.Tracker.Move", data, skip_sid=sid, room=pr.active_location.get_path(), namespace=GAME_NS, )
def get(self): ## remove any old peers plist = Peer.all().filter('datetime <',datetime.now() - timedelta(days=1)) peercount = plist.count() for p in plist: p.delete() ## remove any empty trackers trackers = Tracker.all() trackercount = 0 for tracker in trackers: p = Peer.all().filter('tracker =',tracker).order('-datetime').get() if p == None: tracker.delete() trackercount += 1 ## some simple stats self.response.headers['Content-Type'] = 'text/plain' self.response.out.write("Cleaned %d trackers and %d peers"%(trackercount,peercount)) if trackercount and peercount: logging.info("Cleaned %d trackers and %d peers"%(trackercount,peercount))
def get(self): user = User.get(id=int(get_jwt_identity())) if user.account_type != "admin": return {}, 403 week_ago = datetime.date.today() - datetime.timedelta(days=7) base = Tracker.select().where((Tracker.timestamp >= week_ago) & (Tracker.page_type == "car")) last_7days_view = base.count() diff_users = base.select(Tracker.ip).group_by(Tracker.ip).count() top_10pages = base.select(Tracker.title, fn.Count( Tracker.id)).group_by(Tracker.title).order_by( fn.Count(Tracker.id).desc()).tuples()[:10] for track in top_10pages: print track return { "data": { "last_7days": last_7days_view, "top_10": top_10pages }, "message": "", "status": "success" }
def update_state(user, state): Tracker.update(state=state).where(Tracker.id == user.id).execute()
async def update_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] shape, layer = await _get_shape(data, location, user) if not await has_ownership(layer, room, data, user, shape): return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_table = get_table(shape.type_) type_instance = type_table.get(uuid=shape.uuid) # no backrefs on these tables update_model_from_dict(type_instance, data["shape"], ignore_unknown=True) type_instance.save() # Owners old_owners = {owner.user.name for owner in shape.owners} new_owners = set(data["shape"]["owners"]) for owner in old_owners ^ new_owners: if owner == "": continue delta_owner = User.by_name(owner) if owner in new_owners: ShapeOwner.create(shape=shape, user=delta_owner) else: ShapeOwner.get(shape=shape, user=delta_owner).delete_instance(True) await send_client_initiatives(room, location, delta_owner) # Trackers for tracker in data["shape"]["trackers"]: tracker_db = Tracker.get_or_none(uuid=tracker["uuid"]) reduced = reduce_data_to_model(Tracker, tracker) reduced["shape"] = shape if tracker_db: update_model_from_dict(tracker_db, reduced) tracker_db.save() else: Tracker.create(**reduced) # Auras for aura in data["shape"]["auras"]: aura_db = Aura.get_or_none(uuid=aura["uuid"]) reduced = reduce_data_to_model(Aura, aura) reduced["shape"] = shape if aura_db: update_model_from_dict(aura_db, reduced) aura_db.save() else: Aura.create(**reduced) await sync_shape_update(layer, room, data, sid, shape)
'init_beta': 1, 'init_v': np.diag([4, 2]), 'init_nu': 5, } from models import GgiwTracker as Tracker #cell 8 ### Run Tracker #cell 9 # tracker definition tracker = Tracker(dt=dt, **config) pr = cProfile.Profile() for i in range(steps): scan = measurements[measurements['ts'] == i] pr.enable() tracker.step(scan) pr.disable() estimates, log_lik = tracker.extract() bboxes = tracker.extrackt_bbox() s = io.StringIO() ps = pstats.Stats(pr, stream=s).sort_stats('cumulative') ps.print_stats(10)
def main(args): cap = cv2.VideoCapture(args.video_input) frame_rate = int(round(cap.get(cv2.CAP_PROP_FPS))) video_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) video_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) demo_images_path = os.path.join(args.demo_output, 'demo_images') if not os.path.exists(demo_images_path): os.makedirs(demo_images_path) device = torch.device(args.device) model, _, postprocessors = build_tracktest_model(args) model.to(device) model.eval() tracker = Tracker(score_thresh=args.track_thresh) checkpoint = torch.load(args.resume, map_location='cpu') _, _ = model.load_state_dict(checkpoint['model'], strict=False) print("Model is loaded") mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] color_list = colormap() print("Starting inference") count = 0 tracker.reset_all() pre_embed = None res, img = cap.read() while res: count += 1 resized_img, nh, nw = resize(img) rgb_img = cv2.cvtColor(resized_img, cv2.COLOR_BGR2RGB) tensor_img = F.normalize(F.to_tensor(rgb_img), mean, std) samples = nested_tensor_from_tensor_list([tensor_img]).to(device) outputs, pre_embed = model(samples, pre_embed) orig_sizes = torch.stack( [torch.as_tensor([video_height, video_width])], dim=0).to(device) results = postprocessors['bbox'](outputs, orig_sizes) if count == 1: res_track = tracker.init_track(results[0]) else: res_track = tracker.step(results[0]) for ret in res_track: if ret['active'] == 0: continue bbox = ret['bbox'] tracking_id = ret['tracking_id'] cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color_list[tracking_id % 79].tolist(), thickness=2) cv2.putText(img, "{}".format(tracking_id), (int(bbox[0]), int(bbox[1])), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color_list[tracking_id % 79].tolist(), 2) cv2.imwrite( os.path.join(demo_images_path, "demo{:0>6d}.png".format(count)), img) print('Frame{:d} of the video is done'.format(count)) res, img = cap.read() print('Lenth of the video: {:d} frames'.format(count)) print("Starting img2video") img_paths = gb.glob(os.path.join(demo_images_path, "*.png")) size = (video_width, video_height) videowriter = cv2.VideoWriter( os.path.join(args.demo_output, "demo_video.avi"), cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), frame_rate, size) for img_path in sorted(img_paths): img = cv2.imread(img_path) img = cv2.resize(img, size) videowriter.write(img) videowriter.release() print("img2video is done")
def post(self): data = parser.parse_args() data['request'] = request print "[*] Request: ", data["request"] Tracker.create_from_request(**data) return {}
async def update_shape(sid: int, data: Dict[str, Any]): pr: PlayerRoom = game_state.get(sid) if data["temporary"] and not has_ownership_temp(data["shape"], pr): logger.warning( f"User {pr.player.name} tried to update a shape it does not own.") return # todo clean up this mess that deals with both temporary and non temporary shapes shape, layer = await _get_shape(data, pr) # Overwrite the old data with the new data if not data["temporary"]: if not has_ownership(shape, pr): logger.warning( f"User {pr.player.name} tried to update a shape it does not own." ) return with db.atomic(): # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_instance = shape.subtype # no backrefs on these tables type_instance.update_from_dict(data["shape"], ignore_unknown=True) type_instance.save() # Trackers old_trackers = {tracker.uuid for tracker in shape.trackers} new_trackers = { tracker["uuid"] for tracker in data["shape"]["trackers"] } for tracker_id in old_trackers | new_trackers: remove = tracker_id in old_trackers - new_trackers if not remove: tracker = next(tr for tr in data["shape"]["trackers"] if tr["uuid"] == tracker_id) reduced = reduce_data_to_model(Tracker, tracker) reduced["shape"] = shape if tracker_id in new_trackers - old_trackers: Tracker.create(**reduced) continue tracker_db = Tracker.get(uuid=tracker_id) if remove: tracker_db.delete_instance(True) else: update_model_from_dict(tracker_db, reduced) tracker_db.save() # Auras old_auras = {aura.uuid for aura in shape.auras} new_auras = {aura["uuid"] for aura in data["shape"]["auras"]} for aura_id in old_auras | new_auras: remove = aura_id in old_auras - new_auras if not remove: aura = next(au for au in data["shape"]["auras"] if au["uuid"] == aura_id) reduced = reduce_data_to_model(Aura, aura) reduced["shape"] = shape if aura_id in new_auras - old_auras: Aura.create(**reduced) continue aura_db = Aura.get_or_none(uuid=aura_id) if remove: aura_db.delete_instance(True) else: update_model_from_dict(aura_db, reduced) aura_db.save() # Labels for label in data["shape"]["labels"]: label_db = Label.get_or_none(uuid=label["uuid"]) reduced = reduce_data_to_model(Label, label) reduced["user"] = User.by_name(reduced["user"]) if label_db: update_model_from_dict(label_db, reduced) label_db.save() else: Label.create(**reduced) old_labels = { shape_label.label.uuid for shape_label in shape.labels } new_labels = set(label["uuid"] for label in data["shape"]["labels"]) for label in old_labels ^ new_labels: if label == "": continue if label in new_labels: ShapeLabel.create(shape=shape, label=Label.get(uuid=label)) else: ShapeLabel.get(label=Label.get(uuid=label), shape=shape).delete_instance(True) await sync_shape_update(layer, pr, data, sid, shape)
async def update_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] shape, layer = await _get_shape(data, location, user) if not await has_ownership(layer, room, data, user, shape): return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_instance = shape.subtype # no backrefs on these tables type_instance.update_from_dict(data["shape"], ignore_unknown=True) type_instance.save() # Owners old_owners = {owner.user.name for owner in shape.owners} new_owners = set(data["shape"]["owners"]) for owner in old_owners ^ new_owners: if owner == "": continue delta_owner = User.by_name(owner) if owner in new_owners: ShapeOwner.create(shape=shape, user=delta_owner) else: ShapeOwner.get(shape=shape, user=delta_owner).delete_instance(True) await send_client_initiatives(room, location, delta_owner) # Trackers old_trackers = {tracker.uuid for tracker in shape.trackers} new_trackers = { tracker["uuid"] for tracker in data["shape"]["trackers"] } for tracker_id in old_trackers | new_trackers: remove = tracker_id in old_trackers - new_trackers if not remove: tracker = next(tr for tr in data["shape"]["trackers"] if tr["uuid"] == tracker_id) reduced = reduce_data_to_model(Tracker, tracker) reduced["shape"] = shape if tracker_id in new_trackers - old_trackers: Tracker.create(**reduced) continue tracker_db = Tracker.get(uuid=tracker_id) if remove: tracker_db.delete_instance(True) else: update_model_from_dict(tracker_db, reduced) tracker_db.save() # Auras old_auras = {aura.uuid for aura in shape.auras} new_auras = {aura["uuid"] for aura in data["shape"]["auras"]} for aura_id in old_auras | new_auras: remove = aura_id in old_auras - new_auras if not remove: aura = next(au for au in data["shape"]["auras"] if au["uuid"] == aura_id) reduced = reduce_data_to_model(Aura, aura) reduced["shape"] = shape if aura_id in new_auras - old_auras: Aura.create(**reduced) continue aura_db = Aura.get_or_none(uuid=aura_id) if remove: aura_db.delete_instance(True) else: update_model_from_dict(aura_db, reduced) aura_db.save() # Labels for label in data["shape"]["labels"]: label_db = Label.get_or_none(uuid=label["uuid"]) reduced = reduce_data_to_model(Label, label) reduced["user"] = User.by_name(reduced["user"]) if label_db: update_model_from_dict(label_db, reduced) label_db.save() else: Label.create(**reduced) shape_label_db = ShapeLabel.get_or_none(shape=shape, label=label_db) old_labels = { shape_label.label.uuid for shape_label in shape.labels } new_labels = set(label["uuid"] for label in data["shape"]["labels"]) for label in old_labels ^ new_labels: if label == "": continue if label in new_labels: ShapeLabel.create(shape=shape, label=Label.get(uuid=label)) else: ShapeLabel.get(label=Label.get(uuid=label), shape=shape).delete_instance(True) await sync_shape_update(layer, room, data, sid, shape)
def respond_message(message): if message.text.startswith('/start'): register_user(message) message.text = emoji.demojize(message.text) t = Tracker.get_or_none(Tracker.id == message.chat.id) user = User.get_or_none(id=message.chat.id) if not t or not user: send_message( message.chat.id, ":cross_mark: Not a registered user. Please click on /start.") return # update the username with every message # this is important as it is the only way to find out the user identity User.update(username=message.chat.username, ).where( User.id == message.chat.id).execute() # ------------------------------------ # HOST a game # ------------------------------------ if t.state == 'start' and message.text == ":desktop_computer: Host a Game": host_start(message, user) # end game elif t.state == 'host_game' and message.text == ":cross_mark: Leave": host_leave(message, user) # select from a list of roles elif t.state == 'host_game' and message.text == ":right_arrow: Next": # FIXME: poll is deactivated. inline keyboard is used now. # host_select_roles_with_poll(message, user) host_select_roles(message, user) # select from a list of roles elif t.state == 'host_game' and message.text == ":envelope: Send Roles": host_send_roles(message, user) # ------------------------------------ # New Game # ------------------------------------ join_code_pattern = r"^/start (?P<code>\w{4})$" match = re.match(join_code_pattern, message.text) if match: code = match.group("code") message.text = code if t.state == 'start' and message.text == ":game_die: Join a Game": player_leave(message, user) elif t.state == 'join_game': player_start(message, user) elif t.state == 'start' and match: player_start(message, user) # ------------------------------------ # Change Name # ------------------------------------ if t.state == 'start' and message.text == ":bust_in_silhouette: Change Name": update_state(user, 'change_name') text = f":bust_in_silhouette: Current name: <b>{f2p(user.name)}</b>\n\n" text += ":input_latin_letters: Enter your new name:" send_message(user.id, text, reply_markup=create_keyboard([":cross_mark: Discard"])) elif t.state == 'change_name' and message.text == ":cross_mark: Discard": update_state(user, 'start') send_message(user.id, ":cross_mark: Discard", reply_markup=keyboards.main) elif t.state == 'change_name': if len(message.text) > 100: send_message(user.id, "Name length must be less than 100 characters.") return User.update(name=message.text).where(User.id == user.id).execute() update_state(user, 'start') send_message( user.id, f":white_heavy_check_mark: Your Name is updated now to: <b>{message.text}</b>", reply_markup=keyboards.main) # ------------------------------------ # Settings # ------------------------------------ if t.state == 'start' and message.text == ":gear_selector: Settings": edit_game_settings(message, user)
def main(args): utils.init_distributed_mode(args) print("git:\n {}\n".format(utils.get_sha())) if args.frozen_weights is not None: assert args.masks, "Frozen training is meant for segmentation only" print(args) device = torch.device(args.device) # fix the seed for reproducibility seed = args.seed + utils.get_rank() torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) scaler = torch.cuda.amp.GradScaler(enabled=args.fp16) if args.det_val: assert args.eval, 'only support eval mode of detector for track' model, criterion, postprocessors = build_model(args) elif args.eval: model, criterion, postprocessors = build_tracktest_model(args) else: model, criterion, postprocessors = build_tracktrain_model(args) model.to(device) model_without_ddp = model n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad) print('number of params:', n_parameters) dataset_train = build_dataset(image_set=args.track_train_split, args=args) dataset_val = build_dataset(image_set=args.track_eval_split, args=args) if args.distributed: if args.cache_mode: sampler_train = samplers.NodeDistributedSampler(dataset_train) sampler_val = samplers.NodeDistributedSampler(dataset_val, shuffle=False) else: sampler_train = samplers.DistributedSampler(dataset_train) sampler_val = samplers.DistributedSampler(dataset_val, shuffle=False) else: sampler_train = torch.utils.data.RandomSampler(dataset_train) sampler_val = torch.utils.data.SequentialSampler(dataset_val) batch_sampler_train = torch.utils.data.BatchSampler(sampler_train, args.batch_size, drop_last=True) data_loader_train = DataLoader(dataset_train, batch_sampler=batch_sampler_train, collate_fn=utils.collate_fn, num_workers=args.num_workers, pin_memory=True) data_loader_val = DataLoader(dataset_val, args.batch_size, sampler=sampler_val, drop_last=False, collate_fn=utils.collate_fn, num_workers=args.num_workers, pin_memory=True) # lr_backbone_names = ["backbone.0", "backbone.neck", "input_proj", "transformer.encoder"] def match_name_keywords(n, name_keywords): out = False for b in name_keywords: if b in n: out = True break return out for n, p in model_without_ddp.named_parameters(): print(n) param_dicts = [{ "params": [ p for n, p in model_without_ddp.named_parameters() if not match_name_keywords(n, args.lr_backbone_names) and not match_name_keywords(n, args.lr_linear_proj_names) and p.requires_grad ], "lr": args.lr, }, { "params": [ p for n, p in model_without_ddp.named_parameters() if match_name_keywords(n, args.lr_backbone_names) and p.requires_grad ], "lr": args.lr_backbone, }, { "params": [ p for n, p in model_without_ddp.named_parameters() if match_name_keywords(n, args.lr_linear_proj_names) and p.requires_grad ], "lr": args.lr * args.lr_linear_proj_mult, }] if args.sgd: optimizer = torch.optim.SGD(param_dicts, lr=args.lr, momentum=0.9, weight_decay=args.weight_decay) else: optimizer = torch.optim.AdamW(param_dicts, lr=args.lr, weight_decay=args.weight_decay) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, args.lr_drop) if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu], find_unused_parameters=True) model_without_ddp = model.module if args.dataset_file == "coco_panoptic": # We also evaluate AP during panoptic training, on original coco DS coco_val = datasets.coco.build("val", args) base_ds = get_coco_api_from_dataset(coco_val) else: base_ds = get_coco_api_from_dataset(dataset_val) if args.frozen_weights is not None: checkpoint = torch.load(args.frozen_weights, map_location='cpu') model_without_ddp.detr.load_state_dict(checkpoint['model']) output_dir = Path(args.output_dir) if args.resume: if args.resume.startswith('https'): checkpoint = torch.hub.load_state_dict_from_url(args.resume, map_location='cpu', check_hash=True) else: checkpoint = torch.load(args.resume, map_location='cpu') missing_keys, unexpected_keys = model_without_ddp.load_state_dict( checkpoint['model'], strict=False) unexpected_keys = [ k for k in unexpected_keys if not (k.endswith('total_params') or k.endswith('total_ops')) ] if len(missing_keys) > 0: print('Missing Keys: {}'.format(missing_keys)) if len(unexpected_keys) > 0: print('Unexpected Keys: {}'.format(unexpected_keys)) if not args.eval and 'optimizer' in checkpoint and 'lr_scheduler' in checkpoint and 'epoch' in checkpoint: import copy p_groups = copy.deepcopy(optimizer.param_groups) optimizer.load_state_dict(checkpoint['optimizer']) for pg, pg_old in zip(optimizer.param_groups, p_groups): pg['lr'] = pg_old['lr'] pg['initial_lr'] = pg_old['initial_lr'] print(optimizer.param_groups) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) # todo: this is a hack for doing experiment that resume from checkpoint and also modify lr scheduler (e.g., decrease lr in advance). args.override_resumed_lr_drop = True if args.override_resumed_lr_drop: print( 'Warning: (hack) args.override_resumed_lr_drop is set to True, so args.lr_drop would override lr_drop in resumed lr_scheduler.' ) lr_scheduler.step_size = args.lr_drop lr_scheduler.base_lrs = list( map(lambda group: group['initial_lr'], optimizer.param_groups)) lr_scheduler.step(lr_scheduler.last_epoch) args.start_epoch = checkpoint['epoch'] + 1 # check the resumed model # if not args.eval: # test_stats, coco_evaluator, _ = evaluate( # model, criterion, postprocessors, data_loader_val, base_ds, device, args.output_dir # ) if args.eval: assert args.batch_size == 1, print("Now only support 1.") tracker = Tracker(score_thresh=args.track_thresh) test_stats, coco_evaluator, res_tracks = evaluate(model, criterion, postprocessors, data_loader_val, base_ds, device, args.output_dir, tracker=tracker, phase='eval', det_val=args.det_val, fp16=args.fp16) if args.output_dir: # utils.save_on_master(coco_evaluator.coco_eval["bbox"].eval, output_dir / "eval.pth") if res_tracks is not None: print("Creating video index for {}.".format(args.dataset_file)) video_to_images = defaultdict(list) video_names = defaultdict() for _, info in dataset_val.coco.imgs.items(): video_to_images[info["video_id"]].append({ "image_id": info["id"], "frame_id": info["frame_id"] }) video_name = info["file_name"].split("/")[0] if video_name not in video_names: video_names[info["video_id"]] = video_name assert len(video_to_images) == len(video_names) # save mot results. save_track(res_tracks, args.output_dir, video_to_images, video_names, args.track_eval_split) return print("Start training") start_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: sampler_train.set_epoch(epoch) train_stats = train_one_epoch(model, criterion, data_loader_train, optimizer, device, scaler, epoch, args.clip_max_norm, fp16=args.fp16) lr_scheduler.step() if args.output_dir: checkpoint_paths = [output_dir / 'checkpoint.pth'] # extra checkpoint before LR drop and every 5 epochs if (epoch + 1) % args.lr_drop == 0 or (epoch + 1) % 5 == 0: checkpoint_paths.append(output_dir / f'checkpoint{epoch:04}.pth') for checkpoint_path in checkpoint_paths: utils.save_on_master( { 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch, 'args': args, }, checkpoint_path) log_stats = { **{f'train_{k}': v for k, v in train_stats.items()}, 'epoch': epoch, 'n_parameters': n_parameters } if epoch % 10 == 0 or epoch > args.epochs - 5: test_stats, coco_evaluator, _ = evaluate(model, criterion, postprocessors, data_loader_val, base_ds, device, args.output_dir, fp16=args.fp16) log_test_stats = { **{f'test_{k}': v for k, v in test_stats.items()} } log_stats.update(log_test_stats) if args.output_dir and utils.is_main_process(): with (output_dir / "log.txt").open("a") as f: f.write(json.dumps(log_stats) + "\n") # for evaluation logs # if coco_evaluator is not None: # (output_dir / 'eval').mkdir(exist_ok=True) # if "bbox" in coco_evaluator.coco_eval: # filenames = ['latest.pth'] # if epoch % 50 == 0: # filenames.append(f'{epoch:03}.pth') # for name in filenames: # torch.save(coco_evaluator.coco_eval["bbox"].eval, # output_dir / "eval" / name) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str))
""" link = "https://github.com/patillacode/twallery" sys.stderr.write('\nerror: {0}\n\n'.format(message)) self.print_help() sys.stderr.write('\nPlease check the README or go to {0}\n\n'.format( link)) sys.exit(2) if __name__ == '__main__': try: parser = TrackParser() mandatory = parser.add_argument_group("mandatory arguments") mandatory.add_argument('--hashtags', required=True, nargs='*', help="") args = parser.parse_args() # Create Tracker with given hashtags tracker = Tracker(args.hashtags) stream = tracker.authenticate() # Capture data by the keywords stream.filter(track=tracker.hashtags) except (KeyboardInterrupt, SystemExit): logger.debug("Farewell my friend!") except: logger.error(traceback.format_exc())
async def update_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] # We're first gonna retrieve the existing server side shape for some validation checks if data["temporary"]: # This stuff is not stored so we cannot do any server side validation /shrug shape = data["shape"] layer = location.layers.where(Layer.name == data["shape"]["layer"])[0] else: # Use the server version of the shape. try: shape = Shape.get(uuid=data["shape"]["uuid"]) except Shape.DoesNotExist: logger.warning(f"Attempt to update unknown shape by {user.name}") return layer = shape.layer # Ownership validatation if room.creator != user: if not layer.player_editable: logger.warning( f"{user.name} attempted to move a shape on a dm layer") return if data["temporary"]: if user.name not in shape["owners"]: logger.warning( f"{user.name} attempted to move asset it does not own") return else: if not ShapeOwner.get_or_none(shape=shape, user=user): logger.warning( f"{user.name} attempted to move asset it does not own") return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_table = get_table(shape.type_) type_instance = type_table.get(uuid=shape.uuid) # no backrefs on these tables update_model_from_dict(type_instance, data["shape"], ignore_unknown=True) type_instance.save() # Owners old_owners = {owner.user.name for owner in shape.owners} new_owners = set(data["shape"]["owners"]) for owner in old_owners ^ new_owners: if owner == "": continue delta_owner = User.by_name(owner) if owner in new_owners: ShapeOwner.create(shape=shape, user=delta_owner) else: ShapeOwner.get(shape=shape, user=delta_owner).delete_instance(True) await send_client_initiatives(room, location, delta_owner) # Trackers for tracker in data["shape"]["trackers"]: tracker_db = Tracker.get_or_none(uuid=tracker['uuid']) reduced = reduce_data_to_model(Tracker, tracker) reduced['shape'] = shape if tracker_db: update_model_from_dict(tracker_db, reduced) tracker_db.save() else: Tracker.create(**reduced) # Auras for aura in data["shape"]["auras"]: aura_db = Aura.get_or_none(uuid=aura['uuid']) reduced = reduce_data_to_model(Aura, aura) reduced['shape'] = shape if aura_db: update_model_from_dict(aura_db, reduced) aura_db.save() else: Aura.create(**reduced) # Send to players if layer.player_visible: for room_player in room.players: for psid in state.get_sids(user=room_player.player, room=room): if psid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room_player.player, False) await sio.emit("Shape.Update", data, room=psid, namespace="/planarally") # Send to DM for csid in state.get_sids(user=room.creator, room=room): if csid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room.creator, True) await sio.emit("Shape.Update", data, room=csid, namespace="/planarally")