def do_load(self, event): """Load a script file.""" dlg = wx.FileDialog(self, style = wx.FD_OPEN) if dlg.ShowModal() == wx.ID_OK: path = dlg.GetPath() else: path = None dlg.Destroy() if path: functions.load(path)
def save_question(q): try: data = load(QUESTIONS_FILENAME) except FileNotFoundError: data = [] data.append(q) save(QUESTIONS_FILENAME, data)
async def cringe_words(self, ctx): cringe_words = functions.load("cringe_word_list.json") words = "" for word in cringe_words: words += f"`{word}`, " await ctx.send(words)
def main(): ''' load record data load vehicle data show main menu ''' global debug, gui guiType = 0 try: opts, args = getopt.getopt(sys.argv[1:], "hdcg", ["help", "debug", "cli", "gtk"]) except getopt.GetoptError as err: # print help information and exit: print(err) # will print something like "option -a not recognized" usage() sys.exit(2) for o,a in opts: if o in ("-d", "--debug"): debug=True elif o in ("-c", "--cli"): guiType = 0 elif o in ("-g", "--gtk"): guiType = 1 elif o in ("-h", "--help"): usage() exit() else: assert False, "unhandled option" if debug: print('#### DEBUG MODE ####') if guiType == 0: gui = CLI() # elif guiType == 1: # gui = GUI() FN.load() for v in FN.vehicles: FN.fuel_graph(v) FN.ppl_graph() FN.index() gui.start()
async def remove_cringe_word(self, ctx, word=None): if not word: return await ctx.send("Include in a word maybe???") cringe_words = functions.load("cringe_word_list.json") try: cringe_words.remove(word) functions.save("cringe_word_list.json", cringe_words) await ctx.send(f"`{word}` removed from cringe word list!") except: await ctx.send(f"`{word}` not in cringe word list!")
async def add_cringe_word(self, ctx, word=None): if not word: return await ctx.send("Include in a word maybe???") cringe_words = functions.load("cringe_word_list.json") if word not in cringe_words: cringe_words.append(word) functions.save("cringe_word_list.json", cringe_words) await ctx.send(f"`{word}` added to cringe word list!") else: await ctx.send(f"`{word}` in cringe word list already!")
def feat_select(f): cp = load(read) (X, y, t) = cp.export_data(f) data = numpy.c_[X, y] cov = empirical_covariance(data, False) print cov for i in range(cov.shape[0] - 1): print cov[i, -1]
def process_audio( wav_file, length_in_seconds=12, ): array = process_track(load(wav_file)) n = array.shape[1] / length_in_seconds temp = [] tru_arr = np.transpose( array ) # because there are 128 arrays of frequencies for each timestamp we want arrays of 128 frequencies for each timestamp for i in range(0, length_in_seconds): temp.append(tru_arr[int(10 + (n * i))]) return np.asarray(temp)
def read_multiple_net(accounts, adr): data, ids, usernames, color = [], [], [], [] counter = 0 for acc in accounts: path = adr+'/'+acc #read data for current user raw_data = functions.load_json_list(path+'/'+acc+'_complete.txt') base_usernames = functions.load(path+'/'+acc+'_usernames.txt') base_ids = functions.load(path+'/'+acc+'_ids.txt') #substitution usernames with user ids for current user temp_data, temp_ids, temp_usernames = prepare_data(raw_data, base_ids, base_usernames) data, ids, usernames, color = update_data(data, ids, usernames, temp_data, temp_ids, temp_usernames, color) counter+=1 color = update_color(color, len(data), counter) return data, ids, usernames, color
async def cringenamecheck(self, ctx, profile): functions.log(ctx.guild.name, ctx.author, ctx.command) account = functions.check_account_existence_and_return(profile) if account: embed = functions.default_embed() cringe_check_list = functions.load("cringe_word_list.json") cringe_score = 0 cringe_rating = { 0: "Not cringe!", 1: "Maybe a little cringe?", 2: "Little cringe.", 3: "A bit cringe!", 4: "Cringe!", 5: "Quite cringe!", 6: "Very cringe!", 7: "Super cringe!", 8: "Incredibly cringe!", 9: "Ludicrously cringe!", 10: "THE CRINGIEST!" } display_name = functions.id_to_display_name(account['account_id']) cringe_words = [ ele for ele in cringe_check_list if (ele.casefold() in display_name.casefold()) ] cringe_score = len(cringe_words) * 2 for char in display_name: if not char.isalpha(): cringe_score += 1 cringe_words.append(char) if cringe_score > 10: cringe_score = 10 embed.add_field(name=f"{account['username']}'s display name:", value=f"```{display_name}```") embed.add_field( name="Cringe score", value=f"`{cringe_score}` ({cringe_rating[cringe_score]})", inline=False) flags = "" for flag in cringe_words: flags += f"`{flag}`, " if flags: embed.add_field( name="Flags", value= f"||{flags}||\nThis command is just for fun, and not meant to shame anybody!", inline=False) pfp = functions.id_to_pfp(account['account_id'], True) embed.set_author(name=f"🔗 {account['username']}'s profile", url=f"https://rec.net/user/{account['username']}", icon_url=pfp) else: embed = functions.error_msg(ctx, f"User `@{profile}` doesn't exist!") functions.embed_footer(ctx, embed) # get default footer from function await ctx.send(embed=embed)
async def cringebiocheck(self, ctx, profile): functions.log(ctx.guild.name, ctx.author, ctx.command) account = functions.check_account_existence_and_return(profile) if account: bio = functions.get_bio(account['account_id']) pfp = functions.id_to_pfp(account['account_id'], True) print( f"{ctx.command} > {account['account_id']}, {account['username']}, {bio}, {pfp}" ) embed = functions.default_embed() embed.add_field(name=f"{account['username']}'s bio:", value=f"```{bio}```") flags = "" cringe_check_list = functions.load("cringe_word_list.json") cringe_score = 0 cringe_rating_dict = { 0: "Not cringe!", 1: "A little cringe!", 2: "Cringe!", 3: "Very cringe!", 4: "Yikes..!", 5: "Radically cringe!", 6: "Super cringe!", 7: "Mega cringe!", 8: "Ultra cringe!", 9: "THE CRINGIEST!", 10: "All hope for humanity has been lost!" } if bio: split_bio = bio.split(" ") for word in split_bio: for flag in cringe_check_list: if flag.casefold() in word.casefold(): cringe_score += 1 flags += f"`{flag}`, " if cringe_score > len(cringe_rating_dict) - 1: cringe_rating = cringe_rating_dict[len(cringe_rating_dict) - 1] else: cringe_rating = cringe_rating_dict[cringe_score] embed.add_field(name="Cringe score", value=f"`{cringe_score}` ({cringe_rating})", inline=False) if flags: embed.add_field( name="Flags", value= f"||{flags}||\nThis command is just for fun, and not meant to shame anybody!", inline=False) embed.set_author(name=f"🔗 {account['username']}'s profile", url=f"https://rec.net/user/{account['username']}", icon_url=pfp) else: embed = functions.error_msg(ctx, f"User `@{profile}` doesn't exist!") functions.embed_footer(ctx, embed) # get default footer from function await ctx.send(embed=embed)
import discord import os import functions from discord.ext.commands import CommandNotFound from discord.ext import commands config = functions.load("config.json") client = discord.Client() # Setting up #intents = discord.Intents(messages = True, guilds = True, reactions = True, members = True, presences = True) #client = commands.Bot(command_prefix = '.', intents = intents, help_command=None, case_insensitive=True) client = commands.Bot(command_prefix=config['prefix'], help_command=None, case_insensitive=True) # When bot online @client.event async def on_ready(): print("Bot is ready!") print('Servers connected to:') print(f"Servers: {len(client.guilds)}") for guild in client.guilds: print(f"-{guild.name}") print(f"{guild.owner}") print(f"Members: {len(guild.members)}\n") await client.change_presence( status=discord.Status.online, activity=discord.Game(".help | bit.ly/RecNetBot"))
user = '******' alfa = 0.4 extracting_weights = False plot = True disjoint = False bc_analysis = False cc_analysis = False jsc = False sdi = False entropy = False w = [0.2, 0.5, 0.3] #ret, qt, rep path = 'EGOS DIRECTORY' + user raw_data = functions.load_json_list(path + '/' + user + '_complete.txt') base_usernames = functions.load(path + '/' + user + '_usernames.txt') base_ids = functions.load(path + '/' + user + '_ids.txt') data, ids, usernames = info_diff_func.prepare_data(raw_data, base_ids, base_usernames) print("\n===========", user, "===========\n") #creating adjacency matrix adj = info_diff_func.adjacency(ids, data) #a simple directed graph using networkx G = info_diff_func.simple_graph(adj) #extracting links one_way, two_way = info_diff_func.links(adj)
print('Number of all datapoints:', all_numb) print('Percentage of positive: ', positive / all_numb * 100) print('Percentage of neutral: ', neutral / all_numb * 100) print('Percentage of negative: ', negative / all_numb * 100) # words print('') words = dataset.text.values words = strip_punctuation(words).split() print('Unique words in dataset: ', len(np.unique(words))) # plots for NN grid = load('grid-search') histories = load('histories') plt.clf() plt.figure(figsize=(5, 15)) batch_sizes = [8, 64, 128, 256] learning_rates = [0.1, .05, 0.01, 0.001] plt.figure(figsize=(15, 10)) plt.title('Neural Network accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') for history in histories: plt.plot(history.history['val_acc'], alpha=1) # plt.plot(history.history['acc'], alpha=0.8) labels = ['size=100', 'size=500', 'size=1000']
PickOne = StartIndex[0, TestNumber] + DifferentOne X_test, y_test = X_test_cand[PickOne, :], y_test_cand[PickOne] mean_vals = np.mean(X_train, axis=0) std_val = np.std(X_train) X_train_centered = (X_train - mean_vals) / std_val X_valid_centered = X_valid - mean_vals X_test_centered = (X_test - mean_vals) / std_val del X_data, y_data, X_train, X_valid, X_test g2 = tf.Graph() with g2.as_default(): tf.set_random_seed(random_seed) func.build_cnn() saver = tf.train.Saver() with tf.Session(graph=g2) as sess: func.load(saver, sess, epoch=2, path='./model/') for index, i in enumerate(X_test_centered): print('No.', index, ' Start!') StartThreshold = 0.05 NumberOfImage = 14 threshold = [i * 0.05 + StartThreshold for i in range(NumberOfImage)] for j in threshold: correct, probabilities = TraceBack([i], [y_test[index]], TestNumber[index], \ index, j, ShowNotSave=False) print('correct? :\n', correct[0], '\nprobabilities :\n', probabilities, '\n\n')
def evaluate_config(ext_algo, reg_algo, sum_algo, red_algo, tradeoff, word_len, max_sent, f): features = [] for i in f.keys(): if f[i][1] == True: features.append(f[i][0]) features = "-".join(features) idx = [] for x in f.keys(): if f[x][1] == True: idx.append(x) idx = sorted(idx) d_name = gen_name(ext_algo, reg_algo, red_algo, sum_algo) w2v_model = None if red_algo == "w2v" or red_algo == "cnn": print "\nLoading w2v model..." w2v_path = "../sentiment-mining-for-movie-reviews/Data/GoogleNews-vectors-negative300.bin" w2v_model = Word2Vec.load_word2vec_format(w2v_path, binary=True) # C binary format print "\nLearn..." cp = load(read) (X, y, t) = cp.export_data(f) w = learn_relevance(X, y, reg_algo) print "\nInfo..." print "train shape: ", X.shape print "number of test collections: ", len(t) print "\nGenerate..." # sample_lead_1 = multi_lead(cp.collections['d301i'+'2005'], word_len, max_sent) # sample_lead_2 = multi_lead(cp.collections['D0601A'+'2006'], word_len, max_sent) # sample_regr = rel_summarize(cp.collections['d301i'+'2005'], w, word_len, max_sent, idx) # sample_mmr = mmr_summarize(cp.collections['d301i'+'2005'], w, ext_algo, red_algo, word_len, max_sent, tradeoff, idx) print "\nPrinting sample lead / regression..." # plot_summary(sample_lead_1) # plot_summary(sample_lead_2) # plot_summary(sample_regr) # plot_summary(sample_mmr) if store_test: print "\nGenerating summaries for test collections" os.mkdir(d_name) out_file = open(d_name + "/configurations", "w") out_file.write("features: " + features + "\next_algo: " + ext_algo + "\nsum_algo: " + sum_algo) if sum_algo != "lead": out_file.write("\nregression_algo: " + reg_algo) if sum_algo == "mmr": out_file.write("\nred_algo: " + red_algo + "\ntradeoff: " + str(tradeoff)) start = time.time() for c in t: if sum_algo == "lead": summ = multi_lead(c, word_len, max_sent) out_file = open(d_name + "/" + c.code.lower() + "_" + sum_algo, "w") elif sum_algo == "rel": summ = rel_summarize(c, w, word_len, max_sent, idx) out_file = open(d_name + "/" + c.code.lower() + "_" + reg_algo + "-" + sum_algo, "w") elif sum_algo == "mmr": summ = mmr_summarize(c, w, ext_algo, red_algo, word_len, max_sent, tradeoff, idx, w2v_model) out_file = open(d_name + "/" + c.code.lower() + "_" + reg_algo + "-" + sum_algo + "-" + red_algo, "w") else: raise Exception("sum_algo: Invalid algorithm") if human_inspect: out_file.write("TOPIC\n") out_file.write(c.code + "; " + c.topic_title) out_file.write("\n\nDESCRIPTION\n") out_file.write(c.topic_descr) out_file.write("\n\nSUMMARY\n") for s in summ: out_file.write(s + "\n") out_file.close() print "summarize and store, test collections: %f seconds" % (time.time() - start)
def generate(piano, flute, out_path): write_wav(out_path, combine(load(piano), load(flute)), 40000)
def get_metrics_from_file(file): counts = { 'atss_count': atss.ATSS(load(file)).count(), 'bloc_count': bloc.BLOC(load(file)).count(), 'bloc_count_rel': bloc.BLOC(load(file)).count(relative=True), 'cloc': cloc.CLOC(load(file)).count(), 'cloc_count_rel': cloc.CLOC(load(file)).count(relative=True), 'dpt_count': dpt.DPT(load(file)).count(), 'etp_count': etp.ETP(load(file)).count(), 'loc_count': loc.LOC(load(file)).count(), 'nbeh_count': nbeh.NBEH(load(file)).count(), 'nbeh_count_rel': nbeh.NBEH(load(file)).count(relative=True), 'nbl': nbl.NBL(load(file)).count(), 'ncmd': ncmd.NCMD(load(file)).count(), 'ndk_count': ndk.NDK(load(file)).count(), 'ndk_occurrences': ndk.NDK(load(file)).count(occurrences=True), 'ndm': ndm.NDM(load(file)).count(), 'ndm_occurrences': ndm.NDM(load(file)).count(occurrences=True), 'nemd_count_rel': nemd.NEMD(load(file)).count(relative=True), 'nfl_count': nfl.NFL(load(file)).count(), 'nfmd_count': nfmd.NFMD(load(file)).count(), 'nfmd_count_rel': nfmd.NFMD(load(file)).count(relative=True), 'nicd_count': nicd.NICD(load(file)).count(), 'nierr_count': nierr.NIERR(load(file)).count(), 'nimpr_count': nimpr.NIMPR(load(file)).count(), 'nimpt_count': nimpt.NIMPT(load(file)).count(), 'ninc_count': ninc.NINC(load(file)).count(), 'nincr_count': nincr.NINCR(load(file)).count(), 'ninct_count': ninct.NINCT(load(file)).count(), 'nincv_count': nincv.NINCV(load(file)).count(), 'nlk_count': nlk.NLK(load(file)).count(), 'nlo_count': nlo.NLO(load(file)).count(), 'nlp_count': nlp.NLP(load(file)).count(), 'nmd_count': nmd.NMD(load(file)).count(), 'nnnv_count_rel': nnnv.NNNV(load(file)).count(relative=True), 'nnwv_count': nnwv.NNWV(load(file)).count(), 'nnwv_count_rel': nnwv.NNWV(load(file)).count(relative=True), 'nsh_count': nsh.NSH(load(file)).count(), 'ntnn_count': ntnn.NTNN(load(file)).count(), 'ntun_count_rel': ntun.NTUN(load(file)).count(relative=True), 'nun_count_rel': nun.NUN(load(file)).count(relative=True) } return counts
import os import wx import teamsframe import quizframe from functions import load app = wx.App() if os.path.exists(quizframe.HISTORY_FILENAME) and os.path.isfile( quizframe.HISTORY_FILENAME): history = load(quizframe.HISTORY_FILENAME) frame = quizframe.QuizFrame(history) else: frame = teamsframe.TeamsFrame() frame.Show() app.MainLoop()
""" HangManGame """ print " HangManGame, by PythonSnake" print " 0.1 Beta Version " #import modules import values import random import functions username=raw_input("Hi. What's your name ? ") score=0 if functions.load(values.savefile)!=False and username in functions.load(values.savefile).keys(): s=functions.load(values.savefile) score+=s[username] print "I remember ya ! You had {0} points !".format(s[username]) functions.menu() print "Guess the word ! You have 8 tries only though." answer='y' while answer.lower()[0]=='y': #declaring variables count=0 i=random.randrange(113810) word_to_guess=values.words[i]
reactor = wxreactor.install() import log application.log_object = log.LogObject(application.name) parser = argparse.ArgumentParser(prog = application.name, description = 'A (very) basic command line MUD client.') if not hasattr(parser, 'version'): parser.add_argument('-v', '--version', action = 'version', version = application.version, help = 'Show version information') else: parser.version = application.version parser.add_argument('-l', '--log-file', metavar = 'file', type = argparse.FileType('w'), default = sys.stdout, help = 'The log file.') parser.add_argument('-L', '--log-level', metavar = 'level', choices = ['debug', 'info', 'warning', 'warning', 'error', 'critical'], default = 'info', help = 'Log level') parser.add_argument('file', nargs = '?', help = 'File to load commands from') args = parser.parse_args() logging.basicConfig(stream = args.log_file, level = args.log_level.upper()) logger = logging.getLogger() import connection, command_parser, functions, wx, gui reactor.addSystemEventTrigger('after', 'shutdown', logger.debug, 'Reactor shutdown.') application.factory = connection.MyClientFactory() application.app = wx.App() reactor.registerWxApp(application.app) gui.MainFrame() reactor.addSystemEventTrigger('after', 'shutdown', application.frame.Close, True) application.frame.Show(True) application.frame.Maximize() if args.file: functions.load(args.file) reactor.run() try: application.log_object.flush() except Exception as e: logger.exception(e)
from text_colors import RED, GREEN, BLUE, CYAN, RESET # grabs color variables import kshell_exceptions as err # This is the non-formatted version of the search # command's success string. The curly braces represent # empty spaces which can be formatted with format() search_success_string = '''{}An instance of {}"{}"{} was found in {}"{}"{}! ''' # is_running is set to False when 'exit' is typed is_running = True echo_mode = False version = "0.41 (In-Dev)" fn.load() txt.print_magenta(f"KShell Version {version}") txt.print_magenta( "Echo mode is currently set to false; to turn it on, type 'echo-mode true'." ) txt.print_magenta("To turn echo mode off, type 'echo-mode false'.") txt.print_cyan( "Written in Python 3. Make sure to run with Python 3.6 (preferably 3.7) or higher." ) txt.print_magenta( "Please enjoy! Report any bugs (Traceback errors, etc.) to [email protected]." ) txt.print_magenta("See the documentation or type 'help' for more information.") # while is_running is True, it loops while is_running: # This is the prompt at which the user enters commands