コード例 #1
0
ファイル: file.py プロジェクト: MarkHershey/markkk
def safe_move(src: str, dest: str) -> None:
    """
    safety checks:
        1. check if source exists before move
        2. check if same-name file already exist in destination before move
    Only move file when passing above two checks
    """
    src = Path(src)
    dest = Path(dest)

    if not Path(src).exists():
        logger.error(
            f"safe_move cannot be done, because source file '{src}' not found."
        )
        return
    if Path(dest).exists():
        logger.warning(
            f"safe_move cannot be done, because destination file '{dest}' already exist."
        )
        return
    try:
        os.move(src, dest)
        logger.debug(f"'{src}' has been moved to '{dest}'")
    except Exception as err:
        logger.error(f"Move operation failed, reason: {err}")
コード例 #2
0
ファイル: refresher.py プロジェクト: chtu/GatorGrader
	def run():
		print("Restoring test data...")
		clear_initial_dir()

		for folder in os.listdir(Path.invalid_dir):
			if folder[0] == '.':
				continue
			folder_path = os.path.join(Path.invalid_dir, folder)
			for file in os.listdir(folder_path):
				src_path = os.path.join(folder_path, file)
				dest_path = os.path.join(Path.initial_sub_dir, file)
				os.move(src_path, dest_path)

		move_back_to_initial_dir(Path.valid_checked_dir)
		move_back_to_initial_dir(Path.valid_sub_dir)
		move_back_to_initial_dir(Path.valid_checked_graded_dir)

		test_zips = os.listdir(Path.initial_sub_dir)
		for i in range(0, len(test_zips)):
			test_zip_folder = os.path.join(Path.initial_sub_dir, f"test_zip_{i+1}")
			os.mkdir(test_zip_folder)
			os.move(os.path.join(Path.initial_sub_dir, test_zips[i]), os.path.join(test_zip_folder, test_zips[i]))


		for folder in os.listdir(Path.unzipped_dir):
			if folder[0] == '.':
				continue
			folder_path = os.path.join(Path.unzipped_dir, folder)
			shutil.rmtree(folder_path)

		print("Default test data restored.")
コード例 #3
0
ファイル: refresher.py プロジェクト: chtu/GatorGrader
def move_back_to_initial_dir(dir):
	for filename in os.listdir(dir):
		if filename[0] == '.':
			continue
		src_path = os.path.join(dir, filename)
		dest_path = os.path.join(Path.initial_sub_dir, filename)
		os.move(src_path, dest_path)
コード例 #4
0
ファイル: livetime.py プロジェクト: mahmoud-lsw/PhD-python
def recursive_gtltsum(infiles, outfile):
    """ Run gtltsum recursively to sum all livetime cubes. """
    infiles = list(infiles) # in case generator
    if len(infiles) < 2: raise Exception('Must sum >= 2 livetime cubes')

    temp = NamedTemporaryFile(suffix='.fits',delete=False)
    tempfile = temp.name

    recursive_gtltsum.i=1

    def sum_ltcube(infile1,infile2):
        print 'Merging file %s and %s (%s/%s)' % (infile1, infile2,recursive_gtltsum.i,len(infiles))
        recursive_gtltsum.i+=1
        if infile1 == outfile:
            gtltsum(infile1=infile1, infile2=infile2, outfile=tempfile)
            return tempfile
        else:
            gtltsum(infile1=infile1, infile2=infile2, outfile=outfile)
            return outfile

    accum=reduce(sum_ltcube, infiles)
    if accum == tempfile:
        os.move(tempfile, outfile)
    else:
        os.remove(tempfile)
コード例 #5
0
ファイル: netlog.py プロジェクト: avoinea/netlog
    def rotator(self):
        """rotation process"""
        date = datetime.datetime.now().date()
        while not self.stopping.is_set():
            time.sleep(0.1)
            cur_date = datetime.datetime.now().date()

            if date != cur_date:
                logs = open(self.dirs_file).read().split('\n')
                self.debug_log('rotate:', logs)

                date_str = str(date)
                cur_date_str = str(cur_date)
                del_date_str = str(cur_date - datetime.timedelta(
                        days=self.life_time))

                for log in logs:
                    logfile_src = os.path.join(log, date_str)
                    logfile_dst = os.path.join(log, cur_date_str)
                    logfile_del = os.path.join(log, del_date_str)
                    if os.path.exists(logfile_src):
                        os.move(logfile_src, logfile_dst)
                    if os.path.exists(logfile_del):
                        os.remove(logfile_del)

                self.date = datetime.now().date()
