def Run_Algoritm(Path, Algorithm, Discretization_type, NumOfBins, NumOfNeg): ''' function that runs the algorithm that user choose and return the results of the user inputs and clean the files before that. :return:nothing ''' pre = PreProcessing() test = pd.read_csv(Path + '/test.csv') train = pd.read_csv(Path + '/train.csv') struct = pre.read_structure(Path + '/Structure.txt') pre.Clean_Data(train, struct, Discretization_type, NumOfBins) pre.Delete_Nan_Class_Row(test) pre.Fill_Nan_Values(test, struct) pre.Save_Data(train, Path, 'train') pre.Save_Data(test, Path, 'test') if Algorithm not in ['naive bayes classifier (our)', 'ID3 (our)']: runner = BuildAlgorithm() train, test = runner.Convert_Strings_To_Numbers(Path) return runner.Run(Algorithm, train, test, Path, NumOfNeg) else: process = Processing() model = process.Build_Model(Path, Algorithm, train) process.Save_Model(Path, model) train = pd.read_csv(Path + '/train.csv') pre.Delete_Nan_Class_Row(train) pre.Fill_Nan_Values(train, struct) return process.Running_Algorithm(Path, Algorithm, train, test)
def Validation(model, optimizer, lossfunction, targetvar, train_graphs, val_graphs, train_queue, val_queue, val_queue_fill, train_queue_fill, workers, batch_size, val_batches, epoch, epochs): deadcheck = False traincheck = False val_loss = torch.tensor([0], dtype=float).to(device) for k in range(val_batches): with torch.no_grad(): batch = Processing.GrabBatch(val_queue, device) output = model(batch)[:, 0] loss = lossfunction(output, batch.y[:, targetvar]) val_loss += loss deadcheck = Processing.Process_check(val_queue_fill, deadcheck, k, val_batches) if deadcheck == True and traincheck == False and epoch < epochs - 1: train_queue_fill = Processing.Spawn_Processes( workers, train_graphs, train_queue, batch_size) traincheck = True deadcheck = Processing.Process_check(val_queue_fill, deadcheck, k, val_batches) if deadcheck == False: print('Validation Processes Still Alive. Terminating...') for process in val_queue_fill: process.terminate() if epoch < epochs - 1: train_queue_fill = Processing.Spawn_Processes( workers, train_graphs, train_queue, batch_size) return val_loss, train_queue_fill
def runExperiment(filter, removedWordFile, modelfile, resultFile, vocabFile): data = FileReader.getData(fileToRead, types, 2018) vocabDict = data[0] catDict = data[1] sortedVocabDict = OrderedDict(sorted(vocabDict.items())) removedWords = Processing.filterAndRemove(sortedVocabDict, catDict, filter) Utility.outputListToFile(sortedVocabDict.keys(), vocabFile) Utility.outputListToFile(removedWords, removedWordFile) Processing.smoothAllCategories(vocabDict, catDict, smoothingValue) ModelGenerator.outputModelToFile(modelfile, sortedVocabDict, catDict, smoothingValue) model = FileReader.getModel(modelfile) testData = FileReader.getTestData(fileToRead, 2019) return ModelGenerator.outputBaysianClassification(resultFile, testData, model, types, sortedVocabDict, catDict)
def Predict(model,prediction_graphs,workers,pred_mini_batches,batch_size,currfolder,device,targetvar): # print('PREDICTING: \n \ # model : %s \n \ # n_events: %s' %(baseline,pred_mini_batches*batch_size)) predictions = [] truths = [] pred_events = [] manager = torch.multiprocessing.Manager() q = manager.Queue() slaves = Processing.Spawn_Processes(workers, prediction_graphs, q,batch_size) dead_check = False model.eval() with torch.no_grad(): for mini_batch in range(0,pred_mini_batches): data = Processing.GrabBatch(q,device) prediction = model(data) truth = Pidclass(data.y[:,targetvar]).unsqueeze(1).detach().cpu().numpy() pred_events.extend(data.event_no.detach().cpu().numpy()) predictions.extend(prediction.detach().cpu().numpy()) truths.extend(truth) dead_check =Processing.Process_check(slaves, dead_check, mini_batch, pred_mini_batches) #print (" predict batch ",mini_batch,"out of " ,pred_mini_batches) if( dead_check == False): for slave in slaves: slave.terminate() print('Saving results...') truths = pd.DataFrame(truths) predictions = pd.DataFrame(predictions) pred_events = pd.DataFrame(pred_events) result = pd.concat([pred_events,truths, predictions],axis = 1) result.columns = ['event_no','Pid','Antineutrino','Neutrino'] result.to_csv(currfolder + 'predictions.csv',index=False)
def main(): scanner = Processing.League_Scanner(model_path) img = getimg() while True: img = getimg() img = Processing.process(img, scanner) cv2.imshow("", img) cv2.waitKey(int(1000 / fps))
def addtoredemption(): print("hello") Processing.addtoredemptionhistory(session['user'], session["cardname"], session["cardno"]) session.clear() session['user'] = "******" session["cardname"] = "UOB Platinum Card" session["cardno"] = "9888-6121-0824-1112" return redirect(url_for('allredemption'))
def catalogueuob(): session['user']="******" session["cardname"] = "UOB Platinum Card" session["cardno"]= "9888-6121-0824-1112" if request.method == 'POST': session['cart'] = True fullname = request.form["fullname"] itempoint = request.form["point"] currentpoint = request.form["currentpoint"] redeempoint = request.form["redeempoint"] quantity = request.form["quantity"] print(quantity ) if quantity == "0": flash("Enter a valid quantity!", 'danger') else: Processing.cartdict(session['user'],session["cardname"],session["cardno"],fullname, itempoint,currentpoint,redeempoint,quantity ) print("You have successfully redeemed {} {}".format(quantity, fullname)) # listqty=Processing.list_qty(session['user'],session["cardno"]) uob_redeempts = Processing.processredeemedpoints(session['user'],session["cardname"],session["cardno"]) uob_currentpts = Processing.processcurrentpoints(session['user'],session["cardname"],session["cardno"]) uob_preferreditems = Processing.processpreferreduob(session['user'],session["cardname"],session["cardno"]) uob_allitems = Processing.processallitems(session['user'],session["cardname"],session["cardno"]) uob_retialitems = Processing.processretailitems(session['user'],session["cardname"],session["cardno"]) uob_diningitems = Processing.processdiningitems(session['user'],session["cardname"],session["cardno"]) uob_leisureitems = Processing.processleisureitems(session['user'],session["cardname"],session["cardno"]) #user = session["user"], cardno = session["cardno"], return render_template('catalogueuob.html',uobcurrentpts=uob_currentpts, uobredeempts=uob_redeempts, uobpreferreditems = uob_preferreditems, uoballitems = uob_allitems,uobretialitems=uob_retialitems, uobdiningitems=uob_diningitems, uobleisureitems=uob_leisureitems)
def trying(): uob_currentpts = Processing.processpoints() uob_allitems = Processing.processallitems uob_retialitems = Processing.processretailitems() uob_diningitems = Processing.processdiningitems() uob_leisureitems = Processing.processleisureitems() return render_template('trying.html', uobcurrentpts=uob_currentpts, uoballitems=uob_allitems, uobretialitems=uob_retialitems, uob_diningitems=uob_diningitems, uobleisureitems=uob_leisureitems)
def cartuob(): uobcheckoutList=[] checkoutpoints = Processing.processredeemedpoints(session['user'],session["cardname"],session["cardno"]) uobcheckoutList = Processing.checkout(session['user'],session["cardname"],session["cardno"]) if request.method == 'POST' and 'remove' in request.form: position = request.form["remove"] print(position) Processing.removeitem(session['user'], session["cardname"],session["cardno"],position) return redirect(url_for('cartuob')) return render_template('cartuob.html', uobcheckout=uobcheckoutList, uobcheckoutpts=checkoutpoints)
def r(self): from importlib import reload import traceback import Processing as p try: # Do some things. time.sleep(1) p = reload(p) p.test(driver, self.filename) except Exception: traceback.print_exc()
def formAutomation(self, event): # Hide frame window self.Hide() # Close driver window self.driver.quit() print('Completed Selenium Form Tests') print('Processing...') # Processing and collating analytics data Processing.csv_prettifier(str(Path(self.homeDir + '/Downloads')), '', self.formOutput.GetValue(), True) print('\nComplete') sys.exit()
def doLive(self, lastLength): """ @param lastLength: Last length of file (only read newly logged lines) @return: Processed data, current timestamp, current file length (-1 if finished) Opens the DD logfile and parses all lines up to lastLength No multithreading is performed, as its intended for minor(live) updates only. """ try: logfile = open(self.logfilename, "r") filedata = logfile.readlines() filedata = filedata[lastLength:] logfile.close() except IOError: return [], -1 processedData = [] # No reverse, already have the starting point and such. for L in filedata: data = L.strip() # Attempt to match data (no match for chat, petspam, logout messages, etc) ret = Processing.getMatch(data) if ret == None: continue # Store data and continue loop processedData.append(ret) # END-WHILE return processedData, len(filedata)
def setUp(self): # initialize a configuration object self.session = Processing.Session() # create simulated system input arguments sys_argv = [ \ '/Users/abelbrown/Documents/workspace/ATG/src/Processing.py' ,\ '--year=2013' ,\ '--doy=201' ,\ '--expt=anet' ,\ '--org=aws' ,\ '--stn=igs.yell' ,\ '--stn=igs.p213' ,\ '-stn=igs.yell' ,\ '--network_id=n1' ,\ '--should_iterate=no' ,\ '--sp3_type=osf' ,\ '--dns=napeos' ,\ '--eop_type=bull_b' ,\ '--expt_type=RELAX' ,\ '--minspan=10' \ ] # configure the object using this list of arguments self.session.configure_with_args(sys_argv)
def preProcessExamples(posWords, negWords): count = 0 for fName, example in fileToExample.items(): phrases, tokens, example.label = Processing.getPhrasesAndTokens( example.content, posWords, negWords) example.phrases = phrases example.tokens = tokens if example.label > 0: example.label = 2 elif example.label < 0: example.label = 1 label = 1 for phrase in phrases: addPhrase(phrase, example.rating) for token in tokens: label += addToken(token, example.rating, posWords, negWords) if label > 0: example.groundTruth = 2 elif label < 0: example.groundTruth = 1 fileToExample[fName] = example count += 1 filterPhrasesAndTokens() calculateScore()
def revert(self, symbol, previous=None): """ revert from StateFinder states by using the transition matrix """ if not int(float(symbol[2])) in self.tab: return [symbol] if int(symbol[1]) - int(symbol[0]) < 0: return [] mat = self.tab[int(float(symbol[2]))] sym = [] if previous not in mat: (sval, slen) = self.selectStart(mat) else: (sval, slen) = self.selectNext(mat, previous) curt = int(symbol[0]) while curt < int(symbol[1]): sym.append([ int(curt), int(min(curt + (slen * self.rate), int(symbol[1]))), sval ]) curt += (slen * self.rate) (sval, slen) = self.selectNext(mat, sval) if len(sym) > 0: sym[len(sym) - 1][1] = int(symbol[1]) else: sym.append([int(symbol[0]), int(symbol[1]), sval]) prle = Processing.RLEProcess() return prle.batch_process(sym)
def main(): beer_dataframe = [] # Dataframe de la mustra crafted_beer_db = MongoDatabase('mongodb://localhost:27017/', 'Crafted-Brewery-Database') style_histogram = {} for i in range(0, CRAFTED_BEER_SETS): retrieved_data = crafted_beer_db.fetch_collection( 'Crafted-Brewery-Beers-' + str(i)) beer_dataframe.extend(retrieved_data) # Ranking de los estilos de cerveza mas comunes style_histogram = Processing.data_histogram(retrieved_data, 'Style', histogram=style_histogram) style_histogram.pop("N/A") # Con todos los datos listos, pasamos a un Dataframe para facilitar la visualizacion import seaborn as sns import matplotlib.pyplot as plt beer_dataframe = pd.DataFrame(beer_dataframe) pairplot = beer_dataframe.loc[:, ['ABV', 'IBU']] sns.pairplot(pairplot) plt.savefig('..\Results\Crafted-beer-correlation-pairplot.png') return
def processing_picam(queue1, queue2, resolution, framerate): """ Processing with the Pi cam This function is the function executed by the first thread, it launch the capture of images by the camera and process them by the algorithm established in the file "Processing". Each image returned by the processing algorithm is put on a queue. :param queue1: the fist queue where to put images detected :param queue2: the second queue where to put images detected :param resolution: the resolution of the camera :param framerate: the framerate of the camera """ # Camera configuration camera = PiCamera() camera.resolution = resolution camera.framerate = framerate rawCapture = PiRGBArray(camera, size=resolution) # Give time to make the focus time.sleep(2) i = 0 # Global loop for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True): image = frame.array # Convert frame to array understood by OpenCv images = Processing.pre_processing(image) # Image processing # images_end = Processing.pre_processing_end(image) # !!! WIP !!! images_end = None # TODO : solve end of speed limit detection if images is not None: if i % 2 == 0: queue1.put((images, "speed_limit")) else: queue2.put((images, "speed_limit")) if images_end is not None: if i % 2 == 0: queue1.put((images_end, "speed_limit_end")) else: queue2.put((images_end, "speed_limit_end")) rawCapture.truncate( 0) # Clear the stream in preparation for the next frame if cv2.waitKey(40) & 0xFF == ord('q'): break print("END") print("") print("") # Reset the counter to avoid big number problems if i <= 11: i = i + 1 else: i = 0 cv2.destroyAllWindows()
def setUp(self): # initialize a configuration object self.session = Processing.Session() # init session object properly self.session.options['year'] = 2012 self.session.options['doy'] = 201
def alldbsredemption(): alldbsredemptionList = [] alldbsredemptionList = Processing.processalldbsredemption( session['user'], session["cardno"]) return render_template('alldbsredemption.html', alldbsredemptions=alldbsredemptionList) return render_template('alldbsredemption.html')
def preprocess(parentDir): global rating subdirs = ["/pos", "/neg"] for subdir in subdirs: for fileName in listdir(parentDir + subdir): fname = parentDir + subdir + "/" + fileName example = Example() example.content = readFileContent(fname) example.klass = subdir[1:] example.rating = int(fileName.split("_")[2]) rating[int(fileName.split("_")[2])] = rating[int( fileName.split("_")[2])] + 1 example.name = fileName fileToExample[fname] = example negWords = Processing.getNegativeWords(parentDir) posWords = Processing.getPositiveWords(parentDir) processRatings() preProcessExamples(posWords, negWords) preProcessExamplesWithHash()
def pageLoads(self, event): # Hide frame window self.Hide() # Finding all navigation links and the associated analytics data AnalyticsHits.endpoint_hits(self.webURL.GetValue(), self.homeDir, self.driver) # Close driver window self.driver.quit() print('Downloaded Analytics Data') print('Processing...') # Processing and collating analytics data Processing.csv_prettifier(str(Path(self.homeDir + '/Downloads')), 'Endpoints.csv', 'Pageloads.xlsx', False) print('\nComplete!') sys.exit()
def train_event_fillers(patients): # Train model features, labels = Processing.features_and_labels(patients) classifier, feature_map = Classification.train_classifier(features, labels) # Write models to file classf_file = MODEL_DIR + EVENT_FILLER_MODEL_NAME featmap_file = MODEL_DIR + EVENT_FILLER_FEATMAP_NAME joblib.dump(classifier, classf_file) Pickle.dump(feature_map, open(featmap_file, "wb"))
def main(): while True: screen = GetScreen('TetrisOnline') processed_screen = Processing.ProcessImage(screen) cv2.imshow('window', processed_screen) if cv2.waitKey(25) & 0xFF == ord('q'): cv2.destroyAllWindows() break
def test_connect_to_processing(self): import Processing engine = self.connectivityFixture() outports = Connectors(engine, "multi1", Connector.Port, Connector.Out) processing = Processing.Processing("multi2", engine) self.assertEqual(3, outports > processing) self.assertEqual([], engine.controlConnections()) self.assertEqual([ ('multi1', 'OutPort1', 'multi2', 'InPort1'), ('multi1', 'OutPort2', 'multi2', 'InPort2'), ('multi1', 'OutPort3', 'multi2', 'InPort3'), ], engine.portConnections())
def trying(): session["cart"] = {} session['user'] = "******" session["cardno"] = "9888-6121-0824-1112" # listqty=Processing.list_qty(session['user'],session["cardno"]) uob_currentpts = Processing.processpoints(session['user'], session["cardno"]) uob_trenditems = Processing.processtrenditems(session['user'], session["cardno"]) uob_allitems = Processing.processallitems(session['user'], session["cardno"]) uob_retialitems = Processing.processretailitems(session['user'], session["cardno"]) uob_diningitems = Processing.processdiningitems(session['user'], session["cardno"]) uob_leisureitems = Processing.processleisureitems(session['user'], session["cardno"]) #user = session["user"], cardno = session["cardno"], return render_template('trying.html', uobcurrentpts=uob_currentpts, uobtrenditems=uob_trenditems, uoballitems=uob_allitems, uobretialitems=uob_retialitems, uobdiningitems=uob_diningitems, uobleisureitems=uob_leisureitems)
def getSpo2(self,numSeconds, samplerate): print "begin measure" startTime = wiringpi.millis() Spo2 = Sp2.Spo2Sensor(sampleAvg= 8,sampleRate=samplerate) newSample = False AFthreshold= 17 Spo2.enableAfull() Spo2.setFIFOAF(AFthreshold) interrupt = Button(7) while wiringpi.millis()-startTime < numSeconds*1000: interrupt.when_activated = Spo2.sampleAvailable() if Spo2.newSample == True: Spo2.readSample() Spo2.newSample = False print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" print "Buffer IR: ", len(Spo2.buffer_ir) print "Buffer Red: ", len(Spo2.buffer_red) pro = pr.Processing() #get Red and Ir buffers self.IR = Spo2.buffer_ir self.Red = Spo2.buffer_red #Delay Signal to avoid start overshoot #self.Red = pro.delaySignal(self.Red) #self.IR = pro.delaySignal(self. IR) #Median filter to the signals self.IR = sp.medfilt(self.IR) self.Red = sp.medfilt(self.Red) #low pass filter at 60hz #self.IR = pro.NotchFilter(self.IR, 60,samplerate) #self.Red = pro.NotchFilter(self.Red, 60,samplerate) #lowpass filter at 6Hz: #self.IR = pro.lowPasFIRFilter(self.IR, 6,samplerate) #self.Red = pro.lowPasFIRFilter(self.Red, 6,samplerate) #Compute Spo2Value: self.Spo2Value = pro.calcSpO2(self.Red,self.IR) print "Spo2: ", Spo2Value, "%" #get AC componente to plot the signal: self.Red = pro.getACcomponent(self.Red) self.IR = pro.getACcomponent(self.IR) self.IR = pro.Normalize(self.IR)
def main(camDimensions,per): pygame.init() pygame.camera.init() print("Finding all cameras...") cameras = list_real_cameras() print("Searching for Intel RealSense...") camNumber = findRealSense(cameras) if camNumber != "Error, No <Intel(R) RealSense(TM) 3D Camera> found": print("Identified realSense.") realSense = pygame.camera.Camera(camNumber, camDimensions ) print("Running camera %s" %camNumber) realSense.start() # grab first frame img = realSense.get_image() WIDTH = img.get_width() HEIGHT = img.get_height() screen = pygame.display.set_mode( ( WIDTH, HEIGHT ) ) pygame.display.set_caption(realSense.dev.getdisplayname()) #print("Opening new Camera...") print("----------------------------------") #import Embedded mode = "waiting" infeltrationCount = 0 Running = True while Running : # draw frame screen.blit(img, (0,0)) pygame.display.flip() # grab next frame if per: loadimg = pygame.image.tostring(img, "RGBA",False) pil_image = Image.frombytes("RGBA",(640,480),loadimg) p = Processing.colorPerc(pil_image,136) print(p) img = realSense.get_image() for e in pygame.event.get() : if e.type == pygame.QUIT : #realSense.stop() pygame.quit() Running = False break elif e.type == pygame.KEYDOWN: if e.key == pygame.K_SPACE: pygame.display.set_caption("Captured") name = getTimeString() print("Captured: " + name) pygame.image.save(realSense.get_image(),"../media/" + name + ".png") pygame.display.set_caption(realSense.dev.getdisplayname())
def Trainloop(model,optimizer,lossfunction,targetvar,device,train_graphs,val_graphs,workers,batch_size,train_batches,val_batches,epochs): average_train_loss_per_epoch = list() average_val_loss_per_epoch=list() for epoch in tqdm(range(epochs)): deadcheck=False valcheck=False model.train() train_loss = torch.tensor([0],dtype = float).to(device) if epoch==0: Manager=torch.multiprocessing.Manager() train_queue=Manager.Queue() val_queue=Manager.Queue() train_queue_fill=Processing.Spawn_Processes(workers, train_graphs, train_queue, batch_size) for k in range(train_batches): with torch.enable_grad(): model.train() batch=Processing.GrabBatch(train_queue,device) optimizer.zero_grad() output=model(batch) # print (output) # print (batch.x,output.size(),batch) # print(output.size()) loss=lossfunction(output,batch.y[:,targetvar]) # print (loss) loss.backward() optimizer.step() # print (loss,output,batch.y[:,targetvar]) deadcheck=Processing.Process_check(train_queue_fill,deadcheck,k,train_batches) train_loss +=loss if deadcheck==True and valcheck==False: val_queue_fill=Processing.Spawn_Processes(workers,val_graphs,val_queue,batch_size) valcheck=True # print (k) if(torch.sum(torch.isnan(output)) != 0): raise TypeError('NAN ENCOUNTERED AT : %s / %s'%(k,train_batches)) if( deadcheck == False): print('Training Processes Still Alive. Terminating...') for process in train_queue_fill: process.terminate() val_queue_fill=Processing.Spawn_Processes(workers,val_graphs,val_queue,batch_size) if deadcheck==True and valcheck==False: valcheck=True with torch.no_grad(): val_loss,train_queue_fill=Validation(model,optimizer,lossfunction,targetvar,train_graphs,val_graphs,train_queue,val_queue,val_queue_fill,train_queue_fill,workers,batch_size,val_batches,epoch,epochs) average_train_loss_per_epoch.append(train_loss.item()/(train_batches*batch_size)) average_val_loss_per_epoch.append(val_loss.item()/(val_batches*batch_size)) print (train_loss.item()/(train_batches*batch_size)) deadcheck=Processing.Process_check(train_queue_fill,deadcheck,k,train_batches) if( deadcheck == False): print('Training done. Terminating slaves...') for process in train_queue_fill: process.terminate() del batch,loss,train_loss,val_loss return model,average_train_loss_per_epoch,average_val_loss_per_epoch
def evaluate_best_cfa_threshold(x_tst, y_true, thresholds): """ Takes training data and a list of thresholds and calculates confusion matrices for each threshold :param x_tst: The test data :param y_true: The test labels :param thresholds: List of thresholds :return: """ print("Evaluating CFA Feature...") y_cfas = [] y_peakis = [] confusion_matrices = [] for file in tqdm(x_tst): #print("Current file: " + file) # Calculate the spectrogram spectrogram = Processing.cfa_preprocessing(file) # CFA classification cfa, peakis = CFA.calculate_cfa(file, spectrogram) y_cfas.append(cfa) y_peakis.append(peakis) for threshold in thresholds: print("Evaluation for CFA with threshold " + str(threshold) + ":") y_pred = [] for peakis in y_peakis: if np.mean(peakis) < threshold: y_pred.append(0) # Speech else: y_pred.append(1) # Music report = sklearn.metrics.classification_report(y_true, y_pred, labels, target_names) confusion_matrix = sklearn.metrics.confusion_matrix( y_true, y_pred, labels) print("Report") print(report) print("Confusion Matrix") print(confusion_matrix) confusion_matrices.append(confusion_matrix) #pretty_print(confusion_matrix, "CFA", iteration=str(iteration) + "_" + str(threshold)) print( "----------------------------------------------------------------- \n\n" ) return confusion_matrices # Confusion matrices of all thresholds for 1 run
def post(self): image = request.files["file"] image.filename = "test.jpg" print(image) filename = secure_filename(image.filename) image.save( os.path.join( 'C:/Users/Maciek/Documents/Github/FYP/FYP/Backend/userImage', filename)) result = "null" result = Processing.predictResult() ret = result.astype(str) print(ret) return ret
def initialize(self): # create date object self.date = pyDate.Date(year=self.options['year'], doy=self.options['doy']) # check for pre-existing solution if lazy (solutionAlreadyExists, key) = Resources.soln_exists(self.date, self.options['expt'], self.options['org'], self.options['network_id']) if solutionAlreadyExists and self.isLazy: raise Processing.LazyException("file exists: " + key) # do all the program independent stuff super(Session, self).initialize() # get the resource bucket path bucket = self.get_resources_path() # get the apr file apr_file = glob.glob(os.path.join(bucket, '*.apr')) # yell about it if not found if len(apr_file) != 1: raise GamitException('problem identifying APR resources in ' + bucket) # create apr file wlapr2apr(os.path.join(bucket, apr_file[0])) # get the binaries for gamit self.files['bin'] = Resources.get_bin('gamit', self.work_dir_path) # get the tables for gamit self.files['tables'] = Resources.get_tables('gamit', self.work_dir_path) # create custom setup shell script self.files['setup_script_path'] = self.__create_setup_script() # create custom run script self.files['run_script_path'] = self.__create_run_script() # create the custom cleanup script self.files['teardown_script_path'] = self.__create_teardown_script()
def main(): MAP_WIDTH = 25 MAP_HEIGHT = 25 PLAYER = Objects.Player(int(MAP_WIDTH / 2), int(MAP_HEIGHT / 2)) ITEMS = Objects.Items() ENEMIES = Objects.spawnEnemies(5, MAP_WIDTH, MAP_HEIGHT) MAP = Maps.TestMap(MAP_WIDTH, MAP_HEIGHT, PLAYER, ITEMS, ENEMIES) timer = 0 while True: # Print Updated Map MAP.printMap(PLAYER, ITEMS) # Input from User inp = Processing.processInput(PLAYER, MAP, ITEMS, ENEMIES) # TODO: Update Map, based on input and player position MAP.updateMap(inp, PLAYER, ENEMIES, timer) timer += 1 return (0)
def find_attributes_per_substance(classifier, feature_map, sent, previous_sent): """ Get all attributes assigned to each substance -- {substance: field: [Attributes]} """ attribs_found_per_substance = {subst: {} for subst in SUBSTANCE_TYPES} # Get features attrib_feature_sets, attributes = Processing.features(sent, previous_sent) # Get classifications for attrib, features in zip(attributes, attrib_feature_sets): # If there is only one substance for the type of attribute, just assign to that substance if attrib.type in KNOWN_SUBSTANCE_ATTRIBS: add_attrib_with_known_substance(attribs_found_per_substance, attrib) # Else, use machine learning classifier else: add_attrib_using_classifier(classifier, feature_map, features, attribs_found_per_substance, attrib) return attribs_found_per_substance
def run(dt,outdir): #org = ['g06']; #expt = ['glbl','glbf','glbd','anet','gnet','capp','swpp','tigg','glbk']; #expt = ['glbk']; #expt = ['anet','gnet']; expt = ['glbf']; org = ['n08']; for e in expt: for o in org: # construct the AWS/S3 bucket path soln_bucket = Processing.solution_bucket(dt.year,dt.doy,'',e,o,None); # ok get the snx with this bucket prefix files = Resources.get_resources(soln_bucket, '.mat.gz', outdir); # blab about it ... maybe if len(files) > 0: print soln_bucket,len(files);
def run(fileName): org = ['g06']; expt = ['odot']; fparts = fileName.split('.'); # defensive check if len(fparts) != 4: return; for e in expt: for o in org: # construct the AWS/S3 bucket path soln_bucket = Processing.solution_bucket(fparts[1],fparts[2],'',e,o,fparts[3]); # ok get the snx with this bucket prefix files = Resources.list_resources(soln_bucket,'.mat.gz'); # blab about it ... maybe if len(files) == 0: print 'no solution for',fileName;
import glob import os import sys sys.path.append("PIL") import Processing for filename in glob.glob('input/*.gif'): im = Processing.open(filename) im = im.convert('1') newFilename = os.path.splitext(filename)[0] + '.pbm' im.save(newFilename) print('python tspart.py "' + newFilename + '" "output/' + os.path.splitext(os.path.basename(filename))[0] + '.svg"') os.system('python tspart.py "' + newFilename + '" "output/' + os.path.splitext(os.path.basename(filename))[0] + '.svg"')