class KEY_AUTH(): _logout = False def __init__(self, key, response=fake_response()): self.connection = sqlite3.connect('database.db') self.cursor = self.connection.cursor() self.key = key self.response = response self.session = Session(self.connection, self.cursor) self.credentials = (self.key, self.session.get(self.key)[3]) def login(self): if self.session.checkexpiration( self.key) == False or self._logout == True: self.response.set_cookie('AUTH', 'None') self.cursor.execute('UPDATE sessions SET expiration=? WHERE key=?', (str(datetime.now()), self.key)) self.connection.commit() self.response.headers['Refresh'] = '1' return False return True def logout(self): self._logout = True def close(self): self.connection.close()
def goodLogin(request): logger = logging.getLogger("canvasLogger") # its a POST, so credentials should have been supplied username = request.POST.get('username', '') pwd = request.POST.get('password', '') try: me = User.get_by_key_name(username) except Exception: logger.error('login: Exception - Username or Password Error') try: logger.error('login: Exception:' + sys.exc_type + sys.exc_value) except: pass me = None if me == None: #FAILED LOGIN Session()['message'] = "User Name and/or Password do not match" logger.info('login failed: ' + username) return False else: #good login Session()['username'] = username Session()['message'] = "" logger.info('login good: ' + username) #redirect to the page requestes, if there is one redir = request.POST.get('page', username) return True assert (False)
def __init__(self, key, response=fake_response()): self.connection = sqlite3.connect('database.db') self.cursor = self.connection.cursor() self.key = key self.response = response self.session = Session(self.connection, self.cursor) self.credentials = (self.key, self.session.get(self.key)[3])
def test_basic_card(self): Session.card_information = pull_card_data() self.basicflag = Request(Flags.BASIC_CARDS, None, None, None) self.session1 = Session([None, None]) body = str(Session.card_information['moves']) size = len(body) response_test = bytearray() response_test.append(self.basicflag.flag) _3byte = bytearray() for i in range(0, 3): _3byte.insert(0, size & 0xFF) size >>= 8 response_test += _3byte if isinstance(body, str): response_test += body.encode('utf-8') else: response_test.append(body) self.session1.basic_cards(self.basicflag) self.assertIsNotNone(self.session1.last_response) self.assertEqual(self.session1.last_response, response_test)
def poll_connections(server): Logger.log("Server started") Logger.log(server.getsockname()) connections = [] while server_running: # Occasionally timeout from polling to check if the server is still running try: client, client_address = server.accept() except sock.timeout: continue Logger.log("Anonymous user connected from address: " + client_address[0]) new_session = Session((client, client_address)) new_session.start() connections.append(new_session) for connection in connections: if connection.is_alive(): connection.kill() server.shutdown(sock.SHUT_RDWR) server.close() Logger.log("Server stopped")
def logoff(request): try: room = Session()['room'] if 'room' in Session() else None Session().delete() if room: return HttpResponseRedirect('/' + room + '/') return HttpResponseRedirect('/login/') except Error: self.error(500)
def test_verify(self): self.session1 = Session([None, None]) self.session1.userprofile = {'token': 'makeamericagreatagain'} purrect_token = Request(None, 'makeamericagreatagain', None, None) incorrect_token = Request(None, 'pokemon go to the polls', None, None) self.assertFalse(self.session1.verified(purrect_token)) self.assertFalse(self.session1.verified(incorrect_token)) self.session1.authenticated = True self.assertTrue(self.session1.verified(purrect_token)) self.assertFalse(self.session1.verified(incorrect_token))
def test_session_put(): test_session_data = { "clientPhone": "425-999-9457", "coachId": "coach2", "time": "11", "date": "2016-06-23", "clientName": "Dong Ming" } test_put_session = Session(sessions=TEST_SESSION_DATA, args=test_session_data) with TEST_APP.test_request_context(): response, status = test_put_session.put('test_put_id') assert response == test_session_data assert status == 201 assert 'clientName' in response assert response['clientName'] == 'Dong Ming'
def test_session_put(): test_session_data = { "clientPhone": "425-999-9457", "coachId": "coach2", "time": "11", "date": "2016-06-23", "clientName": "Dong Ming" } test_put_session = Session( sessions=TEST_SESSION_DATA, args=test_session_data) with TEST_APP.test_request_context(): response, status = test_put_session.put('test_put_id') assert response == test_session_data assert status == 201 assert 'clientName' in response assert response['clientName'] == 'Dong Ming'
def register(request): def hash(str): m = hashlib.md5() m.update(settings.SECRET_KEY) m.update(str) return m.hexdigest() if request.method == "GET": t = get_template('login.html') return HttpResponse(t.render([])) else: #add new user username = request.POST.get("reg-username", '') pwd = request.POST.get("reg-password1", "") email = request.POST.get("reg-email", "") if username != '': newUser = User(key_name=username) newUser.email = email newUser.display_name = username #newUser.key name = username newUser.pwdHash = hash(pwd) newUser.put() Session()['username'] = username #add a room for the user #TODO: this is not the key new_room = Room().get_by_key_name(username) if new_room == None: RoomUser().create_room(owner=newUser, room_name=username, is_public_read=False, is_public_write=False) return HttpResponseRedirect('/') else: return HttpResponseRedirect('/register/')
def create_normal_session(): # Create a user object, using session ID. session_id = request.cookies.get('session', None) g.user = Session(g.redis, session_id) # Make sure we log the IP. cf_connecting_ip = request.headers.get('CF-Connecting-IP') if cf_connecting_ip is not None: g.redis.hset('session.' + g.user.session_id + '.meta', 'last_ip', cf_connecting_ip)
def allowed_read_access(room_name): if 'username' in Session(): me = Session()['username'] else: me = None #valid login #TODO: Check access to this room db_room = Room().get_by_key_name(room_name) if me == None: user_me = None else: user_me = User().get_by_key_name(me) if db_room: if db_room.has_read_access(user_me): return True return False
def poll(request): resp = '{"error": "Exception in Poll()"}' if not request.GET: return HttpResponseBadRequest try: #create logger logger = logging.getLogger("canvasLogger") me = Session()['username'] if (me == None) or (me == ''): #not logged in HttpResponseRedirect('/') chatRoomName = request.GET.get('chatRoom') lastStr = request.GET.get('lastMsg') logger.debug('poll? - ' + chatRoomName + '/' + str(lastStr)) lastMsgSent = int(lastStr) #TODO: Query msgs to see if any new (from anyone else) #Check memcache for room's last ID chatRoom = Room.get_by_key_name(chatRoomName) lastId = chatRoom.get_lastMsgId() logger.debug('poll? - Id:' + str(lastId)) msgs = "" if lastMsgSent != lastId: #a new msg #return all msgs from lastMsg to lastId q = db.GqlQuery( "SELECT * FROM ChatMsg " + "WHERE roomName = :1 AND seq > :2 " + "ORDER BY seq", chatRoomName, lastMsgSent) #, lastMsgSent) logger.debug('poll? - querying') msgs = "" for msg in q: msgs += "<br><b>" msgs += msg.user.key().name() msgs += ": </b>" msgs += msg.text logger.debug('poll? - msgs:' + msgs) resp = '{"msg": "' + msgs + '", "lastMsgSeq": "' + str(lastId) + '"}' #resp = HttpResponse('{"msg": "", "lastMsgSeq": "0"}', mimetype='application/javascript') logger.debug("poll - " + e + '/' + chatRoomName + '/' + resp) return HttpResponse('{"msg": "' + msgs + '", "lastMsgSeq": "' + str(lastId) + '"}', mimetype='application/javascript') except Exception: try: resp = '{"error":"' + sys.exc_type + sys.exc_value + '"}' finally: return HttpResponse(resp, mimetype='application/javascript')
def logged_in(): try: session = Session() if 'username' in session: return True else: Audit().log("ACCESS", "None", "Login required for " + f.__name__) return False except: Audit().log("EXCEPTION", "unknown", "Login required for " + f.__name__) return False return True
def uploadImg(request): #create logger logger = logging.getLogger("canvasLogger") file = request.FILES.get("imgUp", None) if file: page_name = request.POST.get('page') Session()['page'] = page_name room = Room().get_by_key_name(Session()['room']) page = Page.gql('WHERE room = :room_key AND title = :title', room_key=str(room.key()), title=page_name).get() if page: pic = file.read() dbpic = DbImage() dbpic.picture = pic dbpic.user = Session()['username'] dbpic.put() #save the image to the content so its there when we reload (we are about to) content = Content(parent=page) content.page = str(page.key()) content.data = str(dbpic.key()) content.x = str(100 + random.randint(0, 100)) content.y = str(100 + random.randint(0, 100)) #TODO: set aspect ratio correctly content.width = str(150) content.height = str(150) content.type = 'img' content.deleted = False #for the transaction, mark as new #content.title = contents[str(item_no)]['title'] content.put() return HttpResponseRedirect('/' + room.key().name() + '/' + page.title) else: return HttpResponse('<textarea>{error:"no page" }</textarea>', mimetype='text/html') else: return HttpResponse('<textarea>{error:"no file" }</textarea>', mimetype='text/html')
def poll_connections(server): Logger.log("Server started") Logger.log(server.getsockname()) while server_running: # Occasionally timeout from polling to check if the server is still running try: client, client_address = server.accept() except sock.timeout: continue Logger.log("Anonymous user connected from address: " + client_address[0]) new_session = Session((client, client_address)) new_session.start() Logger.log("Closing all sessions") for live_thread in threading.enumerate(): if live_thread.name == 'session': live_thread.kill() active_count = threading.active_count() while active_count >= 4: update_count = threading.active_count() if active_count > update_count: active_count = update_count Logger.log("Sessions remaining: " + str(active_count - 3)) Logger.log("*Safe to close server application*") server.shutdown(sock.SHUT_RDWR) server.close() Logger.log("Server stopped")
class AUTH(): def __init__(self, response): self.__key = str(uuid.uuid4()) self.connection = sqlite3.connect('database.db') self.cursor = self.connection.cursor() self.response = response self.session = Session(self.connection, self.cursor) def login(self, user, password): password = self.hashps(password) if self.cursor.execute( 'SELECT * FROM users WHERE username=? AND password=?', (user, password)).fetchone() != None: self.credentials = (self.__key, user, password) self.response.set_cookie('AUTH', self.__key) self.response.headers['Refresh'] = '1' self.session.new(self.__key, user) return "true" else: self.response.set_cookie('AUTH', 'None') return "false" def new(self, user, password): if self.cursor.execute('SELECT id FROM users WHERE username=?', (user, )).fetchone() == None: self.cursor.execute( 'INSERT INTO users (username, password) VALUES (?,?)', (user, self.hashps(password))) self.connection.commit() return True return False def hashps(self, password): return hashlib.sha256(password).hexdigest() def close(self): self.connection.close()
def main(request): logger = logging.getLogger("canvasLogger") try: room = Session()['room'] if 'room' in Session() else None if room: return HttpResponseRedirect('/' + room + '/') t = get_template('index.html') logger.debug("main: got_template") return HttpResponse(t.render(main_context())) except Exception: #not logged in logger.info("main: not logged in") try: logger.error("main: " + sys.exc_type) Session( )["message"] = 'Login Error:' + sys.exc_type + sys.exc_value except: try: logger.error("main: exception logging in") logger.error("main: username: " + Session()['username']) del Session()['username'] except: pass return renderLogin()
def renderLogin(): try: message = Session()["message"] except KeyError: message = '' if (message != None) and (message != ""): #str_message = pickle.loads(message) template_values = Context({'error': message}) else: template_values = Context() t = get_template('login.html') res = HttpResponse(t.render(template_values)) return res
def roomSettings(request): if not request.POST: return HttpResponseBadRequest try: my_email = Session()['username'] if (my_email == None) or (my_email == ''): #not logged in return HttpResponse('Not Logged In') me = User().get_by_key_name(my_email) #check I have permission to set this roomName = request.POST.get("chatRoom") room = Room.get_by_key_name(roomName) if room: if room.owner == str(me.key()): #i am allowed - set it #reset all initially room.group_write = False room.public_read = False room.public_write = False #READ ACCESS #roomys can see if they exist access_rd = request.POST.get("access-rd") if access_rd == "world": room.public_read = True #WRITE ACCESS #if there is a roomy, they can see it, but can only write if group_write set access_wr = request.POST.get("access-wr") if access_wr == "world": room.public_write = True if access_wr == "group": room.group_write = True #SAVE room.put() return HttpResponse(request.POST.get('label')) return HttpResponse('error') except Exception: #create logger logger = logging.getLogger("canvasLogger") logger.error('roomSettings Exception:' + sys.exc_type + sys.exc_value) #TODO: dont return anything if live return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def page(request, room, page=None): #open a page logger = logging.getLogger("canvasLogger") if page == '#': page = None try: me = Session()['username'] except: me = None if (me == None) or (me == ''): logger.info("page: not logged in [" + room + "]") #valid login #TODO: Check access to this room if room: db_room = Room().get_by_key_name(room) if db_room: if me == None: user_me = None else: user_me = User().get_by_key_name(me) if db_room.has_read_access(user_me): logger.info("page: Access ok [" + room + "]") Session()['room'] = room if page: Session()['page'] = page else: Session()['page'] = "" #TODO: Exception here, need to render static welcome page return render_to_response('index.html', main_context(room_name=room)) else: #no access to room #TODO: error message if 'room' in Session(): del Session()['room'] return HttpResponseRedirect("/") #no room if 'room' in Session(): del Session()['room'] return HttpResponseRedirect("/")
def buddiesChecklist(request): if not request.GET: return HttpResponseBadRequest try: my_email = Session()['username'] if (my_email == None) or (my_email == ''): #not logged in return HttpResponse('Not Logged In') me = User().get_by_key_name(my_email) t = get_template('buddieschecklist.html') return HttpResponse(t.render(main_context())) except Exception: #create logger logger = logging.getLogger("canvasLogger") logger.error('buddiesChecklist Exception:' + sys.exc_type + sys.exc_value) #TODO: dont return anything if live return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def newPage(request, room): #add a page if request.method == "GET": logger.error('newPage: GET was not expected') return HttpResponseBadRequest try: #Save Content of RTF editor me = Session()['username'] if (me == None) or (me == ''): #not logged in logger.debug('saveContent: /') HttpResponseRedirect('/') #get room room_name = request.POST.get('room') room = Room().get_by_key_name(room_name) user_me = User().get_by_key_name(me) if room.has_write_access(str(user_me.key())): #get page page_name = request.POST.get('page') page_key = pageNameToKey(room, page_name) if page_key == None: #page doesnt exist - create newPage = Page() newPage.room = str(room.key()) newPage.title = page_name newPage.put() resp = {"isOk": True, "pageName": page_name} json_contents = simplejson.dumps(resp) response = HttpResponse(json_contents, mimetype='application/javascript') return response else: logger.error('newPage: Page Exists') return HttpResponseBadRequest else: logger.error('newPage: Access Denied') return HttpResponseBadRequest except: logger.error('newPage: Exception') return HttpResponseBadRequest
def acceptbuddy(request): #accept a buddy request if not request.POST: return HttpResponseBadRequest try: my_email = Session()['username'] if (my_email == None) or (my_email == ''): #not logged in HttpResponseRedirect('/') me = User().get_by_key_name(my_email) new_buddy_name = request.POST.get('buddyName', '') me.accept_buddy_request(new_buddy_name) t = get_template('buddiespane.html') return HttpResponse(t.render(main_context())) except Exception: #create logger logger = logging.getLogger("canvasLogger") logger.error('acceptbuddy Exception:' + sys.exc_type + sys.exc_value) #TODO: dont return anything if live return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def create_chat_session(): # Create a user object, using session and chat IDs. session_id = request.cookies.get('session', None) # If this is a health check let it pass if request.path == '/health': return # Don't accept chat requests if there's no cookie. if session_id is None: abort(400) # Validate session ID. if session_validator.match(session_id) is None: abort(400) # Validate chat ID. if 'chat' in request.form and validate_chat_url(request.form['chat']): chat = request.form['chat'] else: abort(400) g.chat_type = g.redis.hget('chat.' + chat + '.meta', 'type') if g.chat_type is None: abort(404) g.user = user = Session(g.redis, session_id, chat)
def addbuddy(request): #add a new buddy if not request.POST: return HttpResponseBadRequest try: my_email = Session()['username'] if (my_email == None) or (my_email == ''): #not logged in HttpResponseRedirect('/') me = User().get_by_key_name(my_email) new_buddy_name = request.POST.get('buddyName', '') #add outgoing req me.add_buddy_request(new_buddy_name) t = get_template('buddyreqspane.html') return HttpResponse(t.render(main_context())) except Exception: print 'Exception:' + sys.exc_type + sys.exc_value return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def sendChat(request): #create logger logger = logging.getLogger("canvasLogger") if not request.POST: return HttpResponseBadRequest try: me = Session()['username'] if (me == None) or (me == ''): #not logged in HttpResponseRedirect('/') msg = ChatMsg() roomName = request.POST.get('chatRoom') room = Room.get_by_key_name(roomName) if room: msg.chatRoom = room msg.roomName = room.key().name( ) #needed cos you cant GQL query a key value!!!!!! userMe = User.get_by_key_name(me) if userMe: msg.user = userMe msg.text = request.POST.get('chatMsg') msg.time = datetime.datetime.now() msg.setId(room) msg.put() respTxt = '<br><b>' + me + ': </b>' + request.POST.get( 'chatMsg') #lastId = room.get_lastMsgId() resp = '{"msg":"' + respTxt + '", "lastMsgSeq": "' + str( msg.seq) + '"}' logger.debug("sendChat - " + resp) return HttpResponse(resp, mimetype='application/javascript') return HttpResponse('Exception: Room not found ' + roomName, mimetype='application/javascript') except Exception: return HttpResponse('Exception:' + sys.exc_value, mimetype='application/javascript')
def saveItem(request): try: room_name = request.POST.get('room') room = Room().get_by_key_name(room_name) me = Session()['username'] user_me = User().get_by_key_name(me) if room.has_write_access(str(user_me.key())): #get page page_name = request.POST.get('page') page_key = pageNameToKey(room, page_name) if page_key == None: logger.error('SaveContent: NO PAGE: room:' + room_name + ' page:' + page_name) return HttpResponseServerError #good page, and we have access item = simplejson.loads(request.POST.get('item')) try: content = Content.get(item["key"]) except: content = Content(parent=Page().get(page_key)) if content: content.page = page_key content.data = item['data'] content.x = "10px" if (item['x'] == "") else item['x'] content.y = "10px" if (item['y'] == "") else item['y'] content.width = item['width'] content.height = item['height'] content.type = item['type'] content.deleted = False #for the transaction, mark as new #content.title = contents[str(item_no)]['title'] content.put() return HttpResponse('ok', mimetype='application/javascript') else: return HttpResponseServerError except: pass return HttpResponseServerError
def train_protonetmhlnbs(base_subdataset: LabeledSubdataset, val_subdataset: LabeledSubdataset, n_shot: int, n_way: int, n_iterations: int, batch_size: int, eval_period: int, val_batch_size: int, image_size: int, balanced_batches: bool, train_n_way=15, backbone_name='resnet12-np-o', device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"), **kwargs): session_info = { "task": "few-shot learning", "model": "ProtoNetMHLNBS", "feature_extractor": backbone_name, "n_iterations": n_iterations, "eval_period": eval_period, # "dataset": dataset_name, # "optimizer": optimizer_name, "batch_size": batch_size, "val_batch_size": val_batch_size, "n_shot": n_shot, "n_way": n_way, "train_n_way": train_n_way, "optimizer": 'adam', "image_size": image_size, "balanced_batches": balanced_batches, } session_info.update(kwargs) backbone = FEATURE_EXTRACTORS[backbone_name]() model = ProtoNet_MHLNBS(backbone=backbone).to(device) optimizer = OPTIMIZERS['adam'](model=model) base_sampler = FSLEpisodeSampler(subdataset=base_subdataset, n_way=train_n_way, n_shot=n_shot, batch_size=batch_size, balanced=balanced_batches) val_sampler = FSLEpisodeSampler(subdataset=val_subdataset, n_way=n_way, n_shot=n_shot, batch_size=val_batch_size, balanced=balanced_batches) loss_plotter = PlotterWindow(interval=1000) accuracy_plotter = PlotterWindow(interval=1000) loss_plotter.new_line('Loss') loss_plotter.new_line('Loss Instance') accuracy_plotter.new_line('Train Accuracy') accuracy_plotter.new_line('Validation Accuracy') losses = [] losses_i = [] acc_train = [] acc_val = [] val_iters = [] best_accuracy = 0 best_iteration = -1 print("Training started for parameters:") print(session_info) print() start_time = time.time() for iteration in range(n_iterations): model.train() support_set, batch = base_sampler.sample() # print(support_set.size()) query_set, query_labels = batch # print(query_set.size()) # print(global_classes_mapping) query_set = query_set.to(device) query_labels = query_labels.to(device) optimizer.zero_grad() output, loss, loss_i = model.forward_with_loss(support_set, query_set, query_labels) loss.backward() optimizer.step() labels_pred = output.argmax(dim=1) labels = query_labels cur_accuracy = accuracy(labels=labels, labels_pred=labels_pred) loss_plotter.add_point('Loss', iteration, loss.item()) loss_plotter.add_point('Loss Instance', iteration, loss_i.item()) accuracy_plotter.add_point('Train Accuracy', iteration, cur_accuracy) losses.append(loss.item()) losses_i.append(loss_i.item()) acc_train.append(cur_accuracy) if iteration % eval_period == 0 or iteration == n_iterations - 1: val_start_time = time.time() val_accuracy = evaluate_solution_episodes(model, val_sampler) accuracy_plotter.add_point('Validation Accuracy', iteration, val_accuracy) acc_val.append(val_accuracy) val_iters.append(iteration + 1) if val_accuracy > best_accuracy: best_accuracy = val_accuracy best_iteration = iteration print("Best evaluation result yet!") cur_time = time.time() val_time = cur_time - val_start_time time_used = cur_time - start_time time_per_iteration = time_used / (iteration + 1) print() print("[%d/%d] = %.2f%%\t\tLoss: %.4f" % ( iteration + 1, n_iterations, (iteration + 1) / n_iterations * 100, loss.item())) print("Current validation time: %s" % pretty_time(val_time)) print('Average iteration time: %s\tEstimated execution time: %s' % ( pretty_time(time_per_iteration), pretty_time(time_per_iteration * (n_iterations - iteration - 1)), )) print() cur_time = time.time() training_time = cur_time - start_time print("Training finished. Total execution time: %s" % pretty_time(training_time)) print("Best accuracy is: %.3f" % best_accuracy) print("Best iteration is: [%d/%d]" % (best_iteration + 1, n_iterations)) print() session_info['accuracy'] = best_accuracy session_info['best_iteration'] = best_iteration session_info['execution_time'] = training_time session = Session() session.build(name="ProtoNetMHLNBS", comment=r"ProtoNet with Mahalanobis distance Few-Shot Learning", **session_info) torch.save(model, os.path.join(session.data['output_dir'], "trained_model_state_dict.tar")) iters = list(range(1, n_iterations + 1)) plt.figure(figsize=(20, 20)) plt.plot(iters, losses, label="Loss") plt.plot(iters, losses_i, label="Loss Instance") plt.legend() plt.savefig(os.path.join(session.data['output_dir'], "loss_plot.png")) plt.figure(figsize=(20, 20)) plt.plot(iters, acc_train, label="Train Accuracy") plt.plot(val_iters, acc_val, label="Test Accuracy") plt.legend() plt.savefig(os.path.join(session.data['output_dir'], "acc_plot.png")) session.save_info()
def fit(self, support_set: torch.Tensor): self.n_classes = support_set.size(0) def transform(self, x: torch.Tensor): if len(x.size()) == 3: x = torch.unsqueeze(x, 0) self.n_query = x.size(0) prob = F.softmax(torch.rand(self.n_query, self.n_classes), dim=1) if prob.size(0) == 1: prob = torch.squeeze(prob, 0) return prob if __name__ == '__main__': best_model = RandomClassifier() session_info = { "task": "few-shot learning", "model": "RANDOM", } session = Session() session.build(name="RANDOM", comment=r"RANDOM classifier", **session_info) torch.save( best_model, os.path.join(session.data['output_dir'], "trained_model_state_dict.tar")) session.save_info()
#!/usr/bin/env python3 import argparse from sessions import Session def handle_arguments(): """ :return: commandline arguments """ info = "usage: give port number and target host as commandline arguments." parser = argparse.ArgumentParser(description=info) parser.add_argument("mode", help="Usage mode 'client' or 'proxy'", type=str) parser.add_argument("udp_port", help="Port to listen on client.", type=int) parser.add_argument("target_host", help="Target hosts address.") args = parser.parse_args() return args if __name__ == '__main__': args = handle_arguments() mode = args.mode host = args.target_host udp_port = args.udp_port session = Session(udp_port, host, mode)