def OnExportSurface(self, pubsub_evt):
filename, filetype = pubsub_evt.data
ftype_prefix = {
const.FILETYPE_STL: '.stl',
const.FILETYPE_VTP: '.vtp',
const.FILETYPE_PLY: '.ply',
const.FILETYPE_STL_ASCII: '.stl',
}
if filetype in ftype_prefix:
temp_file = tempfile.mktemp(suffix=ftype_prefix[filetype])
if _has_win32api:
utl.touch(temp_file)
_temp_file = temp_file
temp_file = win32api.GetShortPathName(temp_file)
os.remove(_temp_file)
temp_file = temp_file.decode(const.FS_ENCODE)
self._export_surface(temp_file, filetype)
shutil.move(temp_file, filename)
def file_created(path):
if os.path.exists(recordfile_name):
installed_files = []
if os.path.exists(recordfile_name):
recordfile = open(recordfile_name, "r")
installed_files.extend(line.rstrip("\n") for line in
recordfile)
recordfile.close()
try:
path.decode("ASCII")
except (UnicodeDecodeError, UnicodeEncodeError):
# the contents of the record file used by distutils
# must be ASCII GetShortPathName allows us to avoid
# any issues with encoding because it returns the
# short path as 7-bit string (while still being a
# valid path)
path = win32api.GetShortPathName(path)
installed_files.append(path)
recordfile = open(recordfile_name, "w")
recordfile.write("\n".join(installed_files))
recordfile.close()
def shortPath(path):
"""
Get absolute 'short' path in Unicode, converts to 8.3 windows filenames.
"""
path_ = os.path.abspath(path)
if not Windows():
if not isinstance(path_, unicode):
return unicode(path_)
return path_
if not os.path.exists(path_):
if os.path.isdir(os.path.dirname(path_)):
res = shortPath(os.path.dirname(path_))
return unicode(os.path.join(res, os.path.basename(path_)))
return unicode(path_)
try:
import win32api
spath = win32api.GetShortPathName(path_)
return unicode(spath)
except:
lg.exc()
return unicode(path_)
def Extract(filename, folder):
if _has_win32api:
folder = win32api.GetShortPathName(folder)
folder = decode(folder, const.FS_ENCODE)
tar = tarfile.open(filename, "r")
idir = decode(os.path.split(tar.getnames()[0])[0], 'utf8')
os.mkdir(os.path.join(folder, idir))
filelist = []
for t in tar.getmembers():
fsrc = tar.extractfile(t)
fname = os.path.join(folder, decode(t.name, 'utf-8'))
fdst = open(fname, 'wb')
shutil.copyfileobj(fsrc, fdst)
filelist.append(fname)
fsrc.close()
fdst.close()
del fsrc
del fdst
tar.close()
return filelist
def getShortName(filename):
'''
Get the Short Name of the specified file. This function gets the short path, but maintains the full resolution base filename.
This is a workaround for an issue that Farsite has with the command file containing blanks in the file paths. We can't go to
full 8.3 syntax, because this confuses dealing with Shapefiles. We were having issues with the 3rd Ignition Points file
always gave us grief, no matter what the name.
This is required because:
1) The command file wont support quotes around file paths that contains spaces. So we need a way to remove spaces, thus Short Names
2) Unfortunately Short Names aren't prefix consistent. So the short name prefix of FileName.shp isnt neccessarily the same as Filename.dbf.
Ex:
IT69BF~1.DBF It0001-Ts2028-ignitionPtsFile.dbf
IT3ED5~1.PRJ It0001-Ts2028-ignitionPtsFile.prj
:param filename: The filename we want to get the short path for
:return: The absolute path of the file, with the directory of the file expressing in short format, but the base filename itself in full "resolution"
'''
file_dir = os.path.dirname(filename)
return os.path.join(win32api.GetShortPathName(file_dir),os.path.basename(filename))
def getcwd():
"""
Wrap os.getcwd()
On Windows return ShortPathName (8.3 filename) that contain only ascii
characters.
"""
cwd = os.getcwd()
# TODO os.getcwd should work properly with py3 on windows.
if is_win:
try:
unicode(cwd)
except UnicodeDecodeError:
# Do conversion to ShortPathName really only in case 'cwd' is not
# ascii only - conversion to unicode type cause this unicode error.
try:
import win32api
cwd = win32api.GetShortPathName(cwd)
except ImportError:
pass
return cwd
def remove_folder(path):
"""Recursively delete a directory tree."""
if os.name == "nt" and win32api_available:
path = win32api.GetShortPathName(path)
names = os.listdir(path)
for name in names:
fullname = os.path.join(path, name)
if os.path.isdir(fullname):
remove_folder(fullname)
else:
try:
os.remove(fullname)
except OSError:
try:
os.remove("\\\\?\\" + fullname)
except OSError: # it's a dir?
remove_folder(fullname)
try:
os.rmdir(path)
except OSError:
os.rmdir("\\\\?\\" + path)
def create(scripts, debug, verbosity, workdir, ascii=0):
infos = [] # (path, module, klasses)
for script in scripts:
infos.append(analscriptname(script))
if not os.path.exists(workdir):
os.makedirs(workdir)
outfnm = 'drive%s.py' % infos[0][1]
outfnm = os.path.join(workdir, outfnm)
outf = open(outfnm, 'w')
klassspecs = []
modimports = []
flags = 'debug=%s, quiet=%s' % (debug, verbosity == 0)
paths = []
for path, module, klasses in infos:
if path:
paths.append(path)
modimports.append("import %s" % (module, ))
for klass in klasses:
klassspecs.append("%s.%s" % (module, klass))
for i in range(len(paths)):
path = paths[i]
paths[i] = win32api.GetShortPathName(os.path.normpath(path))
modimports = string.join(modimports, '\n')
klassspecs = string.join(klassspecs, ', ')
d = {
'modules': modimports,
'klasses': klassspecs,
}
outf.write(tmplt % d)
outf.close()
print "**********************************"
print "Driver script %s created" % outfnm
specfnm = Makespec.main([outfnm],
console=debug,
debug=debug,
workdir=workdir,
pathex=paths,
comserver=1,
ascii=ascii)
print "Spec file %s created" % specfnm
def check(self, run):
if not run.run_ok:
log.error("Cannot check failed run %s" % (run))
return False
args = run.get_tmp_files([self.file1, self.gold])
if os.name != "nt":
x = Run({}, "numdiff.py", [(x, AT_OPAQUE) for x in (self.options + args)])
if not x.run():
log.info("numdiff.py %s '%s' '%s'" % tuple([" ".join(self.options)] + args))
return False
run.check_ok = True
else:
# Here we go through bash for windows because numdiff isn't on windows.
# To get a properly cased filed path (required for bash)
# to install for python2.7:
# pip install pypiwin32
import win32api
args = [win32api.GetLongPathName(win32api.GetShortPathName(x)) for x in args]
# Now replace drive to use bash on windows format. e.g. c: gets replaced to /mnt/c/
# and \ gets replaced with /
def windows_drive_to_bash(p):
drive = p[0].lower()
return "/mnt/" + drive + p[2:]
args = [windows_drive_to_bash(x.replace("\\", "/")) for x in args]
x = Run({}, "numdiff.bat", [(x, AT_OPAQUE) for x in (self.options + args)])
if not x.run():
log.info("numdiff.bat %s '%s' '%s'" % tuple([" ".join(self.options)] + args))
return False
run.check_ok = True
return True
def threadPycheckerRun(self):
result=''
rc=-1
try:
options = self.greppattern
files= ' '.join(self.flist)
# Recently MarkH has failed to run pychecker without it having
# been explicitly installed - so we assume it is and locate it
# from its default location.
# Step1 - get python.exe
py = os.path.join(sys.prefix, 'python.exe')
if not os.path.isfile(py):
if "64 bit" in sys.version:
py = os.path.join(sys.prefix, 'PCBuild', 'amd64', 'python.exe')
else:
py = os.path.join(sys.prefix, 'PCBuild', 'python.exe')
try:
py = win32api.GetShortPathName(py)
except win32api.error:
py = ""
# Find checker.py
from distutils.sysconfig import get_python_lib
pychecker = os.path.join(get_python_lib(), 'pychecker', 'checker.py')
if not os.path.isfile(py):
result = "Can't find python.exe!\n"
elif not os.path.isfile(pychecker):
result = "Can't find checker.py - please install pychecker " \
"(or run 'setup.py install' if you have the source version)\n"
else:
cmd='%s "%s" %s %s 2>&1' % (py, pychecker, options,files)
##fin,fout,ferr=os.popen3(cmd)
##result=ferr.read()+fout.read()
result=os.popen(cmd).read()
##rc=f.close()
self.GetFirstView().Append(result)
finally:
self.result=result
print '== Pychecker run finished =='
self.GetFirstView().Append('\n'+'== Pychecker run finished ==')
self.SetModifiedFlag(0)
def move_ensure_casing(source_path, target_path):
"""Moves a file from source_path to target_path.
If the move would result just in the name changing the case apply workarounds
for Linux and Windows to ensure the case change is applied on case-insensitive
file systems. Otherwise use shutil.move to move the file.
"""
source_path = os.path.normpath(source_path)
target_path = os.path.normpath(target_path)
if source_path == target_path:
return
# Special handling is only required if both paths refer to the same file
# but the file name differs in casing.
# Also macOS does allow renaming only the casing and does not need special
# handling.
if not IS_MACOS and samefile_different_casing(source_path, target_path):
if IS_LINUX:
# On Linux always force a double move
_move_force_rename(source_path, target_path)
return
elif IS_WIN and win32api:
# Windows supports case renaming for NTFS and SMB shares, but not
# on FAT32 or exFAT file systems. Perform a normal move first,
# then check the result.
shutil.move(source_path, target_path)
try:
# Get the path in the actual casing as stored on disk
actual_path = win32api.GetLongPathNameW(
win32api.GetShortPathName(target_path))
if samefile_different_casing(target_path, actual_path):
_move_force_rename(source_path, target_path)
except pywintypes.error:
pass
return
# Just perform a normal move
try:
shutil.move(source_path, target_path)
except shutil.SameFileError:
# Sometimes different paths refer to the same file (e.g. network path / local path on Windows)
pass
def _get_win_folder_with_pywin32(csidl_name):
from win32com.shell import shellcon, shell
dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
# Try to make this a unicode path because SHGetFolderPath does
# not return unicode strings when there is unicode data in the
# path.
try:
dir = unicode(dir)
has_high_char = False
for c in dir:
if ord(c) > 255:
has_high_char = True
break
if has_high_char:
try:
import win32api
dir = win32api.GetShortPathName(dir)
except ImportError:
pass
except UnicodeError:
pass
return dir
def testShortLongPathNames(self):
try:
me = __file__
except NameError:
me = sys.argv[0]
fname = os.path.abspath(me).lower()
short_name = win32api.GetShortPathName(fname).lower()
long_name = win32api.GetLongPathName(short_name).lower()
self.assertTrue(
long_name == fname,
"Expected long name ('%s') to be original name ('%s')" % (long_name, fname),
)
self.assertEqual(long_name, win32api.GetLongPathNameW(short_name).lower())
long_name = win32api.GetLongPathNameW(short_name).lower()
self.assertTrue(
type(long_name) == str,
"GetLongPathNameW returned type '%s'" % (type(long_name),),
)
self.assertTrue(
long_name == fname,
"Expected long name ('%s') to be original name ('%s')" % (long_name, fname),
)
def getcwd():
"""
Wrap os.getcwd()
On Windows return ShortPathName (8.3 filename) that contain only ascii
characters.
"""
cwd = os.getcwd()
# os.getcwd works properly with Python 3 on Windows.
# We need this workaround only for Python 2 on Windows.
if is_win and is_py2:
try:
unicode(cwd)
except UnicodeDecodeError:
# Do conversion to ShortPathName really only in case 'cwd' is not
# ascii only - conversion to unicode type cause this unicode error.
try:
import win32api
cwd = win32api.GetShortPathName(cwd)
except ImportError:
pass
return cwd
def genheatmap(fname, filetype=None, move=True):
Common.initFolder(RSInferencer.dname)
loadcmd = {None: "load", "std": "read_std"}
# write script
cmd = "iplot2_pdf"
f = tempfile.SpooledTemporaryFile(mode="wt")
if platform.system() == "Windows":
import win32api
fname = win32api.GetShortPathName(fname)
f.write("%s %s\n" % (loadcmd[filetype], fname))
f.write("%s\n" % cmd)
f.write("quit\n")
f.seek(0)
# invoke psuade
out, error = Common.invokePsuade(f)
f.close()
# process error
if error:
return None
# check output file
mfile = "matlabiplt2pdf.m"
if os.path.exists(mfile):
if move:
mfile_ = RSInferencer.dname + os.path.sep + mfile
os.rename(mfile, mfile_)
mfile = mfile_
else:
error = "RSInference: %s does not exist." % mfile
Common.showError(error, out)
return None
return mfile
def main(argv):
global sqlServerInstance, sqlDbName, sqlUser, sqlPassword, sqlScriptListfilePath, origOutputFilepath, pathToNewSqlDir, newOutputFilepath, sqlCmdDirPath, IsDummyRun
try:
opts, args = getopt.getopt(argv, "dhw",
["dummyrun", "help", "warnings"])
except getopt.GetoptError:
usage()
sys.exit(2)
if (len(args) != 8):
usage()
sys.exit(3)
#assign the args to variables:
sqlServerInstance = args[0]
sqlDbName = args[1]
sqlUser = args[2]
sqlScriptListfilePath = args[3]
origOutputFilepath = args[4]
pathToNewSqlDir = args[5]
newOutputFilepath = args[6]
sqlCmdDirPath = args[7]
#convert sqlCmdDirPath to short file names:
#printOut("looking for sqlcmd.exe at " + sqlCmdDirPath + "\n")
sqlCmdDirPath = win32api.GetShortPathName(sqlCmdDirPath)
for opt, arg in opts:
if opt in ("-d", "--dummyrun"):
IsDummyRun = True
elif opt in ("-h", "--help"):
usage()
sys.exit()
elif opt in ("-w", "--warnings"):
setLogVerbosity(LOG_WARNINGS)
prompt = "Please enter the password for server: " + sqlServerInstance + " database: " + sqlDbName + " user: "******" "
sqlPassword = getpass.getpass(prompt)
def genheatmap(fname, filetype=None, move=True):
Common.initFolder(RSInferencer.dname)
loadcmd = {None: 'load', 'std': 'read_std'}
# write script
cmd = 'iplot2_pdf'
f = tempfile.SpooledTemporaryFile()
if platform.system() == 'Windows':
import win32api
fname = win32api.GetShortPathName(fname)
f.write('%s %s\n' % (loadcmd[filetype], fname))
f.write('%s\n' % cmd)
f.write('quit\n')
f.seek(0)
# invoke psuade
out, error = Common.invokePsuade(f)
f.close()
# process error
if error:
return None
# check output file
mfile = 'matlabiplt2pdf.m'
if os.path.exists(mfile):
if move:
mfile_ = RSInferencer.dname + os.path.sep + mfile
os.rename(mfile, mfile_)
mfile = mfile_
else:
error = 'RSInference: %s does not exist.' % mfile
Common.showError(error, out)
return None
return mfile
def run_test(script, cmdline_rest=""):
dirname, scriptname = os.path.split(script)
# some tests prefer to be run from their directory.
cwd = os.getcwd()
os.chdir(dirname)
try:
executable = win32api.GetShortPathName(sys.executable)
cmd = '%s "%s" %s' % (sys.executable, scriptname, cmdline_rest)
print script
stdin, stdout, stderr = os.popen3(cmd)
stdin.close()
while 1:
char = stderr.read(1)
if not char:
break
sys.stdout.write(char)
for line in stdout.readlines():
print line
stdout.close()
result = stderr.close()
if result is not None:
print "****** %s failed: %s" % (script, result)
finally:
os.chdir(cwd)
def run(self, config, year, *args, **kwargs):
"""Runs the travel model, using appropriate info from config.
"""
tm_config = config["travel_model_configuration"]
tm_data_dir = tm_config["directory"]
self.prepare_for_run(tm_config, year)
year_dir = tm_config[year] #'CoreEA0511202006\\urbansim\\2001'
dir_part1, dir_part2 = os.path.split(year_dir)
while dir_part1:
dir_part1, dir_part2 = os.path.split(dir_part1)
project_year_dir = os.path.join(
tm_data_dir, dir_part2) #C:/SEMCOG_baseline/CoreEA0511202006
logger.log_status('Start travel model from directory %s for year %d' %
(project_year_dir, year))
#for macroname, ui_db_file in tm_config['macro']['run_semcog_travel_model'].iteritems():
#pass
macroname, ui_db_file = tm_config['macro']['run_semcog_travel_model']
loops = 1
logger.log_status('Running travel model ...')
tcwcmd = win32api.GetShortPathName(tm_config['transcad_binary'])
os.system('start /B "start TransCAD" %s' %
tcwcmd) #start TransCAD in background
time.sleep(1)
#os.system("%s -a %s -ai '%s'" % (tcwcmd, ui_db_file, macroname))
run_transcad_macro(macroname, ui_db_file, loops)
try:
pass
##win32process.TerminateProcess(self.hProcess, 0)
except:
logger.log_warning(
"The code has problem to terminate the TransCAD it started.")
def fix_path(self, in_some_path_to_fix):
""" On Windows: to overcome cUrl inability to handle path with unicode chars, we try to calculate the windows
short path (DOS style 8.3 chars). The function that does that, win32api.GetShortPathName,
does not work for paths that do not yet exist so we need to also create the folder.
However if the creation requires admin permissions - it could fail -
in which case we revert to using the long path.
"""
fixed_path = PurePath(in_some_path_to_fix)
if 'Win' in utils.get_current_os_names():
# to overcome cUrl inability to handle path with unicode chars, we try to calculate the windows
# short path (DOS style 8.3 chars). The function that does that, win32api.GetShortPathName,
# does not work for paths that do not yet exist so we need to also create the folder.
# However if the creation requires admin permissions - it could fail -
# in which case we revert to using the long path.
import win32api
fixed_path_parent = str(fixed_path.parent)
fixed_path_name = str(fixed_path.name)
if fixed_path_parent not in self.short_win_paths_cache:
try:
os.makedirs(fixed_path_parent, exist_ok=True)
short_parent_path = win32api.GetShortPathName(
fixed_path_parent)
self.short_win_paths_cache[
fixed_path_parent] = short_parent_path
except Exception as e: # failed to mkdir or get the short path? never mind, just use the full path
self.short_win_paths_cache[
fixed_path_parent] = fixed_path_parent
log.warning(
f"""warning creating short path failed for {fixed_path}, {e}, using long path"""
)
short_file_path = os.path.join(
self.short_win_paths_cache[fixed_path_parent], fixed_path_name)
fixed_path = short_file_path.replace("\\", "\\\\")
return fixed_path
def testShortUnicodeNames(self):
try:
me = __file__
except NameError:
me = sys.argv[0]
fname = os.path.abspath(me).lower()
# passing unicode should cause GetShortPathNameW to be called.
short_name = win32api.GetShortPathName(str(fname)).lower()
self.assertTrue(isinstance(short_name, str))
long_name = win32api.GetLongPathName(short_name).lower()
self.assertTrue(
long_name == fname,
"Expected long name ('%s') to be original name ('%s')" % (long_name, fname),
)
self.assertEqual(long_name, win32api.GetLongPathNameW(short_name).lower())
long_name = win32api.GetLongPathNameW(short_name).lower()
self.assertTrue(
type(long_name) == str,
"GetLongPathNameW returned type '%s'" % (type(long_name),),
)
self.assertTrue(
long_name == fname,
"Expected long name ('%s') to be original name ('%s')" % (long_name, fname),
)
def __savelists__(self):
_dellist = MpGlobal.installPath+"sync_dellist.bat"
_cpylist = MpGlobal.installPath+"sync_copylist.bat"
_filelist = MpGlobal.installPath+"sync_filelist.txt"
# sorting the lists makes it easier to manually compare them
k = lambda record: record[1]
self.listc.sort(key = k)
self.listd.sort()
#self.filelist.sort()
#wf = open("./test_externalfilelist.txt","w")
#for item in self.filelist:
# wf.write( "%s\n"%item )
#wf.close()
wf = open(_dellist,"w")
wf.write( "@echo off\n" )
for item in self.listd:
wf.write( "DEL \"%s\"\n"%item )
wf.close()
wf = open(_cpylist,"w")
wf.write( "@echo off\n" )
for item in self.listdir:
wf.write( "md \"%s\"\n"%item )
for item in self.listc:
s0 = "\"%s\""%win32api.GetShortPathName(item[0].replace('/','\\'))
s1 = "\"%s\""%item[1]
wf.write( "copy %-70s %s\n"%(s0,s1) )
#wf.write( "%s\n"%(item[0]) )
#wf.write( "%s\n"%(item[1]) )
wf.close()
def filterdata(fname, **kwargs):
# read data
data = LocalExecutionModule.readSampleFromPsuadeFile(fname)
# process keyworded arguments
filterVar = None
vmin = None
vmax = None
for key in kwargs:
k = key.lower()
if k == 'input':
filterVar = kwargs[key]
cmd = 'ifilter'
# Get only input variables that are variable
types = data.getInputTypes()
inVarNames = SampleData.getInputNames(data)
varNames = []
for i in range(len(types)):
if types[i] == Model.VARIABLE:
varNames.append(inVarNames[i])
elif k == 'output':
filterVar = kwargs[key]
cmd = 'ofilter'
varNames = SampleData.getOutputNames(data)
elif k == 'vmin':
vmin = kwargs[key]
elif k == 'vmax':
vmax = kwargs[key]
if filterVar is None:
error = 'DataProcessor: In function filterData(), the filter variable is not specified.'
Common.showError(error)
return None
if (vmin is None) | (vmax is None) | (vmin >= vmax):
error = 'DataProcessor: filterData() requires a valid [min, max] range to filter the variable "%s".' % filterVar
Common.showError(error)
return None
# check if the filter variable exists
if filterVar not in varNames:
error = 'DataProcessor: In function filterData(), %s does not contain the filter variable "%s".' % (fname, filterVar)
Common.showError(error)
outfile = fname
return outfile
# get the output index to filter variable
filterIndex = varNames.index(filterVar) + 1 # psuade is 1-indexed
# write script
outfile = Common.getLocalFileName(DataProcessor.dname, fname, '.filtered')
f = tempfile.SpooledTemporaryFile(mode="wt")
if platform.system() == 'Windows':
import win32api
fname = win32api.GetShortPathName(fname)
f.write('load %s\n' % fname)
f.write('%s\n' % cmd) # invoke ifilter or ofilter
if (cmd == 'ifilter' and data.getNumInputs() > 1) or (cmd == 'ofilter' and data.getNumOutputs() > 1):
f.write('%d\n' % filterIndex) # select the filter variable
f.write('%f\n' % vmin) # extract points within range [vmin, vmax]
f.write('%f\n' % vmax)
if platform.system() == 'Windows':
head, tail = os.path.split(outfile)
head = win32api.GetShortPathName(head)
outfile = os.path.join(head, tail)
f.write('write %s\n' % outfile)
f.write('n\n') # write all outputs
f.write('quit\n')
f.seek(0)
# invoke psuade
out, error = Common.invokePsuade(f)
f.close()
# Process error
if error:
return None
if not os.path.exists(outfile):
error = 'DataProcessor: %s does not exist.' % outfile
Common.showError(error, out)
return None
return outfile
def real_path(path):
"""Get the real capitalisation of a path on Windows."""
if not os.path.exists(path):
return path
return win32api.GetLongPathNameW(win32api.GetShortPathName(path))
def getMetadata(self):
if self.dir.endswith(".zip"):
zpfile = zipfile.ZipFile(self.dir)
metadatafile = fnmatch.filter(zpfile.namelist(), "*/GRANULE/*/MTD_TL.xml")
if len(metadatafile) != 1 and self.tileID is not None:
metadatafile = fnmatch.filter(zpfile.namelist(), "*/GRANULE/*/*%s.xml" % self.tileID)
if len(metadatafile) != 1:
raise RuntimeError("No metadata file found!")
# Open metadata file
metaF = zpfile.open(metadatafile[0])
metainfo = eTree.parse(metaF)
rootElement = metainfo.getroot()
# Get IDs
self.ID = [child.text for child in rootElement.iter("TILE_ID")][0]
tileIDindex = self.ID.rfind("_T")+1
self.tileID = self.ID[tileIDindex:tileIDindex+6]
# Get date
datestring = [child.text for child in rootElement.iter("SENSING_TIME")][0]
self.cloudy = [float(child.text) for child in rootElement.iter("CLOUDY_PIXEL_PERCENTAGE")][0]
self.degraded = [float(child.text) for child in rootElement.iter("DEGRADED_MSI_DATA_PERCENTAGE")][0]
self.date = dt.strptime(datestring[:10], "%Y-%m-%d")
metaF.close()
zpfile.close()
else:
metadataMatches = []
if self.tileID is not None:
searchPattern = "*" + self.tileID + "*.xml"
else:
searchPattern = "*.xml"
for (root, dirnames, filenames) in os.walk(self.dir):
for d in fnmatch.filter(dirnames, "GRANULE"):
self.granuleDir = os.path.join(root, d)
for d in os.listdir(self.granuleDir):
for f in fnmatch.filter(os.listdir(os.path.join(self.granuleDir, d)), searchPattern):
metadataMatches.append(os.path.join(self.granuleDir, d, f))
if len(metadataMatches) != 1:
raise RuntimeError("No metadata file found!")
else:
metadatafile = metadataMatches[0]
self.metadatafile = os.path.join(win32api.GetShortPathName(os.path.dirname(metadatafile)), os.path.basename(metadatafile))
try:
metaF = open(self.metadatafile)
except IOError as e:
if len(self.metadatafile) > 256:
raise IOError("File path to metadata file is too long. Move scene to a different location to shorten the file path.")
else:
raise IOError("Meta data file could not be read.")
metainfo = eTree.parse(metaF)
rootElement = metainfo.getroot()
datestring = [child.text for child in rootElement.iter("SENSING_TIME")][0]
self.cloudy = [float(child.text) for child in rootElement.iter("CLOUDY_PIXEL_PERCENTAGE")][0]
self.degraded = [float(child.text) for child in rootElement.iter("DEGRADED_MSI_DATA_PERCENTAGE")][0]
self.date = dt.strptime(datestring[:10], "%Y-%m-%d")
self.ID = [child.text for child in rootElement.iter("TILE_ID")][0]
tileIDindex = self.ID.rfind("_T") + 1
self.tileID = self.ID[tileIDindex:tileIDindex + 6]
metaF.close()
import win32api
mypathraw = raw_input("Enter directory:")
if ( len(mypathraw) < 1 ) : mypath = r'g:\working'
else : mypath = mypathraw
#pprint.pprint(os.listdir(mypath))
#print mypath
for dirname, dirnames, filenames in os.walk(mypath):
print "DIRNAME: "
print dirname
print "DIRNAMES: "
print dirnames
print "FILENAMES: "
#pprint.pprint(filenames)
for fname in filenames:
#fnameshort = win32api.GetShortPathName(fname)
fname2 = os.path.join(dirname, fname)
#print fname2
fnameshort = win32api.GetShortPathName(fname2)
print fname2
#newfname = re.findall('.*Fantasy op.17 - (.*)', fname)
newfname = 'Schumann - ' + fname
print newfname
newfname2 = os.path.join(dirname, newfname)
#newfname2short = win32api.GetShortPathName(newfname2)
if os.path.isfile(fnameshort):
print "OK OK OK OK OK"
os.rename(fnameshort, newfname2)
def ReExecuteElevated(flags):
from win32com.shell.shell import ShellExecuteEx
from win32com.shell import shellcon
import win32process, win32event
import winxpgui # we've already checked we are running XP above
import tempfile
if not flags['quiet']:
print("Requesting elevation and retrying...")
new_params = " ".join(['"' + a + '"' for a in sys.argv])
# If we aren't already in unattended mode, we want our sub-process to
# be.
if not flags['unattended']:
new_params += " --unattended"
# specifying the parent means the dialog is centered over our window,
# which is a good usability clue.
# hwnd is unlikely on the command-line, but flags may come from elsewhere
hwnd = flags.get('hwnd', None)
if hwnd is None:
try:
hwnd = winxpgui.GetConsoleWindow()
except winxpgui.error:
hwnd = 0
# Redirect output so we give the user some clue what went wrong. This
# also means we need to use COMSPEC. However, the "current directory"
# appears to end up ignored - so we execute things via a temp batch file.
tempbase = tempfile.mktemp("pycomserverreg")
outfile = tempbase + ".out"
batfile = tempbase + ".bat"
try:
batf = open(batfile, "w")
try:
cwd = os.getcwd()
print("@echo off", file=batf)
# nothing is 'inherited' by the elevated process, including the
# environment. I wonder if we need to set more?
print("set PYTHONPATH=%s" % os.environ.get('PYTHONPATH', ''), file=batf)
# may be on a different drive - select that before attempting to CD.
print(os.path.splitdrive(cwd)[0], file=batf)
print('cd "%s"' % os.getcwd(), file=batf)
print('%s %s > "%s" 2>&1' % (win32api.GetShortPathName(sys.executable), new_params, outfile), file=batf)
finally:
batf.close()
executable = os.environ.get('COMSPEC', 'cmd.exe')
rc = ShellExecuteEx(hwnd=hwnd,
fMask=shellcon.SEE_MASK_NOCLOSEPROCESS,
lpVerb="runas",
lpFile=executable,
lpParameters='/C "%s"' % batfile,
nShow=win32con.SW_SHOW)
hproc = rc['hProcess']
win32event.WaitForSingleObject(hproc, win32event.INFINITE)
exit_code = win32process.GetExitCodeProcess(hproc)
outf = open(outfile)
try:
output = outf.read()
finally:
outf.close()
if exit_code:
# Even if quiet you get to see this message.
print("Error: registration failed (exit code %s)." % exit_code)
# if we are quiet then the output if likely to already be nearly
# empty, so always print it.
print(output, end=' ')
finally:
for f in (outfile, batfile):
try:
os.unlink(f)
except os.error as exc:
print("Failed to remove tempfile '%s': %s" % (f, exc))
def RegisterServer(clsid,
pythonInstString=None,
desc=None,
progID=None, verProgID=None,
defIcon=None,
threadingModel="both",
policy=None,
catids=[], other={},
addPyComCat=None,
dispatcher = None,
clsctx = None,
addnPath = None,
):
"""Registers a Python object as a COM Server. This enters almost all necessary
information in the system registry, allowing COM to use the object.
clsid -- The (unique) CLSID of the server.
pythonInstString -- A string holding the instance name that will be created
whenever COM requests a new object.
desc -- The description of the COM object.
progID -- The user name of this object (eg, Word.Document)
verProgId -- The user name of this version's implementation (eg Word.6.Document)
defIcon -- The default icon for the object.
threadingModel -- The threading model this object supports.
policy -- The policy to use when creating this object.
catids -- A list of category ID's this object belongs in.
other -- A dictionary of extra items to be registered.
addPyComCat -- A flag indicating if the object should be added to the list
of Python servers installed on the machine. If None (the default)
then it will be registered when running from python source, but
not registered if running in a frozen environment.
dispatcher -- The dispatcher to use when creating this object.
clsctx -- One of the CLSCTX_* constants.
addnPath -- An additional path the COM framework will add to sys.path
before attempting to create the object.
"""
### backwards-compat check
### Certain policies do not require a "class name", just the policy itself.
if not pythonInstString and not policy:
raise TypeError('You must specify either the Python Class or Python Policy which implement the COM object.')
keyNameRoot = "CLSID\\%s" % str(clsid)
_set_string(keyNameRoot, desc)
# Also register as an "Application" so DCOM etc all see us.
_set_string("AppID\\%s" % clsid, progID)
# Depending on contexts requested, register the specified server type.
# Set default clsctx.
if not clsctx:
clsctx = pythoncom.CLSCTX_INPROC_SERVER | pythoncom.CLSCTX_LOCAL_SERVER
# And if we are frozen, ignore the ones that don't make sense in this
# context.
if pythoncom.frozen:
assert sys.frozen, "pythoncom is frozen, but sys.frozen is not set - don't know the context!"
if sys.frozen == "dll":
clsctx = clsctx & pythoncom.CLSCTX_INPROC_SERVER
else:
clsctx = clsctx & pythoncom.CLSCTX_LOCAL_SERVER
# Now setup based on the clsctx left over.
if clsctx & pythoncom.CLSCTX_INPROC_SERVER:
# get the module to use for registration.
# nod to Gordon's installer - if sys.frozen and sys.frozendllhandle
# exist, then we are being registered via a DLL - use this DLL as the
# file name.
if pythoncom.frozen:
if hasattr(sys, "frozendllhandle"):
dllName = win32api.GetModuleFileName(sys.frozendllhandle)
else:
raise RuntimeError("We appear to have a frozen DLL, but I don't know the DLL to use")
else:
# Normal case - running from .py file, so register pythoncom's DLL.
# Although now we prefer a 'loader' DLL if it exists to avoid some
# manifest issues (the 'loader' DLL has a manifest, but pythoncom does not)
pythoncom_dir = os.path.dirname(pythoncom.__file__)
if pythoncom.__file__.find("_d") < 0:
suffix = ""
else:
suffix = "_d"
loadername = "pythoncomloader%d%d%s.dll" % (sys.version_info[0], sys.version_info[1], suffix)
if os.path.isfile(os.path.join(pythoncom_dir, loadername)):
dllName = loadername
else:
# just use pythoncom.
dllName = os.path.basename(pythoncom.__file__)
_set_subkeys(keyNameRoot + "\\InprocServer32",
{ None : dllName,
"ThreadingModel" : threadingModel,
})
else: # Remove any old InProcServer32 registrations
_remove_key(keyNameRoot + "\\InprocServer32")
if clsctx & pythoncom.CLSCTX_LOCAL_SERVER:
if pythoncom.frozen:
# If we are frozen, we write "{exe} /Automate", just
# like "normal" .EXEs do
exeName = win32api.GetShortPathName(sys.executable)
command = '%s /Automate' % (exeName,)
else:
# Running from .py sources - we need to write
# 'python.exe win32com\server\localserver.py {clsid}"
exeName = _find_localserver_exe(1)
exeName = win32api.GetShortPathName(exeName)
pyfile = _find_localserver_module()
command = '%s "%s" %s' % (exeName, pyfile, str(clsid))
_set_string(keyNameRoot + '\\LocalServer32', command)
else: # Remove any old LocalServer32 registrations
_remove_key(keyNameRoot + "\\LocalServer32")
if pythonInstString:
_set_string(keyNameRoot + '\\PythonCOM', pythonInstString)
else:
_remove_key(keyNameRoot + '\\PythonCOM')
if policy:
_set_string(keyNameRoot + '\\PythonCOMPolicy', policy)
else:
_remove_key(keyNameRoot + '\\PythonCOMPolicy')
if dispatcher:
_set_string(keyNameRoot + '\\PythonCOMDispatcher', dispatcher)
else:
_remove_key(keyNameRoot + '\\PythonCOMDispatcher')
if defIcon:
_set_string(keyNameRoot + '\\DefaultIcon', defIcon)
else:
_remove_key(keyNameRoot + '\\DefaultIcon')
if addnPath:
_set_string(keyNameRoot + "\\PythonCOMPath", addnPath)
else:
_remove_key(keyNameRoot + "\\PythonCOMPath")
if addPyComCat is None:
addPyComCat = pythoncom.frozen == 0
if addPyComCat:
catids = catids + [ CATID_PythonCOMServer ]
# Set up the implemented categories
if catids:
regCat = _cat_registrar()
regCat.RegisterClassImplCategories(clsid, catids)
# set up any other reg values they might have
if other:
for key, value in other.items():
_set_string(keyNameRoot + '\\' + key, value)
if progID:
# set the progID as the most specific that was given to us
if verProgID:
_set_string(keyNameRoot + '\\ProgID', verProgID)
else:
_set_string(keyNameRoot + '\\ProgID', progID)
# Set up the root entries - version independent.
if desc:
_set_string(progID, desc)
_set_string(progID + '\\CLSID', str(clsid))
# Set up the root entries - version dependent.
if verProgID:
# point from independent to the current version
_set_string(progID + '\\CurVer', verProgID)
# point to the version-independent one
_set_string(keyNameRoot + '\\VersionIndependentProgID', progID)
# set up the versioned progID
if desc:
_set_string(verProgID, desc)
_set_string(verProgID + '\\CLSID', str(clsid))
# submodules can use the absolute path. This is required e.g. if the
# current directorey changes prior to loading the hooks.
PACKAGEPATH = os.path.abspath(os.path.dirname(__file__))
HOMEPATH = os.path.dirname(PACKAGEPATH)
if is_win and is_py2:
# This ensures for Python 2 that PyInstaller will work on Windows
# with paths containing foreign characters.
try:
unicode(HOMEPATH)
except UnicodeDecodeError:
# Do conversion to ShortPathName really only in case HOMEPATH is not
# ascii only - conversion to unicode type cause this unicode error.
try:
import win32api
HOMEPATH = win32api.GetShortPathName(HOMEPATH)
except ImportError:
pass
# Update __version__ as necessary.
if os.path.exists(os.path.join(HOMEPATH, 'setup.py')):
# PyInstaller is run directly from source without installation or
# __version__ is called from 'setup.py' ...
if compat.getenv('PYINSTALLER_DO_RELEASE') == '1':
# Suppress the git revision when doing a release.
pass
elif 'sdist' not in sys.argv:
# and 'setup.py' was not called with 'sdist' argument.
# For creating source tarball we do not want git revision
# in the filename.
try:
def createPsuadeInFile(data, filename, includePDF=True):
outf = open(filename, 'w')
outf.write('PSUADE\n')
#Write inputs
outf.write('INPUT\n')
outf.write(' dimension = %d\n' % data.getNumInputs())
names = data.getInputNames()
mins = data.getInputMins()
maxs = data.getInputMaxs()
indices = list(range(data.getNumInputs()))
for i, name, minimum, maximum in zip(indices, names, mins, maxs):
outf.write(' variable %d %s = %e %e\n' %
(i + 1, name, minimum, maximum))
distributions = data.getInputDistributions()
for i, dist in zip(indices, distributions):
distType = dist.getDistributionType()
distParams = dist.getParameterValues()
if distType == Distribution.SAMPLE:
outf.write(' PDF %d %c' %
(i + 1, Distribution.getPsuadeName(distType)))
if distParams[0] is not None:
filename = distParams[0]
if platform.system() == 'Windows':
import win32api
filename = win32api.GetShortPathName(filename)
outf.write(' %s' % filename)
if distParams[1] is not None:
outf.write(' %d' % distParams[1])
outf.write('\n')
elif includePDF: # write out PDF info for all non-uniform PDF types
if distType != Distribution.UNIFORM:
outf.write(' PDF %d %c' %
(i + 1, Distribution.getPsuadeName(distType)))
if distParams[0] is not None:
outf.write(' %e' % distParams[0])
if distParams[1] is not None:
outf.write(' %e' % distParams[1])
outf.write('\n')
outf.write('END\n')
#Write outputs
outf.write('OUTPUT\n')
if data.getNumOutputs() == 0:
outf.write(' dimension = 1\n')
names = ['ghostOuput']
indices = list(range(1))
for i, name in zip(indices, names):
outf.write(' variable %d %s\n' % (i + 1, name))
else:
outf.write(' dimension = %d\n' % data.getNumOutputs())
names = data.getOutputNames()
indices = list(range(data.getNumOutputs()))
for i, name in zip(indices, names):
outf.write(' variable %d %s\n' % (i + 1, name))
outf.write('END\n')
#Write Method
outf.write('METHOD\n')
outf.write(' sampling = %s\n' %
SamplingMethods.getPsuadeName(data.getSampleMethod()))
outf.write(' num_samples = %d\n' % data.getNumSamples())
if data.getSampleMethod() != SamplingMethods.GMOAT:
outf.write(' randomize\n')
outf.write('END\n')
#Write Application
outf.write('APPLICATION\n')
driverString = data.getDriverName()
if driverString is None:
driverString = 'NONE'
elif platform.system() == 'Windows':
if os.path.exists(driverString):
import win32api
driverString = win32api.GetShortPathName(driverString)
else:
driverString = 'NONE'
driverString = 'NONE'
outf.write(' driver = %s\n' % driverString)
outf.write(' save_frequency = 1\n')
outf.write('END\n')
#Write Analysis
outf.write('ANALYSIS\n')
outf.write(' diagnostics 2\n')
outf.write('END\n')
outf.write('END\n')
outf.close()