コード例 #6
0
def reformat_files():
    ext = input('Enter format to change to: ')
    for files in os.listdir(os.chdir(path)):
        os.move(files, files + ext)
        done = os.listdir(os.getcwd())
        for fil in done:
            print(fil)
コード例 #7
0
ファイル: analysis.py プロジェクト: Galithil/TACA
def archive_run(run):
    
    rppath=os.path.join(run, 'runParameters.xml')
    try:
        rp=XTenRunParametersParser(os.path.join(run, 'runParameters.xml'))
    except OSError:
        logger.warn("Cannot find the runParameters.xml file at {}. This is quite unexpected. please archive the run {} manually".format(rppath, run))
    else:
        try:
            #Works for recent control software
            runtype=rp.data["Setup"].get("Application Name")
        except KeyError :
            #should work for ancient control software
            runtype=rp.data.get("Application Name")

        if "HiSeq X" in runtype:
            destination=CONFIG['storage']['archive_dir']['HiSeqX']
        elif "MiSeq" in runtype:
            destination=CONFIG['storage']['archive_dir']['MiSeq']
        elif "HiSeq" in runtype:
            destination=CONFIG['storage']['archive_dir']['HiSeq']
        else:
            logger.warn("unrecognized runtype {}, cannot archive the run {}.".format(runtype, run)) 
            destination=None

        if destination:
            logger.info('archiving run {}'.format(run))
            os.move(os.path.abspath(run), os.path.join(destination, os.path.basename(os.path.abspath(run))))
コード例 #8
0
def signalp_runner(input_directory_path, faa_file, output_directory_path):
    #Creating file path
    input_file = input_directory_path + faa_file

    #Creating a subdirectory in the output directory
    output_subdir = output_directory_path + "signalp/"

    #Checking if the subdirectory exists
    if not "signalp" in os.listdir(output_directory_path):
        os.mkdir(output_subdir)

    #Executing PilerCR
    try:
        print("SignalP 5.0 " + contig_file)
        signalp_outout = subprocess.check_output(
            ["signalp -fasta ", input_file, "-org gram- -format short -gff3"])
        os.move("*.gff", "output_directory_path")
        #pilercr_output=subprocess.check_output(["pilercr", "-in", input_file, "-out",output_file, "-noinfo", "-quiet"])

    except subprocess.CalledProcessError as err:
        print("Error running SignalP. Check the input files")
        print("Error thrown: " + err.output)
        return False

    print("Completed running SignalP")
    return True
コード例 #9
0
ファイル: util.py プロジェクト: nathom/audioconvert
def move_to_auto(dir, auto_dir):
    files = find("m4a", dir=dir)

    def filename(f):
        return f.split("/")[-1]

    for file in files:
        os.move(dir + "/" + filename(file), auto_dir + "/" + filename(file))
コード例 #10
0
def move_files(fnames, subdir):
    olddir = path.dirname(fnames[0])
    newdir = path.join(olddir, subdir)
    basenames = [path.basename(fname) for fname in fnames]
    newfnames = [path.join(newdir, basename) for bname in basenames]
    for fname, newfname in zip(fnames, newfnames):
        os.move(fname, newfname)
    return newfnames
コード例 #11
0
ファイル: link-f.py プロジェクト: termim/mylibs
 def link(self, other, mask='*', dryrun=1):
     for fn in self.targets(mask):
         if not islink(fn):
             arc = other.arc(fn)
             if not exists(arc):
                 print("Moving: {} -> {}".format(fn, arc))
                 if not dryrun: os.move(fn)
                 print("Link: {} -> {}".format(fn, arc))
                 if not dryrun: os.symlink(arc, fn)
コード例 #12
0
ファイル: question.py プロジェクト: plgitlogin/plbank
 def creatZip(self,p):
     # create dir from the directory pathdir
     from shutil import rmtree,move
     rmtree('/tmp/env/', ignore_errors=True)
     self.zipname = str(p.resolve() /  "env.zip")
     with cd.cd(str(p)) :
         subprocess.run(['zip','-qjr','env.zip','.'])
     
     os.move(self.zipname,)
コード例 #13
0
    def creation_doss_rognages_ciels(self, dossier, fichier):

        self.dossier = dossier
        self.ficheir = fichier
        
        os.chdir(self.dossier)
        liste = os.listdir(".")
        mettre_fichier = liste[-1]

        os.move(self.fichier, mettre_fichier)
