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()
