def run(pkg, clusterUrl, clusterName, directory): #Initial some thing.Just like copy & extract tccbus.ear packages x = ModifyZip(pkg) x.Copy() x.Extract() #print "Tempdir: %s" % x.tempdir ##modify the file like jndi.properties & jboss.xml in the tccbus.ear program #packages. Just like: # TccBus.ear/TccBusWeb.war/WEB-INF/classes/jndi.properties # TccBus.ear/TccBusEJB.jar/jndi.properties # TccBus.ear/TccBusEJB.jar/META-INF/jboss.xml x.ModifyFile('jndi.properties', clusterUrl, \ clusterName, os.path.join(x.tempdir, 'TccBusWeb.war'), os.path.join(x.tempdir, 'TccBusWeb1.war')) x.ModifyFile('jndi.properties', clusterUrl, \ clusterName, os.path.join(x.tempdir, 'TccBusEJB.jar'), os.path.join(x.tempdir, 'TccBusEJB1.jar')) x.ModifyFile('jboss.xml', clusterUrl, \ clusterName, os.path.join(x.tempdir, 'TccBusEJB1.jar'), os.path.join(x.tempdir, 'TccBusEJB2.jar')) #modify TccBus.ear. Add New zipfile in TccBus.ear. x.ModifyZip(os.path.join(x.tempdir, 'TccBus.ear'), os.path.join(x.tempdir, 'TccBus1.ear'), \ 'TccBusWeb.war', os.path.join(x.tempdir, 'TccBusWeb1.war')) x.ModifyZip(os.path.join(x.tempdir, 'TccBus1.ear'), os.path.join(x.tempdir, 'TccBus2.ear'), \ 'TccBusEJB.jar', os.path.join(x.tempdir, 'TccBusEJB2.jar')) #####Copy the modified package to export dir. shutil.copy2(os.path.join(x.tempdir, 'TccBus2.ear'), os.path.join(directory, 'TccBus.ear'))
def log(self, file, crashReport = None, fileDesc = None, maxPerIssue=25): tmpDir = "" + self.dir if not os.path.isdir(tmpDir): os.makedirs(tmpDir) if crashReport != None: if crashReport.nearNull: tmpDir += "/nearNull" else: tmpDir += "/notNearNull" if not os.path.isdir(tmpDir): os.makedirs(tmpDir) tmpDir += "/" + crashReport.type if not os.path.isdir(tmpDir): os.makedirs(tmpDir) tmpDir += "/" + crashReport.location.replace(":",".") if not os.path.isdir(tmpDir): os.makedirs(tmpDir) count = len(os.listdir(tmpDir))/2 if count >= maxPerIssue: return shutil.copy2(file, tmpDir + ("/%04d_crash" % count) + os.path.splitext(file)[1]) fout = open(tmpDir + ("/%04d_description.txt" % count), "wb") if fileDesc != None: fout.write(fileDesc + "\n\n") if crashReport != None: fout.write(crashReport.getInfo()) fout.close()
def __update_dse_ldif(self): """ This method updates dse.ldif right after instance creation. This is supposed to allow admin modify configuration of the DS which has to be done before IPA is fully installed (for example: settings for replication on replicas) DS must be turned off. """ dse_filename = os.path.join( paths.ETC_DIRSRV_SLAPD_INSTANCE_TEMPLATE % self.serverid, 'dse.ldif' ) with tempfile.NamedTemporaryFile( mode='w', delete=False) as new_dse_ldif: temp_filename = new_dse_ldif.name with open(dse_filename, "r") as input_file: parser = installutils.ModifyLDIF(input_file, new_dse_ldif) parser.replace_value( 'cn=config,cn=ldbm database,cn=plugins,cn=config', 'nsslapd-db-locks', [b'50000'] ) if self.config_ldif: # parse modifications from ldif file supplied by the admin with open(self.config_ldif, "r") as config_ldif: parser.modifications_from_ldif(config_ldif) parser.parse() new_dse_ldif.flush() shutil.copy2(temp_filename, dse_filename) tasks.restore_context(dse_filename) try: os.remove(temp_filename) except OSError as e: logger.debug("Failed to clean temporary file: %s", e)
def main(): # Parameters. bookmarkdir = os.environ["HOME"] + "/Dropbox/Apps/pinboard/" pinboard_credentials = bookmarkdir + "pinboard_credentials.txt" current = bookmarkdir + "most_current_bookmarks.xml" pinboard_api = "https://api.pinboard.in/v1/" yearfmt = "%Y" datefmt = "%m-%d" homeTZ = pytz.timezone("GMT") y = datetime.now(pytz.utc).strftime(yearfmt) t = datetime.now(pytz.utc).strftime(datefmt) daily_file = bookmarkdir + y + "/pinboard-backup." + t + ".xml" # Get the user's authentication token with open(pinboard_credentials) as credentials: for line in credentials: me, token = line.split(":") if not os.path.exists(bookmarkdir + y): os.makedirs(bookmarkdir + y) # Set up a new bookmarks file bookmarkfile = open(daily_file, "w") # Get all the posts from Pinboard u = urllib2.urlopen(pinboard_api + "posts/all?auth_token=" + me + ":" + token) bookmarkfile.write(u.read()) bookmarkfile.close() shutil.copy2(daily_file, current)
def buildApp(): # ---------------------- # Under Windows, we're just going to grab the xulrunner-stub.exe and run Resource Hacker # to rename it to "Kylo", set the icon, and set some version info, etc. reshack_temp_dir = os.path.join(Settings.prefs.build_dir, "stub") if not os.path.exists(reshack_temp_dir): os.makedirs(reshack_temp_dir) build_stub.main(Settings.config.get('App','Version'), Settings.config.get('App','BuildID'), temp_dir = reshack_temp_dir, stub_dir = os.path.join(Settings.prefs.build_dir, "application")) # ---------------------- # We also need mozilla DLLS for lib in ["mozcrt19.dll", "mozutils.dll", "gkmedias.dll"]: f = os.path.join(Settings.prefs.xul_dir, lib) if (os.path.isfile(f)): shutil.copy2(f, os.path.join(Settings.prefs.build_dir, "application")) # ---------------------- # Now let's grab the XULRunner directory and drop it in to our working application directory xulrunner_dir = os.path.join(Settings.prefs.build_dir, "application", "xulrunner") if not os.path.exists(xulrunner_dir): os.makedirs(xulrunner_dir) build_util.syncDirs(Settings.prefs.xul_dir, xulrunner_dir, exclude=["xulrunner-stub.exe"])
def copy_wpt_tree(tree, dest): """Copy the working copy of a Tree to a destination directory. :param tree: The Tree to copy. :param dest: The destination directory""" if os.path.exists(dest): assert os.path.isdir(dest) shutil.rmtree(dest) os.mkdir(dest) for tree_path in tree.paths(): source_path = os.path.join(tree.root, tree_path) dest_path = os.path.join(dest, tree_path) dest_dir = os.path.split(dest_path)[0] if not os.path.isdir(source_path): if not os.path.exists(dest_dir): os.makedirs(dest_dir) shutil.copy2(source_path, dest_path) for source, destination in [("testharness_runner.html", ""), ("testharnessreport.js", "resources/")]: source_path = os.path.join(here, os.pardir, source) dest_path = os.path.join(dest, destination, os.path.split(source)[1]) shutil.copy2(source_path, dest_path) add_license(dest)
def main(): os.chdir(os.path.dirname(os.path.realpath(__file__))) os.system("pip install certifi") print "Copying certifi's cacert.pem" import certifi shutil.copy2(certifi.where(), 'agkyra/resources/cacert.pem')
def can_retrieve_cache(self): if not getattr(self, "outputs", None): return None sig = self.signature() ssig = Utils.to_hex(self.uid()) + Utils.to_hex(sig) dname = os.path.join(self.generator.bld.cache_global, ssig) try: t1 = os.stat(dname).st_mtime except OSError: return None for node in self.outputs: orig = os.path.join(dname, node.name) try: shutil.copy2(orig, node.abspath()) os.utime(orig, None) except (OSError, IOError): Logs.debug("task: failed retrieving file") return None try: t2 = os.stat(dname).st_mtime except OSError: return None if t1 != t2: return None for node in self.outputs: node.sig = sig if self.generator.bld.progress_bar < 1: self.generator.bld.to_log("restoring from cache %r\n" % node.abspath()) self.cached = True return True
def put_files_cache(self): if getattr(self, "cached", None): return None sig = self.signature() ssig = Utils.to_hex(self.uid()) + Utils.to_hex(sig) dname = os.path.join(self.generator.bld.cache_global, ssig) tmpdir = tempfile.mkdtemp(prefix=self.generator.bld.cache_global + os.sep + "waf") try: shutil.rmtree(dname) except: pass try: for node in self.outputs: dest = os.path.join(tmpdir, node.name) shutil.copy2(node.abspath(), dest) except (OSError, IOError): try: shutil.rmtree(tmpdir) except: pass else: try: os.rename(tmpdir, dname) except OSError: try: shutil.rmtree(tmpdir) except: pass else: try: os.chmod(dname, Utils.O755) except: pass
def mvrun(isimstr,**options): """ Move/rename files assosiated with a run """ # Get sim objects print 'Getting info on new file names...' fsimstr=mmlyt.asksimboj(infodict=isimstr.infodict,runtyp=isimstr['runtyp']) fname=mmlparam.par2fname('mmlyt.simlist','mmlsim',inpar=dict(fsimstr)) # Rename old run files fname_new=fname+'_new' fname_old=fname+'_old' if os.path.isfile(fname): os.rename(fname,fname_old) if os.path.isfile(fname_new): print 'Using info from new file: {}'.format(fname_new) shutil.copy2(fname_new,fname) # Get sim objects shutil.copy2(fname,fname_new) # Move files try: for ftype in LIST_FILETYPES: mvfiles(isimstr,fsimstr,ftype,groups='all',**options) cleantree(simstr=isimstr,**options) if os.path.isfile(fname_old): os.remove(fname_old) os.remove(fname_new) except: print "Error moving files:", sys.exc_info()[0] print "Moving run files back..." os.rename(fname,fname_new) if os.path.isfile(fname_old): os.rename(fname_old,fname) raise # Return control return
def copyfile(src, dst, logger=None, force=True, vars=None, subst_content=False): if vars is not None: src = subst_vars(src, **vars) dst = subst_vars(dst, **vars) if not os.path.exists(src) and not force: if logger is not None: logger.info("**Skiping copy file %s to %s. Source does not exists." % (src, dst)) return if logger is not None: logger.info("Copying file %s to %s." % (src, dst)) if vars is None or not subst_content: shutil.copy2(src, dst) return print ("copyfile " + src) f = open(src, "rt") content = f.read() f.close() content = subst_vars(content, **vars) f = open(dst, "wt") f.write(content) f.close()
def _prepare_disks(vm_settings, target_dir): """ Prepare VM disks for OVF appliance creation. File based disks will be copied to VM creation directory. LVM and block-device based disks will be converted into file based images and copied to creation directory. @param target_dir: directory where disks will be copied """ disk_list_dom = get_libvirt_conf_xml(vm_settings["vm_name"])\ .getElementsByTagName("domain")[0].getElementsByTagName("disk") disk_num, disk_list = 0, [] for disk_dom in disk_list_dom: if disk_dom.getAttribute("device") == "disk": disk_num += 1 source_dom = disk_dom.getElementsByTagName("source")[0] filename = "%s%d.img" % (vm_settings["template_name"], disk_num) new_path = path.join(target_dir, filename) if disk_dom.getAttribute("type") == "file": disk_path = source_dom.getAttribute("file") shutil.copy2(disk_path, new_path) elif disk_dom.getAttribute("type") == "block": source_dev = source_dom.getAttribute("dev") execute("qemu-img convert -f raw -O qcow2 %s %s" % (source_dev, new_path)) disk_dict = { "file_size": str(get_file_size_bytes(new_path)), "filename": filename, "new_path": new_path, "file_id": "diskfile%d" % (disk_num), "disk_id": "vmdisk%d.img" % (disk_num), "disk_capacity": str(get_kvm_disk_capacity_bytes(new_path)) } disk_list.append(disk_dict) return disk_list
def copy_python(src, dst, symlinks=False): " Copies just Python source files " import shutil names = os.listdir(src) try: os.makedirs(dst) except: pass errors = [] for name in names: srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): if not name.startswith("."): copy_python(srcname, dstname, symlinks) else: if name.endswith(".py"): print "create", dstname shutil.copy2(srcname, dstname) # XXX What about devices, sockets etc.? except (IOError, os.error), why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error, err: errors.extend(err.args[0])
def create_reference(self): """ Determines and passes the reference files to a reference folder. """ if self.test_status == 'PASSED': reference_dir = os.path.join(self.ref_path, 'regtest-ref') create_dir(reference_dir) ltraj, lprop = self.get_filesname(self.test_path, reference_dir, self.io_dir) try: for prop in lprop: for sprop in prop: remove_file(sprop['old_filename']) shutil.copy2(sprop['new_filename'], sprop['old_filename']) for traj in ltraj: for straj in traj: remove_file(straj['old_filename']) shutil.copy2(straj['new_filename'], straj['old_filename']) except IOError, e: self.test_status = 'ERROR' self.msg += 'Error while copying the new reference!!\n' self.msg += "Unable to copy file. %s" % e else: self.test_status = 'COPIED'
def addFile(self, opath): """Copy PATH to MEDIADIR, and return new filename. If the same name exists, compare checksums.""" mdir = self.dir() # remove any dangerous characters base = re.sub(r"[][<>:/\\&]", "", os.path.basename(opath)) dst = os.path.join(mdir, base) # if it doesn't exist, copy it directly if not os.path.exists(dst): shutil.copy2(opath, dst) return base # if it's identical, reuse if self.filesIdentical(opath, dst): return base # otherwise, find a unique name (root, ext) = os.path.splitext(base) def repl(match): n = int(match.group(1)) return " (%d)" % (n+1) while True: path = os.path.join(mdir, root + ext) if not os.path.exists(path): break reg = " \((\d+)\)$" if not re.search(reg, root): root = root + " (1)" else: root = re.sub(reg, repl, root) # copy and return shutil.copy2(opath, path) return os.path.basename(os.path.basename(path))
def install_step(self): """ Install LAPACK: copy all .a files to lib dir in install directory """ if self.cfg['test_only']: self.log.info('Only testing, so skipping make install.') pass srcdir = self.cfg['start_dir'] destdir = os.path.join(self.installdir, 'lib') try: os.makedirs(destdir) # copy all .a files os.chdir(srcdir) for lib in glob.glob('*.a'): srcfile = os.path.join(srcdir, lib) self.log.debug("Copying file %s to dir %s" % (srcfile, destdir)) shutil.copy2(srcfile, destdir) # symlink libraries to sensible names, if they aren't renamed already for (fromfile, tofile) in [('liblapack_LINUX.a', 'liblapack.a'), ('tmglib_LINUX.a', 'libtmglib.a')]: frompath = os.path.join(destdir, fromfile) topath = os.path.join(destdir, tofile) if os.path.isfile(frompath) and not os.path.isfile(tofile): self.log.debug("Symlinking %s to %s" % (fromfile, tofile)) os.symlink(frompath, topath) except OSError, err: self.log.error("Copying %s to installation dir %s failed: %s" % (srcdir, destdir, err))
def _persist_file(self, abspath): """Persist file and bind mount it back to its current location """ persisted_path = self._config_path(abspath) if os.path.exists(persisted_path): current_checksum = self.checksum(abspath) stored_checksum = self.checksum(persisted_path) if stored_checksum == current_checksum: self._logger.warn('File "%s" had already been persisted', abspath) return else: # If this happens, somehow the bind mount was undone, so we try # and clean up before re-persisting try: if mount.ismount(abspath): mount.umount(abspath) os.unlink(persisted_path) except OSError as ose: self._logger.error('Failed to clean up persisted file ' '"%s": %s', abspath, ose.message) self._prepare_dir(abspath, persisted_path) shutil.copy2(abspath, persisted_path) self.copy_attributes(abspath, persisted_path) mount.mount(persisted_path, abspath, flags=mount.MS_BIND) self._logger.info('File "%s" successfully persisted', abspath) self._add_path_entry(abspath)
def copytree(src, dst, symlinks=False, ignore=None): names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() if not os.path.exists(dst): os.makedirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore) else: shutil.copy2(srcname, dstname) # XXX What about devices, sockets etc.? except (IOError, os.error), why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error, err: errors.extend(err.args[0])
def make_store(problem, opts, exists_handler): """ Create the store directory and populate it with the model definition file. """ # Determine if command line override if opts.store: problem.store = opts.store problem.output_path = os.path.join(problem.store, problem.name) # Check if already exists if not opts.overwrite and os.path.exists(problem.output_path + '.out'): if opts.batch: print( problem.store + " already exists. Use --overwrite to replace.", file=sys.stderr) sys.exit(1) exists_handler(problem.output_path) # Create it and copy model if not os.path.exists(problem.store): os.mkdir(problem.store) shutil.copy2(problem.path, problem.store) # Redirect sys.stdout to capture progress if opts.batch: sys.stdout = open(problem.output_path + ".mon", "w")
def client_cert(source, destination, user=None, group=None): """ Copy the client certificate to the destination creating directories if needed and assign ownership if set. :param string source: The path to look for the certificate, if None the certificate will be copied from the default location. :param string destination: The path to save the certificate. :param string user: The optional name of the user to own the certificate. :param string group: The optional name of the group to own certificate. """ _ensure_directory(destination, user, group) if not source: # When source not specified use the default client certificate path. source = os.path.join(charm_dir(), 'easy-rsa/easyrsa3/pki/issued/client.crt') # Check for the client certificate. if os.path.isfile(source): # Copy the client certificate to the destination. copy2(source, destination) else: # No client certificate file, get the value from unit data. client_cert_key = 'tls.client.certificate' # Save the certificate data to the destination. _save_unitdata(client_cert_key, destination) chown(destination, user, group) # Set the destination path for the client certificate path on the unitdata. unitdata.kv().set('client-cert-path', destination)
def server_cert(source, destination, user=None, group=None): """ Copy the server certificate to the destination, creating directories if needed and assign ownership if set. :param string source: The directory to look for the certificate, if None the certificate will be copied from unit data. :param string destination: The path to save the certificate. :param string user: The optional name of the user to own the certificate. :param string group: The optional name of the group to own certificate. """ _ensure_directory(destination, user, group) if not source: # Must remove the path characters from the local unit name. key_name = local_unit().replace('/', '_') # The location of server certificate is easy-rsa/easyrsa3/pki/issued source = \ os.path.join( charm_dir(), 'easy-rsa/easyrsa3/pki/issued/{0}.crt'.format(key_name)) if os.path.isfile(source): # Copy the server certificate to the destination. copy2(source, destination) else: # No source server certificate, get the value from unit data. server_cert_key = 'tls.server.certificate' # Save the certificate data to the destination directory. _save_unitdata(server_cert_key, destination) chown(destination, user, group) # Set the destination path for the client certificate path on the unitdata. unitdata.kv().set('server-cert-path', destination)
def ca(source, destination, user=None, group=None): """ Copy the Certificate Authority (CA) to the destination, creating parent directories if needed and assign owner if set. The tls layer installs the CA on all the peers in /usr/local/share/ca-certificates/. :param string source: The path to look or the certificate, if None the CA will be copied from the default location. :param string destination: The path to save the CA certificate. :param string user: The optional user name to own the CA certificate. :param string group: The optional group name to own the CA certificate. """ _ensure_directory(destination, user, group) if not source: # When source not specified use the default CA path. source = \ '/usr/local/share/ca-certificates/{0}.crt'.format(service_name()) # Copy the ca certificate to the destination directory. copy2(source, destination) chown(destination, user, group) # Set the destination path for the ca certificate path on the unitdata. unitdata.kv().set('ca-cert-path', destination)
def pull(self): if common.isurl(self.source): self.download() else: shutil.copy2(self.source, self.source_dir) self.provision(self.source_dir)
def install(host, src, dstdir): if isLocal(host): if not exists(host, src): util.output("file does not exist: %s" % src) return False dst = os.path.join(dstdir, os.path.basename(src)) if exists(host, dst): # Do not clobber existing files/dirs (this is not an error) return True util.debug(1, "cp %s %s" % (src, dstdir)) try: if os.path.isfile(src): shutil.copy2(src, dstdir) elif os.path.isdir(src): shutil.copytree(src, dst) except OSError: # Python 2.6 has a bug where this may fail on NFS. So we just # ignore errors. pass else: util.error("install() not yet supported for remote hosts") return True
def browse_curve_file(self, preferredExt="crv"): """ Gets curve file from a file browser. If the returned string from the browser is a valid file, the curve input box is set to that new item and "Default Curve" and "Estimate Curve Only" are disabled Args: preferredExt (str): The extension that the browser will look for whenever listing directories for a curve file """ # make sure to filter out all unwanted files and leave a * (All Files) # filepaths = QtGui.QFileDialog.getOpenFileName(self, "Browse Curve Profile") filepaths = [x for x in filepaths if x.strip() != ""] for f in filepaths: if os.path.isfile(f) and f.lower().endswith(preferredExt): fname = paths.path_leaf(f) shutil.copy2(f, os.path.join(self.curveInputDir, fname)) self.curveInput_cb.addItem(fname) index = self.curveInput_cb.findText(fname, QtCore.Qt.MatchFixedString) if index >= 0: self.curveInput_cb.setCurrentIndex(index) self.defaultCurve_cb.setEnabled(False) self.estimateCurve_cb.setEnabled(False)
def savedir(self, savedir): if savedir is None: self._savedir = None elif hasattr(self, '_savedir') and savedir == self.savedir: return else: if hasattr(self, '_savedir'): orig_dir = self.savedir else: orig_dir = False savedir = abspath(savedir) if not savedir.endswith('.sima'): savedir += '.sima' os.makedirs(savedir) self._savedir = savedir if orig_dir: from shutil import copy2 for f in os.listdir(orig_dir): if f.endswith('.pkl'): try: copy2(os.path.join(orig_dir, f), self.savedir) except IOError: pass if self._read_only: self._read_only = False
def configure_step(self): """Configure SCOTCH build: locate the template makefile, copy it to a general Makefile.inc and patch it.""" # pick template makefile comp_fam = self.toolchain.comp_family() if comp_fam == toolchain.INTELCOMP: #@UndefinedVariable makefilename = 'Makefile.inc.x86-64_pc_linux2.icc' elif comp_fam == toolchain.GCC: #@UndefinedVariable makefilename = 'Makefile.inc.x86-64_pc_linux2' else: self.log.error("Unknown compiler family used: %s" % comp_fam) # create Makefile.inc try: srcdir = os.path.join(self.cfg['start_dir'], 'src') src = os.path.join(srcdir, 'Make.inc', makefilename) dst = os.path.join(srcdir, 'Makefile.inc') shutil.copy2(src, dst) self.log.debug("Successfully copied Makefile.inc to src dir.") except OSError: self.log.error("Copying Makefile.inc to src dir failed.") # the default behaviour of these makefiles is still wrong # e.g., compiler settings, and we need -lpthread try: for line in fileinput.input(dst, inplace=1, backup='.orig.easybuild'): # use $CC and the likes since we're at it. line = re.sub(r"^CCS\s*=.*$", "CCS\t= $(CC)", line) line = re.sub(r"^CCP\s*=.*$", "CCP\t= $(MPICC)", line) line = re.sub(r"^CCD\s*=.*$", "CCD\t= $(MPICC)", line) # append -lpthread to LDFLAGS line = re.sub(r"^LDFLAGS\s*=(?P<ldflags>.*$)", "LDFLAGS\t=\g<ldflags> -lpthread", line) sys.stdout.write(line) except IOError, err: self.log.error("Can't modify/write Makefile in 'Makefile.inc': %s" % (err))
def walk(src, dest): print '****************************************************************' print dest print '****************************************************************' dirCmp = filecmp.dircmp(src, dest, ignore=['Thumbs.db']) for destFile in dirCmp.right_only: destFilePath = dest+'/'+destFile if os.path.isfile(destFilePath): print u'删除文件\n',destFilePath os.remove(destFilePath) else: print u'删除文件夹\n',destFilePath # os.rmdir(destFilePath) shutil.rmtree(destFilePath) for srcFile in dirCmp.left_only: srcFilePath = src+'/'+srcFile destFilePath = dest+'/'+srcFile if os.path.isfile(srcFilePath): print u'复制文件\n',destFilePath shutil.copy2(srcFilePath, dest) else: print u'复制文件夹\n',destFilePath shutil.copytree(srcFilePath, destFilePath) for srcFile in dirCmp.diff_files: srcFilePath = src+'/'+srcFile destFilePath = dest+'/'+srcFile print u'同步文件\n',destFilePath shutil.copy2(srcFilePath, dest) subDirs = set(os.listdir(src))-set(dirCmp.left_only) targetDirs = [subDir for subDir in subDirs if os.path.isdir(src+'/'+subDir)] for targetDir in targetDirs: walk(src+'/'+targetDir, dest+'/'+targetDir)
def _stage_files(self, bin_name=None): dirs = self.query_abs_dirs() abs_app_dir = self.query_abs_app_dir() # For mac these directories are in Contents/Resources, on other # platforms abs_res_dir will point to abs_app_dir. abs_res_dir = self.query_abs_res_dir() abs_res_components_dir = os.path.join(abs_res_dir, 'components') abs_res_plugins_dir = os.path.join(abs_res_dir, 'plugins') abs_res_extensions_dir = os.path.join(abs_res_dir, 'extensions') if bin_name: self.info('copying %s to %s' % (os.path.join(dirs['abs_test_bin_dir'], bin_name), os.path.join(abs_app_dir, bin_name))) shutil.copy2(os.path.join(dirs['abs_test_bin_dir'], bin_name), os.path.join(abs_app_dir, bin_name)) self.copytree(dirs['abs_test_bin_components_dir'], abs_res_components_dir, overwrite='overwrite_if_exists') self.mkdir_p(abs_res_plugins_dir) self.copytree(dirs['abs_test_bin_plugins_dir'], abs_res_plugins_dir, overwrite='overwrite_if_exists') if os.path.isdir(dirs['abs_test_extensions_dir']): self.mkdir_p(abs_res_extensions_dir) self.copytree(dirs['abs_test_extensions_dir'], abs_res_extensions_dir, overwrite='overwrite_if_exists')
def server_key(source, destination, user=None, group=None): """ Copy the server key to the destination, creating directories if needed and assign ownership if set. :param string source: The directory to look for the key, if None the key will be copied from default location. :param string destination: The path to save the key. :param string user: The optional name of the user to own the key. :param string group: The optional name of the group to own key. """ _ensure_directory(destination, user, group) if not source: # Must remove the path characters from the local unit name. key_name = local_unit().replace('/', '_') # The location of server key is easy-rsa/easyrsa3/pki/private source = \ os.path.join( charm_dir(), 'easy-rsa/easyrsa3/pki/private/{0}.key'.format(key_name)) # Copy the key to the destination. copy2(source, destination) chown(destination, user, group) # Set the destination path for the client key path on the unitdata. unitdata.kv().set('server-key-path', destination)
def _applypatch(self, patch, force = False, reverse = False, run = True): import shutil def _applypatchhelper(shellcmd, patch, force = False, reverse = False, run = True): if reverse: shellcmd.append('-R') shellcmd.append(patch['file']) if not run: return "sh" + "-c" + " ".join(shellcmd) return runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) # Add hooks which add a pointer to the original patch file name in the commit message reporoot = (runcmd("git rev-parse --show-toplevel".split(), self.dir) or '').strip() if not reporoot: raise Exception("Cannot get repository root for directory %s" % self.dir) hooks_dir = os.path.join(reporoot, '.git', 'hooks') hooks_dir_backup = hooks_dir + '.devtool-orig' if os.path.lexists(hooks_dir_backup): raise Exception("Git hooks backup directory already exists: %s" % hooks_dir_backup) if os.path.lexists(hooks_dir): shutil.move(hooks_dir, hooks_dir_backup) os.mkdir(hooks_dir) commithook = os.path.join(hooks_dir, 'commit-msg') applyhook = os.path.join(hooks_dir, 'applypatch-msg') with open(commithook, 'w') as f: # NOTE: the formatting here is significant; if you change it you'll also need to # change other places which read it back f.write('echo >> $1\n') f.write('echo "%s: $PATCHFILE" >> $1\n' % GitApplyTree.patch_line_prefix) os.chmod(commithook, 0o755) shutil.copy2(commithook, applyhook) try: patchfilevar = 'PATCHFILE="%s"' % os.path.basename(patch['file']) try: shellcmd = [patchfilevar, "git", "--work-tree=%s" % reporoot, "am", "-3", "--keep-cr", "-p%s" % patch['strippath']] return _applypatchhelper(shellcmd, patch, force, reverse, run) except CmdError: # Need to abort the git am, or we'll still be within it at the end try: shellcmd = ["git", "--work-tree=%s" % reporoot, "am", "--abort"] runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) except CmdError: pass # git am won't always clean up after itself, sadly, so... shellcmd = ["git", "--work-tree=%s" % reporoot, "reset", "--hard", "HEAD"] runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) # Also need to take care of any stray untracked files shellcmd = ["git", "--work-tree=%s" % reporoot, "clean", "-f"] runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) # Fall back to git apply shellcmd = ["git", "--git-dir=%s" % reporoot, "apply", "-p%s" % patch['strippath']] try: output = _applypatchhelper(shellcmd, patch, force, reverse, run) except CmdError: # Fall back to patch output = PatchTree._applypatch(self, patch, force, reverse, run) # Add all files shellcmd = ["git", "add", "-f", "-A", "."] output += runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) # Exclude the patches directory shellcmd = ["git", "reset", "HEAD", self.patchdir] output += runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) # Commit the result (tmpfile, shellcmd) = self.prepareCommit(patch['file']) try: shellcmd.insert(0, patchfilevar) output += runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) finally: os.remove(tmpfile) return output finally: shutil.rmtree(hooks_dir) if os.path.lexists(hooks_dir_backup): shutil.move(hooks_dir_backup, hooks_dir)
def patch_wheel(whl_path, extracted=False): """Patch a wheel in a manner similar to auditwheel. If extracted is False, whl_path must be the path to a .whl file, and this file is replaced with a fixed version. If extracted is True, then whl_path must be a directory containing the extracted contents of the wheel to patch, and the contents of the directory are replaced with the contents of a patched version (the contents are not zipped up). This is necessary for packaging the dependent shared libraries in a way that avoids dependency hell and ensures that Python packages are self-contained and isolated. There are a few reasons for patching the libraries. 1. We need to be able to load the libraries no matter where they are installed. 2. We don't want a system library with the same name to interfere with loading. 3. We don't want two Python packages containing libraries with the same name to interfere with each other. To patch the wheel, we rename the iKnow engine and ICU shared libraries by adding a hash to the file names, and then we re-link them to the newly renamed libraries. This way, we can guarantee that the correct library is loaded when iknowpy is imported.""" print('repairing wheel') # extract wheel if extracted: extracted_dir = whl_path else: extracted_dir = f'dist{os.sep}temp' rmtree(extracted_dir) os.mkdir(extracted_dir) extract_wheel(whl_path, extracted_dir) # copy ICU and iKnow engine library files iculib_map = { } # name of symlink to ICU library -> name of actual ICU library file repair_lib_dir = os.path.join(extracted_dir, 'iknowpy') for lib_path in iculib_paths: if os.path.islink(lib_path): iculib_map[os.path.basename(lib_path)] = os.path.basename( os.path.realpath(lib_path)) else: shutil.copy2(lib_path, repair_lib_dir) for lib_path in enginelib_paths: shutil.copy2(lib_path, repair_lib_dir) # copy extra library files for lib_name in extra_libs: lib_path = ctypes.util.find_library(lib_name) if lib_path is None: raise FileNotFoundError(f'Unable to find library {lib_name}') shutil.copy2(lib_path, repair_lib_dir) # create list of libraries to repair module_pattern = os.path.join(repair_lib_dir, module_name_pattern) repair_lib_paths = glob.glob(module_pattern) if not repair_lib_paths: raise BuildError( f'Unable to find module matching pattern {module_pattern!r}') repair_lib_paths.extend( glob.iglob(os.path.join(repair_lib_dir, iculibs_name_pattern))) repair_lib_paths.extend( glob.iglob(os.path.join(repair_lib_dir, enginelibs_name_pattern))) # repair libraries by setting dependency paths and renaming them patcher = PatchLib() lib_rename = {} # dict from old lib name to new lib name for lib_path in repair_lib_paths: lib_name = os.path.basename(lib_path) if lib_name.startswith('engine.'): # don't rename main module file lib_rename[lib_name] = lib_name else: lib_name_split = lib_name.split('.') with open(lib_path, 'rb') as lib_file: lib_name_split[0] = f'{lib_name_split[0]}-{hashfile(lib_file)}' lib_name_new = '.'.join(lib_name_split) lib_rename[lib_name] = lib_name_new for lib_name in iculib_map: # replace dependency on symlink to dependency on actual library file lib_rename[lib_name] = lib_rename[iculib_map[lib_name]] os.makedirs(CACHE_DIR, exist_ok=True) for lib_path in repair_lib_paths: lib_dir, lib_name = os.path.split(lib_path) print( f'repairing {lib_path} -> {os.path.join(lib_dir, lib_rename[lib_name])}', end='') if not lib_name.startswith('engine.') and os.path.isfile( os.path.join('dist/cache', lib_rename[lib_name])): # copy patched library from cache os.remove(lib_path) shutil.copy2(os.path.join(CACHE_DIR, lib_rename[lib_name]), lib_dir) print(' (cached)') else: dep_libs = patcher.getneeded(lib_path) patcher.setname(lib_path, lib_rename[lib_name]) if dep_libs: if sys.platform == 'linux': patcher.setrpath(lib_path) patcher.replaceneeded(lib_path, dep_libs, lib_rename) os.rename(lib_path, os.path.join(lib_dir, lib_rename[lib_name])) if not lib_name.startswith('engine.'): # copy patched library into cache and remove old entries for old_entry in glob.iglob( os.path.join(CACHE_DIR, lib_name[:lib_name.index('.')] + '-*')): remove(old_entry) shutil.copy2(os.path.join(lib_dir, lib_rename[lib_name]), CACHE_DIR) print() # update record file, which tracks wheel contents and their checksums update_wheel_record(extracted_dir) if not extracted: # repackage wheel repackage_wheel(whl_path, extracted_dir) # remove extracted files print(f'removing {extracted_dir}') rmtree(extracted_dir)
def run(self): metadata = None # metadata from .dist-info/WHEEL file python_tags = [] abi_tags = [] platform_tag = None extracted_dirs = [] tmp_dir_base = f'dist{os.sep}temp' rmtree(tmp_dir_base) # extract wheels whl_paths = glob.glob(f'dist/iknowpy-{version}-*.whl') if len(whl_paths) < 2: raise BuildError('Fewer than 2 wheels were found in dist/') if len(set(map(lambda s: s[s.rindex('-') + 1:], whl_paths))) > 1: raise BuildError( 'Multiple platform tags were found in the wheels in dist/. ' 'Only wheels with the same platform tag can be merged.') for whl_path in whl_paths: whl_name = os.path.basename(whl_path) whl_name = whl_name[:-len('.whl')] # strip off the extension whl_name_split = whl_name.split('-') # whl_name_split has the form [name, version, python_tag, abi_tag, platform_tag] python_tags.append(whl_name_split[2]) abi_tags.append(whl_name_split[3]) platform_tag = whl_name_split[4] extracted_dir = os.path.join(tmp_dir_base, whl_name) extracted_dirs.append(extracted_dir) extract_wheel(whl_path, extracted_dir) # verify that original wheels were created with --no-dependencies flag if glob.glob( os.path.join(extracted_dir, 'iknowpy', enginelibs_name_pattern)): raise BuildError( f'{whl_path} was not built with --no-dependencies and cannot be merged' ) # get the wheel metadata metadata_filepath = os.path.join(extracted_dir, f'iknowpy-{version}.dist-info', 'WHEEL') if metadata is None: metadata = extract_metadata(metadata_filepath) else: merge_metadata(metadata, extract_metadata(metadata_filepath)) # Ensure that all wheels have identical metadata with the exception of # the Tag key, which is expected to be different between wheels that # target different Python versions. This way, we don't merge wheels that # might be incompatible with each other. for key, values in metadata.items(): if key != 'Tag' and len(values) > 1: raise BuildError( f'Wheels have conflicting metadata for key {key!r} and cannot be merged. Conflicting values are {values!r}.' ) python_tags.sort() abi_tags.sort() # copy all engine modules into extracted contents of first wheel for extracted_dir in extracted_dirs[1:]: for module_path in glob.iglob( os.path.join(extracted_dir, 'iknowpy', module_name_pattern)): print( f'copying {module_path} -> {os.path.join(extracted_dirs[0], "iknowpy", os.path.basename(module_path))}' ) shutil.copy2(module_path, os.path.join(extracted_dirs[0], 'iknowpy')) # update metadata metadata_filepath = os.path.join(extracted_dirs[0], f'iknowpy-{version}.dist-info', 'WHEEL') print(f'updating wheel metadata file {metadata_filepath}') with open(metadata_filepath, 'w') as metadata_file: for key, values in metadata.items(): for value in sorted(values): metadata_file.write(f'{key}: {value}\n') # fix up the wheel if no_dependencies: update_wheel_record(extracted_dirs[0]) else: patch_wheel(extracted_dirs[0], True) # create the merged wheel merged_whl_name = f'iknowpy-{version}-{".".join(python_tags)}-{".".join(abi_tags)}-{platform_tag}.whl' merged_whl_path = os.path.join('dist', 'merged', merged_whl_name) print(f'creating merged wheel {merged_whl_path}') repackage_wheel(merged_whl_path, extracted_dirs[0]) # delete temp files rmtree(tmp_dir_base)
no_dependencies = True with open('../../README.md', encoding='utf-8') as readme_file: long_description = readme_file.read() # Strip off badges. They belong in the GitHub version of the README file but # are less appropriate on PyPI. long_description = long_description[long_description.index('# iKnow\n'):] dependent_lib_names = None try: if fast_install: # copy dependent libraries into ./iknowpy dependent_lib_names = [] for lib_path in itertools.chain(iculib_paths, enginelib_paths, extralib_paths): shutil.copy2(lib_path, 'iknowpy') dependent_lib_names.append(os.path.basename(lib_path)) package_data = {'iknowpy': dependent_lib_names} else: # include MIT license in distribution shutil.copy2('../../LICENSE', '.') # include ICU license in distribution icu_license_found = False for root, _, files in os.walk(icudir): for filename in files: if filename == 'LICENSE': icu_license_found = True shutil.copy2(os.path.join(root, filename), 'LICENSE_ICU') break if icu_license_found:
def copytree(src, dst, symlinks=False, ignore=None): """Recursively copy a directory tree using copy2(). The destination directory must not already exist. If exception(s) occur, an Error is raised with a list of reasons. If the optional symlinks flag is true, symbolic links in the source tree result in symbolic links in the destination tree; if it is false, the contents of the files pointed to by symbolic links are copied. The optional ignore argument is a callable. If given, it is called with the `src` parameter, which is the directory being visited by copytree(), and `names` which is the list of `src` contents, as returned by os.listdir(): callable(src, names) -> ignored_names Since copytree() is called recursively, the callable will be called once for each directory that is copied. It returns a list of names relative to the `src` directory that should not be copied. XXX Consider this example code rather than the ultimate tool. """ names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() mkdirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore) else: copy2(srcname, dstname) # XXX What about devices, sockets etc.? except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except OSError as why: if WindowsError is not None and isinstance(why, WindowsError): # Copying file access times may fail on Windows pass else: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def writeMesh(self): """ Convert or copy mesh files """ if self.mesh_obj.Proxy.Type == "Fem::FemMeshGmsh" and not(self.meshConvertedTo2D): # GMSH # Convert GMSH created UNV file to OpenFoam print("Writing GMSH") unvMeshFile = self.case_folder + os.path.sep + self.solver_obj.InputCaseName + u".unv" self.mesh_generated = CfdTools.write_unv_mesh(self.mesh_obj, self.bc_group, unvMeshFile) # FreeCAD always stores the CAD geometry in mm, while FOAM by default uses SI units. This is independent # of the user selected unit preferences. self.setupMesh(unvMeshFile, scale = 0.001) elif self.mesh_obj.Proxy.Type == "Fem::FemMeshGmsh" and self.meshConvertedTo2D: import tempfile tmpdir = tempfile.gettempdir() meshCaseDir = os.path.join(tmpdir, "meshCase") constantDir = os.path.join(meshCaseDir, 'constant') systemDir = os.path.join(meshCaseDir, 'system') polyMeshDir = os.path.join(constantDir, 'polyMesh') unvMeshFile = meshCaseDir + os.path.sep + self.solver_obj.InputCaseName + u".unv" CfdTools.copyFilesRec(polyMeshDir, os.path.join(self.case_folder, 'constant', 'polyMesh')) shutil.copy2(os.path.join(systemDir, 'extrudeMeshDict'), os.path.join(self.case_folder, 'system')) shutil.copy2(os.path.join(meshCaseDir, 'ConvertMeshTo2D'), self.case_folder) shutil.copy2(os.path.join(meshCaseDir, unvMeshFile), self.case_folder) shutil.copy2(os.path.join(meshCaseDir, 'log.extrudeMesh'), self.case_folder) shutil.copy2(os.path.join(meshCaseDir, 'log.ideasUnvToFoam'), self.case_folder) shutil.copy2(os.path.join(meshCaseDir, 'log.transformPoints'), self.case_folder) elif self.mesh_obj.Proxy.Type == "CfdMeshCart": # Cut-cell Cartesian import CfdCartTools ## Move Cartesian mesh files from temporary mesh directory to case directory if self.mesh_obj.MeshUtility == "cfMesh": print("Writing Cartesian mesh\n") #import CfdCartTools self.cart_mesh = CfdCartTools.CfdCartTools(self.mesh_obj) cart_mesh = self.cart_mesh # cart_mesh.get_tmp_file_paths("cfMesh") # Update tmp file locations cart_mesh.get_tmp_file_paths() # Update tmp file locations CfdTools.copyFilesRec(cart_mesh.polyMeshDir, os.path.join(self.case_folder, 'constant', 'polyMesh')) CfdTools.copyFilesRec(cart_mesh.triSurfaceDir, os.path.join(self.case_folder, 'constant', 'triSurface')) # shutil.copy2(cart_mesh.temp_file_meshDict, os.path.join(self.case_folder,'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'system', 'meshDict'), os.path.join(self.case_folder,'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir,'Allmesh'),self.case_folder) shutil.copy2(os.path.join(cart_mesh.meshCaseDir,'log.cartesianMesh'),self.case_folder) shutil.copy2(os.path.join(cart_mesh.meshCaseDir,'log.surfaceFeatureEdges'),self.case_folder) elif self.mesh_obj.MeshUtility == "snappyHexMesh": print("Writing snappyHexMesh generated Cartesian mesh\n") self.cart_mesh = CfdCartTools.CfdCartTools(self.mesh_obj) cart_mesh = self.cart_mesh # cart_mesh.get_tmp_file_paths("snappyHexMesh") # Update tmp file locations cart_mesh.get_tmp_file_paths() # Update tmp file locations CfdTools.copyFilesRec(cart_mesh.polyMeshDir, os.path.join(self.case_folder,'constant','polyMesh')) CfdTools.copyFilesRec(cart_mesh.triSurfaceDir, os.path.join(self.case_folder,'constant','triSurface')) # shutil.copy2(cart_mesh.temp_file_blockMeshDict, os.path.join(self.case_folder,'system')) # shutil.copy2(cart_mesh.temp_file_snappyMeshDict, os.path.join(self.case_folder,'system')) # shutil.copy2(cart_mesh.temp_file_surfaceFeatureExtractDict, os.path.join(self.case_folder,'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'system', 'blockMeshDict'), os.path.join(self.case_folder,'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'system', 'snappyHexMeshDict'), os.path.join(self.case_folder,'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'system', 'surfaceFeatureExtractDict'), os.path.join(self.case_folder,'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'Allmesh'), self.case_folder) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'log.blockMesh'), self.case_folder) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'log.surfaceFeatureExtract'), self.case_folder) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'log.snappyHexMesh'), self.case_folder) if self.meshConvertedTo2D: shutil.copy2(os.path.join(os.path.join(cart_mesh.meshCaseDir,'system'),'extrudeMeshDict'), os.path.join(self.case_folder, 'system')) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'ConvertMeshTo2D'), self.case_folder) shutil.copy2(os.path.join(cart_mesh.meshCaseDir, 'log.extrudeMesh'), self.case_folder) else: raise RuntimeError("Unrecognised mesh type")
"").replace("debug =TRUE,", "") file_copy.extend(txtfile(line)) if "<- bugs(" in line: var = line.split()[0].replace(".", "") if "working.directory = getwd()" in line: code += "coda.data <- as.matrix(read.bugs(\"CODAchain1.txt\"))\nparam_file <- c()\nfor (out_param in colnames(as.matrix(coda.data))) {{\n param_file <- cbind(param_file, paste(gsub(\"\\\\.\", \"_\", out_param), \",[\", paste(coda.data[, out_param], collapse = \" \"), \"],\", out$summary[,\"Rhat\"][out_param]))\n}}\nwrite.table(param_file, file = \"bugs_{0}.out\", row.names=FALSE, col.nam=FALSE, sep=\"\\n\", quote = FALSE)\n\n".format( var) else: if code != "": try: os.mkdir("bugs_bpa/{0}_{1}".format(outputBase, chapter)) except: pass dest = open( "bugs_bpa/{0}_{1}/{0}_{1}R".format(outputBase, chapter), 'w') code = "library(R2OpenBUGS)\nlibrary(coda)" + code dest.write(code) code = "" dest.close() for f in file_copy: try: shutil.copy2( f, "bugs_bpa/{0}_{1}/".format(outputBase, chapter)) except: pass file_copy = [] chapter = chapter_new #if (count <= 0): # break
def run_cfour(name, **kwargs): """Function that prepares environment and input files for a calculation calling Stanton and Gauss's CFOUR code. Also processes results back into Psi4 format. This function is not called directly but is instead called by :py:func:`~driver.energy` or :py:func:`~driver.optimize` when a Cfour method is requested (through *name* argument). In order to function correctly, the Cfour executable ``xcfour`` must be present in :envvar:`PATH` or :envvar:`PSIPATH`. .. hlist:: :columns: 1 * Many :ref:`PSI Variables <apdx:cfour_psivar>` extracted from the Cfour output * Python dictionary of associated file constants accessible as ``P4C4_INFO['zmat']``, ``P4C4_INFO['output']``, ``P4C4_INFO['grd']``, *etc.* :type name: string :param name: ``'c4-scf'`` || ``'c4-ccsd(t)'`` || ``'cfour'`` || etc. First argument, usually unlabeled. Indicates the computational method to be applied to the system. :type keep: :ref:`boolean <op_py_boolean>` :param keep: ``'on'`` || |dl| ``'off'`` |dr| Indicates whether to delete the Cfour scratch directory upon completion of the Cfour job. :type path: string :param path: Indicates path to Cfour scratch directory (with respect to Psi4 scratch directory). Otherwise, the default is a subdirectory within the Psi4 scratch directory. If specified, GENBAS and/or ZMAT within will be used. :type genbas: string :param genbas: Indicates that contents should be used for GENBAS file. GENBAS is a complicated topic. It is quite unnecessary if the molecule is from a molecule {...} block and basis is set through |Psifours| BASIS keyword. In that case, a GENBAS is written from LibMints and all is well. Otherwise, a GENBAS is looked for in the usual places: PSIPATH, PATH, PSIDATADIR/basis. If path kwarg is specified, also looks there preferentially for a GENBAS. Can also specify GENBAS within an input file through a string and setting the genbas kwarg. Note that due to the input parser's aggression, blank lines need to be replaced by the text blankline. """ lowername = name.lower() internal_p4c4_info = {} return_wfn = kwargs.pop('return_wfn', False) # Make sure the molecule the user provided is the active one molecule = kwargs.pop('molecule', core.get_active_molecule()) molecule.update_geometry() optstash = p4util.OptionsState( ['CFOUR', 'TRANSLATE_PSI4']) # Determine calling function and hence dertype calledby = inspect.stack()[1][3] dertype = ['energy', 'gradient', 'hessian'].index(calledby) #print('I am %s called by %s called by %s.\n' % # (inspect.stack()[0][3], inspect.stack()[1][3], inspect.stack()[2][3])) # Save submission directory current_directory = os.getcwd() # Move into job scratch directory psioh = core.IOManager.shared_object() psio = core.IO.shared_object() os.chdir(psioh.get_default_path()) # Construct and move into cfour subdirectory of job scratch directory cfour_tmpdir = kwargs['path'] if 'path' in kwargs else \ 'psi.' + str(os.getpid()) + '.' + psio.get_default_namespace() + \ '.cfour.' + str(uuid.uuid4())[:8] if not os.path.exists(cfour_tmpdir): os.mkdir(cfour_tmpdir) os.chdir(cfour_tmpdir) # Find environment by merging PSIPATH and PATH environment variables lenv = { 'PATH': ':'.join([os.path.abspath(x) for x in os.environ.get('PSIPATH', '').split(':') if x != '']) + \ ':' + os.environ.get('PATH') + \ ':' + core.get_datadir() + '/basis', 'GENBAS_PATH': core.get_datadir() + '/basis', 'CFOUR_NUM_CORES': os.environ.get('CFOUR_NUM_CORES'), 'MKL_NUM_THREADS': os.environ.get('MKL_NUM_THREADS'), 'OMP_NUM_THREADS': os.environ.get('OMP_NUM_THREADS'), 'LD_LIBRARY_PATH': os.environ.get('LD_LIBRARY_PATH') } if 'path' in kwargs: lenv['PATH'] = kwargs['path'] + ':' + lenv['PATH'] # Filter out None values as subprocess will fault on them lenv = {k: v for k, v in lenv.items() if v is not None} # Load the GENBAS file genbas_path = qcdb.search_file('GENBAS', lenv['GENBAS_PATH']) if genbas_path: try: shutil.copy2(genbas_path, psioh.get_default_path() + cfour_tmpdir) except shutil.Error: # should only fail if src and dest equivalent pass core.print_out("\n GENBAS loaded from %s\n" % (genbas_path)) core.print_out(" CFOUR to be run from %s\n" % (psioh.get_default_path() + cfour_tmpdir)) else: message = """ GENBAS file for CFOUR interface not found. Either: [1] Supply a GENBAS by placing it in PATH or PSIPATH [1a] Use cfour {} block with molecule and basis directives. [1b] Use molecule {} block and CFOUR_BASIS keyword. [2] Allow Psi4's internal basis sets to convert to GENBAS [2a] Use molecule {} block and BASIS keyword. """ core.print_out(message) core.print_out(' Search path that was tried:\n') core.print_out(lenv['PATH'].replace(':', ', ')) # Generate the ZMAT input file in scratch if 'path' in kwargs and os.path.isfile('ZMAT'): core.print_out(" ZMAT loaded from %s\n" % (psioh.get_default_path() + kwargs['path'] + '/ZMAT')) else: with open('ZMAT', 'w') as cfour_infile: cfour_infile.write(write_zmat(lowername, dertype, molecule)) internal_p4c4_info['zmat'] = open('ZMAT', 'r').read() #core.print_out('\n====== Begin ZMAT input for CFOUR ======\n') #core.print_out(open('ZMAT', 'r').read()) #core.print_out('======= End ZMAT input for CFOUR =======\n\n') #print('\n====== Begin ZMAT input for CFOUR ======') #print(open('ZMAT', 'r').read()) #print('======= End ZMAT input for CFOUR =======\n') if 'genbas' in kwargs: with open('GENBAS', 'w') as cfour_basfile: cfour_basfile.write(kwargs['genbas'].replace('\nblankline\n', '\n\n')) core.print_out(' GENBAS loaded from kwargs string\n') # Close psi4 output file and reopen with filehandle print('output in', current_directory + '/' + core.outfile_name()) pathfill = '' if os.path.isabs(core.outfile_name()) else current_directory + os.path.sep # Handle threading # OMP_NUM_THREADS from env is in lenv from above # threads from psi4 -n (core.get_num_threads()) is ignored # CFOUR_OMP_NUM_THREADS psi4 option takes precedence, handled below if core.has_option_changed('CFOUR', 'CFOUR_OMP_NUM_THREADS') == True: lenv['OMP_NUM_THREADS'] = str(core.get_option('CFOUR', 'CFOUR_OMP_NUM_THREADS')) #print("""\n\n<<<<< RUNNING CFOUR ... >>>>>\n\n""") # Call executable xcfour, directing cfour output to the psi4 output file cfour_executable = kwargs['c4exec'] if 'c4exec' in kwargs else 'xcfour' try: retcode = subprocess.Popen([cfour_executable], bufsize=0, stdout=subprocess.PIPE, env=lenv) except OSError as e: sys.stderr.write('Program %s not found in path or execution failed: %s\n' % (cfour_executable, e.strerror)) message = ('Program %s not found in path or execution failed: %s\n' % (cfour_executable, e.strerror)) raise ValidationError(message) c4out = '' while True: data = retcode.stdout.readline() data = data.decode('utf-8') if not data: break core.print_out(data) c4out += data internal_p4c4_info['output'] = c4out c4files = {} core.print_out('\n') for item in ['GRD', 'FCMFINAL', 'DIPOL']: try: with open(psioh.get_default_path() + cfour_tmpdir + '/' + item, 'r') as handle: c4files[item] = handle.read() core.print_out(' CFOUR scratch file %s has been read\n' % (item)) core.print_out('%s\n' % c4files[item]) internal_p4c4_info[item.lower()] = c4files[item] except IOError: pass core.print_out('\n') if molecule.name() == 'blank_molecule_psi4_yo': qcdbmolecule = None else: molecule.update_geometry() qcdbmolecule = qcdb.Molecule(molecule.create_psi4_string_from_molecule()) qcdbmolecule.update_geometry() # c4mol, if it exists, is dinky, just a clue to geometry of cfour results psivar, c4grad, c4mol = qcdb.cfour.harvest(qcdbmolecule, c4out, **c4files) # Absorb results into psi4 data structures for key in psivar.keys(): core.set_variable(key.upper(), float(psivar[key])) if qcdbmolecule is None and c4mol is not None: molecule = geometry(c4mol.create_psi4_string_from_molecule(), name='blank_molecule_psi4_yo') molecule.update_geometry() # This case arises when no Molecule going into calc (cfour {} block) but want # to know the orientation at which grad, properties, etc. are returned (c4mol). # c4mol is dinky, w/o chg, mult, dummies and retains name # blank_molecule_psi4_yo so as to not interfere with future cfour {} blocks if c4grad is not None: mat = core.Matrix.from_list(c4grad) core.set_gradient(mat) #print ' <<< [3] C4-GRD-GRAD >>>' #mat.print() # exit(1) # # Things needed core.so module to do # collect c4out string # read GRD # read FCMFINAL # see if theres an active molecule # # Things delegatable to qcdb # parsing c4out # reading GRD and FCMFINAL strings # reconciling p4 and c4 molecules (orient) # reconciling c4out and GRD and FCMFINAL results # transforming frame of results back to p4 # # Things run_cfour needs to have back # psivar # qcdb.Molecule of c4? # coordinates? # gradient in p4 frame # # Process the cfour output # psivar, c4coord, c4grad = qcdb.cfour.cfour_harvest(c4out) # for key in psivar.keys(): # core.set_variable(key.upper(), float(psivar[key])) # # # Awful Hack - Go Away TODO # if c4grad: # molecule = core.get_active_molecule() # molecule.update_geometry() # # if molecule.name() == 'blank_molecule_psi4_yo': # p4grad = c4grad # p4coord = c4coord # else: # qcdbmolecule = qcdb.Molecule(molecule.create_psi4_string_from_molecule()) # #p4grad = qcdbmolecule.deorient_array_from_cfour(c4coord, c4grad) # #p4coord = qcdbmolecule.deorient_array_from_cfour(c4coord, c4coord) # # with open(psioh.get_default_path() + cfour_tmpdir + '/GRD', 'r') as cfour_grdfile: # c4outgrd = cfour_grdfile.read() # print('GRD\n',c4outgrd) # c4coordGRD, c4gradGRD = qcdb.cfour.cfour_harvest_files(qcdbmolecule, grd=c4outgrd) # # p4mat = core.Matrix.from_list(p4grad) # core.set_gradient(p4mat) # print(' <<< P4 PSIVAR >>>') # for item in psivar: # print(' %30s %16.8f' % (item, psivar[item])) #print(' <<< P4 COORD >>>') #for item in p4coord: # print(' %16.8f %16.8f %16.8f' % (item[0], item[1], item[2])) # print(' <<< P4 GRAD >>>') # for item in c4grad: # print(' %16.8f %16.8f %16.8f' % (item[0], item[1], item[2])) # Clean up cfour scratch directory unless user instructs otherwise keep = yes.match(str(kwargs['keep'])) if 'keep' in kwargs else False os.chdir('..') try: if keep or ('path' in kwargs): core.print_out('\n CFOUR scratch files have been kept in %s\n' % (psioh.get_default_path() + cfour_tmpdir)) else: shutil.rmtree(cfour_tmpdir) except OSError as e: print('Unable to remove CFOUR temporary directory %s' % e, file=sys.stderr) exit(1) # Return to submission directory and reopen output file os.chdir(current_directory) core.print_out('\n') p4util.banner(' Cfour %s %s Results ' % (name.lower(), calledby.capitalize())) core.print_variables() if c4grad is not None: core.get_gradient().print_out() core.print_out('\n') p4util.banner(' Cfour %s %s Results ' % (name.lower(), calledby.capitalize())) core.print_variables() if c4grad is not None: core.get_gradient().print_out() # Quit if Cfour threw error if core.variable('CFOUR ERROR CODE'): raise ValidationError("""Cfour exited abnormally.""") P4C4_INFO.clear() P4C4_INFO.update(internal_p4c4_info) optstash.restore() # new skeleton wavefunction w/mol, highest-SCF basis (just to choose one), & not energy # Feb 2017 hack. Could get proper basis in skel wfn even if not through p4 basis kw gobas = core.get_global_option('BASIS') if core.get_global_option('BASIS') else 'sto-3g' basis = core.BasisSet.build(molecule, "ORBITAL", gobas) if basis.has_ECP(): raise ValidationError("""ECPs not hooked up for Cfour""") wfn = core.Wavefunction(molecule, basis) optstash.restore() if dertype == 0: finalquantity = psivar['CURRENT ENERGY'] elif dertype == 1: finalquantity = core.get_gradient() wfn.set_gradient(finalquantity) if finalquantity.rows(0) < 20: core.print_out('CURRENT GRADIENT') finalquantity.print_out() elif dertype == 2: pass #finalquantity = finalhessian #wfn.set_hessian(finalquantity) #if finalquantity.rows(0) < 20: # core.print_out('CURRENT HESSIAN') # finalquantity.print_out() return wfn
def testDoesntMatchAfterCopy2ThenModifyStats(self): shutil.copy2(self.filename_a, self.filename_b) os.utime(self.filename_a, (20, 20)) self.assertFalse( android_profiling_helper._FileMetadataMatches( self.filename_a, self.filename_b))
cv_score = accuracy_score(train_y, train_p) print print("CV Accuracy: %.5f +- %.5f" % (mae_mean, mae_std)) print("CV RES Accuracy: %.5f" % cv_score) name = "%s-%s-%.5f" % (datetime.datetime.now().strftime('%Y%m%d-%H%M'), args.preset, cv_score) print() print("Saving predictions... (%s)" % name) print() print() for part, pred in [('train', train_p), ('test-foldavg', test_foldavg_p), ('test-fulltrain', test_fulltrain_p)]: pred.rename('Loan_Status', inplace=True) pred.index.rename('Loan_ID', inplace=True) pred.to_csv('preds/%s-%s.csv' % (name, part), header=True) copy2(os.path.realpath(__file__), os.path.join("preds", "%s-code.py" % name)) df = pd.DataFrame(columns=["model","CV"]) df.loc[len(df)] = ["'" + name + "',", cv_score] import os # if file does not exist write header if not os.path.isfile('results/models.csv'): df.to_csv('results/models.csv',index_label=None) else: # else it exists so append without writing the header df.to_csv('results/models.csv',mode = 'a',header=False,index_label=None) print("Done.")
def fetchJpgsAndMp4s(traj, outdir): archdir = os.getenv('ARCHDIR') if len(archdir) < 5: archdir = '/home/ec2-user/ukmon-shared/archive' print('getting camera details file') cinfo = cdet.SiteInfo() for obs in traj.observations: statid = obs.station_id fldr = cinfo.getFolder(statid) print(statid, fldr) evtdate = jd2Date(obs.jdt_ref, dt_obj=True) print('station {} event {} '.format(statid, evtdate.strftime('%Y%m%d-%H%M%S'))) # if the event is after midnight the folder will have the previous days date if evtdate.hour < 12: evtdate += timedelta(days=-1) yr = evtdate.year ym = evtdate.year * 100 + evtdate.month ymd = ym * 100 + evtdate.day print('getting jpgs and mp4s') thispth = '{:s}/{:04d}/{:06d}/{:08d}/'.format(fldr, yr, ym, ymd) srcpath = os.path.join(archdir, thispth) print(thispth) flist = glob.glob1(srcpath, 'FF*.jpg') srcfil = None for fil in flist: spls = fil.split('_') fdt = datetime.strptime(spls[2] + '_' + spls[3], '%Y%m%d_%H%M%S') tdiff = (evtdate - fdt).seconds if tdiff > 0 and tdiff < 11: srcfil = fil break if srcfil is not None: srcfil = srcpath + srcfil shutil.copy2(srcfil, outdir) file_name, _ = os.path.splitext(srcfil) srcfil = file_name + '.mp4' try: shutil.copy2(srcfil, outdir) except FileNotFoundError: pass else: print('no jpgs in {}'.format(srcpath)) print('R90 CSV, KML and FTPDetect file') flist = os.listdir(srcpath) for fil in flist: file_name, file_ext = os.path.splitext(fil) if ('FTPdetectinfo' in fil) and (file_ext == '.txt') and ( '_original' not in file_name ) and ('_uncal' not in file_name) and ('_backup' not in file_name): srcfil = srcpath + fil shutil.copy2(srcfil, outdir) elif file_ext == '.csv': srcfil = srcpath + fil shutil.copy2(srcfil, outdir) elif file_ext == '.kml': srcfil = srcpath + fil shutil.copy2(srcfil, outdir) kmldir = os.path.join(archdir, 'kmls') shutil.copy2(srcfil, kmldir) return
def __init__(self): self._logger = logging.getLogger(__name__) # Create config dir if it does not exist yet if not os.path.exists(jasperpath.CONFIG_PATH): try: os.makedirs(jasperpath.CONFIG_PATH) except OSError: self._logger.error("Could not create config dir: '%s'", jasperpath.CONFIG_PATH, exc_info=True) raise # Check if config dir is writable if not os.access(jasperpath.CONFIG_PATH, os.W_OK): self._logger.critical( "Config dir %s is not writable. Jasper " + "won't work correctly.", jasperpath.CONFIG_PATH) # FIXME: For backwards compatibility, move old config file to newly # created config dir old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml') new_configfile = jasperpath.config('profile.yml') if os.path.exists(old_configfile): if os.path.exists(new_configfile): self._logger.warning( "Deprecated profile file found: '%s'. " + "Please remove it.", old_configfile) else: self._logger.warning( "Deprecated profile file found: '%s'. " + "Trying to copy it to new location '%s'.", old_configfile, new_configfile) try: shutil.copy2(old_configfile, new_configfile) except shutil.Error: self._logger.error("Unable to copy config file. " + "Please copy it manually.", exc_info=True) raise # Read config self._logger.debug("Trying to read config file: '%s'", new_configfile) try: with open(new_configfile, "r") as f: self.config = yaml.safe_load(f) except OSError: self._logger.error("Can't open config file: '%s'", new_configfile) raise try: stt_engine_slug = self.config['stt_engine'] except KeyError: stt_engine_slug = 'sphinx' logger.warning( "stt_engine not specified in profile, defaulting " + "to '%s'", stt_engine_slug) stt_engine_class = stt.get_engine_by_slug(stt_engine_slug) try: slug = self.config['stt_passive_engine'] stt_passive_engine_class = stt.get_engine_by_slug(slug) except KeyError: stt_passive_engine_class = stt_engine_class try: tts_engine_slug = self.config['tts_engine'] except KeyError: tts_engine_slug = tts.get_default_engine_slug() logger.warning( "tts_engine not specified in profile, defaulting " + "to '%s'", tts_engine_slug) tts_engine_class = tts.get_engine_by_slug(tts_engine_slug) # Initialize Mic self.mic = Mic(tts_engine_class.get_instance(), stt_passive_engine_class.get_passive_instance(), stt_engine_class.get_active_instance())
def do_custom_build(self): # We're using a system freetype if not options.get('local_freetype'): return src_path = os.path.join( 'build', 'freetype-{0}'.format(LOCAL_FREETYPE_VERSION)) # We've already built freetype if sys.platform == 'win32': libfreetype = 'libfreetype.lib' else: libfreetype = 'libfreetype.a' # bailing because it is already built if os.path.isfile(os.path.join( src_path, 'objs', '.libs', libfreetype)): return # do we need to download / load the source from cache? if not os.path.exists(src_path): os.makedirs('build', exist_ok=True) url_fmts = [ ('https://downloads.sourceforge.net/project/freetype' '/freetype2/{version}/{tarball}'), ('https://download.savannah.gnu.org/releases/freetype' '/{tarball}') ] tarball = 'freetype-{0}.tar.gz'.format(LOCAL_FREETYPE_VERSION) target_urls = [ url_fmt.format(version=LOCAL_FREETYPE_VERSION, tarball=tarball) for url_fmt in url_fmts] for tarball_url in target_urls: try: tar_contents = download_or_cache(tarball_url, LOCAL_FREETYPE_HASH) break except Exception: pass else: raise IOError("Failed to download FreeType. Please download " "one of {target_urls} and extract it into " "{src_path} at the top-level of the source " "repository".format( target_urls=target_urls, src_path=src_path)) print("Extracting {}".format(tarball)) # just to be sure tar_contents.seek(0) with tarfile.open(tarball, mode="r:gz", fileobj=tar_contents) as tgz: tgz.extractall("build") print("Building freetype in {}".format(src_path)) if sys.platform != 'win32': # compilation on all other platforms than windows env = {**os.environ, "CFLAGS": "{} -fPIC".format(os.environ.get("CFLAGS", ""))} subprocess.check_call( ["./configure", "--with-zlib=no", "--with-bzip2=no", "--with-png=no", "--with-harfbuzz=no"], env=env, cwd=src_path) subprocess.check_call(["make"], env=env, cwd=src_path) else: # compilation on windows shutil.rmtree(str(pathlib.Path(src_path, "objs")), ignore_errors=True) FREETYPE_BUILD_CMD = r""" call "%ProgramFiles%\Microsoft SDKs\Windows\v7.0\Bin\SetEnv.Cmd" ^ /Release /{xXX} /xp call "{vcvarsall}" {xXX} set MSBUILD=C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe %MSBUILD% "builds\windows\{vc20xx}\freetype.sln" ^ /t:Clean;Build /p:Configuration="Release";Platform={WinXX} """ import distutils.msvc9compiler as msvc # Note: freetype has no build profile for 2014, so we don't bother... vc = 'vc2010' WinXX = 'x64' if platform.architecture()[0] == '64bit' else 'Win32' xXX = 'x64' if platform.architecture()[0] == '64bit' else 'x86' vcvarsall = msvc.find_vcvarsall(10.0) if vcvarsall is None: raise RuntimeError('Microsoft VS 2010 required') cmdfile = pathlib.Path("build/build_freetype.cmd") cmdfile.write_text(FREETYPE_BUILD_CMD.format( vc20xx=vc, WinXX=WinXX, xXX=xXX, vcvarsall=vcvarsall)) subprocess.check_call([str(cmdfile.resolve())], shell=True, cwd=src_path) # Move to the corresponding Unix build path. pathlib.Path(src_path, "objs/.libs").mkdir() # Be robust against change of FreeType version. lib_path, = (pathlib.Path(src_path, "objs", vc, xXX) .glob("freetype*.lib")) shutil.copy2( str(lib_path), str(pathlib.Path(src_path, "objs/.libs/libfreetype.lib")))
def testMatchesAfterCopy2(self): shutil.copy2(self.filename_a, self.filename_b) self.assertTrue( android_profiling_helper._FileMetadataMatches( self.filename_a, self.filename_b))
def handle_uncaught_exception_wx(t, v, tb): _log.debug('unhandled exception caught:', exc_info=(t, v, tb)) if __handle_access_violation(t, v, tb): return if __handle_ctrl_c(t, v, tb): return if __handle_exceptions_on_shutdown(t, v, tb): return if __ignore_dead_objects_from_async(t, v, tb): return if __handle_import_error(t, v, tb): return if __handle_wxgtk_assertion(t, v, tb): return # other exceptions _cfg = gmCfgINI.gmCfgData() if _cfg.get(option='debug') is False: _log.error('enabling debug mode') _cfg.set_option(option='debug', value=True) root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) _log.debug('unhandled exception caught:', exc_info=(t, v, tb)) if __handle_lost_db_connection(t, v, tb): return gmLog2.log_stack_trace(None, t, v, tb) # only do this here or else we can invalidate the stack trace # by Windows throwing an exception ... |-( # careful: MSW does reference counting on Begin/End* :-( wx.EndBusyCursor() name = os.path.basename(_logfile_name) name, ext = os.path.splitext(name) new_name = os.path.expanduser( os.path.join( '~', '.local', 'gnumed', 'error_logs', '%s_%s%s' % (name, pyDT.datetime.now().strftime('%Y-%m-%d_%H-%M-%S'), ext))) dlg = cUnhandledExceptionDlg(None, -1, exception=(t, v, tb), logfile=new_name) dlg.ShowModal() comment = dlg._TCTRL_comment.GetValue() dlg.DestroyLater() if (comment is not None) and (comment.strip() != ''): _log.error('user comment: %s', comment.strip()) _log.warning('syncing log file for backup to [%s]', new_name) gmLog2.flush() # keep a copy around shutil.copy2(_logfile_name, new_name)
scr2 = w + "/cl_me_km.job" data = 0 for n in range(1,7): ang = 2.7+n*0.1 command = "%s_ang_on_face" %ang os.makedirs(command) print "Creating Folder %s" %command dest = w +"/%s_ang_on_face/" %ang shutil.copy2(scr,dest) print "Coping to '%s'." %(dest) shutil.copy2(scr2,dest) print "Coping to '%s'." %(dest) myfile =w +'/%s_ang_on_face/cl_me_km.com' %ang with open (myfile,'r') as molin: data=molin.readlines() matching = [s for s in data if 'r=' in s] #Zeilenindizes r1 = [i for i, x in enumerate(data) if x ==matching[0]] #Index von zu a"nderender Zeile
def write_static(self, src_root, static): dst = os.path.join(self.root, "content", static.relpath) os.makedirs(os.path.dirname(dst), exist_ok=True) shutil.copy2(os.path.join(src_root, static.relpath), dst)
def create_dockerfile_object(self, directory: str) -> str: """ Writes a dockerfile to the provided directory using the specified arguments on this Docker storage object. In order for the docker python library to build a container it needs a Dockerfile that it can use to define the container. This function takes the specified arguments then writes them to a temporary file called Dockerfile. *Note*: if `files` are added to this container, they will be copied to this directory as well. Args: - directory (str, optional): A directory where the Dockerfile will be created, if no directory is specified is will be created in the current working directory Returns: - str: the absolute file path to the Dockerfile """ # Generate single pip install command for python dependencies pip_installs = "RUN pip install " if self.python_dependencies: for dependency in self.python_dependencies: pip_installs += "{} ".format(dependency) # Generate ENV variables to load into the image env_vars = "" if self.env_vars: white_space = " " * 20 env_vars = "ENV " + " \\ \n{}".format(white_space).join( "{k}={v}".format(k=k, v=v) for k, v in self.env_vars.items()) # Copy user specified files into the image copy_files = "" if self.files: for src, dest in self.files.items(): fname = os.path.basename(src) full_fname = os.path.join(directory, fname) if os.path.exists(full_fname) and filecmp.cmp( src, full_fname) is False: raise ValueError( "File {fname} already exists in {directory}".format( fname=full_fname, directory=directory)) else: shutil.copy2(src, full_fname) copy_files += "COPY {fname} {dest}\n".format( fname=full_fname if self.dockerfile else fname, dest=dest) # Write all flows to file and load into the image copy_flows = "" for flow_name, flow_location in self.flows.items(): clean_name = slugify(flow_name) flow_path = os.path.join(directory, "{}.flow".format(clean_name)) with open(flow_path, "wb") as f: cloudpickle.dump(self._flows[flow_name], f) copy_flows += "COPY {source} {dest}\n".format( source=flow_path if self.dockerfile else "{}.flow".format(clean_name), dest=flow_location, ) # Write all extra commands that should be run in the image extra_commands = "" for cmd in self.extra_commands: extra_commands += "RUN {}\n".format(cmd) # Write a healthcheck script into the image with open(os.path.join(os.path.dirname(__file__), "_healthcheck.py"), "r") as healthscript: healthcheck = healthscript.read() healthcheck_loc = os.path.join(directory, "healthcheck.py") with open(healthcheck_loc, "w") as health_file: health_file.write(healthcheck) if self.dockerfile: with open(self.dockerfile, "r") as contents: base_commands = textwrap.indent("\n" + contents.read(), prefix=" " * 16) else: base_commands = "FROM {base_image}".format( base_image=self.base_image) file_contents = textwrap.dedent("""\ {base_commands} RUN pip install pip --upgrade {extra_commands} {pip_installs} RUN mkdir -p /opt/prefect/ {copy_flows} COPY {healthcheck_loc} /opt/prefect/healthcheck.py {copy_files} {env_vars} """.format( base_commands=base_commands, extra_commands=extra_commands, pip_installs=pip_installs, copy_flows=copy_flows, healthcheck_loc=healthcheck_loc if self.dockerfile else "healthcheck.py", copy_files=copy_files, env_vars=env_vars, )) # append the line that runs the healthchecks if not self.ignore_healthchecks: file_contents += textwrap.dedent(""" RUN python /opt/prefect/healthcheck.py '[{flow_file_paths}]' '{python_version}' """.format( flow_file_paths=", ".join( ['"{}"'.format(k) for k in self.flows.values()]), python_version=(sys.version_info.major, sys.version_info.minor), )) file_contents = "\n".join(line.lstrip() for line in file_contents.split("\n")) dockerfile_path = os.path.join(directory, "Dockerfile") with open(dockerfile_path, "w+") as dockerfile: dockerfile.write(file_contents) return dockerfile_path
def saveSettings(self): cData = [] if len(self.e_fname.text()) > 0 and len(self.e_lname.text()) > 1: cData.append(['globals', "username", (self.e_fname.text() + " " + self.e_lname.text())]) self.core.user = (self.e_fname.text()[0] + self.e_lname.text()[:2]).lower() if hasattr(self.core, "projectName") and self.e_localPath.isEnabled(): lpath = self.core.fixPath(self.e_localPath.text()) if not lpath.endswith(os.sep): lpath += os.sep cData.append(['localfiles', self.core.projectName, lpath]) if self.e_localPath.text() != "disabled": self.core.localProjectPath = lpath rvPath = self.core.fixPath(self.e_rvPath.text()) if rvPath != "" and not rvPath.endswith(os.sep): rvPath += os.sep cData.append(['globals', "rvpath", rvPath]) djvPath = self.core.fixPath(self.e_djvPath.text()) if djvPath != "" and not djvPath.endswith(os.sep): djvPath += os.sep cData.append(['globals', "djvpath", djvPath]) cData.append(["globals", "prefer_djv", str(self.chb_preferDJV.isChecked())]) cData.append(["globals", "showonstartup", str(self.chb_browserStartup.isChecked())]) cData.append(["globals", "autosave", str(self.chb_autosave.isChecked())]) cData.append(["globals", "highdpi", str(self.chb_highDPI.isChecked())]) for i in self.exOverridePlugins: res = self.core.getPlugin(i).prismSettings_saveSettings(self) if type(res) == list: cData += res for i in self.exOverridePlugins: cData.append(['dccoverrides', "%s_override" % i, str(self.exOverridePlugins[i]["chb"].isChecked())]) cData.append(['dccoverrides', "%s_path" % i, str(self.exOverridePlugins[i]["le"].text())]) for i in self.core.prjManagers.values(): res = i.prismSettings_saveSettings(self) if type(res) == list: cData += res if self.core.appPlugin.appType == "3d": if self.chb_autosave.isChecked(): if not hasattr(self.core, "asThread") or not self.core.asThread.isRunning(): self.core.startasThread() else: self.core.startasThread(quit=True) self.core.setConfig(data=cData) if os.path.exists(self.core.prismIni): cData = [] cData.append(['globals', 'project_name', (self.e_curPname.text())]) cData.append(['globals', 'uselocalfiles', str(self.chb_curPuseLocal.isChecked())]) cData.append(['globals', 'forcefps', str(self.chb_curPuseFps.isChecked())]) cData.append(['globals', 'fps', str(self.sp_curPfps.value())]) cData.append(['globals', 'forceversions', str(self.gb_curPversions.isChecked())]) for i in self.core.prjManagers.values(): res = i.prismSettings_savePrjSettings(self) if type(res) == list: cData += res for i in self.forceVersionPlugins: cData.append(['globals', "%s_version" % i, str(self.forceVersionPlugins[i]["le"].text())]) self.core.setConfig(data=cData, configPath=self.core.prismIni) self.core.useLocalFiles = self.chb_curPuseLocal.isChecked() self.core.changeProject(self.core.prismIni) if platform.system() == "Windows": trayStartup = os.path.join(os.getenv('APPDATA'), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "PrismTray.lnk") trayLnk = self.core.fixPath(os.path.join(self.core.prismRoot, "Tools", "PrismTray.lnk")) if self.chb_trayStartup.isChecked(): if os.path.exists(trayLnk): if os.path.exists(trayStartup): try: os.remove(trayStartup) except WindowsError as e: if e.winerror == 32: QMessageBox.warning(self, "Remove link", "Unable to remove autostart link, because the file is used by another process:\n\n%s" % trayStartup) else: raise if not os.path.exists(trayStartup): shutil.copy2(trayLnk, trayStartup) else: QMessageBox.warning(self, "Prism", "Cannot add Prism to the autostart because this shortcut doesn't exist:\n\n%s\n\nExecute '%s\\Win_Setup_Startmenu.bat' to create the shortcut." % (trayLnk, self.core.fixPath(self.core.prismRoot).replace("/", "\\"))) elif os.path.exists(trayStartup): try: os.remove(trayStartup) except WindowsError as e: if e.winerror == 32: QMessageBox.warning(self, "Remove link", "Unable to remove autostart link, because the file is used by another process:\n\n%s" % trayStartup) else: raise elif platform.system() == "Linux": trayStartup = "/etc/xdg/autostart/PrismTray.desktop" trayLnk = "/usr/local/Prism/Tools/PrismTray.desktop" if os.path.exists(trayStartup): try: os.remove(trayStartup) except: QMessageBox.warning(self, "Warning", "Permission denied:\n\n%s\n\nTry to execute this tool as root." % trayStartup) if self.chb_trayStartup.isChecked(): if not os.path.exists(trayStartup): shutil.copy2(trayLnk, trayStartup) os.chmod(trayStartup, 0o777) elif platform.system() == "Darwin": userName = os.environ['SUDO_USER'] if 'SUDO_USER' in os.environ else os.environ['USER'] trayStartup = "/Users/%s/Library/LaunchAgents/com.user.PrismTray.plist" % userName trayLnk = "/Applications/Prism/Prism/Tools/com.user.PrismTray.plist" if os.path.exists(trayStartup): os.remove(trayStartup) if self.chb_trayStartup.isChecked(): if not os.path.exists(trayStartup): shutil.copy2(trayLnk, trayStartup) os.chmod(trayStartup, 0o644) import pwd uid = pwd.getpwnam(userName).pw_uid os.chown(os.path.dirname(trayStartup), uid, -1) os.chown(trayStartup, uid, -1) os.system("launchctl load /Users/%s/Library/LaunchAgents/com.user.PrismTray.plist" % userName) self.core.callback(name="onPrismSettingsSave", types=["custom"], args=[self])
def copyToMirror(self, filename): '''Copy a file to its mirror path.''' mirPath = self.getMirrorPath(filename) destDir = mirPath.parent destDir.mkdir(parents=True, exist_ok=True) shutil.copy2(str(filename), str(mirPath))
def copiarArquivos(dir): base = ABSBASE try: dst = os.path.join(dir, 'css') if os.path.exists(dst): shutil.rmtree(dst) shutil.copytree(os.path.join(base, 'css'), dst) except OSError, e: pass # provavelmente diretório já existe logging.warning(e) # shutil.copy2(os.path.join(base, 'css', 'scriptLattes.css'), dir) # shutil.copy2(os.path.join(base, 'css', 'jquery.dataTables.css'), dir) shutil.copy2(os.path.join(base, 'imagens', 'lattesPoint0.png'), dir) shutil.copy2(os.path.join(base, 'imagens', 'lattesPoint1.png'), dir) shutil.copy2(os.path.join(base, 'imagens', 'lattesPoint2.png'), dir) shutil.copy2(os.path.join(base, 'imagens', 'lattesPoint3.png'), dir) shutil.copy2(os.path.join(base, 'imagens', 'lattesPoint_shadow.png'), dir) shutil.copy2(os.path.join(base, 'imagens', 'doi.png'), dir) try: dst = os.path.join(dir, 'images') if os.path.exists(dst): shutil.rmtree(dst) shutil.copytree(os.path.join(base, 'images'), dst) except OSError, e: pass # provavelmente diretório já existe logging.warning(e)
def runThread(self): # start the forwader thread (once the start button is clicked from the window this function will execute) self.Message = self.messageTxt.toPlainText() # fetching the message form the UI self.Forwards = self.forwardsTxt.toPlainText() # fetching thenumber of forwards form theUI if self.Message == "" and self.imgPath == "": # if Message and Image path are both not definad show the error window self.errorWindow.setErrorMsg( "Please fill in at least one of the two :\n-Image path\n-Text Message\nOtherwise the program will not run") self.errorWindow.show() elif self.Forwards == "": # if the Number of forwards is not definad show the error window self.errorWindow.setErrorMsg( "Please set the number of forwards") self.errorWindow.show() elif (not self.is_number(self.Forwards)) or int(self.Forwards) < 1: # if the forward number is not valid as a number, show the error window self.errorWindow.setErrorMsg( "Please enter a valid number of forwards") self.errorWindow.show() elif (self.loadedCsvFile != None and self.loadedJsonFile != None and self.importedNamesCsvFile == None): # this is the case where you are startin completely new Forward WITHOUT target clients self.WhatsappForwader.setForwards(self.Forwards) # Setting the number of forwards to the forwader self.WhatsappForwader.setImagePath(self.imgPath) # Setting the image path to our forwader self.WhatsappForwader.setMessage(self.Message) # Setting the Message to our forwader self.WhatsappForwader.setFileName(self.loadedFileName) # if there is a loaded record we send it to our forwader here self.WhatsappForwader.setContactMode(variables.NEW_NAMES) # setContactMode is function that defines whether we are using targeted clients or we're starting fresh self.MODE = variables.NEW_NAMES # setting the contact mode in this class aswell self.WhatsappForwader.setContactDict(self.contactDict) # here we are passing the contacts names to our forwader self.WhatsappForwader.setPreviewMode( self.previewCheckBox.isChecked()) # if the preview mode checkbox in the window is checked, self.previewCheckBox.isChecked() will return true otherwise returns false self.WhatsappForwader.setIsDelayMode(self.delayCheckBox.isChecked()) # same as above for the delay checkbox (used to set delay betweeen messages (30 to 60 seconds)) self.WhatsappForwader.start() # start the forwader thread self.startBtn.setStyleSheet( "background-color: white; border: 1px solid #ababab; border-radius: 10px; font-size: 12px;color: #ababab;text-align: center;") # setting style sheet elif (self.loadedCsvFile == None and self.loadedJsonFile == None and self.importedNamesCsvFile != None): # this is the case where you are starting a completely new Forward WITH target clients currentDate = datetime.today().strftime("%Y-%m-%d %H:%M:%S") # we create a name for the folder which will hold all the data of this sessio, the name of the folder is the current time in the format of YY-mm-dd hh:mm:ss os.makedirs(f'records/{currentDate}') # os.makedirs creates teh folder with teh given name jsonFile = open(f'records/{currentDate}/record.json', 'w+') # here we create a new file record.json in the created folder if self.importedNamesCsvFile != None: open(f'records/{currentDate}/importedNames.csv', 'w+') # open the imported names file if there is any shutil.copy2(self.importedNamesCsvFile.name, f'records/{currentDate}/importedNames.csv') # make a copy of the imported names csv file and save it on the local folder jsonData = { "date": currentDate, "Forwards": self.Forwards, "Message": self.Message, "imagePath": self.imgPath, "importedNames": 'False' if self.importedNamesCsvFile == None else 'True' } # this is the structure of the data that will be saved in json file json.dump(jsonData, jsonFile) # dumping the data into the json file self.progressBar.setVisible(True) # setting the prograss bar to be visisble since we now know the number of forwards self.progressLbl.setVisible(True) # setting the label of the progress bar visible for the same reason mentioned above self.WhatsappForwader.setContactMode(variables.IMPORTED_NAMES) # We tell the forwader that the contacts are imported self.MODE = variables.IMPORTED_NAMES # we notify this class that we are working with imported names self.progressLbl.setText(f"0/{self.Forwards}") # we set the text of the progress bar self.progressBar.setMaximum(int(self.Forwards)) # setting the maximum value for the progress bar (aka the number of forwards desired) self.progressBar.setMinimum(0) # min is always 0 ... self.progressBar.setValue(len(self.importedContactDict)) # if we have record that had imported names and was loaded, the progress bar will automatically set the value of the number of contacts that were already scanned self.WhatsappForwader.setForwards(self.Forwards) # set the number of forwards for the forwader self.WhatsappForwader.setImagePath(self.imgPath) # set the image path if any for the forwader self.WhatsappForwader.setContactDict(self.importedContactDict) # we send the loaded contact hashmap for the forwader self.WhatsappForwader.setMessage(self.Message) # sending message for the forwader self.WhatsappForwader.setFileName(currentDate) # sending the folder name for the forwader (it needs it because it writes directly to the files inside the folder to update the scanned names) self.WhatsappForwader.loadCsvFile() # this is the csv file contained in the above mentioned folder , i'm just opening it to get things ready and start adding scanned contact names to it self.WhatsappForwader.setPreviewMode( self.previewCheckBox.isChecked()) # setting if preview mode from checkbox self.WhatsappForwader.setIsDelayMode(self.delayCheckBox.isChecked()) # setting if with delay from checkbox self.WhatsappForwader.start() # start the thread self.startBtn.setStyleSheet( "background-color: white; border: 1px solid #ababab; border-radius: 10px; font-size: 12px;color: #ababab;text-align: center;") # setting style sheet elif (self.loadedCsvFile != None and self.loadedJsonFile != None and self.importedNamesCsvFile != None): # this is the case where you are continuing a previous forward specified from a record file WITHOUT target clients self.WhatsappForwader.setForwards(self.Forwards) # refer to above documentation to see what each function of the forwader does self.WhatsappForwader.setImagePath(self.imgPath) self.WhatsappForwader.setMessage(self.Message) self.WhatsappForwader.setFileName(self.loadedFileName) self.WhatsappForwader.setContactMode(variables.IMPORTED_NAMES) self.MODE = variables.IMPORTED_NAMES self.WhatsappForwader.setContactDict(self.remainingContactDict) self.WhatsappForwader.setPreviewMode( self.previewCheckBox.isChecked()) self.WhatsappForwader.start() self.WhatsappForwader.setIsDelayMode(self.delayCheckBox.isChecked()) self.startBtn.setStyleSheet( "background-color: white; border: 1px solid #ababab; border-radius: 10px; font-size: 12px;color: #ababab;text-align: center;") # setting style sheet else: # this is the case where you are continuing a previous forward specified from a record file WITH target clients currentDate = datetime.today().strftime("%Y-%m-%d %H:%M:%S") # refer to above documentation to see what each function of the forwader does os.makedirs(f'records/{currentDate}') jsonFile = open(f'records/{currentDate}/record.json', 'w+') jsonData = { "date": currentDate, "Forwards": self.Forwards, "Message": self.Message, "imagePath": self.imgPath, "importedNames": 'False' if self.importedNamesCsvFile == None else 'True' } json.dump(jsonData, jsonFile) self.progressBar.setVisible(True) self.progressLbl.setVisible(True) self.WhatsappForwader.setContactMode(variables.NEW_NAMES) self.MODE = variables.NEW_NAMES self.progressLbl.setText(f"0/{self.Forwards}") self.progressBar.setMaximum(int(self.Forwards)) self.progressBar.setMinimum(0) self.progressBar.setValue(len(self.contactDict)) self.WhatsappForwader.setForwards(self.Forwards) self.WhatsappForwader.setImagePath(self.imgPath) self.WhatsappForwader.setMessage(self.Message) self.WhatsappForwader.setFileName(currentDate) self.WhatsappForwader.loadCsvFile() self.WhatsappForwader.setPreviewMode( self.previewCheckBox.isChecked()) self.WhatsappForwader.setIsDelayMode(self.delayCheckBox.isChecked()) self.WhatsappForwader.start() self.startBtn.setStyleSheet( "background-color: white; border: 1px solid #ababab; border-radius: 10px; font-size: 12px;color: #ababab;text-align: center;") # setting style sheet
if sys.platform == "linux": lib_dir = os.path.join(ctp_dir, "linux") package_data.append("*.so") extra_compile_args = ["-Wall"] extra_link_args = ['-Wl,-rpath,$ORIGIN'] elif sys.platform == "win32": lib_dir = os.path.join(ctp_dir, "win") extra_compile_args = ["/GR", "/EHsc"] # extra_link_args = [] package_data.append("*.dll") package_data.append("error.dtd") package_data.append("error.xml") shutil.copy2(header_dir + "/error.dtd", project_dir + "/error.dtd") shutil.copy2(header_dir + "/error.xml", project_dir + "/error.xml") if sys.platform in ["linux", "win32"]: copy_tree(lib_dir, project_dir) common_args = { "cython_include_dirs": [cython_headers], "include_dirs": [header_dir, cpp_header_dir], "library_dirs": [lib_dir], "language": "c++", "extra_compile_args": extra_compile_args, "extra_link_args": extra_link_args, } ext_modules = [
def build_ngraph_tf(build_dir, artifacts_location, ngtf_src_loc, venv_dir, cmake_flags, verbose): pwd = os.getcwd() # Load the virtual env load_venv(venv_dir) command_executor(["pip", "list"]) # Get the absolute path for the artifacts artifacts_location = os.path.abspath(artifacts_location) ngtf_src_loc = os.path.abspath(ngtf_src_loc) print("Source location: " + ngtf_src_loc) os.chdir(ngtf_src_loc) # mkdir build directory path = build_dir try: os.makedirs(path) except OSError as exc: # Python >2.5 if exc.errno == errno.EEXIST and os.path.isdir(path): pass # Run cmake os.chdir(path) cmake_cmd = ["cmake"] cmake_cmd.extend(cmake_flags) cmake_cmd.extend([ngtf_src_loc]) command_executor(cmake_cmd) import psutil num_cores = str(psutil.cpu_count(logical=True)) make_cmd = ["make", "-j" + num_cores, "install"] if verbose: make_cmd.extend(['VERBOSE=1']) command_executor(make_cmd) os.chdir(os.path.join("python", "dist")) ngtf_wheel_files = glob.glob("ngraph_tensorflow_bridge-*.whl") if (len(ngtf_wheel_files) != 1): print("Multiple Python whl files exist. Please remove old wheels") for whl in ngtf_wheel_files: print("Existing Wheel: " + whl) raise Exception("Error getting the ngraph-tf wheel file") output_wheel = ngtf_wheel_files[0] print("OUTPUT WHL FILE: %s" % output_wheel) output_path = os.path.join(artifacts_location, output_wheel) print("OUTPUT WHL DST: %s" % output_path) # Delete just in case it exists try: os.remove(output_path) except OSError: pass # Now copy shutil.copy2(output_wheel, artifacts_location) os.chdir(pwd) return output_wheel
def copy_files(files_list, fromdir, todir): for file in files_list: copy2(fromdir + "\\" + file, todir)
for f in files: # Skip unwanted files if filter and filter(f): continue srcfile = os.path.join(dir, f) destfile = os.path.join(dest, basedir, f) <<<<<<< HEAD # directory creation is lazy and after the file filtering above # to ensure we don't install empty dirs; empty dirs can't be # uninstalled. if not os.path.exists(destdir): os.makedirs(destdir) # use copy2 (not move) to be extra sure we're not moving # directories over; copy2 fails for directories. this would # fail tests (not during released/user execution) shutil.copy2(srcfile, destfile) ======= shutil.move(srcfile, destfile) >>>>>>> e4baf504ede925f4f1e07d823c9b20b3d0dbe14c changed = False if fixer: changed = fixer(destfile) record_installed(srcfile, destfile, changed) clobber(source, lib_dir, True) assert info_dir, "%s .dist-info directory not found" % req # Get the defined entry points ep_file = os.path.join(info_dir[0], 'entry_points.txt') console, gui = get_entrypoints(ep_file)
print("Unfortunately, this can't be left blank") wo_user = input("Enter your name: ") wo_email = input("Enter your email: ") while not re.match(r"^[A-Za-z0-9\.\+_-]+@[A-Za-z0-9\._-]+\.[a-zA-Z]*$", wo_email): print("Whoops, seems like you made a typo - " "the e-mailaddress is invalid...") wo_email = input("Enter your email: ") os.system("git config --global user.name {0}".format(wo_user)) os.system("git config --global user.email {0}".format(wo_email)) if not os.path.isfile('/root/.gitconfig'): shutil.copy2(os.path.expanduser("~") + '/.gitconfig', '/root/.gitconfig') setup( name='wo', version='3.9.4', description=long_description, long_description=long_description, classifiers=[], keywords='', author='WordOps', author_email='*****@*****.**', url='https://wordops.net', license='MIT', packages=find_packages( exclude=['ez_setup', 'examples', 'tests', 'templates']), include_package_data=True,
def rotateFile(filepath, depth=5, suffix='.', verbosity=0): """ backup/rotate a file depth (-1==no limit) refers to num. of backups (rotations) to keep. Behavior: (1) x.txt (current) x.txt.1 (old) x.txt.2 (older) x.txt.3 (oldest) (2) all file stats preserved. Doesn't blow away original file. (3) if x.txt and x.txt.1 are identical (size or checksum), None is returned """ # check argument sanity (should really be down outside of this function) if not filepath or type(filepath) != type(''): raise ValueError("filepath '%s' is not a valid arguement" % filepath) if type(depth) != type(0) or depth < -1 \ or depth > sys.maxint-1 or depth == 0: raise ValueError("depth must fall within range " "[-1, 1...%s]" % (sys.maxint-1)) # force verbosity to be a numeric value verbosity = verbosity or 0 if type(verbosity) != type(0) or verbosity < -1 \ or verbosity > sys.maxint-1: raise ValueError('invalid verbosity value: %s' % (verbosity)) filepath = cleanupAbsPath(filepath) if not os.path.isfile(filepath): raise ValueError("filepath '%s' does not lead to a file" % filepath) pathNSuffix = filepath + suffix pathNSuffix1 = pathNSuffix + '1' if verbosity > 1: sys.stderr.write("Working dir: %s\n" % os.path.dirname(pathNSuffix)) # is there anything to do? (existence, then size, then checksum) checksum_type = 'sha1' if os.path.exists(pathNSuffix1) and os.path.isfile(pathNSuffix1) \ and os.stat(filepath)[6] == os.stat(pathNSuffix1)[6] \ and getFileChecksum(checksum_type, filepath) == \ getFileChecksum(checksum_type, pathNSuffix1): # nothing to do if verbosity: sys.stderr.write("File '%s' is identical to its rotation. " "Nothing to do.\n" % os.path.basename(filepath)) return None # find last in series (of rotations): last = 0 while os.path.exists('%s%d' % (pathNSuffix, last+1)): last = last+1 # percolate renames: for i in range(last, 0, -1): os.rename('%s%d' % (pathNSuffix, i), '%s%d' % (pathNSuffix, i+1)) if verbosity > 1: filename = os.path.basename(pathNSuffix) sys.stderr.write("Moving file: %s%d --> %s%d\n" % (filename, i, filename, i+1)) # blow away excess rotations: if depth != -1: last = last+1 for i in range(depth+1, last+1): path = '%s%d' % (pathNSuffix, i) os.unlink(path) if verbosity: sys.stderr.write("Rotated out: '%s'\n" % ( os.path.basename(path))) # do the actual rotation shutil.copy2(filepath, pathNSuffix1) if os.path.exists(pathNSuffix1) and verbosity: sys.stderr.write("Backup made: '%s' --> '%s'\n" % (os.path.basename(filepath), os.path.basename(pathNSuffix1))) # return the full filepath of the backed up file return pathNSuffix1
import os import sys import shutil figdir = os.path.join("RVAT-Re-dep", "Figures") figlist = ["cp_curves.pdf", "cd_curves.pdf", "perf_re_dep.pdf", "K_trans_bar_graph.pdf", "mom_bar_graph.pdf", "wake_spectra.pdf", "wake_trans_totals.pdf", "meancontquiv_10.pdf", "k_contours_10.pdf", "mean_u_k_profiles.pdf"] for fig in figlist: shutil.copy2(os.path.join(figdir, fig), os.path.join("figures", fig)) figdir = os.path.join("NACAXX20-XFOIL", "figures") figlist = ["all_foils_re_dep.pdf", "cft_re_dep_foils.pdf", "foil_kinematics_ct.pdf"] for fig in figlist: shutil.copy2(os.path.join(figdir, fig), os.path.join("figures", fig))
Keep the empty folders in place (don't delete since it might still be rendered right) Also copy the corresponding yaml in there """ input_path = sys.argv[1] output_path = sys.argv[2] yaml_path = sys.argv[3] # This overrides the softlink # os.makedirs(output_path, exist_ok=True) renders = os.listdir(input_path) is_rendered = [len(os.listdir(path.join(input_path, r, 'segmentation')))==160 for r in renders] updated = 0 for i, r in enumerate(renders): if is_rendered[i]: if not path.exists(path.join(output_path, r)): shutil.move(path.join(input_path, r), output_path) prefix = r[:3] shutil.copy2(path.join(yaml_path, 'yaml_%s'%prefix, '%s.yaml'%r), path.join(output_path, r)) updated += 1 else: print('path exist') else: # Nothing for now. Can do something later pass print('Number of completed renders: ', len(os.listdir(output_path))) print('Number of updated renders: ', updated)