コード例 #14
0
    def _MoveFiles(self):
        _allfiles = os.listdir(self._output_dir)
        _files = []
        for _file in _allfiles:
            if _file.endswith(".fil"):
                _files.append(_file)
            if _file.endswith("_v1.fil"):
               print "WARNING: something went wrong. there is a file, that ends on '_v1.fil': ", _file
               print "this should not happen under normal circumstances. Please investigate."
               #sys.exit(0)
               
        if len(_files) == 0:
            return

        if len(self._valuelist) == 0:
            print "valuelist is empty. Something went wrong. Exit."
            sys.exit(0)
            
        _expected_filelist = []
        
        for i in self._valuelist:
            format_string = "%s_"
            format_string += self._par1_format
            self._sJobLabel = format_string % (self._sJobLabel_Prefix, i)
            _expected_filelist.append("%s_%s.fil" % (self._g4ds_output_prefix, self._sJobLabel))

        #print _expected_filelist

        if len(_files)< len(self._valuelist):
            print "Only a subset has been produced:"
            _fileset = set(_files).intersection(_expected_filelist)
            print _fileset
            print "Is production currently ongoing? Do nothing and wait."
            print "last modification times: "
            for _file in _files:
                print "%s: %s" % (_file, time.ctime(os.path.getmtime(self._output_dir+_file)))
            sys.exit(0)

        else:
            overlap = set(_files).intersection(_expected_filelist)
            if len(overlap)==len(_expected_filelist): #the file lists are identical
                #while 1: #create dir
                i=1
                while i:
                   if os.path.isdir(self._output_dir+"/v%d" % i):
                       i+=1
                   else:
                       os.mkdir(self._output_dir+"/v%d" % i)
                       break


                for _file in os.listdir(self._output_dir+"/*.*"):
                    os.move(_file, self._output_dir+"/v%d" % i)

                print "files have been moved to: %s" % (self._output_dir+"/v%d" % i)
コード例 #15
0
ファイル: configure.py プロジェクト: posva/configure.py
def convert_unix(filename):
    f = open(filename, "U")
    t = tempfile.TemporaryFile()

    for l in f:
        t.write(l)

    f.close()
    t.close()

    os.move(t.name, f.name)
コード例 #16
0
ファイル: configure.py プロジェクト: posva/configure.py
def convert_unix(filename):
    f = open(filename, "U")
    t = tempfile.TemporaryFile()

    for l in f:
        t.write(l)

    f.close()
    t.close()

    os.move(t.name, f.name)
コード例 #17
0
 def shift():
     'Do archiving here'
     'Always do in a try statement, as the task could of been completed already by someone else.'
     try:
         os.move(active_timeline, "~.config/openStatus/network/archive/" + datetime.time.hour + "-" + datetime.time.minute + "-" + datetime.time.second + "-" + datetime.date.day + "-" + datetime.date.month + "-" + datetime.date.year)
         'Just in-case, create a new timeline.'
         writer = open(active_timeline, "w").write("")
         writer.close()
         'If the DynamicShift succeeds, return the error code "0".'
         return 0
     except:
         'If the DynamicShift fails for some reason, return the error code "1".'
         return 1
コード例 #18
0
ファイル: util.py プロジェクト: AlexandreProenca/jurt
def replace_link(linkpath, linkdest):
    if os.path.lexists(linkpath):
        if not os.path.islink(linkpath):
            newname = linkpath + "." + str(int(time.time()))
            logger.warn("%s already exists and it is not a symlink "
                    "as expected, renaming it to %s" % (linkpath,
                        newname))
            os.move(linkpath, newname)
        else:
            logger.debug("removing existing link %s" % (linkpath))
            os.unlink(linkpath)
    logger.debug("creating link %s pointing to %s" % (linkpath, linkdest))
    os.symlink(linkdest, linkpath)
コード例 #19
0
def rename_data(request, post_id):
    data = Post.objects.get(url_id=post_id)
    image = PostImage.objects.filter(post=data.id)
    title = str(data.title).replace(" ", "")
    unique = randomword(4)
    img_dir = settings.IMAGE_DIR
    thumb_dir = settings.MEDIA_ROOT + 'image/thumb'
    print img_dir
    count = 0

    print image
    for x in image:
        # print x.images
        ext = str(x.images).split('.')[-1]
        if count <= image.count():
            try:
                src = ("{0}/{1}".format(settings.MEDIA_ROOT, x.images))
                dest = ("{0}/{1}_{2}_img_{3}.{4}".format(
                    img_dir, unique, title, count, ext))
                print "data belum diubah %s" % src
                print "data setelah diubah %s" % dest
                os.move(src, dest)

                src_thumb = ("{0}/{1}".format(settings.MEDIA_ROOT, x.thumbs))
                dest_thumb = ("{0}/{1}_{2}_img_{3}-150x150thumb.{4}".format(
                    thumb_dir, unique, title, count, ext))
                print "data belum diubah %s" % src_thumb
                print "data setelah diubah %s" % dest_thumb
                os.move(src_thumb, dest_thumb)

                image_name = ("image/{0}_{1}_img_{2}.{3}".format(
                    unique, title, count, ext))
                thumb_name = (
                    "image/thumb/{1}_{2}_img_{3}-150x150thumb.{4}".format(
                        unique, title, count, ext))

                print "image %s" % image_name
                print "thumb %s" % thumb_name

                data = PostImage(post=data,
                                 images=image_name,
                                 thumbs=thumb_name)
                data.save()
                # x.images = ("image/{0}_{1}_img_{2}.{3}".format(unique, title, count, ext))
                # x.save()
                count = count + 1

            except:
                print "error file doesnt exist"
    return HttpResponseRedirect("/")
