def login_post(): # request parsing as json email = request.form.get('email') password = request.form.get('password') remember = True if request.form.get('remember') else False current_app.logger.info("Login action called") try: user = rpc.user_service.getUserByEmailAndPassword(email,password) current_app.logger.info("user fetched from UserService: ",user) userLoaded = User(user_dict=user) #print(userLoaded.user_dict) if user: login_user(userLoaded, remember=remember) session.permanent = True else: return ApiResponse(result=AuthenticationErrors.LoginFailureError.get('message'), status=AuthenticationErrors.LoginFailureError.get('status'), error=nameof(AuthenticationErrors.LoginFailureError)) # return redirect(url_for('auth.signup')) except UserNotFoundException: return ApiResponse(result=AuthenticationErrors.UserNotFoundError.get('message'), status=AuthenticationErrors.UserNotFoundError.get('status'), error=nameof(AuthenticationErrors.UserNotFoundError)) except UserServiceException as ex: return ApiResponse(result=GeneralErrors.InternalServerError.get('message'+ex.msg), status=GeneralErrors.InternalServerError.get('status'), error=ex.errors) except Exception as ex: return returnErrorResponse(ex) return ApiResponse(status=200, result="You have been logged in")
def test_nameof_statements(): a = {'test': 1} test = {} del a[nameof(test)] assert a == {} def func(): return nameof(test) assert func() == 'test' def func2(): yield nameof(test) assert list(func2()) == ['test'] def func3(): raise ValueError(nameof(test)) with pytest.raises(ValueError) as verr: func3() assert str(verr.value) == 'test' for i in [0]: assert nameof(test) == 'test' assert len(nameof(test)) == 4
def test_nameof_expr(): test = {} assert len(varname_module.nameof(test)) == 4 lam = lambda: 0 lam.a = 1 with pytest.raises(VarnameRetrievingError) as vrerr: varname_module.nameof(test, lam.a) assert str(vrerr.value) == ("Only variables should " "be passed to nameof.")
def test_nameof(): a = 1 b = nameof(a) assert b == 'a' nameof2 = nameof c = nameof2(a, b) assert b == 'a' assert c == ('a', 'b') def func(): return varname() + 'abc' f = func() assert f == 'fabc' assert nameof(f) == 'f' assert 'f' == nameof(f) assert len(nameof(f)) == 1 fname1 = fname = nameof(f) assert fname1 == fname == 'f' with pytest.raises(VarnameRetrievingError): nameof(a == 1) with pytest.raises(VarnameRetrievingError): nameof()
def export_info(df): strfile = '../data/' + str(nameof(df)) + '_info.txt' buffer = io.StringIO() df.info(buf=buffer) info = buffer.getvalue() with open(strfile, "a", encoding="utf-8") as f: f.write(info) f.close strfile = str(nameof(df)) + '_desc.csv' print(df.describe().to_csv(strfile)) strfile = str(nameof(df)) + '_freq.csv' df.to_csv(strfile)
async def insert_network_entity(self, _id, elem): ne_dict = asdict(elem) # Prepare dict for upsert del ne_dict[nameof(elem.parent)] del ne_dict[nameof(elem.port)] del ne_dict[nameof(elem.category)] del ne_dict[nameof(elem._id)] # Infers collection name c = self.collection_map[type(elem)] # Data to insert categories = [elem.category] ports = [elem.port] # Forms query, if IP address is present if elem.ip: query = {'ip': elem.ip} # Forms query, if there is only a hostname else: query = {'hostname': elem.hostname} # Define insertion insertion = { '$set': ne_dict, '$push': { 'parents': asdict(elem.parent), }, '$addToSet': { # do not add duplicates 'category': { '$each': categories }, 'port': { '$each': ports } } } # Upsert -> modify existing, ReturnDocument.AFTER is necessary to retrieve ObjectID for net yet existing doc update_result = await self.db[c.value].find_one_and_update( query, insertion, upsert=True, return_document=ReturnDocument.AFTER) _id = update_result['_id'] return _id
def signup_post(): try: user,errors = userSchema.load(request.get_json()) if errors: raise (ValidationFailException(errors,"Validation Failed")) user = rpc.user_service.getUserByEmail(user['email']) if user: # if a user is found, we want to redirect back to signup page so user can try again return ApiResponse(result=AuthenticationErrors.UserAlreadyExistsError.get('message'), status=AuthenticationErrors.UserAlreadyExistsError.get('status'), error=nameof(AuthenticationErrors.UserAlreadyExistsError)) # return redirect(url_for('auth.signup')) except UserNotFoundException: try: print(user) rpc.user_service.createUser(user) except Exception as ex: return returnErrorResponse(ex) except ValidationFailException as ex: return ApiResponse(result=GeneralErrors.ValidationError.get('message'), status=GeneralErrors.ValidationError.get('status'), error=ex.errors) except UserServiceException as ex: return ApiResponse(result=GeneralErrors.InternalServerError.get('message'+ex.msg), status=GeneralErrors.InternalServerError.get('status'), error=ex.errors) except Exception as ex: return returnErrorResponse(ex) return ApiResponse(status=200, result="Your account is created now")
def process_features(datasets): """ Parameters: 1. datasets - an array of your datasets. eg: [yishun, changi, tuassouth] What this function does: 1. Initially, the variables are in the first row of the dataframe. The column names is an np.arange(). Hence, we set the variables (eg: Year, Mean Wind Speed, Minimum Temperature,...) as the index. 2. We replace '—' and '-' with NumPy's NaN. 3. Initially, the numeric features (eg: Temperature, Wind Speed,...) were strings. Hence, we change them into floats. """ numeric_features = [ 'Year', 'Month', 'Day', 'Daily Rainfall Total (mm)', 'Highest 30 min Rainfall (mm)', 'Highest 60 min Rainfall (mm)', 'Highest 120 min Rainfall (mm)', 'Mean Temperature (°C)', 'Maximum Temperature (°C)', 'Minimum Temperature (°C)', 'Mean Wind Speed (km/h)', 'Max Wind Speed (km/h)' ] for dataset in datasets: dataset = dataset.reset_index().drop("index", axis=1) dataset.replace(['—', '-'], np.nan, inplace=True) dataset[numeric_features] = dataset[numeric_features].apply( pd.to_numeric) dataset.to_csv("{}.csv".format(nameof(dataset))) return
async def btn_coroutine(device): async for event in device.async_read_loop(): buttonEvent = rt_btn.ButtonEvent(event) if (buttonEvent.name, buttonEvent.value) == (rt_btn.ButtonName.F1, 1): pnp_client.f1Button.value = "click" await pnp_client.send_telemetry(nameof(pnp_client.f1Button)) if (buttonEvent.name, buttonEvent.value) == (rt_btn.ButtonName.F2, 1): pnp_client.f2Button.value = "click" await pnp_client.send_telemetry(nameof(pnp_client.f2Button)) if (buttonEvent.name, buttonEvent.value) == (rt_btn.ButtonName.F3, 1): pnp_client.f3Button.value = "click" await pnp_client.send_telemetry(nameof(pnp_client.f3Button)) if (buttonEvent.name, buttonEvent.value) == (rt_btn.ButtonName.O, 1): pnp_client.oButton.value = "click" await pnp_client.send_telemetry(nameof(pnp_client.oButton))
async def revoke_indication(self, ctx, *players: discord.Member): contestant_names = load_variable(ctx.guild, 'contestant_names') for player in players: if player.display_name in contestant_names: contestant_names.remove(player.display_name) else: await ctx.send(f'```{player.display_name} is not indicated```') save_variable(ctx.guild, contestant_names, nameof(contestant_names)) await ctx.send("```list updated```")
async def insert_url(self, _id, elem): url_dict = asdict(elem) # Prepare dict for upsert url_dict.pop(nameof(elem.parent)) url_dict.pop(nameof(elem.extractions)) url_dict.pop(nameof(elem._id)) url_dict.pop(nameof(elem.exploits)) # Prepare elements to append extractions = [asdict(e) for e in elem.extractions] exploits = elem.exploits # Retrieve collection name c = self.collection_map[type(elem)] # Forms query query = {'url': elem.url} # Define insertion insertion = { '$set': url_dict, '$push': { 'parents': asdict(elem.parent), }, '$addToSet': { # do not add duplicates 'exploits': { '$each': exploits }, 'extractions': { '$each': extractions } } } # Upsert -> modify existing, ReturnDocument.AFTER is necessary to retrieve ObjectID for net yet existing doc update_result = await self.db[c.value].find_one_and_update( query, insertion, upsert=True, return_document=ReturnDocument.AFTER) _id = update_result['_id'] return _id
def ctd_(sequence, property=ctd_properties[nameof(hydrophobicity)], all_ctd=True): """ Calculate Composition, transition and distribution (CTD) features of protein sequences. Composition is the number of amino acids of a particular property (e.g., hydrophobicity) divided by the total number of amino acids in a protein sequence. Transition characterizes the percent frequency with which amino acids of a particular property is followed by amino acids of a different property. Distribution measures the chain length within which the first, 25%, 50%, 75%, and 100% of the amino acids of a particular property are located, respectively [6]. CTD functionality in the PyBioMed package uses the properties: Polarizability, Solvent Accessibility, Secondary Structure, Charge, Polarity, Normalized VDWV, Hydrophobicity. The output will be of shape N x 147 where N is the number of protein sequences. 21/147 will be composition, 21/147 will be transition and the remaining 105 are distribution. Returns ------- :ctd_df : pd.DataFrame dataframe of CTD descriptor values for all protein sequences. DataFrame will be of the shape N x 147, where N is the number of protein sequences and 147 is the number of features calculated from the descriptors. """ #check input sequence is a string, if not raise type error if not isinstance(sequence, str): raise TypeError( 'Input sequence must be a string, got input of type {}'.format( type(sequence))) #initialise ctd dataframes comp_df = pd.DataFrame() trans_df = pd.DataFrame() distr_df = pd.DataFrame() #if using single property, calculate each of the CTD descriptors individually if not all_ctd: comp_df = ctd_composition(sequence, property=property) trans_df = ctd_transition(sequence, property=property) distr_df = ctd_distribution(sequence, property=property) else: #if using all calculable properties, calculate CTD descriptors for each property for prop in ctd_properties: comp = ctd_composition(sequence, property=ctd_properties[prop]) comp_df = pd.concat([comp_df, comp], axis=1) trans = ctd_transition(sequence, property=ctd_properties[prop]) trans_df = pd.concat([trans_df, trans], axis=1) distr = ctd_distribution(sequence, property=ctd_properties[prop]) distr_df = pd.concat([distr_df, distr], axis=1) #concatenate all descriptors ctd = pd.concat([comp_df, trans_df, distr_df], axis=1) return ctd
async def insert_file(self, elem): _id = await self.insert_gridfs(elem.hash.sha256, elem.blob, metadata={"contentType": elem.encoding}) elem.file_id = _id # Store file metadata in file collection file_dict = asdict(elem) # Removing unused fields del file_dict[nameof(elem.blob)] del file_dict[nameof(elem.encoding)] del file_dict[nameof(elem.parent)] del file_dict[nameof(elem.filename)] del file_dict[nameof(elem._id)] # Performs insertion (which is done by updating an eventually existing entry) c = self.collection_map[type(elem)] # Defines query query = {'hash': asdict(elem.hash)} # Updates file entry by appending filenames, parents and communicating hosts insertion = { '$set': file_dict, '$push': { 'parents': asdict(elem.parent), }, '$addToSet': { # do not add duplicates 'filename': elem.filename } } # Upsert -> modify existing, ReturnDocument.AFTER is necessary to retrieve ObjectID for net yet existing doc update_result = await self.db[c.value].find_one_and_update( query, insertion, upsert=True, return_document=ReturnDocument.AFTER) _id = update_result['_id'] return _id
def get_search(event): global buffer query = buffer[ event.user_id] if buffer[event.user_id] != '' else event.text choise = random.randint(1, 2) if choise == 1: channel = HUMORESKI name = nameof(HUMORESKI) elif choise == 2: channel = ANEC_CATEGORY_B name = nameof(ANEC_CATEGORY_B) text, found_count = search_post(channel, query) print(query + text) vk_bot.messages.send(user_id=event.user_id, message=text, random_id=0) add_text = f'у {name} есть еще {found_count} анеков на эту тему....' vk_bot.messages.send(user_id=event.user_id, message=add_text, keyboard=set_buttons_reactions(no='ХВАТИТ', yes='ЕЩЁ'), random_id=0) buffer[event.user_id] = query
async def send_telemetry_acceleration_loop(): while True: if "x" in acceleration and "y" in acceleration and "z" in acceleration: print("Sending telemetry for acceleration.") pnp_client.acceleration.value = { "x": acceleration["x"], "y": acceleration["y"], "z": acceleration["z"], } await pnp_client.send_telemetry(nameof(pnp_client.acceleration)) await asyncio.sleep(telemetry_interval)
async def indicate_player(self, ctx, *players: discord.Member): """Indicates a player or multiple player for the elimination contest""" try: contestant_names = load_variable(ctx.guild, 'contestant_names') except FileNotFoundError: contestant_names = [] for player in players: if player.display_name in contestant_names: pass else: contestant_names.append(player.display_name) save_variable(ctx.guild, contestant_names, nameof(contestant_names)) await ctx.send('Players set as contestants for elimination')
def comprobS(self, rest, rnum): cont_a = [0 for x in rest.cont] cont_b = [0 for x in rest.cont] for i in self.clases: for j in range(len(rest.cont)): if isinstance(rest.cont[j], varP): aux = i.get_var(rest.cont[j].value) cont_a[j] = aux(i) cont_b[j] = nameof(cont_a) + "[" + str(j) + "]" else: cont_b[j] = str(rest.cont[j]) self.evalSoft[rnum] += eval(" ".join(cont_b)) Estado.repet = []
def connect(host=None, user=None, password=None, database=None): if not all(isinstance(i, str) for i in [host, user, password, database ]): # Handle Argument Errors print("\n\n") for argumentname, argumentdata in zip( [nameof(host), nameof(user), nameof(password), nameof(database)], [host, user, password, database]): if not isinstance(argumentdata, str): print( f"mySQEasyDB Syntax Error (2001, Connection Error): {argumentname} needs to be a string." ) if debug: print(f"\n\nMaking connection to {user}@{host} in {database}..") try: global db db = mysql.connector.connect( host=host, user=user, password=password, database=database, ) global cursor cursor = db.cursor(prepared=True) global selectionCursor selectionCursor = db.cursor(buffered=True) except mysql.connector.Error as error: if debug: print( f"\n\nmySQEasyDB mySQL Error: {error}\n\nEnsure you have entered the correct database information and your database is running.\n\n" ) exit() else: if debug: print(f"Successfully connected to {db.database}!\n\n")
def test_nested_print(self): snarg = dict() snarg[100] = 300 snarg["AA"] = "BB" piffle = dict() piffle[10] = 30 piffle["A"] = "B" piffle["C"] = snarg blarvitz = dict() blarvitz[1] = 3 blarvitz["a"] = "b" blarvitz["c"] = piffle assert (f.nested_print(nameof(blarvitz), blarvitz)) == '''blarvitz[1] = 3
def comprobH(self, rest, rnum): cont_a = [0 for x in rest.cont] cont_b = [0 for x in rest.cont] for i in range(len(self.clases)): for j in range(len(rest.cont)): if isinstance(rest.cont[j], varP): aux = self.clases[i].get_var(rest.cont[j].value) cont_a[j] = aux(self.clases[i]) cont_b[j] = nameof(cont_a) + "[" + str(j) + "]" else: cont_b[j] = str(rest.cont[j]) if eval(" ".join(cont_b)): self.evalHard[rnum] -= rest.risk.value self.clasesOK[i] += 1 Estado.repet = []
async def insert_generic(self, _id, elem): # Infers collection name c = self.collection_map[type(elem)] # Prepare dict to insert elem_dict = asdict(elem) # Removes _id, which is null until now and leads to DuplicateKeyError del elem_dict[nameof(elem._id)] # Inserts doc result = await self.db[c.value].insert_one(elem_dict) # Retrieves MongoDB-ID _id = result.inserted_id return _id
def run(directory: str, priority: int) -> None: """ The method for starting of the Service Uploader. """ file_paths = [] metadata = {} # забрать все пути к файлам из директории all_file_paths_in_directory = get_files_from_dir(directory) file_paths.extend(all_file_paths_in_directory) print(file_paths) # метаданные # сформировать словарь # прокинуть данные в json priority_key = nameof(priority) metadata[priority_key] = priority metadata_file_path = os.path.join(BUCKET, "metadata.txt") with open(metadata_file_path, 'w') as metadata_writer: json.dump(obj=metadata, fp=metadata_writer)
def gen_tokens( text: Union[str, List[str]], label: str = "", lang: Optional[str] = None, gen_para: Union[int, bool] = False, gen_sent: Union[int, bool] = True, gen_phrase: Union[int, bool] = False, ) -> Iterator[Tuple[str, str, int, str]]: # fmt: on """Genereate tokens from text/list of text.""" if isinstance(text, str): text = [elm.strip() for elm in text.splitlines() if elm.strip()] try: label = label.strip() except Exception: label = "" if not label.strip(): label = nameof(text) if lang is None: lang = Detector(" ".join(text)).language.code logger.debug("Deteced lang: %s", lang) if gen_para: for idx, para in enumerate(text): yield para, label, idx + 1, 'para' if gen_sent: for idx, para in enumerate(text): for sent in _sent_tokenizer(para, lang): yield sent, label, idx + 1, 'sent' if gen_phrase: for idx, para in enumerate(text): for sent in _sent_tokenizer(para, lang): raise Exception("need to install phrase_tokenizer" "which is dependant of benepar")
"2": "RKQEND", "3": "MPSTHY" } # '1' -> Buried; '2' -> Exposed, '3' -> Intermediate polarizability = { "name": "polarizability", "1": "GASDT", "2": "CPNVEQIL", "3": "KMHFRYW" } # '1' -> (0-0.108); '2' -> (0.128-0.186), '3' -> (0.219-0.409) #object of physiochemical properties to use for calculating CTD descriptors ctd_properties = { nameof(hydrophobicity): hydrophobicity, nameof(normalized_VDWV): normalized_VDWV, nameof(polarity): polarity, nameof(charge): charge, nameof(sec_struct): sec_struct, nameof(solvent_accessibility): solvent_accessibility, nameof(polarizability): polarizability } def str_to_num(sequence, property): """ Convert sequences str to number from input physiochemical property. Parameters ----------
a = 3 b = 2 names = [ "Exponent", "Modulus", "Integer Division", "Division", "Multiplication", "Subtraction", "Addition" ] print(a**b, "\t", names[0], " ", a, " ", b) print(a % b, "\t", names[1], " ", a, " ", b) print(a // b, "\t", names[2], " ", a, " ", b) print(a / b, "\t", names[3], " ", a, " ", b) print(a * b, "\t", names[4], " ", a, " ", b) print(a - b, "\t", names[5], " ", a, " ", b) print(a + b, "\t", names[6], " ", a, " ", b) print("The String replicator\t" * 2) print("Hello world!!!\nWhat is your name? ") myname = input() print("Ah ACK!! ", myname) from varname import nameof print("Length of variable ", nameof(myname), " : ", len(myname)) print("String of variable ", nameof(myname), " : ", str(myname)) if myname.isdigit(): print("Integer of variable ", nameof(myname), " : ", int(myname)) if myname.isdecimal(): print("Float of variable ", nameof(myname), " : ", float(myname))
def main(argv): try: opts, cml_args = getopt.getopt( argv, "hmvi:o:s:", ["help", "verbose", "midpoint", "ifile=", "ofile=", "style="]) except getopt.GetoptError: usage() sys.exit(2) ifile = "" ofile = "" styles = [] verbose = False midpoint = False for opt, arg in opts: if opt in ("-h", "--help"): usage() sys.exit(0) elif opt in ("-v", "--verbose"): verbose = True elif opt in ("-m", "--midpoint"): midpoint = True elif opt in ("-i", "--ifile"): ifile = str(arg) elif opt in ("-o", "--ofile"): ofile = str(arg) elif opt in ("-s", "--style"): styles = str(arg).split(",") else: continue if arg in argv: argv.remove(arg) argv.remove(opt) if len(argv) != 0: usage() sys.exit(1) n, k, points = read_input(ifile) # DO NOT CALL ARGS DIRECTLY; FOR REFLECTION ONLY # Add values if you'd like functions to be able to call them args = { nameof(ifile): ifile, nameof(ofile): ofile, nameof(styles): styles, nameof(verbose): verbose, nameof(midpoint): midpoint, nameof(n): n, nameof(k): k, nameof(points): points } best = (sys.maxsize, None, None) for style in styles: cur_solution = available_solutions[style] cur_solution_sig = signature(cur_solution) cur_args = [] for param in cur_solution_sig.parameters.keys(): if param not in args: continue cur_args.append(args[param]) cur_clusters = cur_solution(*cur_args) cur_clusters_dict = gen_cluster_dict(cur_clusters, points) cur_clusters_dict = optimize_points(cur_clusters_dict) worst_cluster_distance = get_max_distance_cluster(cur_clusters_dict)[1] if worst_cluster_distance < best[0]: best = tuple( [worst_cluster_distance, cur_clusters_dict, cur_solution]) cluster_dict = best[1] cur_solution = best[2] point_count = 0 point_test = [] for v in cluster_dict.values(): for v1 in v: assert v1 in points point_count += 1 point_test.append(v1) assert len(point_test) == len(set(point_test)) assert point_count == len(points) free_clusters, cluster_dict = organize_clusters(cluster_dict, cur_solution) if free_clusters != 0: print( f"WARNING:: Inefficient use of clusters. {free_clusters} free clusters unused" ) # compute the maximum distance within the clusters worst_cluster_distance = get_max_distance_cluster(cluster_dict)[1] output = format_output(worst_cluster_distance, cluster_dict, points) if verbose: print(output) save_output(ofile, output)
# Flow Control a = True b = False from varname import nameof print("The value of \t", nameof(a), "\t", a) print("The value of \t", nameof(b), "\t", b) print("Now we will evaluate conditions....") operations = [ "Equal to", "Not Equal to", "Less than", "Greater than", "Less than or equal to", "Greater than or equal to" ] print(operations[0], "\t", a == b) print(operations[1], "\t", a != b) print(operations[2], "\t", a < b) print(operations[3], "\t", a > b) print(operations[4], "\t", a <= b) print(operations[5], "\t", a >= b) booleanoperations = ["and", "or", "not"] print(booleanoperations) #ERROR: Does not evaluate the or and not conditions for x in booleanoperations: # print(x) if (x == "and"):
async def _start_contest(self, ctx): contestant_names = load_variable(ctx.guild, 'contestant_names') on_the_hook = [Contestant(player, ctx.guild) for player in contestant_names] save_variable(ctx.guild, on_the_hook, nameof(on_the_hook))
async def reset_contestants(self, ctx): contestant_names = [] save_variable(ctx.guild, contestant_names, nameof(contestant_names)) await ctx.send('```Contestants reset```')
playerluck5 = Player5.luck playerStrength1 = Player1.strength playerStrength2 = Player2.strength playerStrength3 = Player3.strength playerStrength4 = Player4.strength playerStrength5 = Player5.strength # exclaListe = Exclamationsfinales # compListe = Complément # liaisonListe= Liaisons # sujetListe= sujet listTest = [ 'abaisser,aim:er,lower', 'abandonner,aim:er,abandon', 'abasourdir,fin:ir,stun', 'abâtardir,fin:ir,bastardize', 'abattre,bat:tre,tear down', 'abcéder,c:éder,abscess' ] nameWrap = nameof(listVerbs) def recupOneindiceVerbs(liste): newList = [] for i in range(0, 5): listeI = liste[random.randint(0, len(liste))] #print(listeI) indicevirgule = listeI.index(',') newList.append(listeI[0:indicevirgule]) #print(newList) return newList #recupOneindiceVerbs(listVerbs) def recupOneindice(liste):