def crawlAnalyze(self): try: self.Analyzer = Analyze.UnionFile('Comment.csv', 'Likelist.csv', 'ClubMember.csv') self.Analyzer.InitSet() self.Analyzer.Union() self.Analyzer.Diff() self.Analyzer.PrintSet() self.Analyzer.WriteFile() except: try: tmpfile3fd = open('ClubMember.csv', 'r') tmpfile3fd.close() except: #print('缺少社團成員名單,開始爬社團成員') self.crawlClubList() try: tmpfile1fd = open('Comment.csv', 'r') tmpfile2fd = open('Likelist.csv', 'r') tmpfile1fd.close() tmpfile2fd.close() except: #print('缺少Post,開始爬留言按讚...') self.crawlPost() #print('重新開始分析潛水名單...') self.Analyzer = Analyze.UnionFile('Comment.csv', 'Likelist.csv', 'ClubMember.csv') self.Analyzer.InitSet() self.Analyzer.Union() self.Analyzer.Diff() self.Analyzer.PrintSet() self.Analyzer.WriteFile()
def insert_data_markov(sentence_id,sentence, channel_id): # データベースInstanceの作成 psgr = Psgr() try: #トランザクション処理開始 psgr.begin() # messageの形態素解析 analyze = Analyze() # 分かち書きした文章を取得する # 吾輩 は 猫 で ある parse_data = analyze.parse_wakati_sentence(sentence) w1 = '' w2 = '' for data in parse_data: if data[0] == '': continue # 登録用データ↓↓ word = data[0] if w1 and w2: values = (sentence_id, w1, w2, word, channel_id) sqlcom = "INSERT INTO markov_chain (sentence_id, word1, word2, word3, channel_id) VALUES (%s,%s,%s,%s,%s)" psgr.execute(sqlcom,values) w1, w2 = w2, word psgr.commit() del analyze except Exception as e: print (e) psgr.rollback() del psgr
def execute_command(user_input, argv): """ dispatcher function to activate subroutines :param user_input: the function to activate :param argv: CLI-style argv arguments, if applicable """ if user_input == 'Q' or user_input == 'QUIT': exit(1) elif user_input == '!HELP': print('Supported functions:\n' ' -QUOTE\n' ' -WATCH\n' ' -ANALYZE\n') elif user_input == 'QUOTE': import quote quote.__main__(argv) elif user_input == 'WATCH': import watch watch.__main__(argv) elif user_input == 'ANALYZE': import Analyze Analyze.__main__(argv) else: print("Invalid command")
def suggestauthors(topic,num): #read file and find the profs closest match to rawlabel and confirm/return actual label authordict = getauthordict('authordict.csv') ranking = [] similars = [] author = Analyze.idauthor(authordict,topic) if author == '': score=[] stops=nltk.corpus.stopwords.words('english') #stopwords to weed out stops = stops + ['we',',','.','(',')','using','new','propose','investigate'] stops = stops + ['-','show','infer','novel','method'] tokens1 = nltk.word_tokenize(topic) pairs1 = nltk.bigrams(tokens1) tokens1 = tokens1+[bg for bg in pairs1 if bg[0] not in stops and bg[1] not in stops] for auth in authordict.keys(): keyw2 = authordict[auth]['Keywords'] tokens2 = list(filter(None,re.split(r',',keyw2)+re.split(r'[ ,]',keyw2))) score = -sum(1 for token in tokens1 if token in tokens2) heappush(ranking,[score,auth]) while len(similars)<num: authscore = heappop(ranking) similars.append([authscore[1],authordict[authscore[1]]['Keywords']]) else: for auth in authordict: score = Analyze.similarauthors(authordict[author],authordict[auth]) heappush(ranking,[score,auth]) while len(similars)<num: authscore = heappop(ranking) similars.append([authscore[1],authordict[authscore[1]]['Keywords']]) print(authordict[author]['Keywords']) return similars
def idauthor(filename,rawlabel): #read file and find the profs closest match to rawlabel and confirm/return actual label f1 = open(filename,'r+',encoding='utf-8') rawdata=csv.reader(f1) authordict = Analyze.dictauthor(rawdata) f1.close() return Analyze.idauthor(authordict,rawlabel)
def runTests(debug): analyzeTest = Analyze() analyzeTest.setDebug(debug) print ("\nRunning Analyze Tests") stanDevTestSet = [50, 60, 45, 35, 28, 30, 58, 70, 32, 80, 90, 85, 75, 70, 50, 60, 70, 80, 35, 45] stanDevAns = 19.140010 stanDevResult = analyzeTest.calculateSD(stanDevTestSet) print ("Running Standard Deviation Test. Answer should be %f, received %f" % (stanDevAns, stanDevResult))
def analyze_message(sentence, sentence_id,channel_id): psgr = Psgr() cur = psgr.getCur() # messageの解析 try: psgr.begin() analyze = Analyze() parse_data = analyze.parse_sentence(sentence) for data in parse_data: detail_array = ['*'] * 9 detail_array[:len(data[1].split(','))] = data[1].split(',') # 登録用データ↓↓ # word = data[0] # Surfaceデータが取れないので。 word = detail_array[6] part_of_speech = detail_array[0] if part_of_speech == "BOS/EOS": continue part_of_speech_detail1 = detail_array[1] part_of_speech_detail2 = detail_array[2] part_of_speech_detail3 = detail_array[3] conjugate1 = detail_array[4] conjugate2 = detail_array[5] original = detail_array[6] pronunciation1 = detail_array[7] pronunciation2 = detail_array[8] # 単語の登録 values = (word,part_of_speech,part_of_speech_detail1,part_of_speech_detail2,part_of_speech_detail3,conjugate1,conjugate2,original,pronunciation1,pronunciation2) sqlcom = "INSERT INTO words (word,part_of_speech,part_of_speech_detail1,part_of_speech_detail2,part_of_speech_detail3,conjugate1,conjugate2,original,pronunciation1,pronunciation2) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) RETURNING word_id;" psgr.execute(sqlcom,values) word_id = psgr.lastrowid() # 単語と文章を繋ぐ values = (sentence_id,word_id,channel_id) sqlcom = "INSERT INTO sentence_word (sentence_id, word_id, channel_id) VALUES (%s,%s,%s) RETURNING sentence_word_id;" psgr.execute(sqlcom,values) except Exception as err: print(err) psgr.rollback() # コミット psgr.dbCommit() del psgr
def rank(filename,criterion,num): #read data and rank authors based on criteria, and output first num authors criteria = ['Citations','NumPapers','Co-Authors','Citation Rate'] if criterion not in criteria: print('Error: criterion can only be one of the following strings: Citations/NumPapers/Co-Authors') return [] f1 = open(filename,'r+',encoding='utf-8') rawdata=csv.reader(f1) authordict = Analyze.dictauthor(rawdata) f1.close() ranking = [] for author in authordict.keys(): if criterion == 'Co-Authors': heappush(ranking, [-len(authordict[author][criterion]), author]) elif criterion == 'Citation Rate': heappush(ranking, [-(authordict[author]['Citations']/authordict[author]['NumPapers']), author]) else: heappush(ranking, [-authordict[author][criterion], author]) bestofcriterion = [] while len(bestofcriterion)<num: pick = heappop(ranking) bestofcriterion.append([-pick[0],pick[1]]) return bestofcriterion
def results(request): # Handle file upload if request.method == 'POST': print "Results being called" form = DocumentForm(request.POST, request.FILES) if form.is_valid(): newdoc = Document(docfile = request.FILES['docfile']) newdoc.save() parser = TextParsing.TextParsing(request.FILES['docfile'].name) analyzer = Analyze.Analyze() arr = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "trust") score = analyzer.getAverageConversationScores(parser) convo = analyzer.getConversationScore(parser)["trust"] # labels = ['compound', 'neg', 'neu', 'pos'] # ind = np.arange(4) # width = .5 # plt.bar(ind, score, width) # plt.ylabel('Normalized Score') # plt.xticks(ind,labels) # fig, ax = plt.subplots() # plot = ax.bar(ind, score, width) # plt.savefig('ConversationAnalysis/media/graph.png') # Redirect to the document list after POST # return HttpResponseRedirect('MainPage.views.main') else: form = DocumentForm() # A empty, unbound form return render(request, 'appTemps/results.html', {'arr': arr, 'score':score, 'convo':convo})
def results(request): # Handle file upload global arr, score, emoarr, cwords, arr2, p, cmpd if request.method == 'POST': # print "Results being called" form = DocumentForm(request.POST, request.FILES) if form.is_valid(): newdoc = Document(docfile=request.FILES['docfile']) newdoc.save() parser = TextParsing.TextParsing(request.FILES['docfile'].name) analyzer = Analyze.Analyze() analyzer.popDialogEmotion(parser) analyzer.setDialogSentiment(parser) p = json.dumps(analyzer.getPersonData(parser), separators=(',', ':')) arr2 = parser.plotlyBarFreqDist("everyone") cmpd = analyzer.plotlyCompoundSenti(parser) score = analyzer.getAverageConversationScores(parser) emo1 = analyzer.getConversationScore(parser)["anger"] emo2 = analyzer.getConversationScore(parser)["anticipation"] emo3 = analyzer.getConversationScore(parser)["disgust"] emo4 = analyzer.getConversationScore(parser)["fear"] emo5 = analyzer.getConversationScore(parser)["joy"] emo6 = analyzer.getConversationScore(parser)["sadness"] emo7 = analyzer.getConversationScore(parser)["surprise"] emo8 = analyzer.getConversationScore(parser)["trust"] emoarr = [emo1, emo2, emo3, emo4, emo5, emo6, emo7, emo8] cwords = parser.getNCommonWords(50) # print freqdist anger = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "anger") anticipation = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "anticipation") disgust = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "disgust") fear = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "fear") joy = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "joy") sadness = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "sadness") trust = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "trust") arr = [anger, anticipation, disgust, fear, joy, sadness, trust] else: form = DocumentForm() # A empty, unbound form return render( request, 'appTemps/results.html', { 'arr': arr, 'score': score, 'emoarr': emoarr, 'cwords': cwords, 'arr2': arr2, "person": p, "form": form, "documents": documents })
def search_music(self, btn, store, flag): search_key = self.search_entry.get_text().strip() if search_key == '': return None xml_url="http://www.google.cn/music/search?cat=song&q=%s&start=%d&num=%d&cad=player&output=xml" % (search_key, self.count * 20, ONE_PAGE_SIZE) song_list = Analyze.getSongList(xml_url, False) if not song_list or len(song_list) == 0: msgBox = gtk.MessageDialog(parent=self.dialog, flags=gtk.DIALOG_MODAL, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_CLOSE, message_format=_("No more song!")) msgBox.connect("response", lambda a, b: msgBox.hide()) msgBox.run() return None if flag: store.clear() iter = None #'', 'Title', 'Album', 'Artist', 'Time', 'ID' for song in song_list: title = song['name'] album = song['album'] artist = song['artist'] time = song['duration'] id = song['id'] iter = store.append([False, title, album, artist, time, id]) if not flag: self.search_tree.scroll_to_cell(store.get_path(iter)) self.count += 1 if len(song_list) < ONE_PAGE_SIZE: self.has_next = False else: self.has_next = True
def run(self): if not self.songs: self.listType, self.listId, self.album = self.preference.get_prefs() #url="http://www.google.cn/music/chartlisting?cat=song&q=chinese_songs_cn&output=xml" url="http://www.google.cn/music/album?id=B679efdab97c7afc7&output=xml" if self.listType is not None and self.listId is not None: if self.listType == 'song': url="http://www.google.cn/music/chartlisting?cat=song&q=%s&output=xml" % self.listId elif self.listType == 'topic': url="http://www.google.cn/music/topiclisting?cat=song&q=%s&output=xml" % self.listId print 'Load List from the %s' % url self.songs = Analyze.getSongList(url, True) if not self.songs: return None for row in self.source.props.query_model: entry = row[0] self.db.entry_delete(entry) self.is_run = True load_count = 0 load_all = len(self.songs) gobject.idle_add(self.source.notify_progress, True, load_count, load_all) for song in self.songs: if not self.set_stop: time.sleep(0.2) self.add_song(song) load_count += 1 gobject.idle_add(self.source.notify_progress, True, load_count, load_all) self.db.commit() self.is_run = False gobject.idle_add(self.source.notify_progress, False, 1, 1)
def query_score(): username = request.form.get('username') password = request.form.get('password') term = request.form.get('term') # print username # print term json_score = Analyze.get_score(username, password, term) return json_score
def kMeans(data_set, score_funcs, k): assert (k <= len(data_set)) results_list = [] old_centroids = _initializeCentroids(k, data_set) clusters = _group_points(data_set, old_centroids) results_list.append(Analyze.analyze_clusters(clusters, score_funcs)) new_centroids = _findMeanVectors(clusters, data_set) while not _hasConverged(old_centroids, new_centroids): old_centroids = new_centroids clusters = _group_points(data_set, new_centroids) # keep recording the data results_list.append(Analyze.analyze_clusters(clusters, score_funcs)) new_centroids = _findMeanVectors(clusters, data_set) # last item is a repeat: return results_list[:-1]
def Startsimulation(): global status global Analyze Analyze = importlib.reload(Analyze) result = Analyze.__main__() if not(simType == "Sweep"): displayonwindow("Simulation Results", result) status = "Simulation Done"
def analyze(self): global rawData global rawTime global pic global scan rawData, rawTime, pic, scan = Analyze.Analyze(scan, protein, nd2_file, Roi_Data_file, status_file, time_file, n) self.analyze_btn.setText('Analyze scan:%d' % scan) scan += 1
def Render(lastStages, logFilePath=None): try: if (not isinstance(lastStages,list)): lastStages = [lastStages] Analyze.Initialize(logFilePath) out = [] for stage in lastStages: stage.Reset() out.append(stage.GetOutput()) Analyze.PrintResults() return out except Exception, e: # exc_type, exc_value, exc_traceback = sys.exc_info() Analyze.WriteStatus(traceback.format_exc()) # traceback.print_exception(exc_type, exc_value, exc_traceback, file=Analyze.GetLog()) # traceback.print_exception(exc_type, exc_value, exc_traceback, file=sys.stderr) # sys.stderr.write("\n"*2) raise e
def run(self): # First the selected dataset needs to be loaded dataset_name = self.data_selection.get() if dataset_name == "Iris": print("Selecting Iris!") data = load_data.load_iris() elif dataset_name == "Seeds": data = load_data.load_seeds() elif dataset_name == "Glass": data = load_data.load_glass() elif dataset_name == "Banknote": data = load_data.load_banknote() elif dataset_name == "Customers": data = load_data.load_cust_data() # Now run the selected clustering algorithm score_list = [score_funcs.cluster_sse] if self.alg_selection.get() == "K-Means": Analyze.analyze( data, dataset_name, 10, self.build_kMeans_func(*kMeans_params[dataset_name]), score_list) elif self.alg_selection.get() == "DBSCAN": Analyze.analyze( data, dataset_name, 10, self.build_dbscan_func(*dbscan_params[dataset_name]), score_list) elif self.alg_selection.get() == "Competitive Learning": Analyze.analyze(data, dataset_name, 10, self.build_cl_func(*cl_params[dataset_name]), score_list) elif self.alg_selection.get() == "PSO": Analyze.analyze(data, dataset_name, 10, self.build_pso_function(*pso_params[dataset_name]), score_list) elif self.alg_selection.get() == "ACO": Analyze.analyze(data, dataset_name, 10, self.build_aco_func(*aco_params[dataset_name]), score_list)
def dbscan(data_pts, radius, minpts, score_funcs=None): # labels is a dictionary with points as keys and values as the cluster label labels = _cluster(data_pts, radius, minpts) # Assign points to cluster making labels keys and values list of points belonging to individual clusters clusters = defaultdict(list) for key, label in labels.items(): clusters[label].append(key) # Calculate cluster sse result = [Analyze.analyze_clusters(clusters, score_funcs)] return result
def run_optimal(): # Returns the current state of the agent current_state = Monitor.monitor(None, agent) # See what moves are available from the current positions adj_states = Analyze.analyze(current_state) # Get the next action desired_action = Planning.optimalPolicy(adj_states, knowledge) # Apply Environmental uncertainty actual_action = knowledge.action_func(desired_action) # Execute onto the environment next_state = Execution.execute(adj_states + [current_state], actual_action) agent.update(next_state, knowledge.state_value_dict[next_state])
def ACO(dataset, iterations, num_clusters, num_ants, beta, prob_cutoff, num_elite_ants, decay_rate, q, score_funcs): ''' The main function for the ACO algorithm. Takes in the dataset to be clustered, maximum number of iterations, the number of ants to be included, and the score functions to be used. Creates individual ants, tracks the pheromone matrix, and updates the best clustering found so far. ''' pheromone_matrix = _initialize_pheromones(dataset, num_clusters) ants = _initialize_ants(dataset, num_ants, num_clusters, beta, prob_cutoff, pheromone_matrix) best_score = iteration_best_score = float("inf") best_clustering = None results = [] #_print_ant_info(ants) for iteration in range(iterations): #Loop through all data points and have all ants cluster each data point for point_number in range(len(dataset)): for i, ant in enumerate(ants): ant.update_beliefs() #After all data points have been assigned to a cluster for all ants, rank the ants by objective function rank_info = _rank_ants(ants) ants = [ranked_ant[0] for ranked_ant in rank_info.ants_and_scores] #Let the elite (best scoring) ants update the pheromone matrix, then update ants' matrices pheromone_matrix = _update_pheromones(pheromone_matrix, ants[0:num_elite_ants], decay_rate, q) _update_ants_pheromones(pheromone_matrix, ants) iteration_best_score = rank_info.best_score iteration_best_clustering = rank_info.best_clustering #If we found a better clustering this iteration, update the global best if iteration_best_score < best_score: best_score = iteration_best_score best_clustering = iteration_best_clustering #Reset the ants' memory lists _reset_ants(ants) #Score the best cluster, and append it to the list of values to be returned result = Analyze.analyze_clusters(best_clustering, score_funcs) results.append(result) return results
def setUp(): global related global pathNames global all Notes.openFiles() pathNames = Notes.getPathNames() for x in range(len(pathNames)): A.organizeHutchNERData(Notes.readXmlFile(x)) A.isGIrelated() related = A.getGIrelated() all = A.getAll() mapToTxtFileRelated(x) # mapToCsv(x) A.clear() Notes.clear()
def open_plot(self, widget): if not self.project: return marker = self.project.timeline.ruler.get_playback_marker() if not marker: return start, duration = marker frq, power = self.project.appsinkpipeline.get_spectrum( start, start + duration) w = Analyze.Analyze() w.show_all() w.plot_spectrum(frq, power)
def vis_plot_evolution(self, viscontrol, semitone): if not self.project: return playback_marker = self.project.timeline.ruler.get_playback_marker() if not playback_marker: return import scipy.interpolate start, duration = playback_marker ########## dialog = gtk.Dialog( title="interval", flags=gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) entry = gtk.Entry() entry.set_text("0.1") dialog.vbox.add(entry) dialog.show_all() dialog.run() interval = float(entry.get_text()) dialog.destroy() ############# # interval = 0.1 delta = interval / 2. steps = 1.0 * duration / delta x = [] y = [] for step in xrange(int(steps)): pos = start + step * delta frq, power = self.project.appsinkpipeline.get_spectrum( pos - interval / 2., pos + interval / 2.) # frq, power = self.project.appsinkpipeline.get_spectrum(pos,pos+interval) spline = scipy.interpolate.InterpolatedUnivariateSpline( frq, power, None, [None, None], 1) lower = Math.semitone_to_frequency(semitone - 0.5) upper = Math.semitone_to_frequency(semitone + 0.5) total = spline.integral(lower, upper) x.append(pos) y.append(total) w = Analyze.Analyze() w.show_all() w.simple_plot(x, y)
def measure_start(self): if self.adjust == 1: #Adjust gain? self.meas_adjust() else: self.date = ephem.now().tuple() #Date for FITS-file self.receiver.start() self.sig_time = 0 self.ref_time = 0 self.totpowTime = 0 self.config.set('CTRL', 'abort', '0') self.config.set('CTRL', 'state', 'integrating') with open(self.configfil, 'wb') as configfile: self.config.write(configfile) index = 0 start = time.time() while index < self.loops: self.set_index(index) if self.switched == 1: self.measure_switch_in() else: self.loops = 1 self.measure_tot_pow() self.counter = 0 self.sigCount = 0 self.refCount = 0 if int(self.config.get('CTRL', 'abort')) != 1: tc = Analyze(self.sigCount, self.refCount, index, self.fftSize, self.c_freq, self.samp_rate, self.switched, self.user) index += 1 stop = time.time() print "Total time: " print stop - start edit = 0 if int(self.config.get('CTRL', 'abort')) != 1: td = Finalize(index, self.fftSize, self.c_freq, self.samp_rate, edit, self.sig_time, self.ref_time, self.switched, self.totpowTime, self.user, self.date) self.receiver.stop() self.receiver.wait() files = glob.glob('/tmp/ramdisk/*') for f in files: if f.endswith(self.index): os.remove(f) else: continue self.config.set('CTRL', 'state', 'ready') with open(self.configfil, 'wb') as configfile: self.config.write(configfile)
def mapToCsv(num): index = A.getListOfGITRelatedTerms() # for x in range(len(related)): temp = { "probability": pd.Series([""], index=index), "context": pd.Series([""], index=index), } df = pd.DataFrame(temp) for token in related: for prob in index: if token[0] == prob: df.set_value(prob, 'context', token[2]) df.set_value(prob, 'probability', token[1]) temp = os.path.join(csv, pathNames[num]) + ".csv" df.to_csv(temp)
def get_playback_uri(self, entry): if not entry:return None url = self.db.entry_get (entry, rhythmdb.PROP_LOCATION) if not url.endswith('.mp3'): print 'Load the google music:%s' % url url = Analyze.getSongByURL(url)['url'] if url is not None: self.db.set(entry, rhythmdb.PROP_LOCATION, url) print 'Get google song url: %s' % url return url else: return None else: return url
def load_lyrics(self, title, artist, location, lyrics_url): start_time = time.time() * 1000 self.lyrics_is_loaded = False self.lyrics_is_txt = True self.liststore.clear() self.liststore.append([0, _("Loading lyric ......"), "00:00.00"]) genreRe = re.compile("^S[a-zA-z0-9]{16}") # result = genreRe.match(genre) def loader_cb(data): if data is None: self.load_default(title, artist, location) else: self.loadData(data) self.lyrics_is_loaded = True end_time = time.time() * 1000 print "Load lryics spend time %f:" % (end_time - start_time) if lyrics_url is not None: print "Load lyrics from google: %s" % lyrics_url # lyrics = Analyze.getLyrics(lyrics_url) l = rb.Loader() l.get_url(lyrics_url, loader_cb) return filePath = self.find_file(title, artist, location) if filePath is not None: print "Load lyrics from file: %s" % filePath lyrics = Analyze.getLyricsByFile(filePath) if lyrics is None: self.load_default(title, artist, location) else: self.loadData(lyrics) self.lyrics_is_loaded = True end_time = time.time() * 1000 print "Load lryics spend time %f:" % (end_time - start_time) return self.load_default(title, artist, location) # 看起来没有多大必要设置 # self.lyrics_is_loaded = True end_time = time.time() * 1000 print "Load lryics spend time %f:" % (end_time - start_time)
def strategy_bollinger(d_data, ldt_timestamps): ls_symbols = list(d_data['close'].keys()) df_index_bollinger = BollingerBands.bollinger_bands(d_data['close'], ldt_timestamps, ls_symbols=ls_symbols) mkt_benchmark = Analyze.get_mktBenchmark(ldt_timestamps) mkt_bollinger = BollingerBands.bollinger_bands(mkt_benchmark, ldt_timestamps) df_events = copy.deepcopy(df_index_bollinger) * np.NAN for i in range(1,len(ldt_timestamps)): boll_today = df_index_bollinger.ix[ldt_timestamps[i]] boll_yest = df_index_bollinger.ix[ldt_timestamps[i-1]] for c_sym in ls_symbols: if boll_today[c_sym] <= -2.0 and boll_yest[c_sym] > -2.0 and \ mkt_bollinger['$SPX'].ix[ldt_timestamps[i]] >= 1.0: df_events[c_sym].ix[ldt_timestamps[i]] =1 return df_events
def loader_cb(data): topic_list = Analyze.getTopicList(data) if topic_list is not None: store.clear() for topic in topic_list: chartName = topic['name'].encode("utf-8") chartId = topic['id'] chartType = topic['type'] chartPicURL = topic['picURL'] chartDesc = topic['desc'].encode("utf-8") store.append([chartName, chartId, chartType, chartPicURL, chartDesc]) self.load_label.set_label(_("Loaded")) else: msgBox = gtk.MessageDialog(parent=self.dialog, flags=gtk.DIALOG_MODAL, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_CLOSE, message_format=_("No more topic list!")) msgBox.connect("response", lambda a, b: msgBox.hide()) msgBox.run() self.load_label.set_label(_("Loaded"))
def suggestpapers(myfilename,filename,num): ##read data and find similar papers to the papers in file ## f2 = open(myfilename,'r+',encoding='utf-8') mydata = csv.reader(f2) mypapers=[] for paper in mydata: mypapers.append([paper[0],paper[1],paper[2],paper[3],paper[4]]) f2.close() del mypapers[0] similars = [] num = 10 for paper in mypapers: f1 = open(filename,'r+',encoding='utf-8') rawdata = csv.reader(f1) similars.append([paper,Analyze.similarpapers(paper,rawdata,num)]) f1.close() return similars
def add_song(self,song): try: aSong = Analyze.getSongByURL(song['url']) if not aSong: return entry = self.db.entry_new(self.entry_type, aSong['url']) print song print aSong self.db.set(entry, rhythmdb.PROP_TITLE, song['name']) self.db.set(entry, rhythmdb.PROP_ARTIST, song['artist']) self.db.set(entry, rhythmdb.PROP_ALBUM, song['album']) self.db.set(entry, rhythmdb.PROP_DURATION, song['duration']) #self.db.set(entry, rhythmdb.PROP_TRACK_NUMBER, song['track_number']) self.db.set(entry, rhythmdb.PROP_GENRE, self.n2str(aSong['genre'])) self.db.set(entry, rhythmdb.PROP_COMMENT, 'id=%s\nimage=%s\nlyrics=%s' % (song['id'], self.n2str(aSong['image']), self.n2str(aSong['lyrics']))) #self.db.set(entry, rhythmdb.PROP_IMAGE, aSong['image']) except Exception, e: traceback.print_exc()
def pltCitCollab(filename): ####read data from csv file, plot the collaboration-citation data f1 = open(filename,'r+',encoding='utf-8') rawdata = csv.reader(f1) count = sum(1 for row in rawdata) f1.close() print(str(count)+' papers analyzed.') f1 = open(filename,'r+',encoding='utf-8') rawdata=csv.reader(f1) data = Analyze.citacollab(rawdata,count) f1.close() pyp.plot(data[1],data[0],'ro') pyp.xlabel('Citations') pyp.ylabel('Number of co-authors') pyp.show() pyp.close() return data
def pltCitClarity(filename): ##read data from csv file, plot the clarity-citations data f1 = open(filename,'r+',encoding='utf-8') rawdata = csv.reader(f1) count = sum(1 for row in rawdata) f1.close() print(str(count)+' papers analyzed.') f1 = open(filename,'r+',encoding='utf-8') rawdata=csv.reader(f1) data = Analyze.citaclarity(rawdata,count) f1.close() pyp.plot(data[0],data[1],'ro') pyp.xlabel('Abstract length') pyp.ylabel('Citations') pyp.show() pyp.close() return data
def pltCitRate(filename): ##read data from csv file, plot the clarity-citations data f1 = open(filename,'r+',encoding='utf-8') rawdata=csv.reader(f1) authordict = Analyze.dictauthor(rawdata) f1.close() data = numpy.zeros((2,len(authordict))) i=0 for author in authordict.keys(): data[0,i] = authordict[author]['NumPapers'] data[1,i] = authordict[author]['Citations']/authordict[author]['NumPapers'] i += 1 pyp.plot(data[0],data[1],'ro') pyp.xlabel('Number of papers published') pyp.ylabel('Average citations per paper') pyp.show() pyp.close() return data
def competitive_learning(data_set, eta, num_clusters, iterations, score_funcs): ''' The main competitive learning algorithm. Creates a two layer network, then trains the weights of the network by updating the weights of the node with the strongest output for each training example ''' #Initialize variables num_inputs = len( data_set[0]) # Number of inputs is equal to the number of features weight_layer = Layer.Layer(num_inputs, num_clusters, eta) results = [] for iteration in range(iterations): #Train the network, score the resulting clustering, append the score #to the list of scores, and move on to next iteration weight_layer = _train_network(data_set, weight_layer, num_clusters) clustering = _cluster(data_set, weight_layer) result = Analyze.analyze_clusters(clustering, score_funcs) results.append(result) return results
def gen_report_individual(individual,dic_notas,dic_horarios): dataframe=an.create_dataframe(individual) print(dataframe) score=schdl_value(individual,dic_notas,dic_horarios) print("VALOR: "+str(score)) genotype=Crossover.create_genotype(individual) materias=[] for gen in genotype: info=gen.split("-") materia=info[0] if materia not in materias: paralelo=info[2] profesor=dic_horarios[materia][str(paralelo)]["Profesor"] rank=get_rank(profesor,materia,dic_notas) nota=np.mean(np.array(dic_notas[materia][profesor])) print("MATERIA: "+materia) print("PROFESOR: "+profesor) print("RANGO: "+str(rank)) print("NOTA: "+str(nota)) print("▀"*30) materias.append(materia)
def runTraining(folderName): trainingFiles = [] #Liste des fichiers d'entrainement trainingData = [] #données étudiées pos = 0 neg = 0 for dir in os.walk(folderName): dir = dir[1] #get directory list for i, f in enumerate(dir): actualFolder = os.path.join(folderName, f) for files in os.walk( actualFolder): #Parcourir liste dossier dans training trainingFiles.append(files[2]) for j, tf in enumerate( files[2]): #Parcourir liste des fichiers dans *star tempP, tempN = (an.analyzeFile( os.path.join(actualFolder, tf))) pos = (pos + tempP) / 2 neg = (neg + tempN) / 2 trainingData.append([pos, neg]) return trainingData
def main(): if len(sys.argv)==1: print '\n/-----\\\n|ERROR|===>>> Try inputs of the form python Analyze.py foo.p where foo.p is a pickle... not literally.\n\-----/\n' sys.exit(0) picklename=sys.argv[1] SET=[] x=np.array([0.0000000020128,0.000000002108307,0.000000002205033,0.000000002304373,0.000000002404483,0.000000002506767,0.000000002609444,0.000000002714023,0.000000002819564,0.000000002925106,0.000000003032267,0.000000003139197,0.000000003247665,0.000000003356696,0.000000003465344,0.00000000357534,0.000000003684857,0.000000003795656,0.000000003905897,0.000000004017367,0.000000004129093,0.000000004240215,0.000000004352506,0.000000004464105]) x=[i*10**9 for i in x] basename='./20130506_06/A' filenumbers=range(101)[40:71]#[6:20] filenumbers=[('%03d'%filenumber) for filenumber in filenumbers] filenames=[basename+filenumber+'.dat' for filenumber in filenumbers] #GET RID OF THIS NEXT! #filenames=filenames[12:15] for filename in filenames: print filename print '' for filename in filenames: success=False while success==False: TR=Analyze.Analyze(filename) succ=False while succ==False: IN=raw_input("y to accept, or 'skip' or 'repeat': ") if IN=='y': succ=True SET.append(TR) success=True elif IN=='skip': succ=True success=True elif IN=='repeat': succ=True elif IN!='': print "What!?" pickle.dump(SET,open( picklename, 'w')) pb.show()
def doubleresults(request): global arr, score, emoarr, cwords, arr2, p, cmpd form = DocumentForm(request.POST, request.FILES) if form.is_valid(): newdoc = Document(docfile=request.FILES['docfile']) newdoc.save() parser = TextParsing.TextParsing(request.FILES['docfile'].name) analyzer = Analyze.Analyze() analyzer.popDialogEmotion(parser) analyzer.setDialogSentiment(parser) anger = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "anger") anticipation = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "anticipation") disgust = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "disgust") fear = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "fear") joy = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "joy") sadness = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "sadness") trust = analyzer.plotlyEmotion(parser, parser.speakerDict.keys(), "trust") arr1 = [anger, anticipation, disgust, fear, joy, sadness, trust] cmpd1 = analyzer.plotlyCompoundSenti(parser) return render( request, 'appTemps/doubleresults.html', { 'arr': arr, 'score': score, 'emoarr': emoarr, 'cwords': cwords, 'arr2': arr2, "person": p, 'arr1': arr1, 'cmpd1': cmpd1, 'cmpd': cmpd })
def alternativeAbundance(matchf, pds, topn = 50): MASTER = '/home/anthill/fzheng/home/scripts/termanal_updating' # generate the original structures of topn hits # pds = General.changeExt(pdb, 'pds') # cmd = [MASTER + '/createPDS', '--type', 'query', '--pdb', pdb, '--pds', pds] # cmd = ' '.join(cmd) # os.system(cmd) cmd = [MASTER + '/master', '--query', pds, '--matchIn', matchf, '--structOut', General.getBase(pds) + 'tmp', '--outType', 'match', '--bbRMSD', '--topN', str(topn)] cmd = ' '.join(cmd) os.system(cmd) # for these N structures, calculate RMSD between any two. should be O(N^2) odir = os.getcwd() ndir = General.getBase(pds) + 'tmp' os.chdir(ndir) mpdbs = glob.glob('*.pdb') mpdbs.sort() RMSDs = [] print 'calculating pairwise RMSD' for i in range(len(mpdbs)-1): for j in range(i+1, len(mpdbs)): mol1, mol2 = parsePDB(mpdbs[i]), parsePDB(mpdbs[j]) bbAtoms1, bbAtoms2 = mol1.select('backbone').copy(), mol2.select('backbone').copy() trans = calcTransformation(bbAtoms2, bbAtoms1) bbAtoms2_t = applyTransformation(trans, bbAtoms2) rmsd = calcRMSD(bbAtoms1, bbAtoms2_t) RMSDs.append(round(rmsd, 3)) print 'finish calculating RMSD' os.chdir(odir) # now calculate the average Z-score of all the rmsds of the query RMSDs = np.array(RMSDs) qRMSD = Analyze.readColumn(matchf, 0, top = topn) qRMSD = np.array([float(x) for x in qRMSD]) meanRMSD, stdRMSD = np.mean(RMSDs), np.std(RMSDs) Z_qRMSD = (qRMSD - meanRMSD) / stdRMSD return round(np.median(Z_qRMSD), 3)
if args.conres != None: tempfile2 = General.changeExt(args.m, 'seqcontext.fasta2') tempfh2 = open(ldir + '/' + tempfile2, 'w') # output file names nr_matchf = args.outh + '_' + args.m nr_seqf = General.changeExt(nr_matchf, 'seq') nr_env = None oenv = General.changeExt(args.m, args.env) if os.path.isfile(oenv): nr_env = General.changeExt(nr_matchf, args.env) # write a custom .fasta file for match in matches: match_region_indices = Analyze.index_from_match(match) central_index = match_region_indices[args.cres - 1] match_id = General.getBase( General.removePath( match.split()[1] ) ) fullsequence = database[match_id] if central_index - args.wd < 1: seqcontext = fullsequence[0:(2 * args.wd + 1)] elif central_index + args.wd > len(fullsequence): seqcontext = fullsequence[-(2 * args.wd + 1):] else: seqcontext = fullsequence[(central_index - args.wd - 1):(central_index + args.wd)] tempfh.write('>match:'+str(matchind)+'\n'+seqcontext+'\n') if args.conres != None: con_index = match_region_indices[args.conres -1] if con_index - args.wd < 1:
if homol.split()[0] == sid: exclude = homol.split()[1:] break # do it on local directories odir = os.getcwd() ldir = General.createLocalSpace() # copy .match and .seq sub.call(['cp', matchf, seqf, ldir]) os.chdir(ldir) tmphead = args.head if args.rmsd != None: if noHomoNow == 0: tmphead = Analyze.trimByRMSD(matchf, -1, tmphead, 'th1', args.rmsd, sorted = False, h**o = exclude, homo_log = True) noHomoNow = 1 else: tmphead = Analyze.trimByRMSD(matchf, -1, tmphead, 'th1', args.rmsd, sorted = False) if args.smart: if len(segments) == 1: smartcut = mustpress.rmsdEff(segments, 20, 0.9) else: if max(resnums) - min(resnums) < 8: # this is considered close, even there is gap between two segments smartcut = mustpress.rmsdEff(segments, 20, 0.9) - 0.2 # this is about 0.5 else: smartcut = mustpress.rmsdEff(segments, 15, 1.1) # this is about 0.9 if noHomoNow == 0: tmphead = Analyze.trimByRMSD(matchf.replace(args.head, tmphead), 0, tmphead, 'ts', smartcut, h**o = exclude, homo_log = True) noHomoNow = 1 else:
def StartProcess(self): name = self.__class__.__name__ if (len(self._properties)>0): sargs = ["%s = %s" %(str(x),self._properties[x]) for x in sorted(self._properties.keys())] name = "%s [%s]" % (name, string.join(sargs,", ")) Analyze.StartProcess(name)
for seqf in seqfs: pdbf = General.changeExt( seqf.replace(args.head + '_', ''), 'pdb') if not os.path.isfile(pdbf): print(pdbf + ' doesn\'t exist!') continue outf = General.changeExt(pdbf, args.o) if args.wgap != None: # specific to gap assert args.conR == False, 'wgap and conR cannot be specified simultaneously' dirname = General.getBase(pdbf) pdbf = args.wgap + '/' + dirname + '/'+ pdbf index = PDB.findPositionInPDB(pdbf, resnum, cid) aacol = Analyze.readColumn(seqf, index, top = args.uplimit) if args.conR: # should contacting residue be constrained? conid = General.getBase(seqf).split('_')[-1] ccid, cresnum = conid[0], conid[1:] cindex = PDB.findPositionInPDB(pdbf, cresnum, ccid) cres = PDB.getResByInd(pdbf, ccid, cresnum).getResname() cres = PDB.t2s(cres) caacol = Analyze.readColumn(seqf, cindex, top = args.uplimit) if args.env != None: # environment corrected counts envf = General.getBase(seqf.replace(args.head, args.envhead)) + '.' + args.env if not os.path.isfile(envf): print(envf + ' doesn\'t exist!') continue
import glob import Analyze dscdat = glob.glob('*.dsc50.TR*.dat') dscdat.sort() oldpath = '/home/anthill/fzheng/home/designScore/allfeatures_individual/' for d in dscdat: modelname = d.split('.')[-2] oldfile = oldpath + 'allfeatures.' + modelname + '.dat' newdsc = Analyze.readColumn(d, -1) ad = d.replace('dsc', 'abd') sd = d.replace('dsc', 'ssc') newabd = Analyze.readColumn(ad, -1) newssc = Analyze.readColumn(sd, -1) newdsc.insert(0, 'new_designscore') newabd.insert(0, 'new_abundance') newssc.insert(0, 'new_structurescore') newfile = modelname + '.dat' newfh = open(newfile, 'w') array = open(oldfile).readlines() for i in range(len(array)): outstr = '\t'.join(array[i].split()[0:3] + [newdsc[i], newabd[i], newssc[i]]) # outstr = '\t'.join(array[i].split()[0:3] + [newdsc[i]]) newfh.write(outstr + '\n')
def run(): try: while True: # checks if there are any new messages if mess_util.list_after( Main.NEWEST_MESSAGE_ANALYZED_ID) is not None: current_message = mess_util.list()[0] # newest message text = current_message.text.lower() name = current_message.name at_bot = '@' + Main.BOT.name # checks if the bot is mentioned if at_bot.lower() in text: # print(text) Analyze.analyze_message(text, name) # analyzes the message Main.NEWEST_MESSAGE_ANALYZED_ID = current_message.id # sets the new analyzed id # if it is time to check for the day's events (8:30 by default) or # if the bot just started if not Main.checked_events and datetime.datetime.now( ) > CHECK_TIME and datetime.datetime.now() < CHECK_TIME_END: Functions.check_date() # checks if any events have passed # enters terminal command mode except KeyboardInterrupt: Log.log_debug(str(datetime.datetime.now()) + " >> KeyboardInterrupt") command = str(input("Would you like to do?\n")).lower() # reads the chats that have not been read yet if command == 'read': Log.log_debug(str(datetime.datetime.now()) + " >> Messages Read") if mess_util.list_after(Main.NEWEST_MESSAGE_READ_ID) is not None: for m in mess_util.list_after(Main.NEWEST_MESSAGE_READ_ID): print(m.name + ': ' + m.text) Main.NEWEST_MESSAGE_READ_ID = mess_util.list()[0].id # post into the group as the bot elif command == 'post': message = str( input( 'What would you like to say? (type "cancel" to cancel message)\n' )) if message.lower() == 'cancel': run() Log.log_debug( str(datetime.datetime.now()) + " >> Manual Posting: " + message) Functions.post_message(message) # get help information elif command == 'create event': date = str(input('Enter the date of the event\n')).split('/') name = str(input('Enter the name of the event\n')) desc = str(input('Enter the description of the event\n')) if len(date[2]) != 4: date[2] = '20' + date[2] response = Functions.create_event(name, int(date[2]), int(date[1]), int(date[0]), desc) print(response) elif command == 'list events': response = Functions.list_events() print(response) elif command == 'delete event': name = str(input('Enter the name of the event\n')) Functions.delete_event(name) print("Event Deleted") elif command == 'create reminder': day = str(input('Enter the day for the reminder\n')) id = str(input('Enter the name of the reminder\n')) desc = str(input('Enter the description of the event\n')) response = Functions.create_reminder(day, id, desc) print(response) elif command == 'list reminders': response = Functions.list_reminders() print(response) elif command == 'delete reminder': name = str(input('Enter the name of the reminder\n')) Functions.delete_reminder(name) elif command == 'help': Log.log_debug(str(datetime.datetime.now()) + " >> Help") print("Possible Commands:") for command in console_commands: print("\t" + command) elif command == 'info': Log.log_debug(str(datetime.datetime.now()) + " >> Info") command = str(input("What command would you like info about?\n")) print(Info.get_info(command)) # shutdown the system elif command == 'shutdown': Log.log_debug(str(datetime.datetime.now()) + " >> System Shutdown") exit() # cancel command mode elif command == 'cancel': pass Log.log_debug( str(datetime.datetime.now()) + " >> Continuing operation") run()
par.add_argument('--o', required = True, help = 'name of output file') par.add_argument('--uplimit', type = float, help = 'top n sequences to calculate') args = par.parse_args() database_path = '/home/anthill/fzheng/home/searchDB/support_bc-30-sc-correct-20141022/others' odir = os.getcwd() ldir = General.createLocalSpace() outfh = open(ldir + '/' + args.o, 'w') uplimit = args.uplimit nseq = 0 for match_line in open(args.m): if (uplimit != None) and (nseq == uplimit): break match_line = match_line.strip() indices = Analyze.index_from_match(match_line) index1, index2 = indices[args.n[0]], indices[args.n[1]] target_pds = match_line.split()[1] targetid = General.getBase( General.removePath(match_line.split()[1]) ) env_dict = database_path + '/' + targetid[1:3] + '/' + targetid + '.freedom.db' db = shelve.open(env_dict, 'r') # extract post-processed pdb files from target_pds resfile = database_path + '/' + targetid[1:3] + '/' + General.changeExt( General.removePath(target_pds), 'post.res') allres = open(resfile).read().splitlines() resid1, resid2 = allres[index1], allres[index2] resid1, resid2 = resid1[0] + ',' + resid1[1:], resid2[0] + ',' + resid2[1:] fields = ['sumcond', 'crwdnes', 'freedom', 'phi', 'psi', 'aa'] outfh.write(targetid + '\t') if not resid1 in db:
def getauthor(filename,rawlabel): #read file and find the details of the author authordict = getauthordict('authordict.csv') author = Analyze.idauthor(authordict,rawlabel) return author,authordict[author]
def cleanfile(infilename,outfilename): #read file and find the research keywords of the given author f1 = open(infilename,'r+',encoding='utf-8') rawdata=csv.reader(f1) Analyze.cleanfile(rawdata,outfilename) f1.close()
def test(self, widget): if not self.project: return marker = self.project.timeline.ruler.get_playback_marker() if not marker: return start, duration = marker power = numpy.array( self.project.appsinkpipeline.get_data(start, start + duration))**2.0 rate = self.project.appsinkpipeline.caps[0]["rate"] delta_t = self.builder.get_object("delta_t").get_value() decay = self.builder.get_object("decay").get_value() separation = self.builder.get_object("beat_separation").get_value() # delta_t = 0.01 # decay = 0.5 # time needed to get to 1/e # k*decay = 1 # power(t) = exp(-1)*power(t-decay) # power(t) = exp(-k*decay)*power(t-decay) # power(t) = exp(-k*delta_t)*power(t-delta_t) decay_per_chunk = numpy.exp(-delta_t / decay) samples = int(rate * delta_t) limit = numpy.average(power[0:samples]) t = [] level = [] lim = [] tp1 = [] w = Analyze.Analyze() for i in xrange(1, int(len(power) / samples)): limit *= decay_per_chunk chunk = power[samples * i:samples * (i + 1)] avg_power = numpy.average(chunk) power_spectrum = Math.windowed_fft(chunk) bands = len(power_spectrum) frqs = 0.5 * (numpy.arange(bands) + 0.5) * rate / bands time = delta_t * i + start min_frq_idx = numpy.min(numpy.nonzero(frqs > 80.)) max_frq_idx = numpy.max(numpy.nonzero(frqs < 1000.)) min_frq = frqs[min_frq_idx] max_frq = frqs[max_frq_idx] print frqs[0], min_frq, max_frq, frqs[-1] total_power1 = numpy.trapz(power_spectrum[min_frq_idx:max_frq_idx], frqs[min_frq_idx:max_frq_idx]) tp1.append(total_power1) # if avg_power>=limit*(1.0+separation): # if avg_power>=limit+separation: # w.add_line(time, color="g") if avg_power >= limit: limit = avg_power t.append(time) level.append(avg_power) lim.append(limit) w.show_all() w.simple_plot(numpy.array(t), numpy.array(level), color="r") w.simple_plot(numpy.array(t), numpy.array(tp1), color="b") w.simple_plot(numpy.array(t), numpy.array(lim), color="g") # markers for tap in self.project.timeline.rhythm.taps: time = tap.get_time() if not start < time and time < start + duration: continue if type(tap.weight) == float: pass else: w.add_line(time, color="r")
# run confind for all structures for pdb in pdbs: pdbf = args.i + '/' + pdb + '.pdb' assert os.path.isfile( pdbf), 'the pdb file ' + pdbf + ' does not exist; quit...' confind_out = changeExt(pdbf, 'conf') if os.path.isfile(confind_out): continue else: # run confind Master.confind(p=pdbf, o=confind_out, rLib=PATH_rotLib) # find homologs H**o = [] if args.homof != None: H**o = Analyze.findHomo(args.homof) # contact identification pos2cons = {} pos2pdb = {} odir = os.getcwd() for pos in positions: os.chdir(odir) if os.path.isdir(pos): os.system('rm -rf %s/*' % pos) else: os.mkdir(pos) os.chdir(pos) pid, ipos = pos.split('_') icid, iresnum = ipos[0], ''.join(ipos[1:])
if y < 8: A.append(round(a / gamesA, 4)) B.append(round(b / gamesB, 4)) Change.append(round((b / gamesB) - (a / gamesA), 4)) else: A.append(round(a, 4)) B.append(round(b, 4)) Change.append(round(c1, 4)) PlayerData.append(A) PlayerData.append(Change) PlayerData.append(B) DataList.append(PlayerData) # Access the SignificanceArray by calling function from Analyze.py SignificanceArray = Analyze.getSignificance() success = [] # Calculate the projected success for each player for player in DataList: playerSuccess = 0 # Iterate through each statistic for each year for year in range(0, 3): for stat in range(0, 12): # Project player success by multiplying player statistic by the calculated significance of that statistic playerSuccess += player[year + 2][stat] * SignificanceArray[year * 12 + stat][2]
print " d : display internal data structures for debugging" print print "Entering interactive mode. (Press Enter to quit.)" interactive = True import os cwd = os.getcwd() # get current working dir if os.path.basename(cwd) == "Checker" : # is cwd the folder where this pgm lives? # then, move up one level; don't want to deposit junk here! os.chdir(os.pardir) print "Current path is ", os.getcwd() filename = raw_input("Type filename (relative to current path) to check: ") options = raw_input("Type options (any or none of vaxnd): ") while filename != "" : result = Analyze.main(filename, options) if result and html : generateHtml(filename) print repeat = raw_input("Press Enter to repeat with this file; Press q to quit: ") if repeat == "q" : filename = "" else : # it's a command line startup with all info supplied if sys.argv[1][0] == "-" : filename = sys.argv[2] if "n" in sys.argv[1] : html = False result = Analyze.main(filename, sys.argv[1]) else : filename = sys.argv[1] result = Analyze.main(filename)