コード例 #20
0
ファイル: doit.py プロジェクト: wimmer-k/GrROOT
def RunOneRun(n,settings):
    runStr = "%04d" % n
    print "----------------------------------------------------"
    print "----------------------------------------------------"
    print "            Now starting run %s" % runStr
    print "----------------------------------------------------"
    print "----------------------------------------------------"
    os.chdir("Run%s" % runStr)
    os.system("GEB_HFC Global.dat")
    os.move("HFC.dat","HFC_%s" % runStr)
    #os.system("GrROOT_changing -i HFC_%s.dat -o raw.root -s %s -rt" % (runStr,settings))
    #os.system("	Histos -i raw.root -o rawmode2_histos.root")
    #os.system("Calculate -i raw.root -o cal.root -s %s" % settings)
    #os.chdir("../kathrin")
    #os.system("ln -s ../Run%s/cal.root cal_run%s" % (runStr,runStr))
    os.chdir(starting_folder)
コード例 #21
0
ファイル: makeReport.py プロジェクト: drhardison/PALS
def relocate(timestamp):
	dateStamp = date.now()
	year = str(dateStamp.year)
	month = str(dateStamp.month)
	day = str(dateStamp.day)
	
	newDir = (archivesDirectory + year + "/" + month + "/" + day + "/" + timestamp + "/")
	
	dir = dirname(newDir)
	
	if not exists(dir):
		mkdir(dir)
	
	src = cwd + "*"
	dst = newDir + "*"
	move(src, dst)
コード例 #22
0
ファイル: doit.py プロジェクト: wimmer-k/GrROOT
def RunOneRun(n, settings):
    runStr = "%04d" % n
    print "----------------------------------------------------"
    print "----------------------------------------------------"
    print "            Now starting run %s" % runStr
    print "----------------------------------------------------"
    print "----------------------------------------------------"
    os.chdir("Run%s" % runStr)
    os.system("GEB_HFC Global.dat")
    os.move("HFC.dat", "HFC_%s" % runStr)
    #os.system("GrROOT_changing -i HFC_%s.dat -o raw.root -s %s -rt" % (runStr,settings))
    #os.system("	Histos -i raw.root -o rawmode2_histos.root")
    #os.system("Calculate -i raw.root -o cal.root -s %s" % settings)
    #os.chdir("../kathrin")
    #os.system("ln -s ../Run%s/cal.root cal_run%s" % (runStr,runStr))
    os.chdir(starting_folder)
コード例 #23
0
def relocate(timestamp):
    dateStamp = date.now()
    year = str(dateStamp.year)
    month = str(dateStamp.month)
    day = str(dateStamp.day)

    newDir = (archivesDirectory + year + "/" + month + "/" + day + "/" +
              timestamp + "/")

    dir = dirname(newDir)

    if not exists(dir):
        mkdir(dir)

    src = cwd + "*"
    dst = newDir + "*"
    move(src, dst)
コード例 #24
0
 def shift():
     'Do archiving here'
     'Always do in a try statement, as the task could of been completed already by someone else.'
     try:
         os.move(
             active_timeline, "~.config/openStatus/network/archive/" +
             datetime.time.hour + "-" + datetime.time.minute + "-" +
             datetime.time.second + "-" + datetime.date.day + "-" +
             datetime.date.month + "-" + datetime.date.year)
         'Just in-case, create a new timeline.'
         writer = open(active_timeline, "w").write("")
         writer.close()
         'If the DynamicShift succeeds, return the error code "0".'
         return 0
     except:
         'If the DynamicShift fails for some reason, return the error code "1".'
         return 1
