def liveness_scenario_reader(key, scenario, trial_count=0):
global results
num_trials = trial_count
scenario_copy = copy.deepcopy(scenario)
pudding_type = PuddingType[scenario['pudding_type']]
num_discovery_nodes = scenario['n']
threshold = scenario['k']
feasible = scenario['feasible']
event_type = scenario['event_type']
network = Network(pudding_type,
num_discovery_nodes=num_discovery_nodes,
num_relay_nodes=1,
threshold=threshold,
timeout=len(scenario['time']) * 4,
avail_scenarios=scenario['time'],
tested_event_type=event_type)
print('Created network')
print(f'event_type {event_type}')
spare_key_pairs = network.spare_key_pairs
scenario_actors = dict()
for user_event in scenario['user_scenario']:
print(f'scenario is {user_event}')
action = user_event.pop()
actors = list()
for actor in user_event:
if actor not in scenario_actors.keys() or action == 'register':
try:
user = User(network, actor, spare_key_pairs.pop())
except:
print('NOT ENOUGH KEYS')
user = User(network, actor)
scenario_actors[actor] = user
actors.append(scenario_actors[actor])
execute_action(actors, action)
if network.action_success_failure == ErrorCodes.TIMEOUT:
result = False
elif network.action_success_failure == SuccessCodes.REGISTRATION_COMPLETE and event_type == 'register':
result = True
elif network.action_success_failure == SuccessCodes.UPDATE_COMPLETE and event_type == 'update':
result = True
elif network.action_success_failure == SuccessCodes.DISCOVERY_COMPLETE and event_type == 'discover':
result = True
else:
result = None
print(f'Result: {result}')
results[key] = {'feasible': feasible, 'result': result}
# Try again, max. of three times
if result != feasible:
if num_trials < 3:
num_trials += 1
print('Something unexpected happened, trying scenario again\n')
liveness_scenario_reader(key, scenario_copy, num_trials)
else:
assert result == feasible, 'Result and feasibility are not the same'
else:
return network.tick
def get(id):
auth_token = request.headers['Authorization']
authorized = User.is_authorized(auth_token)
if authorized:
user_id = User.decode(auth_token)
chat = Chat.get(id, user_id)
body = json.dumps({'id': chat.id, 'messages': chat.messages})
return Response(body, status=200, mimetype='application/json')
else:
return Response(status=401, smimetype='application/json')
def main():
if len(sys.argv) >= 3:
id = sys.argv[1]
pw = sys.argv[2]
else:
id = os.getenv('XK_ID')
pw = os.getenv('XK_PW')
user = User(id, pw)
print('{} 登录中...'.format(id))
while True:
b, msg = user.login()
if not b:
print(msg)
continue
else:
break
print(user.major, user.grade)
for i, course in enumerate(user.courses):
print('[{}] {} '.format(i, course))
watcher = Watcher()
while True:
choice = input('要选择的课程的序号(q 退出)>>>').strip()
if choice == 'q':
break
try:
course = user.courses[int(choice)]
except (ValueError, IndexError):
print('此课程不存在: ', choice)
continue
if len(course.tasks) == 1:
task = course.tasks[0]
elif len(course.tasks) == 0:
print('你选择的课程 [{}] 没有可选老师'.format(course.name))
continue
else:
print('你选择的课程 [{}] 有以下老师可选:'.format(course.name))
for i, task in enumerate(course.tasks):
print('[{}] {} '.format(i, task))
select_task = input('要选择的老师的序号>>>')
task = course.tasks[int(select_task)]
watcher.add_task(task)
print('添加成功, 正在抢课中')
def register():
form = RegistrationForm()
if form.validate_on_submit():
user = User()
user.username = form.username.data
user.password = form.password.data
db.session.add(user)
db.session.commit()
flash('You can now login.')
return redirect(url_for('auth.login'))
else:
errors = form.errors.items()
return render_template('auth/register.html', form=form, errors=errors)
return render_template('auth/register.html', form=form)
def message(id):
auth_token = request.headers['Authorization']
authorized = User.is_authorized(auth_token)
if authorized:
user_id = User.decode(auth_token)
data = json.loads(request.data)
text = data['text']
Message.create(text, id, user_id)
return Response(status=201, mimetype='application/json')
else:
return Response(status=401, smimetype='application/json')
def create():
auth_token = request.headers['Authorization']
authorized = User.is_authorized(auth_token)
if authorized:
user_id = User.decode(auth_token)
data = json.loads(request.data)
participant = data['participant']
chat_id = Chat.create(user_id, participant)
body = json.dumps({'chat_id': chat_id})
return Response(body, status=201, mimetype='application/json')
else:
return Response(status=401, smimetype='application/json')
def CaptureUserData(self, userData, formaPago):
#obj que almacena todos los datos del usuario
self.master.USER = User(userData[0].get(), userData[1].get(), userData[2].get(), userData[3].get(), userData[4].get(), userData[5].get(), userData[6].get())
if formaPago == 1:
self.master.switch_frame(FacturaAbonoFrame)
else:
self.master.switch_frame(FacturaPagoFrame)
def login():
data = json.loads(request.data)
username = data['username']
password = data['password']
token = User.authenticate(username, password)
return Response(json.dumps({'auth_token': token}),
status=200,
mimetype='application/json')
def enter_as_user(self, answers):
self.session['role'] = constants.USER_ROLE
login = str(answers['login']).strip()
me = User.load(self.redis, login)
if not me:
me = User(login, 'admin' if login.endswith('admin') else 'user',
self.redis)
me.save()
if login.endswith('admin'):
self.thread = self.chat.listen_events({
'%s:%s' % (constants.EVENT_MESSAGE_CREATED, login):
self.handle_message_created,
'%s:%s' % (constants.EVENT_INCOMING_MESSAGE, login):
self.handle_incoming_message,
'%s:%s' % (constants.EVENT_MESSAGE_APPROVED, login):
self.handle_message_approve,
'%s:%s' % (constants.EVENT_MESSAGE_BLOCKED, login):
self.handle_message_block,
'%s:*' % constants.EVENT_MESSAGE_CREATED:
self.handle_else_message_created,
'%s:*' % constants.EVENT_INCOMING_MESSAGE:
self.handle_else_incoming_message,
'%s:*' % constants.EVENT_MESSAGE_APPROVED:
self.handle_else_message_approve,
'%s:*' % constants.EVENT_MESSAGE_BLOCKED:
self.handle_else_message_block,
})
else:
self.thread = self.chat.listen_events({
'%s:%s' % (constants.EVENT_MESSAGE_CREATED, login):
self.handle_message_created,
'%s:%s' % (constants.EVENT_INCOMING_MESSAGE, login):
self.handle_incoming_message,
'%s:%s' % (constants.EVENT_MESSAGE_APPROVED, login):
self.handle_message_approve,
'%s:%s' % (constants.EVENT_MESSAGE_BLOCKED, login):
self.handle_message_block,
})
self.session['me'] = me
UserActionsScene(self.session, self.redis).enter()
def enter_as_user(self, answers):
self.session["role"] = Role.USER
login = str(answers["login"]).strip()
me = User.load(self.redis, login)
if not me:
me = User(login, "admin" if login.endswith("admin") else "user", self.redis)
me.save()
if login.endswith("admin"):
self.thread = self.chat.listen_events(
{
"%s:%s"
% (MessageEvent.CREATED, login): self.handle_message_created,
"%s:%s"
% (MessageEvent.PENDING, login): self.handle_pending_message,
"%s:%s"
% (MessageEvent.CONFIRMED, login): self.handle_message_confirm,
"%s:%s" % (MessageEvent.BANNED, login): self.handle_message_ban,
"%s:*" % MessageEvent.CREATED: self.handle_else_message_created,
"%s:*" % MessageEvent.PENDING: self.handle_else_pending_message,
"%s:*" % MessageEvent.CONFIRMED: self.handle_else_message_confirm,
"%s:*" % MessageEvent.BANNED: self.handle_else_message_ban,
}
)
else:
self.thread = self.chat.listen_events(
{
"%s:%s"
% (MessageEvent.CREATED, login): self.handle_message_created,
"%s:%s"
% (MessageEvent.PENDING, login): self.handle_pending_message,
"%s:%s"
% (MessageEvent.CONFIRMED, login): self.handle_message_confirm,
"%s:%s" % (MessageEvent.BANNED, login): self.handle_message_ban,
}
)
self.session["me"] = me
UserActionsScene(self.session, self.redis).enter()
def register():
data = json.loads(request.data)
first_name = data['first_name']
last_name = data['last_name']
username = data['username']
password = data['password']
token = User.register(first_name, last_name, username, password)
return Response(json.dumps({'auth_token': token}),
status=201,
mimetype='application/json')
def enter(self):
answers = self.ask()
count = int(answers['count'])
delay = float(answers['delay'])
self.users = [
User(login=USERS[math.floor(random() * len(USERS))],
role='user',
redis=self.redis) for _ in range(count)
]
for u in self.users:
u.save()
print('create %s users' % count)
print('\n'.join(map(lambda u: u.login, self.users)))
processes = []
for user in self.users:
processes.append(
multiprocessing.Process(target=self.perform_actions_as,
args=[user, delay]))
processes[-1].start()
for p in processes:
p.join()
import glob
import src.User as User
print(sys.argv[1])
oS = sys.argv[1]
dataFile = "data/PII/data_"
if oS.lower() == "ios":
dataFile = dataFile + "iOS.json"
elif oS.lower() == "android":
dataFile = dataFile + "Android.json"
else:
Exception("Sistema Operativo non valido! (ios | android)")
# appname = sys.argv[1]
user = User(dataFile)
attributes = list(user.__dict__.keys())
items = None
requests = []
for testFile in glob.glob("testFiles_" + oS + "/*.har"):
nomeFile = testFile.split('/')[1].split('.')[0]
print(nomeFile)
with open("Output/Out_" + nomeFile + ".txt", 'a') as outTxtFile:
with open(testFile) as file:
httpData = json.load(file)
traffic = httpData["log"]["entries"]
count = 0
for index, entry in enumerate(traffic):
for item in entry:
from src import db, User, Post, ViewHistory
def create_history(db, post, x=1):
for i in range(0, int(50000 / x)):
hist = ViewHistory()
hist.ip_address = str(IPv4Address(getrandbits(32)))
hist.post = post
db.session.add(hist)
with app.app_context():
db.create_all() # create tables from models
user1 = User(name="Michael Jackson", email='*****@*****.**')
user2 = User(name="Nick Cage", email='*****@*****.**')
user3 = User(name="Adam Sandler", email='*****@*****.**')
user4 = User(name="Arnold Schwarzenegger", email='*****@*****.**')
user5 = User(name="John Cena", email='*****@*****.**')
post1 = Post()
post1.title = "Music is awesome"
post1.body = "Today I performed in front of thousands of people"
post1.author = user1
create_history(db, post1, 5)
from flask import render_template, request, redirect, url_for, abort
from server import app
from src.blockchain import *
from src.smartContract import *
from src.wallet import *
from src.User import *
blockchain = Blockchain()
smartContract = Contract(30000, [0.2, 0.5, 1])
walletObj = Wallet()
idObj = User()
recentDonations = []
@app.route('/')
def index():
return render_template('index.html')
@app.route('/luminary')
def founderIndex():
return render_template('project.html',
role='founder',
id=idObj,
blockchain=blockchain,
recentDonations=recentDonations[::-1],
contract=smartContract)
@app.route('/project/addTransaction', methods=['GET', 'POST'])
def addTransaction():
def get_groups_without_friends(groups, friend_ids):
"""фильтрация групп в которых у пользователя нет друзей"""
group_with_out_friends = []
for group in groups:
group_member = group.get_members_status(friend_ids)
group_members = list(
filter(lambda member: member['member'] == 1, group_member))
if not group_members:
group_with_out_friends.append(group)
return group_with_out_friends
vk = VkApi(
'ed1271af9e8883f7a7c2cefbfddfcbc61563029666c487b2f71a5227cce0d1b533c4af4c5b888633c06ae'
)
vk.add_observer_success(ObserverSuccess())
vk.add_observer_wait(ObserverWait())
vk.add_observer_error(ObserverError())
vk.add_observer_error(ObserverLog())
user_id = input('Введите ID пользователя (171691064):') or 171691064
user = User(vk, user_id)
groups = user.get_groups()
friend_ids = user.get_friend_ids()
group_with_out_friends = get_groups_without_friends(groups, friend_ids)
with open('groups.json', 'w') as file:
json.dump(group_with_out_friends, file, indent=4, default=group_to_json)