def __init__(self, Sound=None): self.spritesheet = Image.SpriteSheet(path="res\\testSheet.png", spriteSize=32) self.OffsetX, self.OffsetY = 0, 0 self.animTiles = [] self.backRendered = False self.playerInputs = Constants.PlayerControls self.Entities = [] super().__init__() self.TileMap, caverns = Mapper.generateCellularAutomata() self.entitypositions = Mapper.placeEnemiesCellular(caverns) for position in self.entitypositions: self.Entities.append( Entities.TestEnemy(x=position[1], y=position[0], Map=self.TileMap)) playerPos = choice(caverns[0]) while playerPos in self.entitypositions: playerPos = choice(caverns[0]) self.player = Entities.Player(x=playerPos[1], y=playerPos[0], map=self.TileMap) self.graph = Pathfinding.Graph(self.TileMap) self.Sound = SoundHandler.Sound() self.Sound.PlayMusic('res/SFX/music.wav') self.offsetScene()
def run(input_): operator = '' a = Stack() # Stack Excution Test count = 0 for i in input_: if i[0] == 'L': a.Loader(i[1]) a.StackViewer() elif i[0] == 'T': temp = [] temp.append(operator) temp.append(a.getStack()) temp.append(i[1]) print(Mapper.Mapper(temp)) a.ClearStack() else: a.StackViewer() print(i) if len(a.stack) == 0: print(Mapper.Mapper(i)) else: a.StackViewer() print(i) operator = i[0] a.ClearStack() a.StackViewer()
def main(): """Funcion principal, donde interactuamos con las demas clases pasandoles los ficheros necesarios e instanciando las clases del MapReduce""" num_cores = 4 files = getArgs() file_manager = FileManager(files) lines_files = file_manager.split_in_lines() num_lines = len(lines_files) partialPart = num_lines / num_cores difference = num_lines - (partialPart * num_cores) mapper = Mapper("") for i in range(partialPart, (num_lines - partialPart) + 1, partialPart): t = threading.Thread(mapper.mapping(lines_files[i - partialPart:i])) t.start() t = threading.Thread( mapper.mapping(lines_files[num_lines - (partialPart + difference):num_lines])) t.start() shuffleDict = mapper.shuffle(mapper.wordsMap) reducer = Reducer() result = reducer.reduce(shuffleDict) dirToTxt(result)
def calcColor(radlvl): """ Determines color based on Mapper.py's color calculation functions. """ red = Mapper.calcRed(radlvl) green = Mapper.calcGreen(radlvl) blue = Mapper.calcBlue(radlvl) return "#" + red + green + blue
class Earcon(object): mapper = Mapper.Mapper() def __init__(self, mapped_values): scale = self.retrieve_scale() self.earcon = self.create_motive(scale, mapped_values) def retrieve_scale(self): scale = Scale.Scale(self.mapper.degree, self.mapper.octave, self.mapper.type).scale return scale def create_motive(self, scale, mapped_values): for item in mapped_values: for key, value in item.items(): if key == "frequency": if value is not None: new_value = scale[value] else: new_value = scale[0] else: if value is not None: new_value = self.mapper.durations[value] else: new_value = self.mapper.durations[-1] item[key] = new_value return mapped_values
def __init__(self): self.provider = DocumentProvider.DocumentProvider() self.jsonMod = JsonModifier.JsonModifier() self.mngCollCreator = MongoCollectionCreator.MongoCollectionCreator().create_collections() self.mapper = Mapper.Mapper() tc = TailableCursor.TailableCursor(self).watch_collection_changes()
def calculate_aggregate_loans(self): # Mapper object aggregator_map = Mapper.Mapper(self.input_path) data = aggregator_map.create_data_frame() # Reducer object reducer = Reducer.Reducer(data) reducer.reduce() reducer.print_to_csv(self.output_path)
def __init__(self, frame, size): self.size = size # make a new camera based on the size of the frame, then create the frame and add a start button. self.camera = Camera((0, 0), self.size[0] // Unit.UNIT, self.size[1] // Unit.UNIT, Unit.UNIT) self.player = Player(100, 100, Unit.UNIT, Unit.UNIT) self.keyboard = Keyboard() self.result = States.STATES[1] frame.set_keydown_handler(self.keyboard.key_down) frame.set_keyup_handler(self.keyboard.key_up) sound = Sound() self.tiles = Mapper.get_start_tiles(self.camera) sound.play_death()
def __init__(self, width, height, mapFile): super().__init__(width, height) self.logger = Logger.Logger(pos = Main.WIDTH, width = Main.LOGWIDTH, height = Main.SCREEN_HEIGHT) path1 = Main.getPath("res/TileSheet.png") path2 = Main.getPath("res/AnimTileSheet.png") self.map = Mapper.Map(mapFile, path1, path2) self.CELLMAP = True if self.CELLMAP: self.tileMap, caverns = self.map.getCavernTileMap() playerLocationY, playerLocationX = random.choice(caverns[0]) playerLocation = (playerLocationX, playerLocationY) self.player = Entities.Player(playerLocation[0],playerLocation[1],"res/playerSheet.png",self.tileMap,3,10, self.logger) enemyLocations = self.calculateEnemyPlacements(caverns, playerLocation) self.Entities = [self.player] for each in enemyLocations: seed = random.randint(0,3) if not seed == 1: self.Entities.append(Entities.TestEnemy(each[0],each[1],self.tileMap)) else: self.Entities.append(Entities.Goblin(each[0], each[1], self.tileMap)) else: self.tileMap = self.map.getTileMap() playerLocationY, playerLocationX = (2,2) playerLocation = (playerLocationY, playerLocationX) self.player = Entities.Player(playerLocationY,playerLocationX, "res/playerSheet.png", self.tileMap, 3, 10, self.logger) self.Entities = [self.player] #Will need to make a system of entity placement that isn't hard coded, but Im not entirely sure how other than random generation or messing around with alpha channels. # ^ IGNORE ALREADY DONE WITH RANDOM GEN self.DummyEnemies = [Entities.TestEnemy(5,5,self.tileMap, 100), Entities.TestEnemy(5,7,self.tileMap, 100), Entities.TestEnemy(4,6,self.tileMap, 100), Entities.TestEnemy(6,6,self.tileMap, 100)] self.Entities.extend(self.DummyEnemies) self.graph = Pathing.Graph(self.tileMap) self.animTiles = [] self.renderedBack = False self.CameraX = -(playerLocation[0] * Tiles.TILESIZE - Main.WIDTH/2) self.CameraY = -(playerLocation[1] * Tiles.TILESIZE - Main.HEIGHT/2)
def __init__(self, sg=None, Grange=None, org='mmu', name='SGPlot.eps'): if not sg is None and not isinstance( sg, SpliceGraph.SpliceGraph) and os.path.exists(sg): sg = SpliceGraph.SpliceGraph(filename=sg) if not isinstance(sg, SpliceGraph.SpliceGraph): sys.stderr.write( "ERROR: not a splice graph received in SpliceGraphPlot.") sys.exit(1) elif not Grange is None: # get splice graphs within genomic range pass else: sys.exit(1) self.sg = sg self.file_name = name self.target_type = name.split('.')[1] # load a splice graph mapper self.mapper = Mapper.Mapper(verbose=0) self.initCanvas()
def analyze_tables(self): for table in self.tables_list: print("Section:" + str(table['section_title']) + " ... Trying to analyze this table: " + str(table)) self.set_table(table) self.find_rows() if self.table_rows_list: logging.info("1. rows found") print("1. Rows FOUND") self.find_headers() if self.table_headers: logging.info("2. headers found") print("2. Headers FOUND") self.extract_data() self.refine_data() if self.data_rows: logging.info("3. Data extracted") logging.debug("DATA: " + str(self.data_rows)) print("3. Data extracted") map_tool = Mapper.Mapper(self.chapter, self.graph, self.topic, self.resource, self.data_rows, 'json', table['section_title']) map_tool.map() else: logging.debug( "e3 - UNABLE TO EXTRACT DATA - resource: " + str(self.resource) + "table : " + str(table)) print("e3 UNABLE TO EXTRACT DATA") else: logging.debug( " e2 Unable to find headers - resource: " + str(self.resource) + " under section : " \ + str(table['section_title'])) print("e2 UNABLE TO FIND HEADERS") else: logging.debug(" e1 Unable to rows - resource: " + str(self.resource) + " table : " + str(table)) print(" e1 UNABLE TO FIND ROWS") self.erase_table_data()
def main(): start_time = datetime.now() # Get the parameters parameters = get_args() Mapper.parameters_verification(parameters) typein = parameters.features_include typeout = parameters.features_exclude kmer = parameters.kmer output_name = parameters.o reads_thr = parameters.thr options = list(parameters.options) for input_file in range(len(parameters.fastq)): start_time_input = datetime.now() if len(parameters.fasta) == 1: genome_file = parameters.fasta[0] #path to genome file else: genome_file = parameters.fasta[input_file] genome_name = os.path.basename(genome_file) genome_name = os.path.splitext(genome_name)[0] #name of the genome riboseq_file = parameters.fastq[input_file] #path of the fastq file riboseq_name = os.path.basename(riboseq_file) riboseq_name = os.path.splitext(riboseq_name)[ 0] #name of the riboseq experience if len(parameters.gff) == 1: gff_file = parameters.gff[0] else: gff_file = parameters.gff[input_file] with open("ORFribomap_{}_{}_log.txt".format(riboseq_name, output_name), "w") as log: # 1. Annotation of the ORFs with ORFtrack mapping_gff = "mapping_orf_{}.gff".format(genome_name) if os.path.exists( mapping_gff ): #if the ORFtrack file exists already, ORFtrack is skipped print( mapping_gff + " exists, it will be used to extract the intergenic ORFs. If the file doesn't result " "from orftrack, please rename it and launch ORFribomap again" .format(genome_name)) else: orftrack_cmd = "orftrack -fna {} -gff {} -chr_exclude chrmt".format( genome_file, gff_file) print("Launch : ", orftrack_cmd) process_orftrack = subprocess.run(orftrack_cmd, shell=True, universal_newlines=True) # 3. Potential launch of cutadapt and definition of the directory that will contain all the analysis files if not parameters.cutdir: cutdir = "." if len(parameters.adapt ) == 1: #the adaptor is used for all the files adapt = parameters.adapt[0] else: adapt = parameters.adapt[ input_file] #each file has its adaptor print(" The cutadapt process will be launched") try: print( "\nNo directory for cutadapt files has been given, the cutadapt process is launching. " "The reads are cut in {}-kmers".format( parameters.kmer)) for size in kmer: log.write( Mapper.cut_reads(size, riboseq_file, adapt, riboseq_name)) except: print('''cutadapt seems to not be installed''') else: #there exist a directory with the the reads already trimmed and cut print( "\nYou entered directory(ies) for cutadapt files. No cutadapt process will be launched" ) time.sleep(1) if len(parameters.cutdir) == 1: cutdir = parameters.cutdir[0] else: cutdir = parameters.cutdir[input_file] for size in kmer: name_dir = "{}/kmer_{}".format(cutdir, size) if not os.path.isdir(name_dir): print( name_dir + " does not exist. The directories need to be named as kmer_x with x the size of " "the kmer. ") exit() # 4.Mapping of the reads on the non-translated sequences print("We start the mapping") # a. Building of the Bowtie index from the orfget output if "I" in options: cmd_bowtie = 'bowtie-build {} {}_all'.format( genome_file, genome_name) print("Command launched: ", cmd_bowtie) process_bowtie = subprocess.run(cmd_bowtie, shell=True, universal_newlines=True, stdout=subprocess.PIPE) log.write(process_bowtie.stdout) else: print( "The basename of Bowtie index files are expected to be : {}_all" .format(genome_name)) # b->f. Mapping of the reads on the Bowtie index if "M" in options: try: #verification that pysam and bokeh are installed import pysam import bokeh except ImportError: print( "You need to install the python packages pysam and bokeh" ) for size in kmer: #mapping of the reads log.write( Mapper.map2bam(cutdir, size, genome_name, riboseq_name, "all")) else: print( "The name and path of the bam files are expected to be :" "./kmer_n/{}_kmer_n_all_sorted_mapped.bam with n the size of the reads" .format(riboseq_name)) # g. Creation of the counting tables and periodicity tables if "B" in options: print("Counting tables are generated") log.write( BAM2Reads(riboseq_name, mapping_gff, kmer, output_name, typein, typeout)) else: print( "The name and path of the counting and periodicity files are expected to be :\n" "./kmer_n/{}_kmer_n_{}_reads.tab with n the size of the reads\n" "./kmer_n/{}_kmer_n_{}_periodicity_start.tab with n the size of the reads\n" "./kmer_n/{}_kmer_n_{}_periodicity_stop.tab with n the size of the reads\n" .format(riboseq_name, output_name, riboseq_name, output_name, riboseq_name, output_name)) # 5. Plotting of phasing, periodicity of the start and the stop if "P" in options: for size in kmer: tab = pd.read_table( "./kmer_{}/{}_kmer_{}_{}_reads.tab".format( size, riboseq_name, size, output_name), sep='\t') # Plot of the reads phase and periodicity Mapper.reads_phase_plot(tab, size, riboseq_name, reads_thr, output_name) Mapper.reads_periodicity(size, riboseq_name, output_name, "start") Mapper.reads_periodicity(size, riboseq_name, output_name, "stop") end_time_input = datetime.now() log.write("Duration for {} :{}".format( riboseq_name, end_time_input - start_time_input)) end_time = datetime.now() print("\n\n") print('Duration: {}'.format(end_time - start_time))
Equalize_bol = True BINS_int = 4 OVERLAP_flt = 0.9 Clust_str = 'CompleteLinkage' ClusterArguments_array = [1] #The epsilon value RightWrong_npArray = np.load('../../Mapper_Data_Files/filter_files/\ Synonyms/rightwrongfilter.npy') while BINS_int < 21: TestObject_ma = ma.Mapper(Cloud_npArray, MetricName_str, LensName_str, LensArguments_array, Equalize_bol, BINS_int, OVERLAP_flt, Clust_str, ClusterArguments_array, DebugMode_bol=False) #TestObject_ma.save_filter_values('../../Mapper_Data_Files/filter_files/', # 'easygoing_neighborsfilters') TestObject_ma.add_mean_properties('RightWrong', RightWrong_npArray) TestObject_ma.load_filter_values( '../../Mapper_Data_Files/filter_files/Synonyms/', 'SynonymsAverageFilter') TestObject_ma.add_filter_to_graph() TestObject_ma.add_labels('Labels', LabelData_npArray)
def analyze_tables(self): """ Method used to analyze tables structure, compose a simple data structure containing data cells and the corresponding headers and give it to a Mapper object. Principal method of a HtmlTableParser object, it finds out headers and data, refines them, and finally join each others in order to be mapped by a Mapper object. :return:nothing """ # Iterates over tables list for html_table in self.tables: # Update the analyzed table count self.tables_analyzed += 1 # Instantiating statistics for this table self.headers_found_num = 0 self.rows_extracted_num = 0 self.data_extracted_num = 0 # set as a class attribute the current html table self.current_html_table = html_table # create a Table object to contain data structures and statistics for a table tab = Table.Table() # set tab.n_rows as a result of count_rows() tab.n_rows = self.count_rows() # set other table properties, such as table attributes tab.table_attributes = html_table.attrib # find out the table section using find_table_section() tab.table_section = self.find_table_section() self.logging.info("Table under section: %s" % tab.table_section) # find headers for this table self.find_headers(tab) # Chose to not use this method as it resolves users' made errors but create problems with correctly # written table # self.check_miss_subheaders(tab) # if headers have been found if tab.headers: self.logging.info("Headers Found") # Refine headers found self.refine_headers(tab) # Once the headers are refined, start to extract data cells self.extract_data(tab) # Refine data cells found self.refine_data(tab) # If data are correctly refined if tab.data_refined: # Count data cells and data rows using table.count_data_cells_and_rows() tab.count_data_cells_and_rows() self.logging.info("Rows extracted: %d" % tab.data_refined_rows) self.logging.info("Data extracted for this table: %d" % tab.cells_refined) # update data cells extracted in order to make a final report self.utils.data_extracted += tab.cells_refined self.utils.rows_extracted += tab.data_refined_rows # Create a MAPPER object in order to map data extracted mapper = Mapper.Mapper(self.chapter, self.graph, self.topic, self.resource, tab.data_refined, 'html', self.utils, tab.table_section) # Start the mapping process mapper.map() # Compose headers not mapped for this resource for header in mapper.headers_not_mapped: if header not in self.headers_not_mapped: # Compose a list with the name of the current resource [0] and with values in [1] support_list = [self.resource, mapper.headers_not_mapped[header]] ''' result Eg in self.headers_not_mapped = {'header1': ['resource1',[value0,value1...]], \ 'header2': ['resource2',[value0, value1, value2...]]...} ''' self.headers_not_mapped[header] = support_list # If no data have been found for this table report this condition with tag E3 else: self.logging.debug("E3 - UNABLE TO EXTRACT DATA - resource: %s" % self.resource) print("E3 UNABLE TO EXTRACT DATA") # Update the count of tables with this condition (no data found) self.no_data += 1 # if no headers have been found report this critical condition with the tag E2 else: self.logging.debug( " E2 Unable to find headers - resource: " + str(self.resource)) print("E2 UNABLE TO FIND HEADERS") # Update the count of tables with this condition (no headers found) self.no_headers += 1 # Adding statistics values and errors to the extraction errors, in order to print a final report self.utils.tot_tables_analyzed += self.tables_analyzed self.utils.headers_errors += self.no_headers self.utils.not_resolved_header_errors += self.headers_not_resolved self.utils.data_extraction_errors += self.no_data
exoutFile6.write("#exon match mode: bothSS\n") exoutFile6.write("#gnId\tgnId\texId\tensemblGnId\tensemblExId\n") exoutFile7.write( "#vega exons for SpliceGraph exons, generated by do_gene_associations.py, indir: %s\n" % options.indir) exoutFile7.write("#exon match mode: singleSS\n") exoutFile7.write("#gnId\tgnId\texId\tensemblGnId\tensemblExId\n") exoutFile8.write( "#vega exons for SpliceGraph exons, generated by do_gene_associations.py, indir: %s\n" % options.indir) exoutFile8.write("#exon match mode: overlap\n") exoutFile8.write("#gnId\tgnId\texId\tensemblGnId\tensemblExId\n") mapper = Mapper.Mapper(verbose=1) sg = sg_iter.next_sg() while (sg): print >> sys.stderr, "doing %s (%i of %i)\r" % ( sg.name, sg_iter.current_index(), sg_iter.number()), # ensembl, exon (gnIds, exIds) = mapper.map2gene(sg, 'ensembl', 'exon') gnInfo = {} maxNbEx = 0 for k in gnIds.iterkeys(): gnInfo[k] = mapper.getGeneInfo(k, 'ensembl', 'biotype') if gnIds[k] > maxNbEx: maxNbEx = gnIds[k]
def main(): start_time = datetime.now() # Get the parameters parameters = get_args() Mapper.parameters_verification(parameters) kmer = range(parameters.kmer[0], parameters.kmer[1] + 1) reads_thr = parameters.thr options = list(parameters.options) for input_file in range(len(parameters.fastq)): start_time_input = datetime.now() if len(parameters.fasta) == 1: genome_file = parameters.fasta[0] else: genome_file = parameters.fasta[input_file] genome_name = os.path.basename(genome_file) genome_name = os.path.splitext(genome_name)[0] riboseq_file = parameters.fastq[input_file] riboseq_name = os.path.basename(riboseq_file) riboseq_name = os.path.splitext(riboseq_name)[0] if len(parameters.gff) == 1: gff_file = parameters.gff[0] else: gff_file = parameters.gff[input_file] with open("ORFphase_{}_log.txt".format(riboseq_name), "w") as log: # 1. Extraction of the non-translated sequences of CDS: genome_CDS = genome_name + "_phasing.nfasta" if os.path.exists(genome_CDS): print( genome_CDS + " exists, it will be used to extract the transcriptome. If the file doesn't result " "from orfget, please rename it and launch ORFphase again". format(genome_name)) else: orfget_cmd = "orfget -fna {} -gff {} -features_include CDS -o {}_phasing -type nucl".format( genome_file, gff_file, genome_name) process_orfget = subprocess.run(orfget_cmd, shell=True, universal_newlines=True, stdout=subprocess.PIPE) # process_orfget = subprocess.run(orfget_cmd, shell=True) log.write(process_orfget.stdout) # 2. Generation of pseudo GFF file of the CDS transcriptome transcriptome_gff = genome_name + "_transcriptome.gff" if os.path.exists(transcriptome_gff): print( transcriptome_gff + " exists, it will be used for aligning the reads, if the file does not result " "from ORFphase, please rename it and relaunch ORFphase please" ) else: transcriptome = read_multiFASTA(fasta_file=genome_CDS) with open(transcriptome_gff, "w") as wgff: for size in transcriptome: wgff.write( '{:20s}\t{}\t{:20s}\t{:d}\t{:d}\t{}\t{}\t{}\t{}\n'. format(size, 'SGD', 'gene', 1, len(transcriptome[size]), '.', '+', '0', str('ID=' + size))) # 3. Potential launch of cutadapt and definition of cutadapt files directory if not parameters.cutdir: cutdir = "." if len(parameters.adapt) == 1: adapt = parameters.adapt[0] else: adapt = parameters.adapt[input_file] print("\nThe cutadapt process will be launched") try: print( "\nNo directory for cutadapt files has been given, the cutadapt process is launching. " "The reads are cut in {}-kmers".format( parameters.kmer)) for size in kmer: log.write( Mapper.cut_reads(size, riboseq_file, adapt, riboseq_name)) except ImportError: print('''cutadapt seems to not be installed''') # with concurrent.futures.ThreadPoolExecutor(max_workers=None) as executor: # for size in kmer: # executor.submit(Mapper.cut_reads, size, riboseq_file, adapt, riboseq_name) else: print( "\nYou entered directory(ies) for cutadapt files. No cutadapt process will be launched" ) if len(parameters.cutdir) == 1: cutdir = parameters.cutdir[0] else: cutdir = parameters.cutdir[input_file] for size in kmer: name_dir = "{}/kmer_{}".format(cutdir, size) if not os.path.isdir(name_dir): print( "The directories need to be named as kmer_x with x the size of the kmer." ) exit() # 4.Mapping of the reads on the non-translated sequences # a. Building of the index print("We start the mapping") if "I" in options: cmd_bowtie = 'bowtie-build {}_phasing.nfasta {}_phasing'.format( genome_name, genome_name) print("Command launched: ", cmd_bowtie) # process_bowtie = subprocess.run(cmd_bowtie, shell=True) process_bowtie = subprocess.run(cmd_bowtie, shell=True, universal_newlines=True, capture_output=True) print(process_bowtie.stderr) log.write(process_bowtie.stdout) else: print( "The basename of Bowtie index files are expected to be : {}_phasing" .format(genome_name)) # b->g. Create count table if "M" in options: try: import pysam import bokeh except ImportError: print( "You need to install the python packages pysam and bokeh" ) for size in kmer: log.write( Mapper.map2bam(cutdir, size, genome_name, riboseq_name, "phasing")) else: print( "The name and path of the bam files are expected to be :" "./kmer_n/{}_kmer_n_sorted_mapped.bam with n the size of the reads" .format(riboseq_name)) if "B" in options: print("Counting tables are generated") log.write( BAM2Reads(riboseq_name, transcriptome_gff, kmer, "phasing")) else: print( "The name and path of the counting file is expected to be :" "./kmer_n/{}_kmer_n_phasing_reads.tab with n the size of the reads" .format(riboseq_name)) # with concurrent.futures.process.ProcessPoolExecutor(max_workers=None) as executor: # executor.map(map_in_bam_and_count, kmer, [gname] * len(kmer), [rname] * len(kmer), [cutdir] * len(kmer), # [parameters.type]*len(kmer),[gff_to_compare]*len(kmer)) # 5. Plotting and finding best read size to have a percentage of phase 0 superior to the threshold if "P" in options: print("The plots of phasing and periodicity are generated") for size in kmer: tab = pd.read_table( "./kmer_{}/{}_kmer_{}_phasing_reads.tab".format( size, riboseq_name, size), sep='\t') # Plot of the reads phase and periodicity print("Phasing plot for kmer {}".format(size)) Mapper.reads_phase_plot(tab, size, riboseq_name, reads_thr, "phasing") print("Periodicity plots for kmer {}".format(size)) Mapper.reads_periodicity(size, riboseq_name, "phasing", "start") Mapper.reads_periodicity(size, riboseq_name, "phasing", "stop") phase_decision_mean_median(kmer, riboseq_name, reads_thr) end_time_input = datetime.now() log.write("Duration for {} :{}".format( riboseq_name, end_time_input - start_time_input)) end_time = datetime.now() print("\n\n") print('Duration: {}'.format(end_time - start_time))
import mygame from pygame.locals import * from Player import * import Players import Mapper import Obj from sys import exit mygame.init() screen = mygame.screen player = Player() player.moveto((3, 89)) players = Players.Players(1, [player]) mp = Mapper.Mapper() mp.load("./data/map/jungle.tmx") mp.set_viewer(player) Obj.Obj.mapper = mp screen.set_mapper(mp) screen.set_viewer(player) default_font = "arial" font = mygame.font.SysFont(default_font, 20) cntClock = 0 cntFrame = 0 cntNetwork = 0 lastClock = time.clock() * 1000
def __init__(self, player): self.platform = Tile.Platform() self.player = player self.inCollisionDown = False self.plat = Mapper.get_platforms()
#!/usr/bin/env python # -*- coding:utf-8 -*- import Mapper import tornado.ioloop import tornado.web settings = { 'template_path': 'Views', 'static_path': 'Statics', 'static_url_prefix': '/statics/', } application = tornado.web.Application( [ #(r"/index", home.IndexHandler), ], **settings) if __name__ == "__main__": Mapper.static_mapper() application.listen(8888) tornado.ioloop.IOLoop.instance().start()
def test_data_frame_with_invalid_csv_file(self): test_mapper = Mapper.Mapper('te3st_loans.csv') with self.assertRaises(ValueError): test_mapper.create_data_frame('csv')
# Make sure output file has a proper value. Input file will be handled by the Parser if outputFile == "": """ Give it the same name as the logFile Also, remove the path (if) trailing the logFile by splicing from the last occurence from '/' """ outputFile = logFile[logFile.rfind("/") + 1:-4] + ".kml" elif outputFile[-4:] != ".kml": outputFile += ".kml" print "Input :", logFile print "Output:", outputFile # Initialize the KML File if widthText == "": KMLWriter.initKML () else: KMLWriter.initKML (widthText) # Map the data obtained from the log file Mapper.mapData (data) # Write all the data to the KML file KMLWriter.endKML (outputFile) """ END - Script Execution """
def create_stack(cls, mongo_uri, cache_dao, google_dao): import .mapper import Mapper return cls(mongo_uri, Mapper(), 'stacks')
def create_outra_coisa(cls, mongo_uri): import .mapper import Mapper return cls(mongo_uri, Mapper(), 'outra_coisa')
def analyze_tables(self): """ Method used to analyze tables structure, compose a simple data structure containing data cells and the corresponding headers and give it to a Mapper object. Principal method of a HtmlTableParser object, it finds out headers and data, refines them, and finally join each others in order to be mapped by a Mapper object. :return:nothing """ # Iterates over tables list for html_table in self.tables: # Update the analyzed table count self.tables_analyzed += 1 # Instantiating statistics for this table self.headers_found_num = 0 self.rows_extracted_num = 0 self.data_extracted_num = 0 # set as a class attribute the current html table self.current_html_table = html_table # create a Table object to contain data structures and statistics for a table tab = Table.Table() # set tab.n_rows as a result of count_rows() tab.n_rows = self.count_rows() # set other table properties, such as table attributes tab.table_attributes = html_table.attrib # find out the table section using find_table_section() tab.table_section = self.find_table_section() print "Section found: ", tab.table_section self.logging.info("Table under section: %s" % tab.table_section) # find headers for this table self.find_headers(tab) # if headers have been found if tab.headers: self.logging.info("Headers Found") # Refine headers found self.refine_headers(tab) if self.mapping: # Once the headers are refined, start to extract data cells self.extract_data(tab) # Refine data cells found self.refine_data(tab) # If data are correctly refined if tab.data_refined: # Count data cells and data rows using table.count_data_cells_and_rows() tab.count_data_cells_and_rows() self.logging.info("Rows extracted: %d" % tab.data_refined_rows) self.logging.info("Data extracted for this table: %d" % tab.cells_refined) # update data cells extracted in order to <make a final report self.utils.data_extracted += tab.cells_refined self.utils.data_extracted_to_map += tab.cells_refined self.utils.rows_extracted += tab.data_refined_rows # Start the mapping process self.all_tables.append(tab) # if i have to map table found (HtmlTableParser can be called even by pyDomainExplorer) # Create a MAPPER object in order to map data extracted mapper = Mapper.Mapper(self.chapter, self.graph, self.topic, self.resource, tab.data_refined, self.utils, self.reification_index, tab.table_section) mapper.map() # update reification index of this resource self.reification_index = mapper.reification_index # If no data have been found for this table report this condition with tag E3 else: self.logging.debug( "E3 - UNABLE TO EXTRACT DATA - resource: %s" % self.resource) print("E3 UNABLE TO EXTRACT DATA") # Update the count of tables with this condition (no data found) self.no_data += 1 else: self.all_tables.append(tab) # if no headers have been found report this critical condition with the tag E2 else: self.logging.debug(" E2 Unable to find headers - resource: " + str(self.resource)) print("E2 UNABLE TO FIND HEADERS") # Update the count of tables with this condition (no headers found) self.no_headers += 1 print "Resource analysis completed \n\n" # Adding statistics values and errors to the extraction errors, in order to print a final report self.utils.tot_tables_analyzed += self.tables_analyzed self.utils.headers_errors += self.no_headers self.utils.not_resolved_header_errors += self.headers_not_resolved self.utils.data_extraction_errors += self.no_data
formatter.generate_validation_file() # Train SOM, if there is no weights. if Path("weights.txt").is_file() is False: # Use pandas for loading data using dataframes. d = os.path.dirname(os.getcwd()) file_name = "huge_merged_csv_file.csv" data = pd.read_csv(file_name, header=None) # Shuffle the data in place. data = data.sample(frac=1).reset_index(drop=True) # create SOM object som = SOM(7, 1) # Train with 100 neurons. som.train(data) # Get output grid grid = som.get_centroids() # Save the weights in a file. result_file = open("weights.txt", "w") result_file.writelines(str(grid)) result_file.close() # Map data to neurons. mapped_vectors = mapper.map_vects() tester.open_test_file() tester.test_som(mapped_vectors)
def test_data_frame(self): dictionary = self.test_dict test_mapper = Mapper.Mapper(dictionary) generated_data_frame = test_mapper.create_data_frame('dict') expected_data_frame = pd.DataFrame(self.test_dict) assert generated_data_frame.equals(expected_data_frame)
def test_data_frame_with_invalid_mode(self): dictionary = self.test_dict test_mapper = Mapper.Mapper(dictionary) with self.assertRaises(ValueError): test_mapper.create_data_frame('csv')
help='method for mapping [default: overlap]'), \ make_option('-p','--inprefix', dest='inprefix', default='SpliceGraphsFiltered_', \ help='iterate over dirs with this prefix [default: SpliceGraphsFiltered_]'), \ make_option('-s','--species', dest='species', default='hsa', \ help='species [default: hsa]'), \ ]) (options, args) = opts.parse_args() if not os.path.isdir(options.inDir): print >> sys.stderr, "ERROR: input directory is not found.\n" opts.print_help(sys.stderr) sys.exit(0) else: mapper = Mapper.Mapper( configFile='/r100/burge/xiao/Tools/splice_graphs/configuration.txt', verbose=1, species=options.species) #mapper = Mapper.Mapper(verbose=1) inDirs = [ d for d in os.listdir(options.inDir) if d.startswith(options.inprefix) ] for inDir in inDirs: chr = inDir.split(options.inprefix)[-1] mapper.mapAllInDir(indir="%s/%s" % (options.inDir, inDir), outfile="%s/Mappings_%s_%s.txt" % (options.inDir, options.type, chr), type=options.type, method=options.method)