コード例 #25
0
ファイル: hostscan.py プロジェクト: pombredanne/OpTools
 def write(self):
     if self.args['writemode'] == 'replace':
         if os.path.isfile(
                 self.args['output']) and self.args['output'] != sys.stdout:
             os.move(self.args['output'],
                     os.path.join(self.args['output'], '.bak'))
     for h in self.keys.keys():
         for i in self.keys[h]:
             _s = '# Automatically added via hostscan.py\n{0} {1} {2}\n'.format(
                 i['host'], i['type'], i['key'])
             if self.args['output'] == sys.stdout:
                 print(_s, end='')
             else:
                 with open(self.args['output'], 'a') as f:
                     f.write(_s)
                 os.chmod(self.args['output'], 0o644)
                 os.chown(self.args['output'],
                          pwd.getpwnam(self.args['chown_user'])[2],
                          grp.getgrnam(self.args['chown_grp'])[2])
     return ()
コード例 #26
0
ファイル: gestion_fichiers.py プロジェクト: Flavienhr/api-mbn
def move_file():
    file_liste = listdir()
    fichiers_liste = [elmt for elmt in file_liste if elmt[-3:] == '.md']
    for i in range(len(fichiers_liste)):
        f = open(fichiers_liste[i], 'r')
        date_trouvee = f.readlines(1)
        f.close()
        date_trouvee = "".join(date_trouvee)
        date_trouvee = date_trouvee.split('/')
        date_trouvee = tuple(date_trouvee)
        jour, mois, annee = date_trouvee
        mois_liste = [
            'Janvier', 'Fevrier', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet',
            'Août', 'Septembre', 'Octobre', 'Novembre', 'Decembre'
        ]
        mois = mois_liste[int(mois) - 1]
        for dossier in file_liste:
            if str(jour + ' ' + mois) in dossier:
                dossier_destination = dossier
        path_destination = dossier_destination + '\ '.strip(
        ) + fichiers_liste[i]
        move(fichiers_liste[i], path_destination)
コード例 #27
0
import os
urls = []
with open('downloads.txt') as f:
    for line in f:
        items = eval(line)
        urls.append(items[0])

for item in os.listdir('.'):
    for url in urls:
        if url in item:
            os.move(item, 'maxers/' + item)
コード例 #28
0
ファイル: Compile.py プロジェクト: Beaux44/PyBot
try:  # if the file does not exist, it will bring up an error
    # these remove the current file because on windows,
    # moving a file to another file's directory even if they
    # are the same file, brings up an error.
    rem(path + "/release/Read.pyc")
    rem(path + "/release/Settings.pyc")
    rem(path + "/release/Socket.pyc")
    rem(path + "/release/Commands.pyc")
    rem(path + "/release/Run.pyc")
    rem(path + "/release/Threads.pyc")

except:
    t(.5)  # waits half a second (to let the HDD remove the .pyc files)
    # moves the .pyc in the building directory to the release directory
    move("Read.pyc", path + "/release/Read.pyc")
    move("Settings.pyc", path + "/release/Settings.pyc")
    move("Socket.pyc", path + "/release/Socket.pyc")
    move("Commands.pyc", path + "/release/Commands.pyc")
    move("Run.pyc", path + "/release/Run.pyc")
    move("Threads.pyc", path + "/release/Threads.pyc")
    quit()  # exits the program

#identical to the except block
t(.5)
move("Read.pyc", path + "/release/Read.pyc")
move("Settings.pyc", path + "/release/Settings.pyc")
move("Socket.pyc", path + "/release/Socket.pyc")
move("Commands.pyc", path + "/release/Commands.pyc")
move("Run.pyc", path + "/release/Run.pyc")
move("Threads.pyc", path + "/release/Threads.pyc")
コード例 #29
0
	def run(self):
		files = glob.glob(config.holding_dir+"/*EF*.xml")
		for xml in files:
			st = os.stat(xml)
			
			image = xml.replace('.xml', '.jpg')
			if not os.path.exists(image):
				print 'Corresponding image not found for', f, 'expected', image
				continue


			if time.time() - st.st_mtime > 10:
				tree = ET.parse(xml)
				root = tree.getroot()

				# deal with xml namespace
				ns = root.tag.split('}')[0].strip('{')
				nss = { 'oppf': ns }

				inspectionid = root.find('oppf:ImagingId', nss).text

				container = self._get_container(inspectionid)
				if container is None:
					continue

				new_path = '{root}/data/{year}/{prop}-{vn}'.format(root=config.upload_dir, year=container['year'], prop=container['prop'], vn=0)
				if not os.path.exists(new_path):
					print 'Upload location for image doesnt exist', new_path
					continue

				position = self.get_position(root.find('oppf:Drop', nss).text, container['platetype'])
				if position is None:
					continue

				sampleid = self._get_sampleid(position, container['containerid'])
				if sampleid is None:
					continue

				mppx = root.find('oppf:SizeInMicrons', nss).find('Width').text / root.find('oppf:SizeInPixels', nss).find('Width').text
				mppy = root.find('oppf:SizeInMicrons', nss).find('Height').text / root.find('oppf:SizeInPixels', nss).find('Height').text

				db.pq("""INSERT INTO BLSampleImage (blsampleid, micronsperpixelx, micronsperpixely, containerinspectionid)
					VALUES (%s,%s,%s,%s)""", [sampleid, mppx, mppy, inspectionid])

				iid = db.id()

				# Use blsampleimageid as file name as we are sure this is unique
				new_file = '{path}/{iid}.jpg'.format(path=new_path, iid=iid)

				db.pq("""UPDATE BLSampleImage set imagefullpath=%s WHERE blsampleimageid=%s""", [new_file, iid])

				# move image
				copyfile(image, new_file)

				# clear up
				os.move(image, image.replace(config.holding_dir, config.holding_dir+'/processed'))
				os.move(f, f.replace(config.holding_dir, config.holding_dir+'/processed'))

				#os.unlink(image)
				#os.unlink(f)


		time.sleep(10)
