def process_and_save(filename): """ Little script to do reading, selecting of the right data, getting it in the right structure and then pickling it. This is supposed to make reading a lot faster when the light cones are to be made. """ picklename = filename+'.pickled' # First check if the pickled version doesn't already exist if '/' in filename: dir = os.listdir(filename.rsplit('/', 1)[0]) else: dir = os.listdir('.') if picklename.rsplit('/', 1)[1] in dir: print "Pickled version already exists for", filename return False data = read_bolshoi(filename, nopickle=True) if not data: return None with open(picklename, 'w') as picklefile: cPickle.dump(data, picklefile) return True
def zip_android(zf, basepath): android_dist_dir = os.path.join(top_dir, 'dist', 'android') zip_dir(zf, os.path.join(cur_dir, 'simplejson'), os.path.join(basepath, 'android', 'simplejson')) android_jar = os.path.join(android_dist_dir, 'titanium.jar') zf.write(android_jar, '%s/android/titanium.jar' % basepath) android_depends = os.path.join(top_dir, 'android', 'dependency.json') zf.write(android_depends, '%s/android/dependency.json' % basepath) titanium_lib_dir = os.path.join(top_dir, 'android', 'titanium', 'lib') for thirdparty_jar in os.listdir(titanium_lib_dir): if thirdparty_jar == "smalljs.jar": continue elif thirdparty_jar == "commons-logging-1.1.1.jar": continue jar_path = os.path.join(top_dir, 'android', 'titanium', 'lib', thirdparty_jar) zf.write(jar_path, '%s/android/%s' % (basepath, thirdparty_jar)) # include all module lib dependencies modules_dir = os.path.join(top_dir, 'android', 'modules') for module_dir in os.listdir(modules_dir): module_lib_dir = os.path.join(modules_dir, module_dir, 'lib') if os.path.exists(module_lib_dir): for thirdparty_jar in os.listdir(module_lib_dir): if thirdparty_jar.endswith('.jar'): jar_path = os.path.join(module_lib_dir, thirdparty_jar) zf.write(jar_path, '%s/android/%s' % (basepath, thirdparty_jar)) android_module_jars = glob.glob( os.path.join(android_dist_dir, 'titanium-*.jar')) for android_module_jar in android_module_jars: jarname = os.path.split(android_module_jar)[1] zf.write(android_module_jar, '%s/android/modules/%s' % (basepath, jarname))
def _fetch_pkg(self, gopath, pkg, rev): """Fetch the package and setup symlinks.""" fetcher = self._get_fetcher(pkg) root = fetcher.root() root_dir = os.path.join(self.workdir, 'fetches', root, rev) # Only fetch each remote root once. if not os.path.exists(root_dir): with temporary_dir() as tmp_fetch_root: fetcher.fetch(dest=tmp_fetch_root, rev=rev) safe_mkdir(root_dir) for path in os.listdir(tmp_fetch_root): shutil.move(os.path.join(tmp_fetch_root, path), os.path.join(root_dir, path)) # TODO(John Sirois): Circle back and get get rid of this symlink tree. # GoWorkspaceTask will further symlink a single package from the tree below into a # target's workspace when it could just be linking from the fetch_dir. The only thing # standing in the way is a determination of what we want to artifact cache. If we don't # want to cache fetched zips, linking straight from the fetch_dir works simply. Otherwise # thought needs to be applied to using the artifact cache directly or synthesizing a # canonical owner target for the fetched files that 'child' targets (subpackages) can # depend on and share the fetch from. dest_dir = os.path.join(gopath, 'src', root) # We may have been `invalidate`d and not `clean-all`ed so we need a new empty symlink # chroot to avoid collision; thus `clean=True`. safe_mkdir(dest_dir, clean=True) for path in os.listdir(root_dir): os.symlink(os.path.join(root_dir, path), os.path.join(dest_dir, path))
def make_target_directory(self, path): path = os.path.abspath(path) try: os.makedirs(path) except OSError as e: self.abort('Could not create target folder: %s' % e) if os.path.isdir(path): try: if len(os.listdir(path)) != 0: raise OSError('Directory not empty') except OSError as e: self.abort('Bad target folder: %s' % e) scratch = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex) os.makedirs(scratch) try: yield scratch except: shutil.rmtree(scratch) raise else: # Use shutil.move here in case we move across a file system # boundary. for filename in os.listdir(scratch): if isinstance(path, unicode): filename = filename.decode(fs_enc) shutil.move(os.path.join(scratch, filename), os.path.join(path, filename)) os.rmdir(scratch)
def test_sequence_output(): directory = tempfile.mkdtemp() assert 0 == len(os.listdir(directory)) cli.main(['--seq', '-v=1', '-e=m', '-o=' + os.path.join(directory, 'test.svg'), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ']) number_of_files = len(os.listdir(directory)) shutil.rmtree(directory) assert 4 == number_of_files
def check_for_node_modules( node_modules ): if os.path.isdir( node_modules ): for dirname in os.listdir( node_modules ): path = os.path.join(node_modules, dirname) for filename in os.listdir(path): if filename.endswith('.js'): PATHS[ 'modules' ][ filename ] = os.path.join( path, filename )
def valid_dir(d): # type: (Dict) -> bool dir = d['path'] if not path.exists(dir): return True if not path.isdir(dir): return False if set(['Makefile', 'make.bat']) & set(os.listdir(dir)): # type: ignore return False if d['sep']: dir = os.path.join('source', dir) if not path.exists(dir): return True if not path.isdir(dir): return False reserved_names = [ 'conf.py', d['dot'] + 'static', d['dot'] + 'templates', d['master'] + d['suffix'], ] if set(reserved_names) & set(os.listdir(dir)): # type: ignore return False return True
def handle(self, **options): for party_slug in sorted(os.listdir(ppc_data_directory)): json_directory = join( ppc_data_directory, party_slug ) for leafname in sorted(os.listdir(json_directory)): if not leafname.endswith('.json'): continue filename = join(json_directory, leafname) image = re.sub(r'\.json$', '-cropped.png', filename) if not exists(image): image = None print '===============================================================' print "filename:", filename with open(filename) as f: ppc_data = json.load(f) ppc_data['party_slug'] = party_slug ppc_data['party_object'] = party_slug_to_popit_party[party_slug] ppc_data['constituency_object'] = get_constituency_from_name( ppc_data['constituency'] ) if options['check']: continue self.handle_person(ppc_data, image)
def env_status(): """ Print information about the test bed to check tests aren't failing to clean up. To see, ensure you use: py.test -s """ folders = [folder for folder in os.listdir(os.path.dirname(CONF.path_to('link'))) if folder.find('cmd') == -1] try: link_d = os.listdir(CONF.path_to('link')) except OSError: link_d = 'DOES NOT EXIST' try: prefix_d = os.listdir(CONF.path_to('prefix')) except OSError: prefix_d = 'DOES NOT EXIST' print('\n') print('Environment Summary BEFORE Cleanup') print('Paths: ', CONF.get('pakit.paths')) print('IDB Entries: ', sorted([key for key, _ in pakit.conf.IDB])) print('Contents Root Dir: ', sorted(folders)) print('Contents Link Dir: ', sorted(link_d)) print('Contents Prefix Dir: ', sorted(prefix_d))
def build_gfortran(ctx, target): binpath = os.path.join(ctx.out_dir, "bin") manpath = os.path.join(ctx.out_dir, "share", "man", "man1") includepath = os.path.join(ctx.out_dir, "include") binfiles = os.listdir(binpath) manfiles = os.listdir(manpath) srcpath = ctx.env.SRCPATH ctx.venv_exec(""" base="gcc-42-5666.3-darwin11" pushd %(srcpath)s/3rdparty rm -fr "$base" mkdir -p "$base" pushd "$base" xar -xf "../$base.pkg" mv *.pkg/Payload Payload.gz pax --insecure -rz -f Payload.gz -s ",./usr,$VIRTUAL_ENV," ln -sf "$VIRTUAL_ENV/bin/gfortran-4.2" "$VIRTUAL_ENV/bin/gfortran" popd rm -fr "$base" popd """ % locals()) # Delete other files installed shutil.rmtree(os.path.join(includepath, "gcc")) for f in os.listdir(binpath): if f not in binfiles and not "gfortran" in f: os.unlink(os.path.join(binpath, f)) for f in os.listdir(manpath): if f not in manfiles and not "gfortran" in f: os.unlink(os.path.join(manpath, f))
def test_basic(self): """grab_driver_files: copy drivers into place, return module list""" # create a bunch of fake extracted files outdir = self.tmpdir + '/extract-outdir' moddir = outdir + "/lib/modules/%s/kernel/" % os.uname()[2] fwdir = outdir + "/lib/firmware/" modules = makefiles(moddir+"net/funk.ko", moddir+"fs/lolfs.ko.xz") firmware = makefiles(fwdir+"funk.fw") makefiles(outdir+"/usr/bin/monkey", outdir+"/other/dir/blah.ko") mod_upd_dir = self.tmpdir+'/module-updates' fw_upd_dir = self.tmpdir+'/fw-updates' # use our updates dirs instead of the default updates dirs with mock.patch.multiple("driver_updates", MODULE_UPDATES_DIR=mod_upd_dir, FIRMWARE_UPDATES_DIR=fw_upd_dir): modnames = grab_driver_files(outdir) self.assertEqual(set(modnames), set(["funk", "lolfs"])) modfiles = set(['funk.ko', 'lolfs.ko.xz']) fwfiles = set(['funk.fw']) # modules/firmware are *not* in their old locations self.assertEqual([f for f in modules+firmware if os.path.exists(f)], []) # modules are in the system's updates dir self.assertEqual(set(os.listdir(mod_upd_dir)), modfiles) # modules are also in outdir's updates dir self.assertEqual(set(os.listdir(outdir+'/'+mod_upd_dir)), modfiles) # repeat for firmware self.assertEqual(set(os.listdir(fw_upd_dir)), fwfiles) self.assertEqual(set(os.listdir(outdir+'/'+fw_upd_dir)), fwfiles)
def getDownloadedMusicList (): dirs = os.listdir(__resource__) for dir in dirs: mp3Path = __resource__ + '/' + dir + '/mp3/' picPath = __resource__ + '/' + dir + '/pic/' filename, file_extension = os.path.splitext(dir) print 'file_extension ', file_extension print 'filename ', filename #filter js files if isExcludeFiles(file_extension) : continue if mp3Path == 'static/css/mp3/': continue mp3 = os.listdir(mp3Path) mp3 = map(lambda x : mp3Path + x, mp3) #print 'mp3Path:', mp3Path #print mp3 pic = os.listdir(picPath) pic = map(lambda x : picPath + x, pic) #print 'picPath:', picPath #print pic return None
def load(self): now = int(time.time()) """ Try to import the requested modules ; put the imported modules in self.imported_modules. The previous imported modules, if any, are cleaned before. """ # We get all modules file with .py modules_files = [ fname[:-3] for fname in os.listdir(self.modules_path) if fname.endswith(".py") ] # And directories modules_files.extend([ fname for fname in os.listdir(self.modules_path) if os.path.isdir(os.path.join(self.modules_path, fname)) ]) # Now we try to load thems # So first we add their dir into the sys.path if not self.modules_path in sys.path: sys.path.append(self.modules_path) # We try to import them, but we keep only the one of # our type del self.imported_modules[:] for fname in modules_files: #print "Try to load", fname try: m = __import__(fname) if not hasattr(m, 'properties'): continue # We want to keep only the modules of our type if self.modules_type in m.properties['daemons']: self.imported_modules.append(m) except Exception , exp: logger.log("Warning in importing module : %s" % exp)
def download(self, cameras, path): left_dir = os.path.join(path, 'left') right_dir = os.path.join(path, 'right') target_dir = os.path.join(path, 'raw') if not os.path.exists(target_dir): os.mkdir(target_dir) left_pages = [os.path.join(left_dir, x) for x in sorted(os.listdir(left_dir))] right_pages = [os.path.join(right_dir, x) for x in sorted(os.listdir(right_dir))] # Write the orientation as a JPEG comment to the end of the file if len(left_pages) != len(right_pages): logger.warn("The left and right camera produced an inequal" " amount of images, please fix the problem!") logger.warn("Will not combine images") return if (self.config['first_page'] and not self.config['first_page'].get(str) == 'left'): combined_pages = reduce(operator.add, zip(right_pages, left_pages)) else: combined_pages = reduce(operator.add, zip(left_pages, right_pages)) logger.info("Combining images.") for idx, fname in enumerate(combined_pages): fext = os.path.splitext(os.path.split(fname)[1])[1] target_file = os.path.join(target_dir, "{0:04d}{1}" .format(idx, fext)) shutil.copyfile(fname, target_file) shutil.rmtree(right_dir) shutil.rmtree(left_dir)
def clear_project(exitIfError=True): """ This function will erease the tables and views that were created The name of the table that is going to be deleted, are all in the config file in the constant forler. This function is dropping/deleting all views and the single table """ tables_to_delete = db.get_table_names() db.clear_qc_data(tables_to_delete) db.drop_table(QC_TABLE_NAME) if os.path.exists(WEB_APP_PATH+"assets/img/"): files = os.listdir(WEB_APP_PATH+"assets/img/") else: files = [] for img_folder in files: print "removing : ",WEB_APP_PATH+"assets/img/"+img_folder rmtree(WEB_APP_PATH+"assets/img/"+img_folder) if os.path.exists(WEB_APP_PATH+"assets/reports/"): files = os.listdir(WEB_APP_PATH+"assets/reports/") else: files = [] for report in files: print "removing : ",WEB_APP_PATH+"assets/reports/"+report os.remove(WEB_APP_PATH+"assets/reports/"+report) # recreate the database tables and views create_database(exitIfError)
def __locateRequest(self, requestName, assigned=False): """ Locate the sub requests associated with a requestName :param self: self reference :param str requestName: request name :param bool assigned: flag to include/exclude Assigned requests """ self.log.info("__locateRequest: Attempting to locate %s." % requestName) requestTypes = os.listdir(self.root) subRequests = [] try: for requestType in requestTypes: reqDir = "%s/%s" % (self.root, requestType) if os.path.isdir(reqDir): statusList = os.listdir(reqDir) if not assigned and "Assigned" in statusList: statusList.remove("Assigned") for status in statusList: statusDir = os.path.join(reqDir, status) if os.path.isdir(statusDir): requestNames = os.listdir(statusDir) if requestName in requestNames: requestPath = os.path.join(statusDir, requestName) subRequests.append(requestPath) self.log.info("__locateRequest: Successfully located %s." % requestName) return S_OK(subRequests) except Exception, error: errStr = "__locateRequest: Exception while locating request." self.log.exception(errStr, requestName, lException=error) return S_ERROR(errStr)
def getDBSummary(self): """ Obtain a summary of the contents of the requestDB :param self: self reference :return: S_OK with dict[requestType][status] => nb of files """ self.log.info("getDBSummary: Attempting to get database summary.") requestTypes = os.listdir(self.root) try: summaryDict = {} for requestType in requestTypes: summaryDict[requestType] = {} reqTypeDir = os.path.join(self.root, requestType) if os.path.isdir(reqTypeDir): statusList = os.listdir(reqTypeDir) for status in statusList: reqTypeStatusDir = os.path.join(reqTypeDir, status) requests = os.listdir(reqTypeStatusDir) summaryDict[requestType][status] = len(requests) self.log.info("getDBSummary: Successfully obtained database summary.") return S_OK(summaryDict) except Exception, x: errStr = "getDBSummary: Exception while getting DB summary." self.log.exception(errStr, lException=x) return S_ERROR(errStr)
def main(max_stations=0, folder='.'): try: makedirs(output_folder+'/'+folder) except OSError: pass all_files = [ f for f in listdir(data_folder) if isfile(join(data_folder,f)) and f.endswith('.gz') ] for ndf in all_files: string = '_%dstations' % max_stations new_name=ndf[:-7]+string+ndf[-7:] rename(data_folder+'/'+ndf, data_folder+'/'+new_name) all_files = [ f for f in listdir(data_folder) if isfile(join(data_folder,f)) and f.endswith('.gz') ] for a_f in all_files: move(data_folder+'/'+a_f, output_folder+'/'+folder+'/'+a_f) print "Moved:", a_f[0:-3] data_files = [ f for f in listdir(output_folder+'/'+folder) if isfile(join(output_folder+'/'+folder,f)) and f.endswith('.dat.gz') ] print "\n" for d_f in data_files: fin = gzip.open(output_folder+'/'+folder+'/'+d_f, 'rb') data = fin.read() fin.close() with open(output_folder+'/'+folder+'/'+d_f[0:-3],'w') as fout: fout.write(data) print "Unzipped:", d_f[0:-3]
def cleanup(self, action): if not self.steps_filename: return if not self.question_yes_no("All unused PPM files will be moved to a" " backup directory. Are you sure?", "Clean up data directory?"): return # Remember the current step index current_step_index = self.current_step_index # Get the backup dir backup_dir = os.path.join(self.steps_data_dir, "backup") # Create it if it doesn't exist if not os.path.exists(backup_dir): os.makedirs(backup_dir) # Move all files to the backup dir for filename in glob.glob(os.path.join(self.steps_data_dir, "*.[Pp][Pp][Mm]")): shutil.move(filename, backup_dir) # Get the used files back for step in self.steps: self.set_state_from_step_lines(step, backup_dir, warn=False) self.get_step_lines(self.steps_data_dir) # Remove the used files from the backup dir used_files = os.listdir(self.steps_data_dir) for filename in os.listdir(backup_dir): if filename in used_files: os.unlink(os.path.join(backup_dir, filename)) # Restore step index self.set_step(current_step_index) # Inform the user self.message("All unused PPM files may be found at %s." % os.path.abspath(backup_dir), "Clean up data directory")
def get_data_old(data_dir, data_x, data_y): #if we ened up needing the not-data-wrapper version label_num = 0 labels = []#so we actually know what each index value associated represents, str reps for f in os.listdir(os.path.abspath(data_dir)): f = os.path.abspath(data_dir + f) label = f.split("/")[-1] labels.append(label) if os.path.isdir(f): for sample_index, sample in enumerate(os.listdir(f)): #get our spectrogram for the sample samplerate, audio_raw = wav.read(f + "/" + sample) #start with zeros so we have our blank trailing space audio = np.zeros(max_audio_len) #convert our signed integer to an unsigned one by adding 32768, then divide by max of unsigned integer to get percentage and use that as our float value #fill as far as we've got for a_index, a in enumerate(audio_raw): audio[a_index] = float((a+32768)/65536.0) data_x[sample_index] = audio data_y[sample_index][label_num] = 1.0 #audio = [float((a+32768)/65536.0) for a in audio] label_num += 1 return zip(data_x, data_y)
def run(self): dst = self.config.get_dst_folder() cdv_dst = self.config.get_cordova_dst_folder(self.key) if os.path.exists(cdv_dst): names = os.listdir(cdv_dst) for name in names: if not name.startswith('.'): name = os.path.join(cdv_dst, name) if os.path.isfile(name): os.remove(name) else: shutil.rmtree(name) names = os.listdir(dst) for name in names: if not name.startswith('.'): src = os.path.join(dst, name) copy = os.path.join(cdv_dst, name) if os.path.isfile(src): shutil.copy(src, copy) else: shutil.copytree(src, copy, ignore=shutil.ignore_patterns('.*')) for r, d, f in os.walk(cdv_dst): for files in filter(lambda x: x.endswith('.html'), f): p = os.path.join(r, files) self.replace_cordova_tag(p) self.copy_icons(dst) self.copy_splash(dst)
def recreate_images(result_dir, noisy_image_dir): # Read noisy images first test_images = {} for image_name in os.listdir(noisy_image_dir): if image_name.endswith('.png'): image_path = os.path.join(noisy_image_dir, image_name) image = util.img_as_float(io.imread(image_path)) image_name_noext = os.path.splitext(image_name)[0] test_images[image_name_noext] = image # Enumerate results - image directories for image_name in sorted(os.listdir(result_dir)): image_dir = os.path.join(result_dir, image_name) if os.path.isdir(image_dir): print image_name for result_file in sorted(os.listdir(image_dir)): if result_file.endswith('.net'): # Instantiate trained ANN from .net file net_path = os.path.join(image_dir, result_file) ann = libfann.neural_net() ann.create_from_file(net_path) # Filter the same image which it was trained with filtered_image = filter_fann( test_images[image_name], ann) param_set_name = os.path.splitext(result_file)[0] io.imsave( os.path.join(image_dir, param_set_name + '.png'), filtered_image)
def run_ocr(result_dir, output_file): DEFAULT_TEXT = 'Lorem ipsum\ndolor sit amet,\nconsectetur\n\nadipiscing elit.\n\nDonec vel\naliquet velit,\nid congue\nposuere.' csv_file = open(output_file, 'w') fieldnames = ['image', 'param_set', 'ocr'] writer = csv.DictWriter(csv_file, fieldnames=fieldnames) writer.writeheader() # Enumerate images for image_name in sorted(os.listdir(result_dir)): image_dir = os.path.join(result_dir, image_name) if os.path.isdir(image_dir): print image_name # Enumerate parameter sets for result_file in sorted(os.listdir(image_dir)): if result_file.endswith('.png'): image_path = os.path.join(image_dir, result_file) image = util.img_as_float(io.imread(image_path)) ocr = ocr_accuracy(image, DEFAULT_TEXT) result_ps_name = os.path.splitext(result_file)[0] # # Write into csv file result_row = { 'image': image_name, 'param_set': result_ps_name, 'ocr': ocr, } writer.writerow(result_row) csv_file.close() return None
def load_designs(db, root='designs'): for design in os.listdir(root): views = dict() path = os.path.join(root, design) if not os.path.isdir(path): continue path = os.path.join(root, design, 'views') for filename in os.listdir(path): name, ext = os.path.splitext(filename) if ext != '.js': continue with open(os.path.join(path, filename)) as codefile: code = codefile.read() if name.startswith('map_'): name = name[len('map_'):] key = 'map' elif name.startswith('reduce_'): name = name[len('reduce_'):] key = 'reduce' else: key = 'map' views.setdefault(name, dict())[key] = code id = "_design/%s" % design try: doc = db[id] except couchdb.http.ResourceNotFound: logging.debug("loading %s", id) db.save(dict(_id=id, views=views)) else: if doc['views'] != views: doc['views'] = views logging.debug("updating %s", id) db.save(doc) else: logging.debug("no change %s", id)
def __init__(self): self.options = config.YAML_CONFIG.get('options') # where graphite lives self.graphite_base = config.YAML_CONFIG.get('graphite') # where the graphite renderer is self.graphite_render = "%s/render/" % self.graphite_base # where to find graph, dash etc templates self.graph_templates = config.YAML_CONFIG.get('templatedir') # the dash site might have a prefix for its css etc self.prefix = self.options.get('prefix', "") # the page refresh rate self.refresh_rate = self.options.get('refresh_rate', 60) # how many columns of graphs do you want on a page self.graph_columns = self.options.get('graph_columns', 2) # how wide each graph should be self.graph_width = self.options.get('graph_width') # how hight each graph sould be self.graph_height = self.options.get('graph_height') # Dashboard title self.dash_title = self.options.get('title', 'Graphite Dashboard') # Dashboard logo self.dash_logo = self.options.get('logo') # Time filters in interface self.interval_filters = self.options.get('interval_filters', []) self.intervals = self.options.get('intervals', []) self.top_level = {} for category in [ name for name in os.listdir(self.graph_templates) if not name.startswith('.') and os.path.isdir(os.path.join(self.graph_templates, name)) ]: if os.listdir( os.path.join(self.graph_templates,category) ) != []: self.top_level[category] = leonardo.Leonardo( self.graphite_base, "/render/", self.graph_templates, category, { "width" : self.graph_width, "height" : self.graph_height } ) self.search_elements = [ "%s/%s" % (d['category'], d['name']) for dash in self.top_level for d in self.top_level[dash].dashboards() ] elements_string = "" for item in self.search_elements: elements_string += '"%s",' % item self.search_elements = "[%s]" % elements_string[:-1]
def diff(options, a, b): def print_meta(s): codec_print(simple_colorize(s, "magenta"), options) if os.path.isfile(a) and os.path.isfile(b): if not filecmp.cmp(a, b, shallow=False): diff_files(options, a, b) elif os.path.isdir(a) and os.path.isdir(b): a_contents = set(os.listdir(a)) b_contents = set(os.listdir(b)) for child in sorted(a_contents.union(b_contents)): if child not in b_contents: print_meta("Only in %s: %s" % (a, child)) elif child not in a_contents: print_meta("Only in %s: %s" % (b, child)) elif options.recursive: diff(options, os.path.join(a, child), os.path.join(b, child)) elif os.path.isdir(a) and os.path.isfile(b): print_meta("File %s is a directory while %s is a file" % (a, b)) elif os.path.isfile(a) and os.path.isdir(b): print_meta("File %s is a file while %s is a directory" % (a, b))
def getFiles(self, subject): """Get a dictionary with a list of all candidate filenames for associated data, such as roi overlays, flatmap caches, and ctm caches. """ surfparse = re.compile(r'(.*)/([\w-]+)_([\w-]+)_(\w+).*') surfpath = os.path.join(filestore, subject, "surfaces") if self.subjects[subject]._warning is not None: warnings.warn(self.subjects[subject]._warning) surfs = dict() for surf in os.listdir(surfpath): ssurf = os.path.splitext(surf)[0].split('_') name = '_'.join(ssurf[:-1]) hemi = ssurf[-1] if name not in surfs: surfs[name] = dict() surfs[name][hemi] = os.path.abspath(os.path.join(surfpath,surf)) filenames = dict( surfs=surfs, xfms=os.listdir(os.path.join(filestore, subject, "transforms")), xfmdir=os.path.join(filestore, subject, "transforms", "{xfmname}", "matrices.xfm"), anats=os.path.join(filestore, subject, "anatomicals", '{type}{opts}.{ext}'), surfinfo=os.path.join(filestore, subject, "surface-info", '{type}{opts}.npz'), masks=os.path.join(filestore, subject, 'transforms', '{xfmname}', 'mask_{type}.nii.gz'), cachedir=os.path.join(filestore, subject, "cache"), rois=os.path.join(filestore, subject, "rois.svg").format(subj=subject), ) return filenames
def run_q(result_dir, output_file): csv_file = open(output_file, 'w') # fieldnames = ['image', 'param_set', 'final_error', 'training_time'] fieldnames = ['image', 'param_set', 'q'] writer = csv.DictWriter(csv_file, fieldnames=fieldnames) writer.writeheader() # Enumerate images for image_name in sorted(os.listdir(result_dir)): image_dir = os.path.join(result_dir, image_name) if os.path.isdir(image_dir): print image_name # Enumerate parameter sets for result_file in sorted(os.listdir(image_dir)): if result_file.endswith('.png'): image_path = os.path.join(image_dir, result_file) image = util.img_as_float(io.imread(image_path)) q = q_py(image) # result_json_path = os.path.join(image_dir, result_json) result_ps_name = os.path.splitext(result_file)[0] # result_data = read_results(result_json_path) # # last_epoch_error = float(parse_epochs(result_data)[-1]['error']) # last_epoch_error = float(parse_epochs(result_data)[-1]) # # Write into csv file result_row = { 'image': image_name, 'param_set': result_ps_name, 'q': q, } writer.writerow(result_row) csv_file.close() return None
def action_uninstall(plat=None, x64=None, ext=None, **kwargs): plat, x64, ext, folder, location = fix_args(plat, x64, ext) print 'Uninstalling flow123d...' if plat == 'linux': # only remove install folder pass if plat == 'windows': uninstaller_location = os.path.abspath(os.path.join(folder, 'Uninstall.exe')) command = [uninstaller_location, '/S'] process, stdout, stderr = run_command(command) check_error(process, stdout, stderr) if process.returncode != 0: return process.returncode # add sleep since windows spawns child which is not bound by parent # so exiting parent does not exit children as well time.sleep(5) shutil.rmtree(os.path.abspath(folder), True) shutil.rmtree(os.path.abspath('output'), True) if os.path.exists(folder): print 'Uninstallation not successful!' print os.listdir(folder) return 1 print 'Uninstallation successful!' return 0
def parse_results(result_dir, output_file): csv_file = open(output_file, 'w') # fieldnames = ['image', 'param_set', 'final_error', 'training_time'] fieldnames = ['image', 'param_set', 'final_error'] writer = csv.DictWriter(csv_file, fieldnames=fieldnames) writer.writeheader() # Enumerate images for image_name in sorted(os.listdir(result_dir)): image_dir = os.path.join(result_dir, image_name) if os.path.isdir(image_dir): print image_name # Enumerate parameter sets for result_json in sorted(os.listdir(image_dir)): if result_json.endswith('.json'): result_json_path = os.path.join(image_dir, result_json) result_ps_name = os.path.splitext(result_json)[0] result_data = read_results(result_json_path) # last_epoch_error = float(parse_epochs(result_data)[-1]['error']) last_epoch_error = float(parse_epochs(result_data)[-1]) # Write into csv file result_row = { 'image': image_name, 'param_set': result_ps_name, 'final_error': last_epoch_error, # 'training_time': result_data['training_time'] } writer.writerow(result_row) csv_file.close() return None
def get_ring(ring_name, required_replicas, required_devices, server=None, force_validate=None, ipport2server=None, config_paths=None): if not server: server = ring_name ring = Ring('/etc/swift', ring_name=ring_name) if ipport2server is None: ipport2server = {} # used internally, even if not passed in if config_paths is None: config_paths = defaultdict(dict) store_config_paths(server, config_paths) repl_name = '%s-replicator' % server repl_configs = { i: readconf(c, section_name=repl_name) for i, c in config_paths[repl_name].items() } servers_per_port = any( int(c.get('servers_per_port', '0')) for c in repl_configs.values()) add_ring_devs_to_ipport2server(ring, server, ipport2server, servers_per_port=servers_per_port) if not VALIDATE_RSYNC and not force_validate: return ring # easy sanity checks if ring.replica_count != required_replicas: raise unittest.SkipTest( '%s has %s replicas instead of %s' % (ring.serialized_path, ring.replica_count, required_replicas)) devs = [dev for dev in ring.devs if dev is not None] if len(devs) != required_devices: raise unittest.SkipTest( '%s has %s devices instead of %s' % (ring.serialized_path, len(devs), required_devices)) for dev in devs: # verify server is exposing mounted device ipport = (dev['ip'], dev['port']) _, server_number = get_server_number(ipport, ipport2server) conf = repl_configs[server_number] for device in os.listdir(conf['devices']): if device == dev['device']: dev_path = os.path.join(conf['devices'], device) full_path = os.path.realpath(dev_path) if not os.path.exists(full_path): raise unittest.SkipTest( 'device %s in %s was not found (%s)' % (device, conf['devices'], full_path)) break else: raise unittest.SkipTest( "unable to find ring device %s under %s's devices (%s)" % (dev['device'], server, conf['devices'])) # verify server is exposing rsync device rsync_export = conf.get('rsync_module', '').rstrip('/') if not rsync_export: rsync_export = '{replication_ip}::%s' % server cmd = "rsync %s" % rsync_module_interpolation(rsync_export, dev) p = Popen(cmd, shell=True, stdout=PIPE) stdout, _stderr = p.communicate() if p.returncode: raise unittest.SkipTest('unable to connect to rsync ' 'export %s (%s)' % (rsync_export, cmd)) for line in stdout.decode().splitlines(): if line.rsplit(None, 1)[-1] == dev['device']: break else: raise unittest.SkipTest("unable to find ring device %s under " "rsync's exported devices for %s (%s)" % (dev['device'], rsync_export, cmd)) return ring
# Split for validation val = float(args.valfrac) # Split for prediction (These files will not be trained nor validated on) test = float(args.testfrac) # Test if the inputs are somehow reasonable assert(test>0 and val>0 and test+val<0.5) # directory where the .root files live #path = /scratch-cbe/users/benjamin.wilhelmy/DeepLepton/v2/step2/2016/muo/pt_3.5_-1/STopvsTop path = args.path # read .root filenames from directory filenames = os.listdir(path) filenames = [f for f in filenames if '.root' in f] # Cut filenames to length if len(filenames) < N: print('Not enough files in directory, will use the ones that are\ available.') N_files = len(filenames) elif N == 0: N_files = len(filenames) else: N_files = int(N) random.shuffle(filenames) filenames = filenames[:N_files] # Split into train and predict files
def convert(self, output): """ Convert the output from LaTeX into images Arguments: output -- output file object """ if not self.command and self.executeConverter is Imager.executeConverter: log.warning('No imager command is configured. ' + 'No images will be created.') return cwd = os.getcwd() # Make a temporary directory to work in tempdir = tempfile.mkdtemp() os.chdir(tempdir) # Execute converter rc, images = self.executeConverter(output) if rc: log.warning('Image converter did not exit properly. ' + 'Images may be corrupted or missing.') # Get a list of all of the image files if images is None: images = [ f for f in os.listdir('.') if re.match(r'^img\d+\.\w+$', f) ] if len(images) != len(self.images): log.warning( 'The number of images generated (%d) and the number of images requested (%d) is not the same.' % (len(images), len(self.images))) # Sort by creation date #images.sort(lambda a,b: cmp(os.stat(a)[9], os.stat(b)[9])) images.sort( lambda a, b: cmp(int(re.search(r'(\d+)\.\w+$', a).group(1)), int(re.search(r'(\d+)\.\w+$', b).group(1)))) os.chdir(cwd) if PILImage is None: log.warning('PIL (Python Imaging Library) is not installed. ' + 'Images will not be cropped.') # Move images to their final location for src, dest in zip(images, self.images.values()): # Move the image directory = os.path.dirname(dest.path) if directory and not os.path.isdir(directory): os.makedirs(directory) try: shutil.copy2(os.path.join(tempdir, src), dest.path) except OSError: shutil.copy(os.path.join(tempdir, src), dest.path) # Crop the image try: dest.crop() status.dot() except Exception, msg: import traceback traceback.print_exc() log.warning('failed to crop %s (%s)', dest.path, msg)
def parse_extensions(base_dir, extensions_dir, public_dir, base_url, stdnotes_ext_list_path, ghub_headers): """ Build Standard Notes extensions repository using Github meta-data """ extension_path = extensions_dir public_path = public_dir os.chdir(public_path) extensions = [] std_ext_list = [] std_ext_list = parse_stdnotes_extensions(stdnotes_ext_list_path) # Get all extensions, sort extensions alphabetically along by their by type extfiles = [ x for x in sorted(os.listdir(extension_path)) if not x.endswith('theme.yaml') and x.endswith('.yaml') ] themefiles = [ y for y in sorted(os.listdir(extension_path)) if y.endswith('theme.yaml') ] extfiles.extend(themefiles) for extfile in extfiles: with open(os.path.join(extension_path, extfile)) as extyaml: ext_yaml = yaml.load(extyaml, Loader=yaml.FullLoader) ext_has_update = False repo_name = ext_yaml['github'].split('/')[-1] repo_dir = os.path.join(public_path, repo_name) # If we have valid github personal access token if ghub_headers: # Get extension's github release meta-data ext_git_info = json.loads( requests.get( 'https://api.github.com/repos/{github}/releases/latest'. format(**ext_yaml), headers=ghub_headers).text) try: ext_version = ext_git_info['tag_name'] except KeyError: # No github releases found print('Skipping: {:38s}\t(github repository not found)'.format( ext_yaml['name'])) continue # Check if extension directory already exists if not os.path.exists(repo_dir): os.makedirs(repo_dir) # Check if extension with current release already exists if not os.path.exists(os.path.join(repo_dir, ext_version)): ext_has_update = True os.makedirs(os.path.join(repo_dir, ext_version)) # Grab the release and then unpack it with requests.get(ext_git_info['zipball_url'], headers=ghub_headers, stream=True) as zipball_stream: with open( os.path.join(repo_dir, ext_version) + ".zip", 'wb') as zipball_file: shutil.copyfileobj(zipball_stream.raw, zipball_file) # unpack the zipball process_zipball(repo_dir, ext_version) else: ext_version, ext_has_update = git_clone_method( ext_yaml, public_path, ext_has_update) if extfile in std_ext_list: ext_id = ext_yaml['id'].rsplit('.', 1)[1] ext_yaml['id'] = '%s.%s' % (LOCAL_HOSTNAME, ext_id) # Build extension info (stateless) # https://domain.com/sub-domain/my-extension/index.json extension = dict( identifier=ext_yaml['id'], name=ext_yaml['name'], content_type=ext_yaml['content_type'], area=ext_yaml.get('area', None), version=ext_version, description=ext_yaml.get('description', None), marketing_url=ext_yaml.get('marketing_url', None), thumbnail_url=ext_yaml.get('thumbnail_url', None), valid_until='2030-05-16T18:35:33.000Z', url='/'.join([base_url, repo_name, ext_version, ext_yaml['main']]), download_url='https://github.com/{}/archive/{}.zip'.format( ext_yaml['github'], ext_version), latest_url='/'.join([base_url, repo_name, 'index.json']), flags=ext_yaml.get('flags', []), dock_icon=ext_yaml.get('dock_icon', {}), layerable=ext_yaml.get('layerable', None), statusBar=ext_yaml.get('statusBar', None), ) # Strip empty values extension = {k: v for k, v in extension.items() if v} # Check if extension is already up-to-date if ext_has_update: # Generate JSON file for each extension with open(os.path.join(public_path, repo_name, 'index.json'), 'w') as ext_json: json.dump(extension, ext_json, indent=4) if extfile.endswith("theme.yaml"): print('Theme: {:34s} {:6s}\t(updated)'.format( ext_yaml['name'], ext_version.strip('v'))) else: print('Extension: {:30s} {:6s}\t(updated)'.format( ext_yaml['name'], ext_version.strip('v'))) else: # ext already up-to-date if extfile.endswith("theme.yaml"): print('Theme: {:34s} {:6s}\t(already up-to-date)'.format( ext_yaml['name'], ext_version.strip('v'))) else: print('Extension: {:30s} {:6s}\t(already up-to-date)'.format( ext_yaml['name'], ext_version.strip('v'))) extensions.append(extension) os.chdir('..') # Generate the main repository index JSON # https://domain.com/sub-domain/my-index.json with open(os.path.join(public_path, 'index.json'), 'w') as ext_json: json.dump( dict( content_type='SN|Repo', valid_until='2030-05-16T18:35:33.000Z', packages=extensions, ), ext_json, indent=4, ) print("\nProcessed: {:20s}{} extensions. (Components: {}, Themes: {})". format("", len(extfiles), len(extfiles) - len(themefiles), len(themefiles))) print("Repository Endpoint URL: {:6s}{}/index.json".format("", base_url))
vertical=True, x_prefix="< ", ) if __name__ == "__main__": if len(sys.argv) < 3: print( "Must provide two arguments: 1) The directory that saves a list of " "directories which contain block cache trace analyzer result files " "2) the directory to save plotted graphs.") exit(1) csv_result_dir = sys.argv[1] output_result_dir = sys.argv[2] print("Processing directory {} and save graphs to {}.".format( csv_result_dir, output_result_dir)) for csv_relative_dir in os.listdir(csv_result_dir): csv_abs_dir = csv_result_dir + "/" + csv_relative_dir result_dir = output_result_dir + "/" + csv_relative_dir if not os.path.isdir(csv_abs_dir): print("{} is not a directory".format(csv_abs_dir)) continue print("Processing experiment dir: {}".format(csv_relative_dir)) if not os.path.exists(result_dir): os.makedirs(result_dir) plot_miss_ratio_graphs(csv_abs_dir, result_dir) plot_access_timeline(csv_abs_dir, result_dir) plot_reuse_graphs(csv_abs_dir, result_dir) plot_percentage_access_summary(csv_abs_dir, result_dir) plot_access_count_summary(csv_abs_dir, result_dir)
def choosetm(): f = listdir("templates/background") print(f) return render_template("choosetm.html", fil=f)
def process_json_file(json_file_path, src_dir, ori_dst_dir, binary_dst_dir, instance_dst_dir): """ :param json_file_path: :param src_dir: origin clip file path :param ori_dst_dir: :param binary_dst_dir: :param instance_dst_dir: :return: """ assert ops.exists(json_file_path), '{:s} not exist'.format(json_file_path) image_nums = len(os.listdir(ori_dst_dir)) with open(json_file_path, 'r') as file: for line_index, line in enumerate(file): info_dict = json.loads(line) image_dir = ops.split(info_dict['raw_file'])[0] image_dir_split = image_dir.split('/')[1:] image_dir_split.append(ops.split(info_dict['raw_file'])[1]) image_name = '_'.join(image_dir_split) image_path = ops.join(src_dir, info_dict['raw_file']) assert ops.exists(image_path), '{:s} not exist'.format(image_path) h_samples = info_dict['h_samples'] lanes = info_dict['lanes'] image_name_new = '{:s}.png'.format('{:d}'.format(line_index + image_nums).zfill(4)) src_image = cv2.imread(image_path, cv2.IMREAD_COLOR) dst_binary_image = np.zeros([src_image.shape[0], src_image.shape[1]], np.uint8) dst_instance_image = np.zeros([src_image.shape[0], src_image.shape[1]], np.uint8) for lane_index, lane in enumerate(lanes): assert len(h_samples) == len(lane) lane_x = [] lane_y = [] for index in range(len(lane)): if lane[index] == -2: continue else: ptx = lane[index] pty = h_samples[index] lane_x.append(ptx) lane_y.append(pty) if not lane_x: continue lane_pts = np.vstack((lane_x, lane_y)).transpose() lane_pts = np.array([lane_pts], np.int64) cv2.polylines(dst_binary_image, lane_pts, isClosed=False, color=255, thickness=5) cv2.polylines(dst_instance_image, lane_pts, isClosed=False, color=lane_index * 50 + 20, thickness=5) dst_binary_image_path = ops.join(binary_dst_dir, image_name_new) dst_instance_image_path = ops.join(instance_dst_dir, image_name_new) dst_rgb_image_path = ops.join(ori_dst_dir, image_name_new) cv2.imwrite(dst_binary_image_path, dst_binary_image) cv2.imwrite(dst_instance_image_path, dst_instance_image) cv2.imwrite(dst_rgb_image_path, src_image) print('Process {:s} success'.format(image_name))
warnings.filterwarnings("ignore") #Using google colab drive.mount('/content/gdrive') # Using transfer learning on pre trained model from imagenet from keras.applications import InceptionResNetV2 conv_base = InceptionResNetV2(weights='imagenet', include_top=False, input_shape=(150, 150, 3)) DIR = '/content/gdrive/My Drive/Household Image/' #directory in my drive X = [] #train data Y = [] #Its label files = [ i + str('/') + img_dir for i in os.listdir(DIR) for img_dir in os.listdir(DIR + f'{i}') ] random.shuffle(files) #shuffling the data for i in files: print(i) img = cv2.imread(DIR + i, 1) img = cv2.resize(img, (150, 150)) #resizing optimum size img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) X.append(img) if 'Status A' in i: Y.append(1) else: Y.append(0) x = np.array(X) #all the image data after pre processing
def remove_path_key_file(key,path): ls = os.listdir(path) print(ls) for i in ls : if key in i : os.remove(path+'\\'+i)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. # # from setuptools import setup, find_packages from os import listdir, system langs = [] for l in listdir('languages'): if l.endswith('ts'): system('lrelease-qt5 languages/%s' % l) langs.append(('languages/%s' % l).replace('.ts', '.qm')) system('pyrcc5 kaptan.qrc -o kaptan5/rc_kaptan.py') datas = [('/usr/share/applications', ['data/kaptan.desktop']), # welcome uygulaması ile başlatılacak. #('/etc/skel/.config/autostart', ['data/kaptan.desktop']), ('/usr/share/icons/hicolor/scalable/apps', ['data/images/kaptan-icon.svg']), ('/usr/share/kaptan/languages', langs)] setup( name = "kaptan",
''' json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model.h5") print("Loaded model from disk") model=loaded_model ''' model=load_model("keras_model_test.h5") model.summary() #####################test############################## testPathDir=os.listdir(testFolder) allTestX=[] allTestY=[] allTestZ=[] allTestsent=[] TestBol=True #testPathDir=trainPathDir #testFolder=trainFolder extractAllTrain(allTestX,allTestY,allTestZ,testPathDir,testFolder, allTestsent, TestBol)
q = 1 scale_path = 'scale100' input_path = "E:\Faks\Zavrsni\Backups\FullDB3\Test Data\\" + scale_path + '\\' data_path = "E:\Faks\Zavrsni\Backups\FullDB3\Data\\" # input_path = "E:\Faks\Zavrsni\\FullDB\Test Data\\" + scale_path + '\\' # data_path = "E:\Faks\Zavrsni\\FullDB\Data\\" loaded = {} possible = {} # Picking up the saved data of all known planes planes = listdir(data_path) for plane in planes: cameras = listdir(data_path + plane) for camera in cameras: file = open(data_path + plane + '\\' + camera + '\\' + 'normal.txt', "r") name = '' for line in file: if line[0] == '#': name = line.strip()
cv2.imshow("img", dist_transform) cv2.waitKey(0) cv2.destroyAllWindows() # Now, mark the region of unknown with zero markers[unknown==255] = 0 markers = cv2.watershed(img, markers) """ path = "C:/Users/Christian/Desktop/Fourth_CV/Complete_images/MitoSegNet" path_gt = "C:/Users/Christian/Desktop/Fourth_CV/Complete_images/Ground_Truth" for img in os.listdir(path): print(img) image = cv2.imread(path + os.sep + img, cv2.IMREAD_GRAYSCALE) image_copy = copy.copy(image) org_img = copy.copy(image) gt = cv2.imread(path_gt + os.sep + img, cv2.IMREAD_GRAYSCALE) # label image mask labelled = label(image) # Get region props of labelled images reg_props = regionprops(labelled)
classes.add(c.strip()) return sorted(classes) if __name__ == '__main__': # Parse arguments. if len(sys.argv) != 4: raise Exception('Include the input and output directories as arguments, e.g., python driver.py input output.') model_input = sys.argv[1] input_directory = sys.argv[2] output_directory = sys.argv[3] # Find files. input_files = [] for f in os.listdir(input_directory): if os.path.isfile(os.path.join(input_directory, f)) and not f.lower().startswith('.') and f.lower().endswith('mat'): input_files.append(f) if not os.path.isdir(output_directory): os.mkdir(output_directory) classes=get_classes(input_directory,input_files) # Load model. print('Loading 12ECG model...') model = load_12ECG_model(model_input) # Iterate over files. print('Extracting 12ECG features...') num_files = len(input_files)
if len(scales) < 2: scales += scales dataset_path = args.dataset_path cam_dir = os.path.join(dataset_path, 'Cameras') img_dir = os.path.join(dataset_path, 'Rectified') dep_dir = os.path.join(dataset_path, 'Depths') new_dataset_path = args.output_path or dataset_path.rstrip( '\\', '/') + '_resized' new_cam_dir = os.path.join(new_dataset_path, 'Cameras') new_img_dir = os.path.join(new_dataset_path, 'Rectified') new_dep_dir = os.path.join(new_dataset_path, 'Depths') # Resize camera profiles os.makedirs(new_cam_dir, exist_ok=True) for camfile in os.listdir(cam_dir): if camfile.find('cam') == -1: continue with open(os.path.join(cam_dir, camfile), 'r') as f: lines = [line.strip() for line in f.readlines()] intrinsic = np.fromstring(' '.join(lines[7:10]), dtype=float, sep=' ').reshape((3, 3)) intrinsic_scale = np.array([ [scales[0], 1, scales[0]], [1, scales[1], scales[1]], [1, 1, 1], ]) intrinsic = (intrinsic * intrinsic_scale).tolist() lines = [line + '\n' for line in lines] with open(os.path.join(new_cam_dir, camfile), 'w') as f: f.writelines(lines[0:7])
def get_directories(directory_path): return os.listdir(directory_path)
def get_immediate_subdirectories(a_dir): return [name for name in os.listdir(a_dir) if os.path.isdir(os.path.join(a_dir, name))]
def predict(gr): """ Weight all the neural nets and work it out @param: ungrayed pixel @return: the averaged vals """ global gamma r,g,b=0,0,0 trainers=list(os.listdir(r"C:\Users\Devansh\Desktop\Projects\img\TrainedData")) d=r"C:\Users\Devansh\Desktop\Projects\img\TrainedData" l=len(trainers) i=0 types=len(trainers) x=[gr] pred=list() while(i< types ): t=d+"/"+ trainers[i] clf = joblib.load(t) pred=clf.predict(x)[0] b+=pred[2]/types g+=pred[1]/types r+=pred[0]/types i+=1 #by adjusting the values and scaling them, we can reduce the effects of overfitting. gamma+=((0.2126 * r + 0.7152 * g + 0.0722 * b)/255) *(random.randrange(-300000,300000)/30000) #optimize (range will give a -10<val<10) print(gamma) if gamma>=0: r=(random.randrange(int((r-gamma-1)),int(r+gamma)+1 )) g=(random.randrange((int(g-gamma-1)),int(g+gamma)+1 )) b=(random.randrange((int(b-gamma-1)),int(b+gamma)+1 )) else: r=(random.randrange(int((r+gamma-1)),int(r-gamma)+1 )) g=(random.randrange((int(g+gamma-1)),int(g-gamma)+1 )) b=(random.randrange((int(b+gamma-1)),int(b-gamma)+1 )) """ print("Created: ",r,g,b) correction=(.2126*random.randrange(0,int(r)+1)+.7152*random.randrange(0,int(g)+1)+0.722*random.randrange(0,int(b)+1)) print(correction) #to use when I start testing and building my model with error calculations r=(random.randrange(abs(int(r-2*correction)),int(r+1+2*correction)))/(types) g=(random.randrange(abs(int(g-2*correction)),int(g+1+2*correction)))/(types) b=(random.randrange(abs(int(b-2*correction)),int(b+1+2*correction)))/(types) prediction= [r,g,b ] print("Weighed", r,g,b) """ prediction=[r,g,b] for i in range (len(prediction)): if(prediction[i]>255): prediction[i]%=255 #build equivalence classes for predictions elif(prediction[i]<0): prediction[i]*=-1 if(prediction[i]>255): prediction[i]%=255 #build equivalence classes for predictions gamma+=(prediction[i]-pred[i])**2 gamma%=math.sqrt(abs(gamma)) #self correction with gamma return prediction
print "Done." print "Inserting Types..." for label, template in types.items(): inserter.insert_task_types(template, relation=False, task=task, label=label) for label, template in relation_types.items(): inserter.insert_task_types(template, relation=True, task=task, label=label) print "Done." else: print "Preparing Task..." task = inserter.get_task_id() if task is None: task = inserter.create_task(USERNAME) print "Done." for filename in os.listdir(filepath): if ".xml" in filename: files.append(filepath + filename) for filename in files: print filename documents = [] user_documents = [] entities = [] pairs = [] offsets = [] tree = ET.parse(filename) root = tree.getroot() for document in root.iter('document'):
def get_files_in_directory(a_dir): files = [f for f in os.listdir(a_dir) if os.path.isfile(os.path.join(a_dir, f))] return files
# !/usr/bin/python # -*- coding: UTF-8 -*- import os, sys path1 = 'D:\home\zeewei\\20190319\\radar_data\\2_108_1' # 所需修改文件夹所在路径 dirs = os.listdir(path1) i = 0 for dir in dirs: if dir[0:5] == 'road1': os.rename( os.path.join(path1, str(dir)), os.path.join(path1, 'road1_' + str(dir[4:5]) + '_' + str(dir[5:]))) print("重命名成功: , ", dir) i += 1
activity['position_x'] = None activity['position_y'] = None activity['entities'] = [] activity['agents'] = [] activity['properties'] = {} activities.append(activity) session['activities'] = activities description(document, file, filtered_data, agents, entities, show_a_e) export_json(session, file) if __name__ == "__main__": # document = input('Base de dados: ') # file = input('Extrair para: ') # sheet = "sessao" # controlHarvestToMicelioSession(document, sheet, file) ODS_DIR = './Sessoes/' sheet = "sessao" files = os.listdir(ODS_DIR) for document in files: file = document.replace('.ods', '.json') if document[(len(document) - 4)::] == '.ods': controlHarvestToMicelioSession(ODS_DIR + document, sheet, file)
def all_beautiful_memories_begin(): import log files_list = os.listdir(BIZ_PATH) files_list = set(['biz.' + x[:x.rfind(".")] for x in files_list if x.endswith(".py")]) map(__import__, files_list)
entryNodes = root.findall('classpathentry') linkedLibs = [] for node in entryNodes: entryKind = node.get('kind') entryPath = node.get('path') entryKind = entryKind.strip(' \n\r\t') entryPath = entryPath.strip(' \n\r\t') if entryKind == 'lib' and entryPath.endswith('.jar'): linkedLibs.append(entryPath) plugins = pluginStr.split(':') modified = False for pluginName in plugins: pluginAndroidDir = pluginsDir + '/' + pluginName + '/android' for fileName in os.listdir(pluginAndroidDir): if os.path.splitext(fileName)[1] == '.jar': needAdd = True for linkedJar in linkedLibs: jarName = os.path.basename(linkedJar) if fileName == jarName: needAdd = False break if needAdd: modified = True pathAttr = 'plugin-x/' + pluginName + '/android/' + fileName root.append(getLibElement(pathAttr)) linkedLibs.append(pathAttr) if modified:
#!/usr/bin/python ## Author: Eric FONTANILLAS ## Date: 03.01.12 ## Object: Recursively run the script "16_PATRON_stats.r" which compute stats and report graph pdf) for each branch reported in the codeml output import string, os ## 1 ## Open input/output branch_folder = "12_2_Branches" L1 = os.listdir(branch_folder) file_PATRON = open("16_PATRON_stats.r", "r") PATRON = file_PATRON.read() out_graph = "18_statsOutput_perBranches_GRAPHS" out_table = "18_statsOutput_perBranches_TABLES" for file in L1: print "\n\tProcess branch '%s' ..." % file[:-4] XXX_IN = "%s/%s" % (branch_folder, file) name_fasta = file[:-4] XXX_OUT_GRAPH = "%s/%s.pdf" % (out_graph, name_fasta) XXX_OUT_TABLE = "%s/%s.csv" % (out_table, name_fasta) New_PATRON = string.replace(PATRON, "XXX_IN", XXX_IN) New_PATRON = string.replace(New_PATRON, "XXX_OUT_GRAPH", XXX_OUT_GRAPH) New_PATRON = string.replace(New_PATRON, "XXX_OUT_TABLE", XXX_OUT_TABLE)
from FCS import Fcs from FCS import StainFcs from FCS import Write from tkinter import filedialog import random import os # 选择路径 Fpath = filedialog.askdirectory() for file in [ file for file in os.listdir(Fpath) if os.path.splitext(file)[1] == ".fcs" ]: filename = Fpath + '/' + file fcs = Fcs(filename) # # 写到excel中 # fcs.fcs2excel() # 染色通道 # stain_fcs = StainFcs(filename) # stain_fcs.fcs2excel(folder_name="Stain_excel") # # 写出到fcs中 # save_dir = fcs.file_dir + "/WriteFcs" # # excel文件夹不存在时创建 # if not os.path.exists(save_dir): # os.makedirs(save_dir) # filename = save_dir + '/' + file #
import os a = int(input("정수 입력 : ")) if (a % 3 == 0 and a % 4 == 0): print("3과 4의 공배수") elif (a % 3 == 0): print("3의 배수") elif (a % 4 == 0): print("4의 배수") else: print("3의 배수도, 4의 배수도 아닙니다") b = "c:\\temp\\201632023\\room1\\room2" print(b) a = b.count("\\") l = b.split("\\", a) del (l[a]) b = "" for s in l: if (s == "c:"): b += s else: b += "\\" + s print(b) print(os.listdir("c:\\temp\\201632023\\")) if (len(os.listdir("c:\\temp\\201632023\\room1\\room2")) == 0): print("없어!") else: print("있어!")
import pydensecrf.densecrf as dcrf import numpy as np import sys from skimage.io import imread, imsave from pydensecrf.utils import unary_from_labels, create_pairwise_bilateral, create_pairwise_gaussian, unary_from_softmax from os import listdir, makedirs from os.path import isfile, join import os davis_path = '/your path/datasets/davis16-test/' setting = '/your path/results/davis/' out_folder = '/your path/results/davis-crf/' for d in listdir(setting): vidDir = join(davis_path, d) resDir = join(out_folder, d) if not os.path.exists(resDir): os.makedirs(resDir) for f in listdir(vidDir): img = imread(join(vidDir, f)) segDir = join(setting, d) frameName = str.split(f, '.')[0] anno_rgb = imread(segDir + '/' + frameName + '.png').astype(np.uint32) min_val = np.min(anno_rgb.ravel()) max_val = np.max(anno_rgb.ravel()) out = (anno_rgb.astype('float') - min_val) / (max_val - min_val) labels = np.zeros((2, img.shape[0], img.shape[1]))
def waf_entry_point(current_directory,version,wafdir): Logs.init_log() if Context.WAFVERSION!=version: Logs.error('Waf script %r and library %r do not match (directory %r)'%(version,Context.WAFVERSION,wafdir)) sys.exit(1) if'--version'in sys.argv: Context.run_dir=current_directory ctx=Context.create_context('options') ctx.curdir=current_directory ctx.parse_args() sys.exit(0) Context.waf_dir=wafdir Context.launch_dir=current_directory no_climb=os.environ.get('NOCLIMB',None) if not no_climb: for k in no_climb_commands: if k in sys.argv: no_climb=True break cur=current_directory while cur: lst=os.listdir(cur) if Options.lockfile in lst: env=ConfigSet.ConfigSet() try: env.load(os.path.join(cur,Options.lockfile)) ino=os.stat(cur)[stat.ST_INO] except Exception: pass else: for x in[env.run_dir,env.top_dir,env.out_dir]: if Utils.is_win32: if cur==x: load=True break else: try: ino2=os.stat(x)[stat.ST_INO] except OSError: pass else: if ino==ino2: load=True break else: Logs.warn('invalid lock file in %s'%cur) load=False if load: Context.run_dir=env.run_dir Context.top_dir=env.top_dir Context.out_dir=env.out_dir break if not Context.run_dir: if Context.WSCRIPT_FILE in lst: Context.run_dir=cur next=os.path.dirname(cur) if next==cur: break cur=next if no_climb: break if not Context.run_dir: if'-h'in sys.argv or'--help'in sys.argv: Logs.warn('No wscript file found: the help message may be incomplete') Context.run_dir=current_directory ctx=Context.create_context('options') ctx.curdir=current_directory ctx.parse_args() sys.exit(0) Logs.error('Waf: Run from a directory containing a file named %r'%Context.WSCRIPT_FILE) sys.exit(1) try: os.chdir(Context.run_dir) except OSError: Logs.error('Waf: The folder %r is unreadable'%Context.run_dir) sys.exit(1) try: set_main_module(Context.run_dir+os.sep+Context.WSCRIPT_FILE) except Errors.WafError ,e: Logs.pprint('RED',e.verbose_msg) Logs.error(str(e)) sys.exit(1)
#!/usr/bin/env python3 import os import shutil inputtie = '/home/hannelore/PROJECTHH/Data/cgMLSTschemes/MLST-548/wgMLST/schema-548/' outputtie = '/home/hannelore/PROJECTHH/Data/cgMLSTschemes/MLST-548/cgMLST/scheme-548-cgMLST/' fileList = os.listdir(inputtie) print(fileList) cfil = open ('/home/hannelore/PROJECTHH/Data/cgMLSTschemes/MLST-548/cgMLST/cgMLSTschema.txt', 'r') for line in cfil: #Had problems matching line to file: but found that the number of characters differed (1 extra for line) #tried to remove with strip and replace (" ","") but this did not work, removing the last character did, it was an /n """ line.split() line.replace(" ","") """ line=line[:-1] for item in fileList: ''' print("line is", line) print(type(line)) print(len(line)) print("item is", item) print(type(item)) print(len(item)) ''' if(line == item): inputpath= str(inputtie) + str(line)