def constraint_test(): """ Verify constraint checking methods.""" import itertools, sys show_analysis = False #Generated via grammar gr = grammar.Grammar('grammars/test_constraints.bnf') inputs = ([1 for _ in range(100)], [ i%3 for i in range(100)]) for _input in inputs: output = gr.generate(_input) azr = analyser.Analyser('test',output['phenotype'],True) try: azr.create_graph() except ValueError as e: print(__name__, "ERROR", _input, e) continue azr.parse_graph() azr.apply_stresses() azr.create_slf_file() azr.test_slf_file() azr.parse_results() azr.print_stresses() if show_analysis: azr.show_analysis() #Fixed generated lengths = (1000, 10000) levels = (5, 10) for length_idx, level_idx in itertools.permutations([0,1]): try: GRAPH = constrained_offset_graph(lengths[length_idx], levels[length_idx]) except ValueError as e: print(__name__, "ERROR", lengths[length_idx], levels[length_idx], e) continue GRAPH.save_graph("pylon") print "nodes:", GRAPH.number_of_nodes() print "edges", GRAPH.number_of_edges() #will it blend? azr = analyser.Analyser('test',"moo",True) azr.my_graph = GRAPH azr.parse_graph() azr.apply_stresses() azr.create_slf_file() azr.test_slf_file() azr.parse_results() azr.print_stresses() if show_analysis: azr.show_analysis()
def button_handler(self, name): """records selected individuals and assigns fitness values""" self.buttons[name].focus_force() self.last_button = name current_indiv = None for indiv in self.ge.individuals: if indiv.uid == int(name): print "found:", name current_indiv = indiv if self.buttons[name]['background'] == "green": print "unassigning fitness to indiv", name for indiv in self.ge.individuals: if indiv.uid == int(self.last_button): analyser = AZR.Analyser(indiv.uid,indiv.phenotype,False) current_indiv.fitness = analyser.test_mesh() print current_indiv.fitness self.buttons[name]['background'] = self.defCol self.buttons[name]['relief'] = "raised" else: print "assigning good fitness to indiv:", name current_indiv.fitness = [0, 0, 0] self.buttons[name]['background'] = "green" self.buttons[name]['relief'] = "sunken" self.save_indiv("best" + str(self.chosen)) self.chosen += 1
def print_stats(generation, individuals): global TIME def ave(values): return float(sum(values))/len(values) def std(values, ave): return math.sqrt(float(sum((value-ave)**2 for value in values))/len(values)) newTime = time.time() genTime = newTime - TIME TIME = newTime ave_weight= ave([i.weightTotal for i in individuals if i.phenotype is not None]) std_weight= std([i.weightTotal for i in individuals if i.phenotype is not None], ave_weight) ave_fit = ave([i.fitness[0] for i in individuals if i.phenotype is not None]) std_fit = std([i.fitness[0] for i in individuals if i.phenotype is not None], ave_fit) ave_used_codons = ave([i.used_codons for i in individuals if i.phenotype is not None]) std_used_codons = std([i.used_codons for i in individuals if i.phenotype is not None], ave_used_codons) print("Gen:%d best:%s weight:s:%d ave:%.1f+-%.1f Used:%.1f+-%.1f tt:%.2f Avrg No:%d+-%.1f" % (generation,individuals[0].fitness,individuals[0].weightTotal,ave_fit,std_fit,ave_used_codons,std_used_codons,genTime,ave_weight,std_weight)) if SAVE_BEST: print "saving best individual" bestMesh = AZR.Analyser(individuals[0].phenotype) filename = 'xxx.'+str(generation) bestMesh.create_mesh(filename)
def print_stats(generation, individuals): def ave(values): return float(sum(values)) / len(values) def std(values, ave): return math.sqrt( float(sum((value - ave)**2 for value in values)) / len(values)) ave_fitness_b = ave( [i.fitness_b for i in individuals if i.phenotype is not None]) std_fitness_b = std( [i.fitness_b for i in individuals if i.phenotype is not None], ave_fitness_b) ave_fit = ave( [i.fitness[1] for i in individuals if i.phenotype is not None]) std_fit = std( [i.fitness[1] for i in individuals if i.phenotype is not None], ave_fit) ave_used_codons = ave( [i.used_codons for i in individuals if i.phenotype is not None]) std_used_codons = std( [i.used_codons for i in individuals if i.phenotype is not None], ave_used_codons) print( "Gen:%d best compliance, deflection (mm) and weight (kg):%s Avg. deflection (mm):%.1f+-%.1f" % (generation, individuals[0].fitness, ave_fit, std_fit)) if SAVE_BEST: print "saving best individual" best_mesh = AZR.Analyser(0, individuals[0].phenotype) filename = './saved/best.' + str(generation) best_mesh.create_mesh(filename)
def save_dxf(self): print "saving individual as DXF:",self.last_button for indiv in self.ge.individuals: if indiv.uid == int(self.last_button): analyser = AZR.Analyser(indiv.uid,indiv.phenotype,False) analyser.create_graph() analyser.save_dxf(self.ge.generation, name='indiv') self.show_msg("saved bridge as DXF "+self.last_button+" in dxf folder")
def write_mesh(fronts, name): counter = 0 for front in fronts: for indiv in front: mesh = AZR.Analyser(indiv.uid, str(indiv.phenotype)) mesh.create_graph() filename = FRONT_FOLDER + "/" + name + "." + str(counter) mesh.create_mesh(filename) counter += 1
def build_individual(filename, genome, grammar): """map genotype and save mesh file""" ind = Individual(None) generated_values = grammar.generate(genome) ind.set_values(generated_values) analyser = AZR.Analyser(filename, ind.phenotype, False) analyser.create_graph() analyser.create_mesh(filename) return ind
def build_individual(filename,genome,grammar): ind = Individual(None) generatedValues= grammar.generate(genome) ind.set_values(generatedValues) analyser = AZR.Analyser(filename,ind.phenotype,False) print "recreating mesh in folder:",filename analyser.create_graph() analyser.create_mesh(filename) return ind
def structural_fitness(graph): azr = analyser.Analyser('test',"moo",True) azr.myGraph=graph azr.parse_graph(graph) azr.apply_stresses() azr.create_slf_file() azr.test_slf_file() azr.parse_results() fitness, weight = azr.calculate_fitness() return fitness
def save_picture(self, name=None): save = True if save: Ganalyser = analyser.Analyser("test", None, False) if name == None: filename = self.popFolder + "img%03d" % (graph.nodeCounter) else: filename = name Ganalyser.myGraph = self.copy() Ganalyser.parse_graph(Ganalyser.myGraph) Ganalyser.create_mesh(filename) graph.nodeCounter += 1
def __init__(self,uid,program): self.uid = uid self.program = program self.analyser = AZR.Analyser(uid,program) self.bridge_weight=0 self.fixed_list=[] self.load_nodes=[] self.nodeselfloads=[] self.load_elems=[] self.beams=[] self.stress_log=[] self.iterations = 3
def mutate_individual(ind,grammar,mutOp): # before = ind.derivation_tree.textual_tree_view().splitlines() if mutOp == "int": ind = int_flip_mutation(ind,False) elif mutOp == "nodal": ind = nodal_mutation(ind,False) elif mutOp == "struct": ind = struct_mutation(ind,False) generatedValues= grammar.generate(ind.genome) ind.set_values(generatedValues) # after = ind.derivation_tree.textual_tree_view().splitlines() # d = difflib.Differ() # differences = list(d.compare(before,after)) # for line in differences: # if line.startswith('-')or line.startswith('+'): # print line analyser = AZR.Analyser(ind.UID,ind.phenotype,True) analyser.create_graph() return ind
def create_annotations(self, chapters=0, caching=CachingType.NONE): """Analyse the text and create the annotations. Using the analyser, generate the annotations for all the chapters. Args: chapters (int, optional, default=0): How many chapters to analyse. 0 means analyse all. caching (:obj:`CachingType, optional, default=0): What caching to use. Can be CachingType.NONE, CachingType.ANNOTATIONS, CachingType.HTML, CachingType.HTML_ANNOTATIONS """ if chapters == 0: text = ' '.join(self.chapters) else: text = ' '.join(self.chapters[:chapters]) ana = analyser.Analyser(text) self.annotations = ana.generate_annotations(caching)
def main(): """ Method for testing pylon creating functions.""" GRAPH = lambda_graph() GRAPH.save_graph("pylon") meshName = "pylon.mesh" cmd = "./population/linuxShow " + meshName process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE) process.communicate() print "nodes:", GRAPH.number_of_nodes() print "edges", GRAPH.number_of_edges() #will it blend? azr = analyser.Analyser('test', "moo", True) azr.my_graph = GRAPH azr.assign_load_case() azr.parse_graph() azr.apply_stresses() azr.create_slf_file() azr.test_slf_file() azr.parse_results() azr.show_analysis()
# -*- coding: utf-8 -*- """ Created on Fri Jul 7 00:32:12 2017 @author: Appu B """ import twitteragent import keys from tweetparser import Parser import analyser agent = twitteragent.Agent(keys.ckey, keys.csecret) agent.set_keys() tweets = agent.search("linux", 300) processed_tweets = Parser(tweets).parse() ar = analyser.Analyser(processed_tweets) reach = ar.calc_reach() x = str(max((processed_tweets['created_at']))) y = str(min((processed_tweets['created_at']))) print("Aanalyzed tweets from %s to %s :" % (y, x)) print("The number of accounts reached :", reach) print("***************************************") populartweets = ar.popular_tweets() print("The most popular tweets") print(populartweets) mostRT = ar.most_RT() print("most rt") print(mostRT) mostFV = ar.most_favorited() print("most favorited") print(mostFV)
def __call__(self, unique_id, program): analyser = AZR.Analyser(unique_id, program) fitness_a, fitness_b, fitness_c = analyser.test_mesh() return fitness_a, fitness_b, fitness_c
new_datasets = analyser.AnalyserUtils.filter_coords( data, True, True, False) for entry in new_datasets: if entry['title_short'] in datasets: print("Dataset already in Plotlist") continue lst_plots.append(entry['title_short']) datasets[entry['title_short']] = entry return datasets plot_types = ['Hexbin', 'Histogram - Blur', 'Histogram - Clear'] plot_type = 'Histogram - Clear' replay_analyser = analyser.Analyser(replay) if 'Wasteland' in replay_analyser.replay.header['MapName']: arena = plotter.WASTELAND overlays = [plotter.OUTLINE, plotter.FIELDLINE] elif 'labs_utopia_p' in replay_analyser.replay.header['MapName']: arena = plotter.UTOPIA_RETRO overlays = [plotter.OUTLINE] else: arena = plotter.STANDARD overlays = [plotter.OUTLINE, plotter.FIELDLINE, plotter.BOOST] hexbin = False interpolate = False # 0.1 - 5 scale = 4.5
print("Sending API call - please wait approx 20 seconds") scan_results = scanner.run_pairs_scan() pp.pprint(scan_results) elif user_choice == 3: print("Please enter the first ticker e.g LTC-PERP") ticker_1 = str(input()) print("Please enter the second ticker e.g DOGE-PERP") ticker_2 = str(input()) analyser = analyser.Analyser(ticker_1, ticker_2) results = analyser.show_scores() print(" ") print("Trace Statistics") print(f"VS: {results[0]}") print(f"Crit-90%: {results[1]}") print(f"Crit-95%: {results[2]}") print(f"Crit-99%: {results[3]}") print(f"EV: {results[4]}") print(f"Crit-90%: {results[5]}") print(f"Crit-95%: {results[6]}") print(f"Crit-99%: {results[7]}")
def __call__(self,UID, program): analyser = AZR.Analyser(UID,program) analyser.test_mesh() fitness = self.calculate_stress(analyser) weight = self.calculate_weight(analyser) return fitness, weight
pylon_graph.connect_nodes(all_brace_ids) pylon_graph.node[all_brace_ids[-1]]['label'] = 'ground' rotated_graph = pylon_graph.copy_and_rotate_around_xy_plane( pylon_graph, 180) mirror_graph = pylon_graph.copy_and_offset_with_mirror( rotated_graph, [0, 0, 0], True) full_graph = pylon_graph.copy_and_rotate_around_xy_plane(mirror_graph, 90) final_graph = pylon_graph.sanitise_pylon(full_graph, width[1]) pylon_graph.replace_graph(final_graph) return pylon_graph testGraph = mutant() testGraph.save_graph("test") analyser = analyser.Analyser('test', "moo", True) analyser.my_graph = testGraph analyser.parse_graph() #using medit to show the graph meshName = "test.mesh" cmd = "./population/linuxShow " + meshName process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE) process.communicate() #using slffea to show the mesh #analyser.apply_stresses() #analyser.create_slf_file()
def run_analysis(indiv): analyser = AZR.Analyser(indiv.UID,indiv.phenotype) analyser.show_mesh()
def apply_annotations(self, text): """Apply the annotations on the words. Args: text (str): The text to annotate. Returns: The annotated text. """ # split text into individual words words = text.split(' ') # Get just the annotation words words_to_annotate = [ann.word for ann in self.annotations] ana = analyser.Analyser(None) # Deal with multiple words proper nouns proposed_ann_word = words[0] in_word = False number_of_words = 1 for index, current_word in enumerate(words): # We need to remove extra stuff, like when looked for annotations current_word = ana.preprocess_input(current_word) # Test next word next_word = "~!~" if index + 1 < len(words): next_word = ana.preprocess_input(words[index + 1]) if not in_word: if (current_word + " " + next_word) in words_to_annotate: proposed_ann_word = current_word + " " + next_word number_of_words = 2 in_word = True continue else: proposed_ann_word = current_word number_of_words = 1 else: if (proposed_ann_word + " " + next_word) in words_to_annotate: proposed_ann_word += " " + next_word number_of_words += 1 continue else: in_word = False # Check if the word or its lower case version is to be annotated if proposed_ann_word in words_to_annotate: # Get the annotation tag ann = self.annotations[words_to_annotate.index( proposed_ann_word)] # We didn't find the meaning if ann.data is None: continue tag = enclose_in_html_tag( 'a', str(proposed_ann_word), { 'class': 'annotation', 'data-content': '' + cgi.escape(ann.data, True), 'title': "<a target='_blank' " + "href='" + ann.url + "'>More</a>" }) # If we have image if ann.image_url is not None and ann.image_url != '': img_tag = enclose_in_html_tag('img', '', { 'class': 'ann-img', 'src': ann.image_url }, False) img_tag += enclose_in_html_tag('figcaption', str(proposed_ann_word)) img_tag = enclose_in_html_tag('figure', img_tag, {'class': 'ann-figure'}) tag += img_tag # Replace the processed word found with a tag with the # annotation if number_of_words == 1: words[index] = re.sub(proposed_ann_word, tag, current_word) else: # Delete words words[index - number_of_words + 1:index + 1] = [] # Replace with tag words.insert(index - number_of_words + 1, tag) # Remove annotation from list if ann in self.annotations: self.annotations.remove(ann) words_to_annotate.remove(proposed_ann_word) # Rebuild the original text text = ' '.join(words) return text
def main(): global loader STX = 2 # 엑셀 파일에 있는 금칙어를 로드, loader = dataloader.DataLoader() loader.load_data('/Users/andrew/Downloads/pWords.xlsx') # 형태소분석기를 로드 tokenizer = analyser.Analyser() # TCP/IP 구성 정보를 로드 global tcp_config global conn global interval try: with open('tcp_config.json', encoding='utf-8') as json_file: tcp_config = json.load(json_file) except FileNotFoundError: print("No File exists...") exit('socket configuration exception') host = tcp_config['hostname'] port = tcp_config['port'] interval = tcp_config['interval'] error_cnt = 0 while True: conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: conn.connect((host, port)) except ConnectionRefusedError: conn.close() time.sleep(10) continue while True: try: content = conn.recv(200) except socket.error as e: print("error while receiving :: " + str(e), e.errno) if e.errno == errno.EPIPE: conn.close() break else: raise # exit("terminating") except: print("error 2 while receiving :: ") print(errno) break line_time = timeutil.TimeElapsed() if len(content) == 0: error_cnt += 1 if error_cnt > 3: error_cnt = 0 break if content[0] != STX: print('wrong data from the server..') continue actual_data = content[2:] print('[' + actual_data.decode(encoding='cp949') + ']') # 일반로직에 따라수신한 문장의 단어별 일따라 금지어 존재 검색 pword_list = check_pword(actual_data.decode(encoding='cp949')) if len(pword_list) > 1: print(pword_list, len(pword_list)) # 복합명사 처리를 위해 속기기록을 형태소 분석하여 명사만 가져온다 nouns_list = tokenizer.get_noun_tokens( actual_data.decode(encoding='cp949')) for noun in nouns_list: print('Noun', noun) print("Time spent to analyse line: ", line_time.getelapsed()) print('------------------------------------')
def create_meshes(population): """assign uid and creating meshes""" for idx, indiv in enumerate(population): indiv.uid = idx analyser = AZR.Analyser(indiv.uid, indiv.phenotype, True) analyser.create_graph()
import json, analyser, geoLocation, requests, time from scapy.layers.dns import DNS from scapy.layers.inet import TCP, IP from scapy.all import * counter = 0 # rdpcap comes from scapy and loads in our pcap file packets = rdpcap( '/home/mrodger4/workspaces/CS491/network-edge-packet-inspector/server/src/example/pcap1.pcap' ) pcapHelp = analyser.Analyser() # create a for loop for all packets for pkt in packets: counter += 1 data = pcapHelp.analyse(pkt) json.loads(data) print data break # total = len(packets) # current = 0 # start_time = time.time() # for pkt in packets: # current += 1 # data = analyser.analyse(pkt) # temp = json.loads(data) # requests.post('http://localhost:8090/api/pcap/save', json=temp) # print "Uploading: %d/%d" % (current,total) #
def run_analysis(indiv): """create mesh and show it using bmpost""" analyser = AZR.Analyser(indiv.uid, indiv.phenotype) analyser.show_mesh()
for line in loadFile: if line.startswith("phenotype:"): line = line.lstrip("phenotype:") phenotype = line print "writing program to test.py" footer = open("./footer.txt", 'r') saveFile = open("./test.py", 'w') imports = "import analyser, subprocess, graph\nfrom geometry import *\n" saveFile.write(imports) saveFile.write(analyser.python_filter(line) + "\n") for line in footer: saveFile.write(line) saveFile.close analyser = analyser.Analyser('test', phenotype, True) analyser.create_graph() #analyser.parse_graph(analyser.myGraph) #using medit to show the graph meshName = "indiv.test.mesh" cmd = "ffmedit " + meshName process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE) process.communicate() #using slffea to show the mesh analyser.apply_stresses() analyser.create_slf_file()
def create_meshes(population): #assign UID and creating meshes for idx,indiv in enumerate(population): indiv.UID = idx analyser = AZR.Analyser(indiv.UID,indiv.phenotype,True) analyser.create_graph()
def __init__(self, db): self.analyser = analyser.Analyser(db) self.db = db