コード例 #30
0
ファイル: toBeagle.py プロジェクト: tiagoantao/mega-analysis
    except IOError:
        pass  # no snp list

    convert_impute2_to_beagle(
        open("%s.sample" % chro), open("%s.haps" % chro), gzip.open("T%s.gz" % chro, "w"), is_phased=True
    )
    if snps is not None or inds is not None:
        project_beagle_phase(
            gzip.open("%s.gz" % chro, "w"),
            gzip.open("T%s.gz" % chro),
            ind_retain=inds,
            snp_retain=snps,
            want_phased=True,
            is_phased=True,
        )
    else:
        os.move("T%s.gz" % chro, "%s.chro" % chro)
    sys.exit(0)


if os.path.exists("inds"):
    print("projecting individuals")
if os.path.exists("snps"):
    print("projecting snps")
lexec = MEGA.executor

for i in range(maxChro):
    k = i + 1
    lexec.submit("python", MEGA.phasingScripts + "/toBeagle.py %d" % k)
lexec.wait(True)
コード例 #31
0
 def move_file(src, dst):
     os.move(src, dst)
     return dst
コード例 #32
0
# split data
X_train, X_test, y_train, y_test = train_test_split(X,
                                                    y,
                                                    test_size=0.2,
                                                    random_state=42)

# generating train.txt
for i, j in zip(X_train, y_train):
    with open(os.path.join(abs_path, 'trainlist01.txt'), 'a') as f:
        f.write(i + " " + j)
        f.write('\n')

# generating test.txt
for i, j in zip(X_test, y_test):
    with open(os.path.join(abs_path, 'testlist01.txt'), 'a') as f:
        f.write(i)
        f.write('\n')
os.move("D:/TESIS/ULTIMO/data/classInd.txt D:/TESIS/ULTIMO/data/annotation/")
os.move("D:/TESIS/ULTIMO/data/testlist01.txt D:/TESIS/ULTIMO/data/annotation/")
os.move(
    "D:/TESIS/ULTIMO/data/trainlist01.txt D:/TESIS/ULTIMO/data/annotation/")
os.remove("D:/TESIS/ULTIMO/data/trainval.txt")

# # generating train.txt
# for i,label in enumerate(labels):
#     video_names=os.listdir(os.path.join(abs_path,image_folder,'val',label))
#     for video_name in video_names:
#         with open(os.path.join(abs_path,'val.txt'),'a') as f:
#             f.write(os.path.join(abs_path,image_folder,'val',label,video_name)+ " " + dict_labels[label])
#             f.write('\n')
コード例 #33
0
 def save_cache(self, save_file):
     self.connection.close()
     os.move(self.cachename, save_file)
     self.connection = sqlite.connect(save_file)
     self.cursor = self.connection.cursor()
     self.cachename = save_file
