def _copyWalker(self, walkData):
staticFolder = False
for folder in self._staticPaths:
path = FileUtils.cleanupPath(walkData.folder, isDir=True)
folder = FileUtils.cleanupPath(folder, isDir=True)
if path == folder or FileUtils.isInFolder(path, folder):
staticFolder = True
break
copiedNames = []
for item in walkData.names:
if not staticFolder and not StringUtils.ends(item, self._FILE_COPY_TYPES):
continue
sourcePath = FileUtils.createPath(walkData.folder, item)
if os.path.isdir(sourcePath):
continue
destPath = FileUtils.changePathRoot(
sourcePath, self.sourceWebRootPath, self.targetWebRootPath)
try:
FileUtils.getDirectoryOf(destPath, createIfMissing=True)
shutil.copy(sourcePath, destPath)
lastModified = FileUtils.getUTCModifiedDatetime(sourcePath)
SiteProcessUtils.createHeaderFile(destPath, lastModified)
SiteProcessUtils.copyToCdnFolder(destPath, self, lastModified)
copiedNames.append(item)
except Exception, err:
self.writeLogError(u'Unable to copy file', error=err, extras={
'SOURCE':sourcePath,
'TARGET':destPath })
return
def initializeFromInternalPath(cls, referencePath, force =False):
""" Used to explicitly initialiize the pyglass environment when running inside the source
code respository with a standard structure where the repository root has a src and
a resources folder. """
if cls.isInitialized and not force:
return True
path = FileUtils.cleanupPath(referencePath, noTail=True)
if os.path.isfile(path):
path = FileUtils.getDirectoryOf(referencePath, noTail=True)
rootPath = None
while path:
srcPath = FileUtils.makeFolderPath(path, 'src', isDir=True)
resPath = FileUtils.makeFolderPath(path, 'resources', isDir=True)
if os.path.exists(srcPath) and os.path.exists(resPath):
rootPath = path
break
path = FileUtils.getDirectoryOf(path, noTail=True)
if not rootPath:
return False
cls._rootResourcePath = FileUtils.makeFolderPath(rootPath, 'resources')
cls._rootLocalResourcePath = FileUtils.makeFolderPath(rootPath, 'resources', 'local')
return True
def __init__(self):
"""Creates a new instance of PyGlassApplication."""
QtCore.QObject.__init__(self)
self._qApplication = None
self._window = None
self._splashScreen = None
# Sets a temporary standard out and error for deployed applications in a write allowed
# location to prevent failed write results.
if PyGlassEnvironment.isDeployed:
if appdirs:
userDir = appdirs.user_data_dir(self.appID, self.appGroupID)
else:
userDir = FileUtils.createPath(
os.path.expanduser('~'), '.pyglass', self.appGroupID, self.appID, isDir=True)
path = FileUtils.createPath(
userDir,
self.appID + '_out.log', isFile=True)
folder = FileUtils.getDirectoryOf(path, createIfMissing=True)
sys.stdout = open(path, 'w+')
FileUtils.createPath(
appdirs.user_data_dir(self.appID, self.appGroupID),
self.appID + '_error.log',
isFile=True)
folder = FileUtils.getDirectoryOf(path, createIfMissing=True)
sys.stderr = open(path, 'w+')
PyGlassEnvironment.initializeAppSettings(self)
def save(self, toPDF=True):
""" Writes the current _drawing in SVG format to the file specified at initialization. If
one wishes to have create a PDF file (same file name as used for the .SVG, but with
suffix .PDF), then call with toPDF True). """
if not self.siteMapReady:
return
# Make sure the directory where the file will be saved exists before saving
FileUtils.getDirectoryOf(self._drawing.filename, createIfMissing=True)
self._drawing.save()
# we're done if no PDF version is also required
if not toPDF:
return
# strip any extension off of the file name
basicName = self.fileName.split(".")[0]
# load up the command
cmd = ["/Applications/Inkscape.app/Contents/Resources/bin/inkscape", "-f", None, "-A", None]
cmd[2] = basicName + ".svg"
cmd[4] = basicName + ".pdf"
# and execute it
response = SystemUtils.executeCommand(cmd)
if response["error"]:
print("response[error]=%s" % response["error"])
def __init__(self, parent, test =True, install =True, check =False, verbose =True, **kwargs):
"""Creates a new instance of MayaIniRemoteThread."""
super(MayaIniRemoteThread, self).__init__(parent, **kwargs)
self._test = test
self._verbose = verbose
self._install = install
self._check = check
self._output = {}
self._cadenceEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath(
FileUtils.getDirectoryOf(cadence.__file__), noTail=True))
self._elixirEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath(
FileUtils.getDirectoryOf(elixir.__file__), noTail=True))
def _handleImportSitemaps(self):
self.mainWindow.showLoading(
self,
u'Browsing for Sitemap File',
u'Choose the Sitemap CSV file to import into the database')
path = PyGlassBasicDialogManager.browseForFileOpen(
parent=self,
caption=u'Select CSV File to Import',
defaultPath=self.mainWindow.appConfig.get(UserConfigEnum.LAST_BROWSE_PATH) )
self.mainWindow.hideLoading(self)
if not path or not StringUtils.isStringType(path):
self.mainWindow.toggleInteractivity(True)
return
# Store directory location as the last active directory
self.mainWindow.appConfig.set(
UserConfigEnum.LAST_BROWSE_PATH, FileUtils.getDirectoryOf(path) )
self.mainWindow.showStatus(
self,
u'Importing Sitemaps',
u'Reading sitemap information into database')
SitemapImporterRemoteThread(
parent=self,
path=path
).execute(
callback=self._sitemapImportComplete,
logCallback=self._handleImportStatusUpdate)
def rootPath(self):
if self._rootPath:
return self._rootPath
if self._appFilePath:
return FileUtils.getDirectoryOf(self._appFilePath)
return FileUtils.createPath(os.path.expanduser('~'), self.appName, isDir=True)
def initialize(my_path):
if os.path.isfile(my_path):
my_path = FileUtils.getDirectoryOf(my_path)
path = FileUtils.makeFolderPath(my_path, 'data')
SystemUtils.remove(path)
os.makedirs(path)
return path
def redirectLogOutputs(self, prefix =None, logFolderPath =None):
""" Sets a temporary standard out and error for deployed applications in a write allowed
location to prevent failed write results. """
if not PyGlassEnvironment.isDeployed:
return
if not prefix:
prefix = self.appID
if not prefix.endswith('_'):
prefix += '_'
if logFolderPath:
logPath = logFolderPath
elif PyGlassEnvironment.isInitialized:
logPath = PyGlassEnvironment.getRootLocalResourcePath('logs', isDir=True)
else:
prefix += 'init_'
if appdirs:
logPath = appdirs.user_data_dir(self.appID, self.appGroupID)
else:
logPath = FileUtils.createPath(
os.path.expanduser('~'), '.pyglass', self.appGroupID, self.appID, isDir=True)
FileUtils.getDirectoryOf(logPath, createIfMissing=True)
try:
sys.stdout.flush()
sys.stdout.close()
except Exception as err:
pass
sys.stdout = open(FileUtils.makeFilePath(logPath, prefix + 'out.log'), 'w+')
try:
sys.stderr.flush()
sys.stderr.close()
except Exception as err:
pass
sys.stderr = open(FileUtils.makeFilePath(logPath, prefix + 'error.log'), 'w+')
return True
def _getSourcePaths(cls, otherPaths =None):
nimbleEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath(
FileUtils.getDirectoryOf(nimble.__file__), noTail=True) )
pyaidEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath(
FileUtils.getDirectoryOf(pyaid.__file__), noTail=True) )
pyglassEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath(
FileUtils.getDirectoryOf(pyglass.__file__), noTail=True) )
additions = [nimbleEntry, pyaidEntry, pyglassEntry]
if not otherPaths:
return additions
for p in otherPaths:
additions.append(
p if isinstance(p, MayaEnvEntry) else
MayaEnvEntry.fromRootPath(p) )
return additions
def compileCss(cls, site, path):
outPath = FileUtils.changePathRoot(
path, site.sourceWebRootPath, site.targetWebRootPath)
FileUtils.getDirectoryOf(outPath, createIfMissing=True)
if site.isLocal:
shutil.copy(path, outPath)
site.writeLogSuccess(u'COPIED', unicode(path))
else:
cmd = cls.modifyNodeCommand([
FileUtils.createPath(
StaticFlowEnvironment.nodePackageManagerPath, 'minify', isFile=True),
'"%s"' % path,
'"%s"' % outPath])
iniDirectory = os.curdir
os.chdir(os.path.dirname(path))
result = SystemUtils.executeCommand(cmd)
if result['code']:
site.logger.write(unicode(result['error']))
site.writeLogError(u'CSS compilation failure:', extras={
'PATH':path,
'ERROR':result['error']})
os.chdir(iniDirectory)
return False
site.writeLogSuccess(u'COMPRESSED', unicode(path))
os.chdir(iniDirectory)
source = FileUtils.getContents(outPath)
if not source:
return False
FileUtils.putContents(
cls._CSS_CDN_IMAGE_RE.sub('url(\g<quote>' + site.cdnRootUrl + '/', source),
outPath)
lastModified = FileUtils.getUTCModifiedDatetime(path)
SiteProcessUtils.createHeaderFile(outPath, lastModified)
cls.copyToCdnFolder(outPath, site, lastModified)
return True
def _getSourcePaths(cls, otherPaths=None):
nimbleEntry = MayaEnvEntry.fromRootPath(
FileUtils.createPath(FileUtils.getDirectoryOf(nimble.__file__),
noTail=True))
pyaidEntry = MayaEnvEntry.fromRootPath(
FileUtils.createPath(FileUtils.getDirectoryOf(pyaid.__file__),
noTail=True))
pyglassEntry = MayaEnvEntry.fromRootPath(
FileUtils.createPath(FileUtils.getDirectoryOf(pyglass.__file__),
noTail=True))
additions = [nimbleEntry, pyaidEntry, pyglassEntry]
if not otherPaths:
return additions
for p in otherPaths:
additions.append(p if isinstance(p, MayaEnvEntry) else MayaEnvEntry
.fromRootPath(p))
return additions
def compileCoffeescript(cls, site, path):
csPath = FileUtils.cleanupPath(path, isFile=True)
outPath = FileUtils.changePathRoot(
csPath[:-6] + 'js', site.sourceWebRootPath, site.targetWebRootPath)
FileUtils.getDirectoryOf(outPath, createIfMissing=True)
outDir = os.path.dirname(outPath)
result = cls.compileCoffeescriptFile(csPath, outDir, minify=not site.isLocal)
if result['code']:
site.writeLogError(u'Failed to compile: "%s"' % unicode(path))
print result
return False
else:
site.writeLogSuccess(u'COMPILED', unicode(path))
lastModified = FileUtils.getUTCModifiedDatetime(csPath)
SiteProcessUtils.createHeaderFile(outPath, lastModified)
if site.isLocal:
return True
cls.copyToCdnFolder(outPath, site, lastModified)
site.writeLogSuccess(u'COMPRESSED', unicode(outPath))
return True
def copyToCdnFolder(cls, targetPath, processor, lastModified =None, headers =None):
if processor.isLocal:
return False
folder = targetPath[len(processor.targetWebRootPath):].replace('\\', '/').strip('/').split('/')
destPath = FileUtils.createPath(
processor.targetWebRootPath, processor.cdnRootFolder, folder, isFile=True)
destFolder = FileUtils.getDirectoryOf(destPath)
if not os.path.exists(destFolder):
os.makedirs(destFolder)
shutil.copy(targetPath, destPath)
if not headers:
headers = dict()
if 'Expires' not in headers:
headers['Expires'] = TimeUtils.dateTimeToWebTimestamp(
datetime.datetime.utcnow() + datetime.timedelta(days=360))
cls.createHeaderFile(destPath, lastModified=lastModified, headers=headers)
return True
def _handleExport(self):
self.mainWindow.showLoading(
self,
u'Browsing for Exporting File',
u'Choose the file location to save the export')
defaultPath = self.mainWindow.appConfig.get(UserConfigEnum.LAST_SAVE_PATH)
if not defaultPath:
defaultPath = self.mainWindow.appConfig.get(UserConfigEnum.LAST_BROWSE_PATH)
path = PyGlassBasicDialogManager.browseForFileSave(
parent=self, caption=u'Specify Export File', defaultPath=defaultPath)
self.mainWindow.hideLoading(self)
if not path:
self.mainWindow.toggleInteractivity(True)
return
# Store directory location as the last save directory
self.mainWindow.appConfig.set(
UserConfigEnum.LAST_SAVE_PATH,
FileUtils.getDirectoryOf(path) )
if not path.endswith('.json'):
path += '.json'
self.mainWindow.showStatus(
self,
u'Exporting Tracks',
u'Writing track information from database')
self._thread = TrackExporterRemoteThread(
self, path=path,
pretty=self.exportPrettyCheck.isChecked(),
compressed=self.exportCompressCheck.isChecked(),
difference=self.exportDiffCheck.isChecked())
self._thread.execute(
callback=self._handleImportComplete,
logCallback=self._handleImportStatusUpdate)
def _handleImport(self):
label = u'CSV'
importType = TrackImporterRemoteThread.CSV
self.mainWindow.showLoading(
self,
u'Browsing for Track File',
u'Choose the %s file to import into the database' % label)
path = PyGlassBasicDialogManager.browseForFileOpen(
parent=self,
caption=u'Select %s File to Import' % label,
defaultPath=self.mainWindow.appConfig.get(UserConfigEnum.LAST_BROWSE_PATH) )
self.mainWindow.hideLoading(self)
if not path or not StringUtils.isStringType(path):
self.mainWindow.toggleInteractivity(True)
return
# Store directory location as the last active directory
self.mainWindow.appConfig.set(
UserConfigEnum.LAST_BROWSE_PATH, FileUtils.getDirectoryOf(path) )
self.mainWindow.showStatus(
self,
u'Importing Tracks',
u'Reading track information into database')
TrackImporterRemoteThread(
parent=self,
path=path,
verbose=self.verboseDisplayCheck.isChecked(),
importType=importType,
compressed=False
).execute(
callback=self._handleImportComplete,
logCallback=self._handleImportStatusUpdate )
def _processFolderDefinitions(self, path):
cd = ConfigsDict(JSON.fromFile(path))
directory = FileUtils.getDirectoryOf(path)
for item in os.listdir(directory):
# Only find content source file types
if not StringUtils.ends(item, ('.sfml', '.html')):
continue
# Skip files that already have a definitions file
itemPath = FileUtils.createPath(directory, item, isFile=True)
itemDefsPath = itemPath.rsplit('.', 1)[0] + '.def'
if os.path.exists(itemDefsPath):
continue
test = SiteProcessUtils.testFileFilter(
itemPath,
cd.get(('FOLDER', 'EXTENSION_FILTER')),
cd.get(('FOLDER', 'NAME_FILTER')))
if not test:
continue
JSON.toFile(itemDefsPath, dict(), pretty=True)
return True
def modifyEnvFile(cls, target, install =True, test =False):
"""Doc..."""
pathSep = OsUtils.getPerOsValue(u';', u':')
nimblePath = FileUtils.createPath(
FileUtils.getDirectoryOf(nimble.__file__),
'..', isDir=True, noTail=True)
pyaidPath = FileUtils.createPath(
FileUtils.getDirectoryOf(pyaid.__file__),
'..', isDir=True, noTail=True)
pyglassPath = FileUtils.createPath(
FileUtils.getDirectoryOf(pyglass.__file__),
'..', isDir=True, noTail=True)
removals = []
additions = [nimblePath]
if not StringUtils.matches(pyaidPath, additions):
additions.append(pyaidPath)
if not StringUtils.matches(pyglassPath, additions):
additions.append(pyglassPath)
with open(target, 'r') as f:
contents = f.read()
result = cls._PYTHON_PATH_PATTERN.search(contents)
if not result:
if install:
contents += (u'\n' if contents else u'') + u'PYTHONPATH=' + pathSep.join(additions)
else:
return cls.MAYA_ENV_MODIFIED_RESULT_NT([], [])
else:
paths = result.groupdict()['paths'].split(pathSep)
index = 0
while index < len(paths):
if not additions:
break
p = paths[index]
# If path already exists don't add it again
if p in additions:
additions.remove(p)
if not install:
removals.append(p)
paths.remove(p)
else:
index += 1
continue
elif not install:
index += 1
continue
# Remove unrecognized paths that import nimble, pyaid, or pyglass
testPaths = [
FileUtils.createPath(p, u'nimble', isDir=True),
FileUtils.createPath(p, u'pyaid', isDir=True),
FileUtils.createPath(p, u'pyglass', isDir=True) ]
for test in testPaths:
if os.path.exists(test):
paths.remove(p)
continue
index += 1
paths += additions
contents = contents[:result.start()] + u'PYTHONPATH=' + pathSep.join(paths) \
+ u'\n' + contents[result.end():]
result = cls.MAYA_ENV_MODIFIED_RESULT_NT(additions if install else [], removals)
if test:
return result
with open(target, 'w') as f:
f.write(contents)
return result
# helloPythonImport.py
# (C)2014
# Scott Ernst
""" This example shows how to use the advanced import scripting in Nimble. """
from __future__ import print_function, absolute_import, unicode_literals, division
import sys
from pyaid.file.FileUtils import FileUtils
import nimble
# Add the src path for this example to the python system path for access to the scripts
scriptPath = FileUtils.createPath(FileUtils.getDirectoryOf(__file__),
'src',
isDir=True)
sys.path.append(scriptPath)
from helloPythonImportExample.scripts import CreateSpheres
# Create a Nimble connection object. This object will be used to send and receive across the
# nimble communication bridge between this script and the Nimble server running in Maya
conn = nimble.getConnection()
# Add the script src path to the Maya Python environment as well so that it can import and run
# the scripts directly
result = conn.addToMayaPythonPath(scriptPath)
if not result.success:
print(
'Unable to modify Maya Python path. Are you sure Maya is running a Nimble server?'
# helloPythonImport.py
# (C)2014
# Scott Ernst
""" This example shows how to use the advanced import scripting in Nimble. """
from __future__ import print_function, absolute_import, unicode_literals, division
import sys
from pyaid.file.FileUtils import FileUtils
import nimble
# Add the src path for this example to the python system path for access to the scripts
scriptPath = FileUtils.createPath(FileUtils.getDirectoryOf(__file__), 'src', isDir=True)
sys.path.append(scriptPath)
from helloPythonImportExample.scripts import CreateSpheres
# Create a Nimble connection object. This object will be used to send and receive across the
# nimble communication bridge between this script and the Nimble server running in Maya
conn = nimble.getConnection()
# Add the script src path to the Maya Python environment as well so that it can import and run
# the scripts directly
result = conn.addToMayaPythonPath(scriptPath)
if not result.success:
print('Unable to modify Maya Python path. Are you sure Maya is running a Nimble server?')
print(result)
sys.exit(1)
def getProjectPath(*args, **kwargs):
return FileUtils.createPath(
FileUtils.getDirectoryOf(__file__),
'..', '..', *args, **kwargs)
#---------------------------------------------------------------------------------------------------
# INITIALIZE PYGLASS ENVIRONMENT
# When running outside of a PyGlass application, the PyGlass environment must be initialized
# explicitly, including specifying the relationship between the run script (this file) and
# the resource directory. This must be done before importing database classes so that the
# database import correctly locates the database file and initializes the model classes to
# that file.
from pyaid.system.SystemUtils import SystemUtils
from pyaid.file.FileUtils import FileUtils
from pyglass.app.PyGlassEnvironment import PyGlassEnvironment
location = FileUtils.getDirectoryOf(__file__)
PyGlassEnvironment.initializeExplicitAppSettings(
FileUtils.createPath(location, '..', 'resources', isDir=True),
FileUtils.createPath(location, '..', 'resources', 'local', isDir=True) )
#---------------------------------------------------------------------------------------------------
# RUN TEST SCRIPT
from cadence.models.tracks.Tracks_SiteMap import Tracks_SiteMap
from cadence.svg.CadenceDrawing import CadenceDrawing
model = Tracks_SiteMap.MASTER
session = model.createSession()
siteMap = session.query(model).filter(model.index == 13).first()
fileName = 'test_new.svg'
# Scott Ernst
from __future__ import \
print_function, absolute_import, \
unicode_literals, division
import os
import re
import sqlalchemy as sqla
import pandas as pd
from pyaid.file.FileUtils import FileUtils
ROOT_PROJECT_PATH = FileUtils.makeFolderPath(
FileUtils.getDirectoryOf(__file__), '..', '..')
_data = None
#_______________________________________________________________________________
def getProjectPath(*args, **kwargs):
""" Creates an absolute path from the relative path arguments within the
project folder.
"""
return FileUtils.createPath(ROOT_PROJECT_PATH, *args, **kwargs)
#_______________________________________________________________________________
def getResourcesPath(*args, **kwargs):
""" Creates an absolute path from the relative path arguments within the
project folder.
"""
# initializeStatsEnv.py
# (C)2015
# Scott Ernst
from __future__ import print_function, absolute_import, unicode_literals, division
import sys
import os
from pyaid.file.FileUtils import FileUtils
from pyaid.string.StringUtils import StringUtils
from pyaid.system.SystemUtils import SystemUtils
rootPath = FileUtils.getDirectoryOf(__file__)
#---------------------------------------------------------------------------------------------------
# INPUTS
inputPath = FileUtils.createPath('input', isDir=True)
if os.path.exists(inputPath):
SystemUtils.remove(inputPath)
os.makedirs(inputPath)
localDatabasePath = FileUtils.createPath(
rootPath, '..', 'resources', 'local', 'apps', 'Cadence', 'data', isDir=True)
if not os.path.exists(localDatabasePath):
print('[ERROR]: No local database resource folder exists')
sys.exit(1)
for filename in os.listdir(localDatabasePath):
# Scott Ernst
from __future__ import print_function, absolute_import, unicode_literals, division
import os
import sys
from pyaid.file.FileUtils import FileUtils
from pyaid.json.JSON import JSON
from pyaid.system.SystemUtils import SystemUtils
FOLDER_NAME = 'Statistical-Results'
#---------------------------------------------------------------------------------------------------
rootPath = FileUtils.getDirectoryOf(__file__)
localAnalysisPath = FileUtils.makeFolderPath(rootPath, '..', 'resources', 'local', 'analysis')
analysisConfigPath = FileUtils.makeFilePath(localAnalysisPath, 'analysis.json')
config = JSON.fromFile(analysisConfigPath)
if 'OUTPUT_PATH' not in config:
rootTargetPath = localAnalysisPath
else:
rootTargetPath = FileUtils.cleanupPath(config['OUTPUT_PATH'], isDir=True)
targetPath = FileUtils.makeFolderPath(rootTargetPath, FOLDER_NAME)
if os.path.exists(targetPath):
SystemUtils.remove(targetPath)
import locale
import numpy as np
import pandas as pd
import plotly.graph_objs as plotlyGraph
from cadence.analysis.shared import DataLoadUtils, PlotConfigs
from cadence.analysis.shared.plotting import PlotlyUtils
from plotly import plotly
################################################################################
locale.setlocale(locale.LC_ALL, ('en_US', 'utf8'))
PLOTLY_FOLDER = 'Comparison'
MY_DIR = FileUtils.getDirectoryOf(__file__)
DATA_DIR = FileUtils.makeFolderPath(MY_DIR, 'data')
OUT_PATH = FileUtils.makeFilePath(DATA_DIR, 'deviation.h5')
METADATA_FILE = FileUtils.makeFilePath(DATA_DIR, 'deviation.metadata.json')
#_______________________________________________________________________________
def _getLayout(
metadata, title, fixed = False, xAxis =None, yAxis =None, **kwargs
):
if not xAxis:
xAxis = {}
xAxis.setdefault('title', 'Deviation (%)')
if not yAxis:
yAxis = {}
yAxis.setdefault('title', 'Frequency')
def _handleReplaceDatabase(self):
self.mainWindow.showLoading(
self,
u'Browsing for Database File',
u'Choose a valid database (*.vcd) file')
defaultPath = self.appConfig.get(UserConfigEnum.DATABASE_IMPORT_PATH)
if not defaultPath:
defaultPath = self.appConfig.get(UserConfigEnum.LAST_BROWSE_PATH)
path = PyGlassBasicDialogManager.browseForFileOpen(
parent=self,
caption=u'Select Database File',
defaultPath=defaultPath)
self.mainWindow.hideLoading(self)
if not path:
self.mainWindow.toggleInteractivity(True)
return
# Store directory for later use
self.appConfig.set(
UserConfigEnum.DATABASE_IMPORT_PATH,
FileUtils.getDirectoryOf(path) )
self.mainWindow.showStatus(
self,
u'Replacing Database File',
u'Removing existing database file and replacing it with selection')
sourcePath = getattr(Tracks_Track, 'URL')[len(u'sqlite:'):].lstrip(u'/')
if not OsUtils.isWindows():
sourcePath = u'/' + sourcePath
savePath = '%s.store' % sourcePath
try:
if os.path.exists(savePath):
SystemUtils.remove(savePath, throwError=True)
except Exception as err:
self.mainWindow.appendStatus(
self, u'<span style="color:#CC3333">ERROR: Unable to access database save location.</span>')
self.mainWindow.showStatusDone(self)
return
try:
SystemUtils.move(sourcePath, savePath)
except Exception as err:
self.mainWindow.appendStatus(
self, u'<span style="color:#CC3333;">ERROR: Unable to modify existing database file.</span>')
self.mainWindow.showStatusDone(self)
return
try:
SystemUtils.copy(path, sourcePath)
except Exception as err:
SystemUtils.move(savePath, sourcePath)
self.mainWindow.appendStatus(
self, u'<span style="color:#CC3333;">ERROR: Unable to copy new database file.</span>')
self.mainWindow.showStatusDone(self)
return
if os.path.exists(savePath):
SystemUtils.remove(savePath)
self.mainWindow.appendStatus(self, u'<span style="color:#33CC33;">Database Replaced</span>')
self.mainWindow.showStatusDone(self)
def targetPath(self):
""" Absolute path to the location where the rss file will be generated. """
return FileUtils.createPath(
FileUtils.getDirectoryOf(self.page.targetPath), 'rss.xml', isFile=True)
