def talk_to_me(bot, update, user_data): # Ответ от бота get_user_data(user_data) user_msg = f"Привет {update.message.chat.first_name} {user_data['emoji']}!! \nТы написал: {update.message.text}" logging.info( f'User: {update.message.chat.username}, Chat id: {update.message.chat.id}, Message: {update.message.text}' ) update.message.reply_text(user_msg, reply_markup=get_keyboard())
def read_data_first(self): # self.inventory.read_data() user_data = utils.get_user_data() path = os.path.join("data", user_data["character_name"], constants.PLAYER_DATA_FILE) # print("path: {}".format(path)) mylist = utils.read_data_file(path, num_of_fields=11) mydict = mylist[0] # print("mydict: {}".format(mydict)) # ---- self.x = mydict["x"] self.y = mydict["y"] self.name = mydict["name"] self.kind = mydict["kind"] if utils.is_int(mydict["direction"]) == True: self.direction = int(mydict["direction"]) else: self.direction = utils.convert_direction_to_integer(mydict["direction"]) self.max_hit_points = mydict["max_hit_points"] self.hit_points = mydict["hit_points"] self.chance_to_hit = mydict["chance_to_hit"] self.experience = mydict["experience"] self.profession = mydict["profession"] self.gold = mydict["gold"] # ---- self.load_images()
def delete(cls, username): """ api call - delete user """ # block reserved users if username in Users.RESERVED: abort(400, "Username \"%s\" is reserved" % username) # do not allow user to delete reserved values data = get_user_data([], relaxed=True) if username in (g.user.username, "admin", "root"): abort(400, "You cannot delete this account") # need to get groups before deleting user so they can be cleaned up groups = [] r = current_app.mongo.db.users.find_one({"username": username}) if r is not None and "groups" in r and len(r["groups"]) > 0: groups = r["groups"] # perform delete operation Rest.delete.__func__(cls, current_app.mongo.db.users, delete_one=("username", username), rule_dn="/users/%s" % username) # remove user from groups if "sync_groups" in data and data["sync_groups"]: r = current_app.mongo.db.groups.update_many( {}, {"$pull": { "members": "%s" % username }}) cls.logger.debug("removed user:%s from %s groups" % (username, r.modified_count)) return {"success": True}
def create(cls): """ api call - create new user, returns dict with username """ # get user data with required parameters and validate parameters data = get_user_data(["username", "password"]) username = force_attribute_type("username", Users.META["username"]["type"], data["username"]) password = Users.hash_pass( force_attribute_type("password", Users.META["password"]["type"], data["password"])) role = data.get("role", Users.META["role"]["default"]) if not Roles.valid(role): abort(400, "Invalid role: %s" % role) # block reserved users from being created if username in Users.RESERVED: abort(400, "Username \"%s\" is reserved" % username) # find groups that user may already be a member of groups = Users.find_groups(username) # create user update = Rest.create.__func__(cls, current_app.mongo.db.users, rule_dn="/users/", override_attr={ "username": username, "password": password, "role": role, "groups": groups }) return {"success": True, "username": username}
def update(cls, username): """ api call - update user """ # block reserved users if username in Users.RESERVED: abort(400, "Username \"%s\" is reserved" % username) # pre-processing custom attributes data = get_user_data([]) override_attr = {} # encrypt password if provided in update if "password" in data: override_attr["password"] = User.hash_pass( force_attribute_type("password", cls.META["password"]["type"], data["password"])) # validate role if provided in update if "role" in data: if not Roles.valid(data["role"]): abort(400, "Invalid role: %s" % data["role"]) override_attr["role"] = data["role"] # perform update (aborts on error) update = Rest.update.__func__( cls, current_app.mongo.db.users, update_one=("username", username), rule_dn="/users/%s" % username, override_attr=override_attr, ) return {"success": True}
def read_data_restart(self, x=-1, y=-1): # print("mydict: {}".format(mydict)) # self.inventory = Inventory("player") # self.inventory.read_data() user_data = utils.get_user_data() path = os.path.join("data", user_data["character_name"], constants.PLAYER_DATA_FILE) mylist = utils.read_data_file(path, num_of_fields=11) mydict = mylist[0] # ---- if x == -1 and y == -1: self.x = mydict["x"] self.y = mydict["y"] else: if x == -1 or y == -1: raise ValueError("Error!") self.x = x self.y = y # ---- self.name = mydict["name"] self.kind = mydict["kind"] if utils.is_int(mydict["direction"]) == True: self.direction = -90 else: self.direction = utils.convert_direction_to_integer(mydict["direction"]) self.max_hit_points = mydict["max_hit_points"] self.hit_points = mydict["hit_points"] self.chance_to_hit = mydict["chance_to_hit"] self.experience = mydict["experience"] self.profession = mydict["profession"] self.gold = mydict["gold"] # ---- self.load_images() # ---- self.direction = "DOWN"
def save_data(self): player_data = utils.get_user_data() filename = "{}.txt".format(self.name) filepath = os.path.join("data", player_data["character_name"], "monsters", filename) fileline = self.get_fileline() with open(filepath, "w") as f: f.write(fileline)
def save_data(self): # save player data user_data = utils.get_user_data() player_string = self.get_fileline() filepath = os.path.join("data", user_data["character_name"], constants.PLAYER_DATA_FILE) with open(filepath, "w") as f: f.write(player_string)
def update(cls, group): """ api call - update a single group (full set update...) """ # if 'members' in update, then we're overwriting field. This means # we need to read the current members BEFORE performing the update data = get_user_data([]) members = [] members_update = False if "members" in data: members_update = True r = current_app.mongo.db.groups.find_one({"group": group}) if r is not None and "members" in r and len(r["members"])>0 and \ type(r["members"]) is list: # append to members members from current group members += r["members"] # perform update (aborts on error) update = Rest.update.__func__( cls, current_app.mongo.db.groups, update_one=("group", group), rule_dn="/groups/%s" % group, ) if members_update: # remove group from old members (full list of old members) if len(members) > 0: Users.remove_groups(members, group) # add group to new members if "members" in update and len(update["members"]) > 0: Users.add_groups(update["members"], group) return {"success": True}
def update(dn): """ api call - update a single rule (full set update...) """ dn = force_attribute_type("dn", Rules.META["dn"]["type"], dn) # build update list based on user data and writeable attributes data = get_user_data([]) update = {} for attr in Rules.META: if Rules.META[attr]["write"] and attr in data: update[attr] = force_attribute_type(attr, Rules.META[attr]["type"], data[attr]) # for now only admins can set owner - might open up later... if g.user.role == Roles.FULL_ADMIN and "owner" in data: update["owner"] = data["owner"] # if attribute provided that cannot be written, return error for v in data: # skip 'dn' and 'owner' (already handled) if v == "dn" or v == "owner": continue if v not in Rules.META or not Rules.META[v]["write"]: abort(400, "unknown or invalid attribute '%s'" % v) # ensure at least one valid attribute provided for rule if len(update) == 0: abort(400, "no valid parameter provided") r = current_app.mongo.db.rules.update_one({"dn": dn}, {"$set": update}) if r.matched_count == 0: abort(404, "Rule(%s) not found" % dn) return {"success": True}
def update_incr(cls): """ api call - incremental add/remove of entries in list - group is provided as a required attribute (similar to create) - list_name {"add":[list], "remove":[list]} """ # get user data with required parameters (only dn is required) data = get_user_data(["group"]) group = force_attribute_type("group", Groups.META["group"]["type"], data["group"]) # perform update_incr (aborts on error) update = Rest.update_incr.__func__( cls, current_app.mongo.db.groups, update_one=("group", group), rule_dn="/groups/%s" % group, ) # need to remove/add users from appropriate groups # (always perform 'remove' operation first) if "members" in update: m_update = update["members"] if "remove" in m_update and len(m_update["remove"]) > 0: Users.remove_groups(m_update["remove"], group) if "add" in m_update and len(m_update["add"]) > 0: Users.add_groups(m_update["add"], group) return {"success": True}
def update(): """ handles login :return: json object of login data """ email = request.form["email"] data = {"email": email} update_user_token(data) return jsonify(get_user_data(email))
def register(request): serialized = UserSerializer(data=request.POST) if serialized.is_valid(): user_data = utils.get_user_data(request.POST) utils.create_inactive_user(**user_data) return Response(utils.USER_CREATED_RESPONSE_DATA, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def register(request): serialized = UserSerializer(data=request.POST) if serialized.is_valid(): user_data = utils.get_user_data(request.POST) utils.create_inactive_user(**user_data) return Response(utils.USER_CREATED_RESPONSE_DATA, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def update_incr(): """ api call - incremental add/remove of entries in list - dn is provided as a required attribute (similar to create) - list_name {"add":[list], "remove":[list]} """ # get user data with required parameters (only dn is required) data = get_user_data(["dn"]) dn = force_attribute_type("dn", Rules.META["dn"]["type"], data["dn"]) update = {} # validate optional attributes for v in ("read_users", "write_users", "read_groups", "write_groups"): if v in data: update[v] = {} if type(data[v]) is not dict: abort(400, "attribute '%s' should by type 'dict'" % v) for opt in ("add", "remove"): if opt not in data[v]: continue if type(data[v][opt]) is not list: abort( 400, "attribute %s[%s] should be type 'list'" % (v, opt)) if len(data[v][opt]) == 0: continue update[v][opt] = [] for entry in data[v][opt]: # force entry to string and append to update update[v][opt].append(str(entry)) # no validate data provided, pop index if len(update[v]) == 0: update.pop(v, None) # ensure at least one valid attribute provided for rule if len(update) == 0: incr_msg = "Expected at least one 'add' or 'remove' attribute" abort(400, "No valid parameter provided. %s" % incr_msg) # perform add/remove updates for v in update: if "add" in update[v] and len(update[v]["add"]) > 0: r = current_app.mongo.db.rules.update_one( {"dn": dn}, {"$addToSet": { v: { "$each": update[v]["add"] } }}) if r.matched_count == 0: abort(404, "Rule(%s) not found" % dn) if "remove" in update[v] and len(update[v]["remove"]) > 0: r = current_app.mongo.db.rules.update_one( {"dn": dn}, {"$pullAll": { v: update[v]["remove"] }}) if r.matched_count == 0: abort(404, "Rule(%s) not found" % dn) return {"success": True}
def create(): """ api call - create new rule, returns DICT (not json) """ # get user data with required parameters (only dn is required) data = get_user_data(["dn"]) # minimum required attributes update = {"dn": data["dn"]} # for now only admins can set owner - might open up later... if g.user.role == Roles.FULL_ADMIN and "owner" in data: update["owner"] = data["owner"] else: update["owner"] = g.user.username # validate mandatory attributes for v in ("dn", "owner"): update[v] = force_attribute_type(v, str, update[v]) # dn must always be in the form /path... update["dn"] = "/%s" % update["dn"].strip("/") # reserved dn 'incr' used by api call to update_incr if update["dn"] == "/incr": abort(400, "'/incr' is no a valid DN") # validate optional attributes for v in Rules.META: if Rules.META[v]["write"] and v in data and v not in update: update[v] = force_attribute_type(v, Rules.META[v]["type"], data[v]) elif v not in update: # ensure all attributes are set for create operation update[v] = Rules.META[v]["default"] # if attribute provided that cannot be written, return error for v in data: # skip 'dn' and 'owner', already handled if v == "dn" or v == "owner": continue if v not in Rules.META or not Rules.META[v]["write"]: abort(400, "unknown or invalid attribute '%s'" % v) try: current_app.mongo.db.rules.insert_one(update) except DuplicateKeyError as e: abort(400, "Dn \"%s\" already exists" % update["dn"]) # create returns dict, not json, allowing calling function to # add/remove attributes as required by api return {"success": True, "dn": update["dn"]}
def reset_data_files(self): self.environment.read_data() self.fauna.read_data() # ---- user_data = utils.get_user_data() # source_file = os.path.join("data", constants.MONSTERS_ORIGINAL_DATA_FILE) # destination_file = os.path.join("data", user_data["character_name"], constants.MONSTERS_DATA_FILE) # copyfile(source_file, destination_file) # ---- copy original file to player's directory --- source_file = os.path.join("data", constants.PLAYER_ORIGINAL_DATA_FILE) destination_file = os.path.join("data", user_data["character_name"], constants.PLAYER_DATA_FILE) copyfile(source_file, destination_file) # ---- ---- self.all_sprites = pygame.sprite.Group()
def read_data(self, name_and_location): # filepath = os.path.join("data", constants.MONSTERS_DATA_FILE) # number_of_fields = 8 # mylist = utils.read_data_file(filepath, number_of_fields) # mydict = mylist[0] filename = "{}.txt".format(name_and_location[0].strip()) player_data = utils.get_user_data() filepath = os.path.join("data", player_data["character_name"], "monsters", filename) number_of_fields = 11 mylist = utils.read_data_file(filepath, number_of_fields) mydict = mylist[0] # ---- # self.x = mydict["x"] # self.y = mydict["y"] self.x = name_and_location[1] self.y = name_and_location[2] # self.name = mydict["name"] if mydict["name"].lower() != name_and_location[0].lower().strip(): raise ValueError("Error! mydict[name]: {}; name_and_location[0].strip(): {}".format(mydict["name"], name_and_location[0].strip())) self.name = mydict["name"].lower() self.kind = mydict["kind"] self.maximum_damage = mydict["maximum_damage"] self.max_hit_points = mydict["max_hit_points"] self.hit_points = mydict["hit_points"] self.chance_to_hit = mydict["chance_to_hit"] self.experience = mydict["experience"] # --------------------------------------------- self.monster_image = mydict["monster_image"] self.monster_image_dead = mydict["monster_image_dead"] # --------------------------------------------- filepath = os.path.join("data", "images", self.monster_image) try: self.image = pygame.image.load(filepath).convert_alpha() except: s = "Couldn't open: {}".format(filepath) raise ValueError(s) self.image = pygame.transform.scale(self.image, (constants.TILESIZE, constants.TILESIZE)) self.rect = self.image.get_rect() self.rect = self.rect.move(self.x * constants.TILESIZE, self.y * constants.TILESIZE) # --------------------------------------------- filepath = os.path.join("data", "images", self.monster_image_dead) print("reading filepath: {}".format(filepath)) self.image_dead_monster = pygame.image.load(filepath).convert_alpha() self.image_dead_monster = pygame.transform.scale(self.image_dead_monster, (constants.TILESIZE, constants.TILESIZE)) # --------------------------------------------- if self.hit_points <= 0: self.image = self.image_dead_monster
def __add_clicked_cb(self, button): chooser = ObjectChooser(self) try: result = chooser.run() if result == Gtk.ResponseType.ACCEPT: logging.debug('ObjectChooser: %r', chooser.get_selected_object()) jobject = chooser.get_selected_object() # add the information about the sharer user_data = utils.get_user_data() jobject.metadata['shared_by'] = json.dumps(user_data) # And add a comment to the Journal entry if 'comments' in jobject.metadata: comments = json.loads(jobject.metadata['comments']) else: comments = [] comments.append({ 'from': user_data['from'], 'message': _('I shared this.'), 'icon-color': '[%s,%s]' % (user_data['icon'][0], user_data['icon'][1]) }) jobject.metadata['comments'] = json.dumps(comments) if jobject and jobject.file_path: if self._master: datastore.write(jobject) self._jm.append_to_shared_items(jobject.object_id) else: tmp_path = os.path.join(self._activity_root, 'instance') logging.error('temp_path %s', tmp_path) packaged_file_path = utils.package_ds_object( jobject, tmp_path) url = 'ws://%s:%d/websocket/upload' % (self.ip, self.port) uploader = utils.Uploader(packaged_file_path, url) uploader.connect('uploaded', self.__uploaded_cb) cursor = Gdk.Cursor.new(Gdk.CursorType.WATCH) self.get_window().set_cursor(cursor) uploader.start() finally: chooser.destroy() del chooser
def login(): """ handles login :return: json object of login data """ name, email, image = request.form["name"], request.form[ "email"], request.form["image"] data = {"name": name, "email": email, "image": image} query = "select * from users where email='{}'".format(email) conn = create_connection() results = run_query(conn, query) if len(results) == 0 or results is None: insert_user(data) else: update_user_token(data) update_user_image(data) return jsonify(get_user_data(email))
def register(request): serialized = {} user_data = {} if request.META['CONTENT_TYPE'] == 'application/json': serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): user_data = request.DATA elif request.META['CONTENT_TYPE'] == 'application/x-www-form-urlencoded': serialized = UserSerializer(data=request.POST) if serialized.is_valid(): user_data = utils.get_user_data(request.POST) if serialized.is_valid(): utils.create_inactive_user(**user_data) return Response(utils.USER_CREATED_RESPONSE_DATA, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def success(): if request.method == 'POST': username = request.form['username'] if not username: return render_template("failure.html", error='Please enter a username') # Check if user is in db user = User.from_name(username) if not user: try: user_data = get_user_data(username) comments_data = get_comment_data(username) except HTTPError as err: if err.response.status_code == 404: return render_template( "failure.html", error=f'User \'{username}\' does not exist') return render_template("failure.html", error='External API error') user = User(**user_data) user.comments = [ Comment(**comment_data) for comment_data in comments_data ] user.prediction = pred_lean(user) db.session.add(user) user.searches += 1 if not user.prediction: user.prediction = pred_lean(user) db.session.commit() return render_template( "success.html", stance_name=user.prediction.stance_name(), user=user.name, img=user.prediction.img(), h_fullstance=user.prediction.stance_name(axis='h_binary'), v_fullstance=user.prediction.stance_name(axis='v_binary'), h_confidence=f'{abs(user.prediction.h_pos):.0%}', v_confidence=f'{abs(user.prediction.v_pos):.0%}') elif request.method == 'GET': return redirect(url_for('index'))
def update_pwreset(): # only allowed non-authenticated update. User must provide correct # username and key within pwreset timeout for successful reset # get user data with required parameters data = get_user_data(["username", "password", "key"]) u = Users.load_user(data["username"]) if u is None: abort(400, "Incorrect username or inactive key provided") # ensure key is correct and still valid if data["key"] != u.pw_reset_key: abort(400, "Incorrect username or inactive key provided") pwtimeout = int(current_app.config.get("pw_reset_timeout", 7200)) if u.pw_reset_timestamp + pwtimeout < int(time.time()): # key has timed out, reset it and return an error current_app.mongo.db.users.update_one({"username": u.username}, { "$set": { "pw_reset_key": "", "pw_reset_timestamp": 0 }, }) #abort(400, "key timeout (now: %s/saved: %s/diff: %s)" %( # int(time.time()), # u.pw_reset_timestamp, # int(time.time()) - (u.pw_reset_timestamp+pwtimeout) #)) abort(400, "Incorrect username or inactive key provided") # ok to update password current_app.mongo.db.users.update_one({"username": u.username}, { "$set": { "pw_reset_key": "", "pw_reset_timestamp": 0, "password": Users.hash_pass(data["password"]) }, }) return {"success": True}
def register(request): serialized = {} user_data = {} if hasattr(settings, 'REGISTRATION_API_USER_SERIALIZER'): serializer = utils.get_serializer( settings.REGISTRATION_API_USER_SERIALIZER) else: serializer = UserSerializer if 'CONTENT_TYPE' not in request.META or \ ('CONTENT_TYPE' in request.META and request.META['CONTENT_TYPE'].startswith('application/json')): serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): user_data = request.DATA elif 'CONTENT_TYPE' in request.META and \ request.META['CONTENT_TYPE'].startswith('application/x-www-form-urlencoded'): serialized = UserSerializer(data=request.POST) if serialized.is_valid(): user_data = utils.get_user_data(request.POST) if user_data: create_user_data = {} for mapping in settings.REGISTRATION_API_USER_DATA_MAPPING: create_user_data[mapping] = user_data.get(mapping, '') try: utils.create_inactive_user(**create_user_data) except IntegrityError: return Response({'error': 'user failed to create'}, status=status.HTTP_400_BAD_REQUEST) else: return Response(utils.USER_CREATED_RESPONSE_DATA, status=status.HTTP_201_CREATED) else: error = '' if isinstance(serialized, serializer): error = serialized._errors return Response(error, status=status.HTTP_400_BAD_REQUEST)
def create(cls): """ api call - create new group, returns dict with group name """ # special checks for group put in override fields data = get_user_data(["group"]) group = force_attribute_type("group", str, data["group"]) if group == "incr": abort(400, "'incr' is no a valid group name") # create new group Rest.create.__func__(cls, current_app.mongo.db.groups, rule_dn="/groups/", required_attr=[], override_attr={"group": group}) # add group to list of users if 'members' provided if "members" in data and len(data["members"]) > 0: Users.add_groups(data["members"], group) # create returns dict, not json, allowing calling function to # add/remove attributes as required by api return {"success": True, "group": group}
def register(request): serialized = {} user_data = {} if hasattr(settings, 'REGISTRATION_API_USER_SERIALIZER'): serializer = utils.get_serializer(settings.REGISTRATION_API_USER_SERIALIZER) else: serializer = UserSerializer if 'CONTENT_TYPE' not in request.META or \ ('CONTENT_TYPE' in request.META and request.META['CONTENT_TYPE'].startswith('application/json')): serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): user_data = request.DATA elif 'CONTENT_TYPE' in request.META and \ request.META['CONTENT_TYPE'].startswith('application/x-www-form-urlencoded'): serialized = UserSerializer(data=request.POST) if serialized.is_valid(): user_data = utils.get_user_data(request.POST) if user_data: create_user_data = {} for mapping in settings.REGISTRATION_API_USER_DATA_MAPPING: create_user_data[mapping] = user_data.get(mapping, '') try: utils.create_inactive_user(**create_user_data) except IntegrityError: return Response({'error': 'user failed to create'}, status=status.HTTP_400_BAD_REQUEST) else: return Response(utils.USER_CREATED_RESPONSE_DATA, status=status.HTTP_201_CREATED) else: error = '' if isinstance(serialized, serializer): error = serialized._errors return Response(error, status=status.HTTP_400_BAD_REQUEST)
def update(cls, fabric): """ api call - update ep_settings """ # check if user provided apic password, if so encrypt it override_attr = {} data = get_user_data([]) if "apic_password" in data: override_attr["apic_password"] = aes_encrypt(data["apic_password"]) if override_attr["apic_password"] is None: abort(500, "encryption block failed") if "ssh_password" in data: override_attr["ssh_password"] = aes_encrypt(data["ssh_password"]) if override_attr["ssh_password"] is None: abort(500, "encryption block failed") # perform update (aborts on error) update = Rest.update.__func__( cls, current_app.mongo.db.ep_settings, rule_dn="/ept/settings", update_one=("fabric", fabric), override_attr=override_attr, ) return {"success": True}
def create(cls): """ api call - create new fabric settings """ # check if user provided apic password, if so encrypt it override_attr = {} data = get_user_data(["fabric"]) fabric = data["fabric"] if "apic_password" in data: override_attr["apic_password"] = aes_encrypt(data["apic_password"]) if override_attr["apic_password"] is None: abort(500, "encryption block failed") if "ssh_password" in data: override_attr["ssh_password"] = aes_encrypt(data["ssh_password"]) if override_attr["ssh_password"] is None: abort(500, "encryption block failed") Rest.create.__func__( cls, current_app.mongo.db.ep_settings, rule_dn="/ept/settings/", required_attr=["fabric"], override_attr=override_attr, ) return {"success": True, "fabric": fabric}
with open(nonexist_file) as f: reader = csv.reader(f) nonexist = {row[0] for row in reader} with open(data_file) as f: reader = csv.reader(f) usernames = {row[2]: row[3] for row in reader if row[2] not in nonexist} total = len(usernames) nonexist_new = set() # Buffer-Like construction that we use to write non-existent users to csv for i, (username, stance_name) in enumerate(usernames.items()): if stance_name == 'libright2': stance_name = 'libright' if stance_name != 'None' and not User.from_name(username): try: user_data = get_user_data(username) comments_data = get_comment_data(username) except HTTPError as e: print(f'{username:<24} | HTTPError {e.response.status_code} thrown') if e.response.status_code in [404, 403]: nonexist_new.add(username) continue user = User(**user_data) user.comments = [Comment(**comment_data) for comment_data in comments_data] user.stance = Stance.from_str(username, stance_name) db.session.add(user) db.session.commit() print(f'{username:<24} | {len(comments_data)} comments gathered') if i % 20 == 0:
def greeting(bot, update, user_data): emoji = get_user_data(user_data) msg = f"Hello, {emoji}" update.message.reply_text(msg, reply_markup=get_keyboard())
def change_emoji(bot, update, user_data): if 'emoji' in user_data: del user_data['emoji'] emoji = get_user_data(user_data) update.message.reply_text(f'Done. {emoji}', reply_markup=get_keyboard())
def main(): usernames = [] team_scorecard = {} final_ans = {} print "Enter the usernames of your team-members:" while True: user_input = raw_input().lower() if user_input: usernames.append(user_input) else: if len(usernames) == 0: print colored("You did not enter any usernames. Try again!", "red") exit() else: for username in usernames: print colored("\tExtracting {0} profile".format(username), "green") user_scorecard = get_user_data(username) normalised_user_scorecard = get_normalised_scorecard(user_scorecard) team_scorecard = update_scorecard(team_scorecard, normalised_user_scorecard) break normalised_scorecard = get_normalised_scorecard(team_scorecard) LANGUAGES = config.get("Languages", "seed").split("\n") IGNORE_LANGUAGES = config.get("Languages", "ignore").split("\n") for lang in team_scorecard: if lang not in LANGUAGES: LANGUAGES.append(lang) LANGUAGES = [lang for lang in LANGUAGES if lang not in IGNORE_LANGUAGES] score = [0] * len(LANGUAGES) i = 0 COUNT = len(LANGUAGES) * 10000 while i < COUNT: ctr = random.choice(LANGUAGES) score[LANGUAGES.index(ctr)] += 1 i += 1 ctr = 0 for lang in LANGUAGES: normalisation = 1 if lang in normalised_scorecard.keys(): normalisation = normalised_scorecard[lang] + 1 final_ans[lang] = score[ctr] * normalisation ctr += 1 final_score_list = [] od = OrderedDict(sorted(final_ans.items(), key=lambda(k,v):(v,k), reverse=True)) language_total_score = sum(final_ans.values()) for i in od: language_per_score = od[i] / language_total_score * 100 final_score_list.append([i, language_per_score]); print_headers = ["Language", "Percentage Score"] print tabulate(final_score_list, headers= print_headers, tablefmt='orgtbl')
def __state_change_cb(self, download, gparamspec): state = self._download.get_status() if state == WebKit.DownloadStatus.STARTED: # Check free space and cancel the download if there is not enough. total_size = self._download.get_total_size() logging.debug('Total size of the file: %s', total_size) enough_space = self.enough_space(total_size, path=self.temp_path) if not enough_space: logging.debug('Download canceled because of Disk Space') self.cancel() self._canceled_alert = Alert() self._canceled_alert.props.title = _('Not enough space ' 'to download') total_size_mb = total_size / 1024.0**2 free_space_mb = self._free_available_space( path=self.temp_path) - SPACE_THRESHOLD / 1024.0**2 filename = self._download.get_suggested_filename() self._canceled_alert.props.msg = \ _('Download "%{filename}" requires %{total_size_in_mb}' ' MB of free space, only %{free_space_in_mb} MB' ' is available' % {'filename': filename, 'total_size_in_mb': format_float(total_size_mb), 'free_space_in_mb': format_float(free_space_mb)}) ok_icon = Icon(icon_name='dialog-ok') self._canceled_alert.add_button(Gtk.ResponseType.OK, _('Ok'), ok_icon) ok_icon.show() self._canceled_alert.connect('response', self.__stop_response_cb) self._activity.add_alert(self._canceled_alert) else: self._download.connect('notify::progress', self.__progress_change_cb) self._create_journal_object() self._object_id = self.dl_jobject.object_id alert = TimeoutAlert(9) alert.props.title = _('Download started') alert.props.msg = _('%s' % self._download.get_suggested_filename()) self._activity.add_alert(alert) alert.connect('response', self.__start_response_cb) alert.show() global _active_downloads _active_downloads.append(self) elif state == WebKit.DownloadStatus.FINISHED: self._stop_alert = Alert() self._stop_alert.props.title = _('Download completed') self._stop_alert.props.msg = \ _('%s' % self._download.get_suggested_filename()) open_icon = Icon(icon_name='zoom-activity') self._stop_alert.add_button(Gtk.ResponseType.APPLY, _('Show in Journal'), open_icon) open_icon.show() ok_icon = Icon(icon_name='dialog-ok') self._stop_alert.add_button(Gtk.ResponseType.OK, _('Ok'), ok_icon) ok_icon.show() self._activity.add_alert(self._stop_alert) self._stop_alert.connect('response', self.__stop_response_cb) self._stop_alert.show() if self._dest_path.endswith('.journal'): metadata, preview_data, file_path = \ utils.unpackage_ds_object(self._dest_path) original_object_id = metadata['original_object_id'] for key in metadata.keys(): self.dl_jobject.metadata[key] = metadata[key] self.dl_jobject.metadata['preview'] = dbus.ByteArray( preview_data) self.dl_jobject.file_path = file_path datastore.write(self.dl_jobject, transfer_ownership=True, reply_handler=self.__internal_save_cb, error_handler=self.__internal_error_cb, timeout=360) # notify to the server, the object was successfully downloaded url = 'ws://%s:%d/websocket' % (self._activity.ip, self._activity.port) messanger = utils.Messanger(url) data = utils.get_user_data() data['object_id'] = original_object_id messanger.send_message('DOWNLOADED', data) else: self.dl_jobject.metadata['title'] = \ self._download.get_suggested_filename() self.dl_jobject.metadata['description'] = _('From: %s') \ % self._source self.dl_jobject.metadata['progress'] = '100' self.dl_jobject.file_path = self._dest_path # sniff for a mime type, no way to get headers from WebKit sniffed_mime_type = mime.get_for_file(self._dest_path) self.dl_jobject.metadata['mime_type'] = sniffed_mime_type datastore.write(self.dl_jobject, transfer_ownership=True, reply_handler=self.__internal_save_cb, error_handler=self.__internal_error_cb, timeout=360) elif state == WebKit.DownloadStatus.CANCELLED: self.cleanup()
def __state_change_cb(self, download, gparamspec): state = self._download.get_status() if state == WebKit.DownloadStatus.STARTED: # Check free space and cancel the download if there is not enough. total_size = self._download.get_total_size() logging.debug('Total size of the file: %s', total_size) enough_space = self.enough_space( total_size, path=self.temp_path) if not enough_space: logging.debug('Download canceled because of Disk Space') self.cancel() self._canceled_alert = Alert() self._canceled_alert.props.title = _('Not enough space ' 'to download') total_size_mb = total_size / 1024.0 ** 2 free_space_mb = self._free_available_space( path=self.temp_path) - SPACE_THRESHOLD / 1024.0 ** 2 filename = self._download.get_suggested_filename() self._canceled_alert.props.msg = \ _('Download "%{filename}" requires %{total_size_in_mb}' ' MB of free space, only %{free_space_in_mb} MB' ' is available' % {'filename': filename, 'total_size_in_mb': format_float(total_size_mb), 'free_space_in_mb': format_float(free_space_mb)}) ok_icon = Icon(icon_name='dialog-ok') self._canceled_alert.add_button(Gtk.ResponseType.OK, _('Ok'), ok_icon) ok_icon.show() self._canceled_alert.connect('response', self.__stop_response_cb) self._activity.add_alert(self._canceled_alert) else: self._download.connect('notify::progress', self.__progress_change_cb) self._create_journal_object() self._object_id = self.dl_jobject.object_id alert = TimeoutAlert(9) alert.props.title = _('Download started') alert.props.msg = _('%s' % self._download.get_suggested_filename()) self._activity.add_alert(alert) alert.connect('response', self.__start_response_cb) alert.show() global _active_downloads _active_downloads.append(self) elif state == WebKit.DownloadStatus.FINISHED: self._stop_alert = Alert() self._stop_alert.props.title = _('Download completed') self._stop_alert.props.msg = \ _('%s' % self._download.get_suggested_filename()) open_icon = Icon(icon_name='zoom-activity') self._stop_alert.add_button(Gtk.ResponseType.APPLY, _('Show in Journal'), open_icon) open_icon.show() ok_icon = Icon(icon_name='dialog-ok') self._stop_alert.add_button(Gtk.ResponseType.OK, _('Ok'), ok_icon) ok_icon.show() self._activity.add_alert(self._stop_alert) self._stop_alert.connect('response', self.__stop_response_cb) self._stop_alert.show() if self._dest_path.endswith('.journal'): metadata, preview_data, file_path = \ utils.unpackage_ds_object(self._dest_path) original_object_id = metadata['original_object_id'] for key in metadata.keys(): self.dl_jobject.metadata[key] = metadata[key] self.dl_jobject.metadata['preview'] = dbus.ByteArray( preview_data) self.dl_jobject.file_path = file_path datastore.write(self.dl_jobject, transfer_ownership=True, reply_handler=self.__internal_save_cb, error_handler=self.__internal_error_cb, timeout=360) # notify to the server, the object was successfully downloaded url = 'ws://%s:%d/websocket' % (self._activity.ip, self._activity.port) messanger = utils.Messanger(url) data = utils.get_user_data() data['object_id'] = original_object_id messanger.send_message('DOWNLOADED', data) else: self.dl_jobject.metadata['title'] = \ self._download.get_suggested_filename() self.dl_jobject.metadata['description'] = _('From: %s') \ % self._source self.dl_jobject.metadata['progress'] = '100' self.dl_jobject.file_path = self._dest_path # sniff for a mime type, no way to get headers from WebKit sniffed_mime_type = mime.get_for_file(self._dest_path) self.dl_jobject.metadata['mime_type'] = sniffed_mime_type datastore.write(self.dl_jobject, transfer_ownership=True, reply_handler=self.__internal_save_cb, error_handler=self.__internal_error_cb, timeout=360) elif state == WebKit.DownloadStatus.CANCELLED: self.cleanup()