コード例 #34
0
ファイル: generate-report.py プロジェクト: ebu/OSCIED
        result = cmd("sudo make html", fail=False)
        with open("build_html.log", "w", "utf-8") as log_file:
            log_file.write("Output:\n{0}\nError:\n{1}".format(result["stdout"], result["stderr"]))
        if result["returncode"] != 0:
            print_error("Unable to generate HTML version of the report, see build_html.log")

    if args.pdf:
        print(HELP_PDF)
        result = cmd("sudo make latexpdf", fail=False)
        with open("build_pdf.log", "w", "utf-8") as log_file:
            log_file.write("Output:\n{0}\nError:\n{1}".format(result["stdout"], result["stderr"]))
        if result["returncode"] != 0:
            print_error("Unable to generate PDF version of the report, see build_pdf.log")
        print("Move PDF into releases directory")
        for pdf_filename in glob.glob(join(DAVID_REPORT_BUILD_PATH, "*.pdf")):
            os.move(pdf_filename, DAVID_REPORT_RELEASE_PATH)

    # pecho u'Compress report'
    # cd "$DAVID_REPORT_RELEASE_PATH" || xecho "Unable to find path $DAVID_REPORT_RELEASE_PATH"
    # gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook -dNOPAUSE -dQUIET -dBATCH \
    #  -sOutputFile=MA_DavidFischer_OSCIED_compressed.pdf MA_DavidFischer_OSCIED.pdf

    if args.wiki:
        print(HELP_WIKI)
        file_regex = re.compile(r":file:`([^`]*)`")
        include_regex = re.compile(r"(?P<space>\s*)\.\. literalinclude::\s+(?P<link>\S+)\s*")
        option_regex = re.compile(r"(?P<space>\s*):(?P<name>\S+):\s+(?P<value>\S+)\s*")
        c_data = "".join(filter(lambda l: ":orphan:" not in l, open(DAVID_REPORT_COMMON_FILE, "r", "utf-8")))
        for rst_src_filename in glob.glob(join(WIKI_SOURCE_PATH, "*.rst")):
            rst_dst_filename = join(WIKI_BUILD_PATH, basename(rst_src_filename))
            with open(rst_src_filename, "r", "utf-8") as rst_src_file:
コード例 #35
0
ファイル: files.py プロジェクト: cirosantilli/python-utils
def move(paths, rename_func, do_move=False, **kwargs):
    """convenient interface for moving multiple paths

    rename func can takes the entire path, not only the basename,
    but it can only alter the basename only, and not the containing directory.

    files cannot change contaning directories after the rename.

    :param paths: paths to act on

        not an iterator, so that sorting can be done.

        relative paths are converted to full paths before rename_func acts on them

        rationale: absolute paths are taken even if only basebame can be renamed
        so that functions that use data inside the file can work. if you want
        to do a function that uses only basename information, use the act_basename_only
        decorator

    :type paths: list of strigs
    :param rename_func: rename function of that returns the *full path* from a given *full path*
    :type rename_func: function with signature (string,*args,**kwargs)
    :param do_move: if True, really renames, else, only outputs changes that would be done
    :type do_move: boolean
    :param mv_func: if given, uses this function to rename files from old to new name. default: os.rename

        this function can suppose that:

        - the target parent directory exists
        - the target file does not exist

        it should throw any exception if the rename fails.

    :type mv_func: func(stringn,string). side effect: move old_path to new_path

    :param can_change_dirs: default: False
    
        if True, new path can be in a new dir from old one.
    
        else, if this is tried a warning is logged, and move is skipped

        example:

            old path:

                /usr/file.py

            new path:

                /home/file.py

            if True, the move works

    :type can_change_dirs: boolean
    :param make_missing_dirs: default: False
    
        if True, automatically makes any non existant directories that
        would be necessary for the new path.
        
        else, loggs a warning and skips current move

        this option implies can_change_dirs

        if a file is going to be moved to a different parent dir,
        and the parent dir is an existing file, only moves if overwrite == True
        and make_missing_dirs == True

        example:

            existing dirs:

                /usr/

            old path:

                /usr/file.py

            new path:

                /usr/non/existant/dirs/file.py

            if True, creates:

                /usr/non/
                /usr/non/existant/
                /usr/non/existant/dir/

            and then moves the old path there:

                /usr/non/existant/dir/file.py
                
    :type make_missing_dirs: boolean
    :param overwrite: default: False
    
        if True overwrites existing files without asking.

        else, logs a warning, and skips move

        if a file is going to be moved to a different parent dir,
        and the parent dir is an existing file, only moves if overwrite == True
        and make_missing_dirs == True

    :type overwrite: boolean.

    :param sort_func: default: sorted(reverse=True)

        function used to sort paths, and therefore decide order in which paths are renamed

        clearly, this function can have an impact on the rename results.

        example:

            existing files:

                /a
                /b

            rename func: lambda p: 'c'

            in this case, either a or b will be renamed,
            depending on which goes first.

            if overwrite is True, loss of data would occur

        rationale hehind default:

            with sorted(reverse=True), when renameing basenames, which is the major use case,
            one always renames parent dirs before files inside them.

    :type sort_func: function([string, ...])

    TODO
    ====

        - THE MOVE DIRS IS BUGGED DON'T USE IT!!!!!!

        - rename do_move to do_mv

        - add act on abspath/act on relpath option

    """

    sort_func = kwargs.pop("sort_func", sorted)
    func_args = kwargs.pop("func_args", [])
    func_kwargs = kwargs.pop("func_kwargs", {})
    make_missing_dirs = kwargs.pop("make_missing_dirs", True)
    can_change_dirs = kwargs.pop("can_change_dirs", True) or make_missing_dirs
    mv_func = kwargs.pop("mv_func", os.rename)
    overwrite = kwargs.pop("overwrite", False)

    paths = map(os.path.abspath, paths)
    paths = sort_func(paths, reverse=True)
    warnings = []
    errors = []
    for path in paths:

        head, bname = os.path.split(path)
        new_bname = rename_func(path, *func_args, **func_kwargs)
        new_path = os.path.join(head, new_bname)

        if new_path != path:

            logging.info("%s\n%s\n" % (path, new_path))

            # make sure new path is clear
            if os.path.exists(new_path):
                if overwrite and do_move:
                    try:
                        remove_recursive(new_path)
                    except Exception, e:
                        errors.append("os error: could not remove existing path" "\n%s\n%s\n\n%s" % (path, new_path, e))
                        continue
                else:
                    warnings.append(
                        "new path already exists." "rename skipped\nold path:" "%s\nnew path:  %s" % (path, new_path)
                    )
                    continue

            # make sure new dir exists
            old_dir = os.path.split(path)[0]
            new_dir = os.path.split(new_path)[0]
            if old_dir != new_dir:
                makedirs = False
                continue  # TODO this is for security before I get the tests done!!!!!!
                if can_change_dirs:
                    if os.path.exists(new_dir):
                        if not os.path.isdir(new_dir):  # its a file
                            if make_missing_dirs:
                                makedirs = True
                                if (
                                    not os.path.commonprefix([old_path, new_dir]) == old_path
                                ):  # old_path is an ancestor for new path
                                    if overwrite:
                                        try:
                                            shutil.rmtree(new_path)
                                        except Exception, e:
                                            print e, "TODO"
                                            continue
                                    else:
                                        print overwrite_error  # TODO
                                elif overwrite:  # new_dir == old_path: must move old path to temp path!
                                    # TODO get temppath
                                    try:
                                        os.move(path, tmppath)
                                    except Exception, e:
                                        errors.append("TODO" % (path, new_path, e))
                                        continue
                                    path = temppath
                            else:
                                print "missing dirs warn TODO"
                    elif make_missing_dirs:
                        makedirs = True
                    else:
                        print "missing dirs warn TODO"

                    # now that the area is clear, make the missing dirs if needed
                    if makedirs and do_move:
                        try:
                            os.makedirs(new_dir)  # ensure dir exists
                        except Exception, e:
                            errors.append(
                                "os error: could not create non-existant dirs for new path. \n%s\n%s\n\n%s"
                                % (path, new_path, e)
                            )
                            continue
                    else:
                        warnings.append("new dir does not exist\n%s\n%s\n" % (path, new_path))
                        continue
コード例 #36
0
ファイル: move_sc_1.py プロジェクト: nyspisoccog/ks_scripts

def splitall(path):
    allparts = []
    while 1:
        parts = os.path.split(path)
        if parts[0] == path:   # sentinel for absolute paths
            allparts.insert(0, parts[0])
            break
        elif parts[1] == path:  # sentinel for relative paths
            allparts.insert(0, parts[1])
            break
        else:
            path = parts[0]
            allparts.insert(0, parts[1])
    return allparts


root = '/media/katie/storage/7508/func'

for d in os.listdir(root):
    for letter in ['L', 'M']:
        if letter in s_name:
            old_path = os.path.join(root, d)
            dir_name = 'run_' + d[d.find(letter)-1:d.find(letter)+2]
            new_path = os.path.join(root, dir_name)
            print old_path
            print new_path
            os.move(old_path, new_path)

コード例 #37
0
from os import path

with open("Package.swift") as file:
    data = file.readlines()

for i in range(len(data)):
    if "//dev" in data[i]:
        data[i] = data[i][2:]
    if "//nodev" in data[i]:
        data[i] = "//" + data[i]

with open("Package.swift", "w") as file:
    file.writelines(data)

with open("*****@*****.**") as file:
    data = file.readlines()

for i in range(len(data)):
    if "//dev" in data[i]:
        data[i] = data[i][2:]
    if "//nodev" in data[i]:
        data[i] = "//" + data[i]

with open("*****@*****.**", "w") as file:
    file.writelines(data)

if path.exists("Package.resolved"):
    move("Package.resolved", "Package.resolved.nodanger")
if path.exists("Package.resolved.danger"):
    move("Package.resolved.danger", "Package.resolved")