eric: comparison src/eric7/Project/Project.py

-:2b015db9761a
+:ba20efe10336
 pyqtSlot,
 )
 from PyQt6.QtGui import QAction, QKeySequence
 from PyQt6.QtWidgets import QDialog, QInputDialog, QLineEdit, QMenu, QToolBar
-from eric7 import Globals, Preferences, Utilities
+from eric7 import EricUtilities, Preferences, Utilities
 from eric7.CodeFormatting.BlackFormattingAction import BlackFormattingAction
 from eric7.CodeFormatting.BlackUtilities import aboutBlack
 from eric7.CodeFormatting.IsortFormattingAction import IsortFormattingAction
 from eric7.CodeFormatting.IsortUtilities import aboutIsort
 from eric7.EricGui import EricPixmapCache
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.EricWidgets.EricListSelectionDialog import EricListSelectionDialog
 from eric7.EricWidgets.EricProgressDialog import EricProgressDialog
 from eric7.Globals import recentNameProject
+from eric7.RemoteServerInterface import EricServerFileDialog
 from eric7.Sessions.SessionFile import SessionFile
 from eric7.SystemUtilities import (
 FileSystemUtilities,
 OSUtilities,
 PythonUtilities,
 eols = [os.linesep, "\n", "\r", "\r\n"]
 DefaultMake = "make"
 DefaultMakefile = "makefile"
-def __init__(self, parent=None, filename=None):
+def __init__(self, parent=None, filename=None, remoteServer=None):
 """
 Constructor
 @param parent parent widget (usually the ui object)
 @type QWidget
-@param filename optional filename of a project file to open
+@param filename optional filename of a project file to open (defaults to None)
-@type str
+@type str (optional)
+@param remoteServer reference to the 'eric-ide' server interface object
+@type EricServerInterface
 """
 super().__init__(parent)
 self.ui = parent
+self.__remoteServer = remoteServer
+self.__remotefsInterface = remoteServer.getServiceInterface("FileSystem")
 self.__progLanguages = [
 "Python3",
 "MicroPython",
 "Ruby",
 if filename is not None:
 self.openProject(filename)
 else:
 self.vcs = self.initVCS()
-self.__model = ProjectBrowserModel(self)
+self.__model = ProjectBrowserModel(self, fsInterface=self.__remotefsInterface)
 self.codemetrics = None
 self.codecoverage = None
 self.profiledata = None
 self.applicationDiagram = None
 self.translationsRoot = ""  # the translations prefix
 self.name = ""
 self.opened = False
 self.subdirs = []
 # record the project dir as a relative path (i.e. empty path)
-self.otherssubdirs = []
 self.vcs = None
 self.vcsRequested = False
 self.dbgVirtualEnv = ""
 self.dbgCmdline = ""
 self.dbgWd = ""
 self.recent = []
 Preferences.Prefs.rsettings.sync()
 rp = Preferences.Prefs.rsettings.value(recentNameProject)
 if rp is not None:
 for f in rp:
-if pathlib.Path(f).exists():
+if (
+FileSystemUtilities.isRemoteFileName(f)
+and (
+not self.__remoteServer.isServerConnected()
+or self.__remotefsInterface.exists(f)
+)
+) or pathlib.Path(f).exists():
 self.recent.append(f)
 def __saveRecent(self):
 """
 Private method to save the list of recently opened filenames.
 @param index key of the list to be checked
 @type str
 """
 removed = False
 removelist = []
-for file in self.__pdata[index]:
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-if not os.path.exists(os.path.join(self.ppath, file)):
+for file in self.__pdata[index]:
-removelist.append(file)
+if not self.__remotefsInterface.exists(
-removed = True
+self.__remotefsInterface.join(self.ppath, file)
+):
+removelist.append(file)
+removed = True
+else:
+for file in self.__pdata[index]:
+if not os.path.exists(os.path.join(self.ppath, file)):
+removelist.append(file)
+removed = True
 if removed:
 for file in removelist:
 self.__pdata[index].remove(file)
 self.setDirty(True)
 def __readProject(self, fn):
 """
-Private method to read in a project (.epj) file.
+Private method to read in a project file (.epj).
 @param fn filename of the project file to be read
 @type str
 @return flag indicating success
 @rtype bool
 """
 with EricOverrideCursor():
 res = self.__projectFile.readFile(fn)
 if res:
-self.pfile = os.path.abspath(fn)
+if FileSystemUtilities.isRemoteFileName(fn):
-self.ppath = os.path.abspath(os.path.dirname(fn))
+self.pfile = fn
+self.ppath = self.__remotefsInterface.dirname(fn)
+self.name = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(fn)
+)[0]
+self.__remotefsInterface.populateFsCache(self.ppath)
+else:
+self.pfile = os.path.abspath(fn)
+self.ppath = os.path.abspath(os.path.dirname(fn))
+self.name = os.path.splitext(os.path.basename(fn))[0]
 # insert filename into list of recently opened projects
 self.__syncRecent()
 if self.__pdata["TRANSLATIONPATTERN"]:
 self.translationsRoot = self.__pdata["TRANSLATIONPATTERN"].split(
 "%language%"
 )[0]
 elif self.__pdata["MAINSCRIPT"]:
 self.translationsRoot = os.path.splitext(self.__pdata["MAINSCRIPT"])[0]
-if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
-dn = self.translationsRoot
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+if self.__remotefsInterface.isdir(
+self.__remotefsInterface.join(self.ppath, self.translationsRoot)
+):
+dn = self.translationsRoot
+else:
+dn = self.__remotefsInterface.dirname(self.translationsRoot)
 else:
-dn = os.path.dirname(self.translationsRoot)
+if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
-if dn not in self.subdirs:
+dn = self.translationsRoot
+else:
+dn = os.path.dirname(self.translationsRoot)
+if dn and dn not in self.subdirs:
 self.subdirs.append(dn)
-self.name = os.path.splitext(os.path.basename(fn))[0]
 # check, if the files of the project still exist in the
 # project directory
 for fileCategory in self.getFileCategories():
 self.__checkFilesExist(fileCategory)
 # get the names of subdirectories the files are stored in
 for fileCategory in [c for c in self.getFileCategories() if c != "OTHERS"]:
 for fn in self.__pdata[fileCategory]:
-dn = os.path.dirname(fn)
+dn = (
-if dn not in self.subdirs:
+self.__remotefsInterface.dirname(fn)
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else os.path.dirname(fn)
+)
+if dn and dn not in self.subdirs:
 self.subdirs.append(dn)
 # get the names of other subdirectories
 for fn in self.__pdata["OTHERS"]:
-dn = os.path.dirname(fn)
+dn = (
-if dn not in self.otherssubdirs:
+self.__remotefsInterface.dirname(fn)
-self.otherssubdirs.append(dn)
+if FileSystemUtilities.isRemoteFileName(fn)
+else os.path.dirname(fn)
+)
 return res
 def __writeProject(self, fn=None):
 """
 with EricOverrideCursor():
 res = self.__projectFile.writeFile(fn)
 if res:
-self.pfile = os.path.abspath(fn)
+if FileSystemUtilities.isRemoteFileName(fn):
-self.ppath = os.path.abspath(os.path.dirname(fn))
+self.pfile = fn
-self.name = os.path.splitext(os.path.basename(fn))[0]
+self.ppath = self.__remotefsInterface.dirname(fn)
+self.name = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(fn)
+)[0]
+else:
+self.pfile = os.path.abspath(fn)
+self.ppath = os.path.abspath(os.path.dirname(fn))
+self.name = os.path.splitext(os.path.basename(fn))[0]
 self.setDirty(False)
 # insert filename into list of recently opened projects
 self.__syncRecent()
 Private method to read in the user specific project file (.eqj).
 """
 if self.pfile is None:
 return
-fn1, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.eqj".format(fn1))
+fn1, _ext = self.__remotefsInterface.splitext(
-if os.path.exists(fn):
+self.__remotefsInterface.basename(self.pfile)
-self.__userProjectFile.readFile(fn)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.eqj"
+)
+if not self.__remotefsInterface.exists(fn):
+return
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.eqj")
+if not os.path.exists(fn):
+return
+self.__userProjectFile.readFile(fn)
 def __writeUserProperties(self):
 """
 Private method to write the user specific project data to a JSON file.
 """
 if self.pfile is None:
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.eqj".format(fn))
+fn1, _ext = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.eqj"
+)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.eqj")
 with EricOverrideCursor():
 self.__userProjectFile.writeFile(fn)
 def __showContextMenuSession(self):
 """
 enable = True
 if self.pfile is None:
 enable = False
 else:
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn_sess = os.path.join(self.getProjectManagementDir(), "{0}.esj".format(fn))
+fn, _ext = self.__remotefsInterface.splitext(
-enable = os.path.exists(fn_sess)
+self.__remotefsInterface.basename(self.pfile)
+)
+fn_sess = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn}.esj"
+)
+enable = self.__remotefsInterface.exists(fn)
+else:
+fn, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn_sess = os.path.join(self.getProjectManagementDir(), f"{fn}.esj")
+enable = os.path.exists(fn_sess)
 self.sessActGrp.findChild(QAction, "project_load_session").setEnabled(enable)
 self.sessActGrp.findChild(QAction, "project_delete_session").setEnabled(enable)
 @pyqtSlot()
 def __readSession(self, quiet=False, indicator=""):
 self.tr("Read Project Session"),
 self.tr("Please save the project first."),
 )
 return
-fn1, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(
+fn1, _ext = self.__remotefsInterface.splitext(
-self.getProjectManagementDir(), "{0}{1}.esj".format(fn1, indicator)
+self.__remotefsInterface.basename(self.pfile)
 )
-if os.path.exists(fn):
+fn = self.__remotefsInterface.join(
-self.__sessionFile.readFile(fn)
+self.getProjectManagementDir(), f"{fn1}{indicator}.esj"
+)
+if not self.__remotefsInterface.exists(fn):
+return
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}{indicator}.esj")
+if not os.path.exists(fn):
+return
+self.__sessionFile.readFile(fn)
 @pyqtSlot()
 def __writeSession(self, quiet=False, indicator=""):
 """
 Private method to write the session data to an XML file (.esj).
 self.tr("Save Project Session"),
 self.tr("Please save the project first."),
 )
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(
+fn1, _ext = self.__remotefsInterface.splitext(
-self.getProjectManagementDir(), "{0}{1}.esj".format(fn, indicator)
+self.__remotefsInterface.basename(self.pfile)
 )
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}{indicator}.esj"
+)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}{indicator}.esj")
 self.__sessionFile.writeFile(fn)
 def __deleteSession(self):
 """
 self.tr("Delete Project Session"),
 self.tr("Please save the project first."),
 )
 return
-fname, ext = os.path.splitext(os.path.basename(self.pfile))
+try:
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), f"{fname}.esj")
+title = self.tr("Delete Remote Project Session")
-if os.path.exists(fn):
+fname, _ext = self.__remotefsInterface.splitext(
-try:
+self.__remotefsInterface.basename(self.pfile)
-os.remove(fn)
-except OSError:
-EricMessageBox.critical(
-self.ui,
-self.tr("Delete Project Session"),
-self.tr(
-"<p>The project session file <b>{0}</b> could"
-" not be deleted.</p>"
-).format(fn),
 )
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fname}.esj"
+)
+if self.__remotefsInterface.exists(fn):
+self.__remotefsInterface.remove(fn)
+else:
+title = self.tr("Delete Project Session")
+fname, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fname}.esj")
+if os.path.exists(fn):
+os.remove(fn)
+except OSError:
+EricMessageBox.critical(
+self.ui,
+title,
+self.tr(
+"<p>The project session file <b>{0}</b> could"
+" not be deleted.</p>"
+).format(fn),
+)
 def __readTasks(self):
 """
 Private method to read in the project tasks file (.etj).
 """
 self.tr("Read Tasks"),
 self.tr("Please save the project first."),
 )
 return
-base, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.etj".format(base))
+base, _ext = self.__remotefsInterface.splitext(
-if os.path.exists(fn):
+self.__remotefsInterface.basename(self.pfile)
-self.__tasksFile.readFile(fn)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{base}.etj"
+)
+if not self.__remotefsInterface.exists(fn):
+return
+else:
+base, ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{base}.etj")
+if not os.path.exists(fn):
+return
+self.__tasksFile.readFile(fn)
 def writeTasks(self):
 """
 Public method to write the tasks data to a JSON file (.etj).
 """
 if self.pfile is None:
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
+base, _ext = self.__remotefsInterface.splitext(
-fn = os.path.join(self.getProjectManagementDir(), "{0}.etj".format(fn))
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{base}.etj"
+)
+else:
+base, ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{base}.etj")
 self.__tasksFile.writeFile(fn)
 def __showContextMenuDebugger(self):
 """
 Private slot called before the Debugger menu is shown.
 """
 enable = True
 if self.pfile is None:
 enable = False
 else:
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.edj".format(fn))
+fn1, _ext = self.__remotefsInterface.splitext(
-enable = os.path.exists(fn)
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.edj"
+)
+enable = self.__remotefsInterface.exists(fn)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.edj")
+enable = os.path.exists(fn)
 self.dbgActGrp.findChild(
 QAction, "project_debugger_properties_load"
 ).setEnabled(enable)
 self.dbgActGrp.findChild(
 QAction, "project_debugger_properties_delete"
 self.tr("Read Debugger Properties"),
 self.tr("Please save the project first."),
 )
 return
-fn1, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.edj".format(fn1))
+fn1, _ext = self.__remotefsInterface.splitext(
-if os.path.exists(fn) and self.__debuggerPropertiesFile.readFile(fn):
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.edj"
+)
+if not self.__remotefsInterface.exists(fn):
+return
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.edj")
+if not os.path.exists(fn):
+return
+if self.__debuggerPropertiesFile.readFile(fn):
 self.debugPropertiesLoaded = True
 self.debugPropertiesChanged = False
 @pyqtSlot()
 def __writeDebugProperties(self, quiet=False):
 self.tr("Save Debugger Properties"),
 self.tr("Please save the project first."),
 )
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.edj".format(fn))
+fn1, _ext = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.edj"
+)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.edj")
 with EricOverrideCursor():
 self.__debuggerPropertiesFile.writeFile(fn)
 def __deleteDebugProperties(self):
 self.tr("Delete Debugger Properties"),
 self.tr("Please save the project first."),
 )
 return
-fname, ext = os.path.splitext(os.path.basename(self.pfile))
+try:
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), f"{fname}.edj")
+title = self.tr("Delete Remote Debugger Properties")
-if os.path.exists(fn):
+fname, _ext = self.__remotefsInterface.splitext(
-try:
+self.__remotefsInterface.basename(self.pfile)
-os.remove(fn)
-except OSError:
-EricMessageBox.critical(
-self.ui,
-self.tr("Delete Debugger Properties"),
-self.tr(
-"<p>The project debugger properties file"
-" <b>{0}</b> could not be deleted.</p>"
-).format(fn),
 )
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fname}.edj"
+)
+if self.__remotefsInterface.exists(fn):
+self.__remotefsInterface.remove(fn)
+else:
+title = self.tr("Delete Debugger Properties")
+fname, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fname}.edj")
+if os.path.exists(fn):
+os.remove(fn)
+except OSError:
+EricMessageBox.critical(
+self.ui,
+title,
+self.tr(
+"<p>The project debugger properties file"
+" <b>{0}</b> could not be deleted.</p>"
+).format(fn),
+)
 def __initDebugProperties(self):
 """
 Private method to initialize the debug properties.
 """
 """
 Private slot to display the debugger properties dialog.
 """
 from .DebuggerPropertiesDialog import DebuggerPropertiesDialog
-dlg = DebuggerPropertiesDialog(self)
+dlg = DebuggerPropertiesDialog(
+self, isRemote=FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 dlg.storeData()
 def getDebugProperty(self, key):
 """
 @param key key of the property
 @type str
 @return value of the property
 @rtype Any
 """
-if key == "INTERPRETER":
+if key == "INTERPRETER" and not FileSystemUtilities.isRemoteFileName(
+self.ppath
+):
 return (
 ericApp()
 .getObject("VirtualEnvManager")
 .getVirtualenvInterpreter(self.debugProperties["VIRTUALENV"])
 )
 """
 tbPath = self.__pdata["TRANSLATIONSBINPATH"]
 for langFile in self.__pdata["TRANSLATIONS"][:]:
 qmFile = self.__binaryTranslationFile(langFile)
 if qmFile:
-if qmFile not in self.__pdata["TRANSLATIONS"] and os.path.exists(
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-os.path.join(self.ppath, qmFile)
+if qmFile not in self.__pdata[
-):
+"TRANSLATIONS"
-self.appendFile(qmFile)
+] and self.__remotefsInterface.exists(
-if tbPath:
+self.__remotefsInterface.join(self.ppath, qmFile)
-qmFile = os.path.join(tbPath, os.path.basename(qmFile))
+):
+self.appendFile(qmFile)
+if tbPath:
+qmFile = self.__remotefsInterface.join(
+tbPath, self.__remotefsInterface.basename(qmFile)
+)
+if qmFile not in self.__pdata[
+"TRANSLATIONS"
+] and self.__remotefsInterface.exists(
+self.__remotefsInterface.join(self.ppath, qmFile)
+):
+self.appendFile(qmFile)
+else:
 if qmFile not in self.__pdata["TRANSLATIONS"] and os.path.exists(
 os.path.join(self.ppath, qmFile)
 ):
 self.appendFile(qmFile)
+if tbPath:
+qmFile = os.path.join(tbPath, os.path.basename(qmFile))
+if qmFile not in self.__pdata[
+"TRANSLATIONS"
+] and os.path.exists(os.path.join(self.ppath, qmFile)):
+self.appendFile(qmFile)
 def removeLanguageFile(self, langFile):
 """
 Public slot to remove a translation from the project.
 self.__model.removeItem(langFile)
 self.__pdata["TRANSLATIONS"].remove(langFile)
 if qmFile:
 with contextlib.suppress(ValueError):
 if self.__pdata["TRANSLATIONSBINPATH"]:
-qmFile = self.getRelativePath(
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-os.path.join(
+qmFile = self.__remotefsInterface.join(
 self.__pdata["TRANSLATIONSBINPATH"],
-os.path.basename(qmFile),
+self.__remotefsInterface.basename(qmFile),
 )
-)
+else:
+qmFile = self.getRelativePath(
+os.path.join(
+self.__pdata["TRANSLATIONSBINPATH"],
+os.path.basename(qmFile),
+)
+)
 self.__model.removeItem(qmFile)
 self.__pdata["TRANSLATIONS"].remove(qmFile)
 self.setDirty(True)
 def deleteLanguageFile(self, langFile):
 """
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 try:
-fn = os.path.join(self.ppath, langFile)
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-if os.path.exists(fn):
+fn = self.__remotefsInterface.join(self.ppath, langFile)
-os.remove(fn)
+if self.__remotefsInterface.exists(fn):
+self.__remotefsInterface.remove(fn)
+else:
+fn = os.path.join(self.ppath, langFile)
+if os.path.exists(fn):
+os.remove(fn)
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
-self.tr("Delete translation"),
+self.tr("Delete Translation"),
 self.tr(
 "<p>The selected translation file <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>"
 ).format(langFile, str(err)),
 )
 """
 dirty = False
 # make it relative to the project root, if it starts with that path
 # assume relative paths are relative to the project root
-newfn = self.getRelativePath(fn) if os.path.isabs(fn) else fn
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-newdir = os.path.dirname(newfn)
+newfn = self.getRelativePath(fn) if fn.startswith(self.ppath) else fn
+newdir = self.__remotefsInterface.dirname(newfn)
+else:
+newfn = self.getRelativePath(fn) if os.path.isabs(fn) else fn
+newdir = os.path.dirname(newfn)
 if isSourceFile:
 filetype = "SOURCES"
 else:
 filetype = "OTHERS"
-bfn = os.path.basename(newfn)
+bfn = (
+self.__remotefsInterface.basename(newfn)
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else os.path.basename(newfn)
+)
 if fnmatch.fnmatch(bfn, "*.ts") or fnmatch.fnmatch(bfn, "*.qm"):
 filetype = "TRANSLATIONS"
 else:
 for pattern in sorted(self.__pdata["FILETYPES"], reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
 self.__pdata["OTHERS"].append(newfn)
 self.othersAdded(newfn, updateModel)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
-if newdir not in self.otherssubdirs:
-self.otherssubdirs.append(newdir)
 if dirty:
 self.setDirty(True)
 @pyqtSlot()
 dlg = AddFileDialog(self, self.parent(), fileTypeFilter, startdir=startdir)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 fnames, target, isSource = dlg.getData()
 if target != "":
+isRemote = FileSystemUtilities.isRemoteFileName(target)
 for fn in fnames:
-targetfile = os.path.join(target, os.path.basename(fn))
+targetfile = (
-if not FileSystemUtilities.samepath(os.path.dirname(fn), target):
+self.__remotefsInterface.join(
+target, self.__remotefsInterface.basename(fn)
+)
+if isRemote
+else os.path.join(target, os.path.basename(fn))
+)
+if not FileSystemUtilities.samepath(
+(
+self.__remotefsInterface.dirname(fn)
+if isRemote
+else os.path.dirname(fn)
+),
+target,
+):
 try:
-if not os.path.isdir(target):
+if isRemote:
-os.makedirs(target)
+if not self.__remotefsInterface.isdir(target):
+self.__remotefsInterface.makedirs(target)
-if os.path.exists(targetfile):
+else:
+if not os.path.isdir(target):
+os.makedirs(target)
+if (not isRemote and os.path.exists(targetfile)) or (
+isRemote and self.__remotefsInterface.exists(targetfile)
+):
 res = EricMessageBox.yesNo(
 self.ui,
-self.tr("Add file"),
+self.tr("Add File"),
 self.tr(
 "<p>The file <b>{0}</b> already"
 " exists.</p><p>Overwrite it?</p>"
 ).format(targetfile),
 icon=EricMessageBox.Warning,
 )
 if not res:
 return  # don't overwrite
-shutil.copy(fn, target)
+if isRemote:
+self.__remotefsInterface.shutilCopy(fn, target)
+else:
+shutil.copy(fn, target)
 except OSError as why:
 EricMessageBox.critical(
 self.ui,
-self.tr("Add file"),
+self.tr("Add File"),
 self.tr(
 "<p>The selected file <b>{0}</b> could"
 " not be added to <b>{1}</b>.</p>"
 "<p>Reason: {2}</p>"
 ).format(fn, target, str(why)),
 patterns.append(pattern)
 elif patterntype == "__IGNORE__":
 ignorePatterns.append(pattern)
 files = []
+isRemote = FileSystemUtilities.isRemoteFileName(target)
 for pattern in patterns:
-sstring = "{0}{1}{2}".format(source, os.sep, pattern)
+if isRemote:
-files.extend(glob.glob(sstring))
+sstring = self.__remotefsInterface.join(source, pattern)
+files.extend(self.__remotefsInterface.glob(sstring))
+else:
+sstring = os.path.join(source, pattern)
+files.extend(glob.glob(sstring))
 if len(files) == 0:
 if not quiet:
 EricMessageBox.information(
 self.ui,
-self.tr("Add directory"),
+self.tr("Add Directory"),
 self.tr(
 "<p>The source directory doesn't contain"
 " any files belonging to the selected category.</p>"
 ),
 )
 return
-if not FileSystemUtilities.samepath(target, source) and not os.path.isdir(
+if not FileSystemUtilities.samepath(target, source) and not (
-target
+(not isRemote and os.path.isdir(target))
+or (isRemote and self.__remotefsInterface.isdir(target))
 ):
 try:
-os.makedirs(target)
+if isRemote:
+self.__remotefsInterface.makedirs(target)
+else:
+os.makedirs(target)
 except OSError as why:
 EricMessageBox.critical(
 self.ui,
-self.tr("Add directory"),
+self.tr("Add Directory"),
 self.tr(
 "<p>The target directory <b>{0}</b> could not be"
 " created.</p><p>Reason: {1}</p>"
 ).format(target, str(why)),
 )
 for file in files:
 for pattern in ignorePatterns:
 if fnmatch.fnmatch(file, pattern):
 continue
-targetfile = os.path.join(target, os.path.basename(file))
+targetfile = (
+self.__remotefsInterface.join(
+target, self.__remotefsInterface.basename(file)
+)
+if isRemote
+else os.path.join(target, os.path.basename(file))
+)
 if not FileSystemUtilities.samepath(target, source):
 try:
-if os.path.exists(targetfile):
+if (not isRemote and os.path.exists(targetfile)) or (
+isRemote and self.__remotefsInterface.exists(targetfile)
+):
 res = EricMessageBox.yesNo(
 self.ui,
-self.tr("Add directory"),
+self.tr("Add Directory"),
 self.tr(
 "<p>The file <b>{0}</b> already exists.</p>"
 "<p>Overwrite it?</p>"
 ).format(targetfile),
 icon=EricMessageBox.Warning,
 )
 if not res:
 continue
 # don't overwrite, carry on with next file
-shutil.copy(file, target)
+if isRemote:
+self.__remotefsInterface.shutilCopy(file, target)
+else:
+shutil.copy(file, target)
 except OSError:
 continue
 self.appendFile(targetfile)
 def __addRecursiveDirectory(self, filetype, source, target):
 pattern
 for pattern, filetype in self.__pdata["FILETYPES"].items()
 if filetype == "__IGNORE__"
 ]
-# now recurse into subdirectories
+# now recurs into subdirectories
-with os.scandir(source) as dirEntriesIterator:
+if FileSystemUtilities.isRemoteFileName(target):
-for dirEntry in dirEntriesIterator:
+for entry in self.__remotefsInterface.listdir(source)[2]:
-if dirEntry.is_dir() and not any(
+if entry["is_dir"] and not any(
-fnmatch.fnmatch(dirEntry.name, ignore_pattern)
+fnmatch.fnmatch(entry["name"], ignore_pattern)
 for ignore_pattern in ignore_patterns
 ):
 self.__addRecursiveDirectory(
-filetype, dirEntry.path, os.path.join(target, dirEntry.name)
+filetype,
+entry["path"],
+self.__remotefsInterface.join(target, entry["name"]),
 )
+else:
+with os.scandir(source) as dirEntriesIterator:
+for dirEntry in dirEntriesIterator:
+if dirEntry.is_dir() and not any(
+fnmatch.fnmatch(dirEntry.name, ignore_pattern)
+for ignore_pattern in ignore_patterns
+):
+self.__addRecursiveDirectory(
+filetype, dirEntry.path, os.path.join(target, dirEntry.name)
+)
 @pyqtSlot()
 def addDirectory(self, fileTypeFilter=None, startdir=None):
 """
 Public method used to add all files of a directory to the project.
 @param fn file name or directory name to add
 @type str
 """
 if fn:
+separator = (
+self.__remotefsInterface.separator()
+if FileSystemUtilities.isRemoteFileName(fn)
+else os.sep
+)
 # if it is below the project directory, make it relative to that
 fn = self.getRelativePath(fn)
 # if it ends with the directory separator character, remove it
-if fn.endswith(os.sep):
+if fn.endswith(separator):
 fn = fn[:-1]
 if fn not in self.__pdata["OTHERS"]:
 self.__pdata["OTHERS"].append(fn)
 self.othersAdded(fn)
 self.setDirty(True)
-if os.path.isdir(fn) and fn not in self.otherssubdirs:
-self.otherssubdirs.append(fn)
 def renameMainScript(self, oldfn, newfn):
 """
 Public method to rename the main script.
 @param oldfn old filename
 @param newfn new filename of the file
 @type str
 @return flag indicating success
 @rtype bool
 """
+isRemote = FileSystemUtilities.isRemoteFileName(oldfn)
 fn = self.getRelativePath(oldfn)
 isSourceFile = fn in self.__pdata["SOURCES"]
 if newfn is None:
-newfn = EricFileDialog.getSaveFileName(
+if isRemote:
-None,
+newfn = EricServerFileDialog.getSaveFileName(
-self.tr("Rename file"),
+None,
-oldfn,
+self.tr("Rename File"),
-"",
+oldfn,
-options=EricFileDialog.DontConfirmOverwrite,
+"",
 )
+else:
+newfn = EricFileDialog.getSaveFileName(
+None,
+self.tr("Rename File"),
+oldfn,
+"",
+options=EricFileDialog.DontConfirmOverwrite,
+)
+if newfn:
+newfn = FileSystemUtilities.toNativeSeparators(newfn)
 if not newfn:
 return False
-newfn = FileSystemUtilities.toNativeSeparators(newfn)
+if (not isRemote and os.path.exists(newfn)) or (
-if os.path.exists(newfn):
+isRemote and self.__remotefsInterface.exists(newfn)
+):
 res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Rename File"),
 self.tr(
 """<p>The file <b>{0}</b> already exists."""
 )
 if not res:
 return False
 try:
-os.rename(oldfn, newfn)
+if isRemote:
+self.__remotefsInterface.replace(oldfn, newfn)
+else:
+os.rename(oldfn, newfn)
 except OSError as msg:
 EricMessageBox.critical(
 self.ui,
 self.tr("Rename File"),
 self.tr(
 @type str
 @param isSourceFile flag indicating that this is a source file
 even if it doesn't have the source extension
 @type bool
 """
+if FileSystemUtilities.isRemoteFileName(oldname):
+oldDirName = self.__remotefsInterface.dirname(oldname)
+newDirName = self.__remotefsInterface.dirname(newname)
+else:
+oldDirName = os.path.dirname(oldname)
+newDirName = os.path.dirname(newname)
 fn = self.getRelativePath(oldname)
-if os.path.dirname(oldname) == os.path.dirname(newname):
+if oldDirName == newDirName:
 if self.__isInPdata(oldname):
 self.removeFile(oldname, False)
 self.appendFile(newname, isSourceFile, False)
 self.__model.renameItem(fn, newname)
 else:
 @param start prefix
 @type str
 @return list of files starting with a common prefix
 @rtype list of str
 """
+isRemote = FileSystemUtilities.isRemoteFileName(self.ppath)
 filelist = []
 start = self.getRelativePath(start)
 for fileCategory in [
 c for c in self.getFileCategories() if c != "TRANSLATIONS"
 ]:
 for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(start):
-filelist.append(os.path.join(self.ppath, entry))
+filelist.append(
+self.__remotefsInterface.join(self.ppath, entry)
+if isRemote
+else os.path.join(self.ppath, entry)
+)
 return filelist
 def __reorganizeFiles(self):
 """
 Private method to reorganize files stored in the project.
 """
 reorganized = False
+isRemote = FileSystemUtilities.isRemoteFileName(self.ppath)
-# init data store for the reorganization
+# initialize data store for the reorganization
 newPdata = {}
 for fileCategory in self.getFileCategories():
 newPdata[fileCategory] = []
 # iterate over all files checking for a reassignment
 for fileCategory in self.getFileCategories():
 for fn in self.__pdata[fileCategory][:]:
 filetype = fileCategory
-bfn = os.path.basename(fn)
+bfn = (
+self.__remotefsInterface.basename(fn)
+if isRemote
+else os.path.basename(fn)
+)
 for pattern in sorted(self.__pdata["FILETYPES"], reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
 filetype = self.__pdata["FILETYPES"][pattern]
 break
 @param olddn original directory name
 @type str
 @param newdn new directory name
 @type str
 """
+isRemote = FileSystemUtilities.isRemoteFileName(self.ppath)
 olddn = self.getRelativePath(olddn)
 newdn = self.getRelativePath(newdn)
 for fileCategory in [
 c for c in self.getFileCategories() if c != "TRANSLATIONS"
 ]:
 for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(olddn):
 entry = entry.replace(olddn, newdn)
 self.appendFile(
-os.path.join(self.ppath, entry), fileCategory == "SOURCES"
+(
+self.__remotefsInterface.join(self.ppath, entry)
+if isRemote
+else os.path.join(self.ppath, entry)
+),
+fileCategory == "SOURCES",
 )
 self.setDirty(True)
 def moveDirectory(self, olddn, newdn):
 """
 if fileCategory not in typeStrings:
 typeStrings.append(fileCategory)
 self.__pdata[fileCategory].remove(entry)
 entry = entry.replace(olddn, newdn)
 self.__pdata[fileCategory].append(entry)
-if fileCategory == "OTHERS":
+if fileCategory != "OTHERS" and newdn not in self.subdirs:
-if newdn not in self.otherssubdirs:
+self.subdirs.append(newdn)
-self.otherssubdirs.append(newdn)
-else:
-if newdn not in self.subdirs:
-self.subdirs.append(newdn)
 if typeStrings:
 # the directory is controlled by the project
 self.setDirty(True)
 self.__model.removeItem(olddn)
 typeString = typeStrings[0]
 The directory is not deleted from the project directory.
 @param dn directory name to be removed from the project
 @type str
 """
+separator = (
+self.__remotefsInterface.separator()
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else os.sep
+)
 dirty = False
 dn = self.getRelativePath(dn)
 for entry in self.__pdata["OTHERS"][:]:
 if entry.startswith(dn):
 self.__pdata["OTHERS"].remove(entry)
 dirty = True
-dn2 = dn if dn.endswith(os.sep) else dn + os.sep
+dn2 = dn if dn.endswith(separator) else dn + separator
 for fileCategory in [c for c in self.getFileCategories() if c != "OTHERS"]:
 for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(dn2):
 self.__pdata[fileCategory].remove(entry)
 dirty = True
 @type str
 @return flag indicating success
 @rtype bool
 """
 try:
-os.remove(os.path.join(self.ppath, fn))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-path, ext = os.path.splitext(fn)
+self.__remotefsInterface.remove(
-if ext == ".ui":
+self.__remotefsInterface.join(self.ppath, fn)
-fn2 = os.path.join(self.ppath, "{0}.h".format(fn))
-if os.path.isfile(fn2):
-os.remove(fn2)
-head, tail = os.path.split(path)
-for ext in [".pyc", ".pyo"]:
-fn2 = os.path.join(self.ppath, path + ext)
-if os.path.isfile(fn2):
-os.remove(fn2)
-pat = os.path.join(
-self.ppath, head, "__pycache__", "{0}.*{1}".format(tail, ext)
 )
-for f in glob.glob(pat):
+filepath = self.__remotefsInterface.splitext(fn)[0]
-os.remove(f)
+head, tail = self.__remotefsInterface.split(filepath)
+for ext in [".pyc", ".pyo"]:
+fn2 = self.__remotefsInterface.join(self.ppath, filepath + ext)
+if self.__remotefsInterface.isfile(fn2):
+self.__remotefsInterface.remove(fn2)
+pat = self.__remotefsInterface.join(
+self.ppath, head, "__pycache__", "{0}.*{1}".format(tail, ext)
+)
+for f in self.__remotefsInterface.glob(pat):
+self.__remotefsInterface.remove(f)
+else:
+os.remove(os.path.join(self.ppath, fn))
+filepath = os.path.splitext(fn)[0]
+head, tail = os.path.split(filepath)
+for ext in [".pyc", ".pyo"]:
+fn2 = os.path.join(self.ppath, filepath + ext)
+if os.path.isfile(fn2):
+os.remove(fn2)
+pat = os.path.join(
+self.ppath, head, "__pycache__", "{0}.*{1}".format(tail, ext)
+)
+for f in glob.glob(pat):
+os.remove(f)
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
-self.tr("Delete file"),
+self.tr("Delete File"),
 self.tr(
 "<p>The selected file <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>"
 ).format(fn, str(err)),
 )
 return False
 self.removeFile(fn)
-if ext == ".ui":
-self.removeFile(fn + ".h")
 return True
 def deleteDirectory(self, dn):
 """
 Public method to delete a directory from the project directory.
 @param dn directory name to be removed from the project
 @type str
 @return flag indicating success
 @rtype bool
 """
-if not os.path.isabs(dn):
+dn = self.getAbsolutePath(dn)
-dn = os.path.join(self.ppath, dn)
 try:
-shutil.rmtree(dn, ignore_errors=True)
+if FileSystemUtilities.isRemoteFileName(dn):
+self.__remotefsInterface.shutilRmtree(dn, ignore_errors=True)
+else:
+shutil.rmtree(dn, ignore_errors=True)
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
-self.tr("Delete directory"),
+self.tr("Delete Directory"),
 self.tr(
 "<p>The selected directory <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>"
 ).format(dn, str(err)),
 )
 Public slot to built a new project.
 This method displays the new project dialog and initializes
 the project object with the data entered.
 """
+#       assume remote project without VCS if connected to server
 from eric7.VCS.CommandOptionsDialog import VcsCommandOptionsDialog
 from .PropertiesDialog import PropertiesDialog
 if not self.checkDirty():
 return
-dlg = PropertiesDialog(self, new=True)
+isRemote = self.__remoteServer.isServerConnected()
+dlg = PropertiesDialog(self, new=True, isRemote=isRemote)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 self.closeProject()
 # reset the auto save flag
 autoSaveProject = Preferences.getProject("AutoSaveProject")
 self.initFileTypes()
 self.setDirty(True)
 self.reloadAct.setEnabled(True)
 self.closeAct.setEnabled(True)
 self.saveasAct.setEnabled(True)
+self.saveasRemoteAct.setEnabled(
+self.__remoteServer.isServerConnected()
+and FileSystemUtilities.isRemoteFileName(self.pfile)
+)
 self.actGrp2.setEnabled(True)
 self.propsAct.setEnabled(True)
-self.userPropsAct.setEnabled(True)
+self.userPropsAct.setEnabled(not isRemote)
 self.filetypesAct.setEnabled(True)
 self.lexersAct.setEnabled(True)
 self.sessActGrp.setEnabled(False)
 self.dbgActGrp.setEnabled(True)
 self.menuDebuggerAct.setEnabled(True)
 self.menuSessionAct.setEnabled(False)
 self.menuCheckAct.setEnabled(True)
 self.menuShowAct.setEnabled(True)
 self.menuDiagramAct.setEnabled(True)
-self.menuApidocAct.setEnabled(True)
+self.menuApidocAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.menuPackagersAct.setEnabled(True)
-self.pluginGrp.setEnabled(self.__pdata["PROJECTTYPE"] in ["E7Plugin"])
+self.pluginGrp.setEnabled(
+self.__pdata["PROJECTTYPE"] in ["E7Plugin"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.addLanguageAct.setEnabled(bool(self.__pdata["TRANSLATIONPATTERN"]))
-self.makeGrp.setEnabled(self.__pdata["MAKEPARAMS"]["MakeEnabled"])
+self.makeGrp.setEnabled(
-self.menuMakeAct.setEnabled(self.__pdata["MAKEPARAMS"]["MakeEnabled"])
+self.__pdata["MAKEPARAMS"]["MakeEnabled"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
+self.menuMakeAct.setEnabled(
+self.__pdata["MAKEPARAMS"]["MakeEnabled"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.menuOtherToolsAct.setEnabled(True)
-self.menuFormattingAct.setEnabled(True)
+self.menuFormattingAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
+self.menuVcsAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.projectAboutToBeCreated.emit()
 hashStr = str(
 QCryptographicHash.hash(
 self.__pdata["LEXERASSOCS"] = {
 "*.py": "MicroPython",
 }
 # create the project directory if it doesn't exist already
-if not os.path.isdir(self.ppath):
+ppathExists = (
+self.__remotefsInterface.isdir(self.ppath)
+if isRemote
+else os.path.isdir(self.ppath)
+)
+if not ppathExists:
 try:
-os.makedirs(self.ppath)
+if isRemote:
+self.__remotefsInterface.makedirs(self.ppath)
+else:
+os.makedirs(self.ppath)
 except OSError:
 EricMessageBox.critical(
 self.ui,
 self.tr("Create project directory"),
 self.tr(
 return
 # create an empty __init__.py file to make it a Python package
 # (only for Python and Python3)
 if self.__pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
-fn = os.path.join(self.ppath, "__init__.py")
+if isRemote:
-with open(fn, "w", encoding="utf-8"):
+fn = self.__remotefsInterface.join(self.ppath, "__init__.py")
-pass
+self.__remotefsInterface.writeFile(fn, b"")
+else:
+fn = os.path.join(self.ppath, "__init__.py")
+with open(fn, "w", encoding="utf-8"):
+pass
 self.appendFile(fn, True)
 # create an empty main script file, if a name was given
 if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
+if isRemote:
-ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+if not self.__remotefsInterface.isabs(
+self.__pdata["MAINSCRIPT"]
+):
+ms = self.__remotefsInterface.join(
+self.ppath, self.__pdata["MAINSCRIPT"]
+)
+else:
+ms = self.__pdata["MAINSCRIPT"]
+self.__remotefsInterface.makedirs(
+self.__remotefsInterface.dirname(ms), exist_ok=True
+)
+self.__remotefsInterface.writeFile(ms, b"")
 else:
-ms = self.__pdata["MAINSCRIPT"]
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-os.makedirs(os.path.dirname(ms), exist_ok=True)
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
-with open(ms, "w"):
+else:
-pass
+ms = self.__pdata["MAINSCRIPT"]
+os.makedirs(os.path.dirname(ms), exist_ok=True)
+with open(ms, "w"):
+pass
 self.appendFile(ms, True)
-if self.__pdata["MAKEPARAMS"]["MakeEnabled"]:
+if self.__pdata["MAKEPARAMS"]["MakeEnabled"] and not isRemote:
 mf = self.__pdata["MAKEPARAMS"]["MakeFile"]
 if mf:
 if not os.path.isabs(mf):
 mf = os.path.join(self.ppath, mf)
 else:
 os.makedirs(os.path.dirname(mf), exist_ok=True)
 with open(mf, "w"):
 pass
 self.appendFile(mf)
-tpd = os.path.join(self.ppath, self.translationsRoot)
+if isRemote:
-if not self.translationsRoot.endswith(os.sep):
+tpd = self.__remotefsInterface.join(
-tpd = os.path.dirname(tpd)
+self.ppath, self.translationsRoot
-if not os.path.isdir(tpd):
+)
-os.makedirs(tpd, exist_ok=True)
+if not self.translationsRoot.endswith(
-if self.__pdata["TRANSLATIONSBINPATH"]:
+self.__remotefsInterface.separator()
-tpd = os.path.join(self.ppath, self.__pdata["TRANSLATIONSBINPATH"])
+):
+tpd = self.__remotefsInterface.dirname(tpd)
+if not self.__remotefsInterface.isdir(tpd):
+self.__remotefsInterface.makedirs(tpd, exist_ok=True)
+if self.__pdata["TRANSLATIONSBINPATH"]:
+tpd = self.__remotefsInterface.join(
+self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
+)
+if not self.__remotefsInterface.isdir(tpd):
+self.__remotefsInterface.makedirs(tpd, exist_ok=True)
+else:
+tpd = os.path.join(self.ppath, self.translationsRoot)
+if not self.translationsRoot.endswith(os.sep):
+tpd = os.path.dirname(tpd)
 if not os.path.isdir(tpd):
 os.makedirs(tpd, exist_ok=True)
+if self.__pdata["TRANSLATIONSBINPATH"]:
+tpd = os.path.join(
+self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
+)
+if not os.path.isdir(tpd):
+os.makedirs(tpd, exist_ok=True)
 # create management directory if not present
 self.createProjectManagementDir()
 self.saveProject()
 # set the auto save flag to its supposed value
 Preferences.setProject("AutoSaveProject", autoSaveProject)
 return
 if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
+if isRemote:
-ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+if not self.__remotefsInterface.isabs(
+self.__pdata["MAINSCRIPT"]
+):
+ms = self.__remotefsInterface.join(
+self.ppath, self.__pdata["MAINSCRIPT"]
+)
+else:
+ms = self.__pdata["MAINSCRIPT"]
+msExists = self.__remotefsInterface.exists(ms)
 else:
-ms = self.__pdata["MAINSCRIPT"]
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-if not os.path.exists(ms):
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+else:
+ms = self.__pdata["MAINSCRIPT"]
+msExists = os.path.exists(ms)
+if not msExists:
 try:
-os.makedirs(os.path.dirname(ms), exist_ok=True)
+if isRemote:
-with open(ms, "w"):
+self.__remotefsInterface.makedirs(
-pass
+self.__remotefsInterface.dirname(ms), exist_ok=True
+)
+self.__remotefsInterface.writeFile(ms, b"")
+else:
+os.makedirs(os.path.dirname(ms), exist_ok=True)
+with open(ms, "w"):
+pass
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
 self.tr("Create main script"),
 self.tr(
-"<p>The mainscript <b>{0}</b> could not"
+"<p>The main script <b>{0}</b> could not"
 " be created.<br/>Reason: {1}</p>"
 ).format(ms, str(err)),
 )
 self.appendFile(ms, True)
 else:
 ms = ""
-if self.__pdata["MAKEPARAMS"]["MakeEnabled"]:
+if self.__pdata["MAKEPARAMS"]["MakeEnabled"] and not isRemote:
 mf = self.__pdata["MAKEPARAMS"]["MakeFile"]
 if mf:
 if not os.path.isabs(mf):
 mf = os.path.join(self.ppath, mf)
 else:
 self.tr("New Project"),
 self.tr("""Add existing files to the project?"""),
 yesDefault=True,
 )
 if res:
-self.newProjectAddFiles(ms)
+self.newProjectAddFiles(ms, isRemote=isRemote)
-addAllToVcs = res
+addAllToVcs = res and not isRemote
 # create an empty __init__.py file to make it a Python package
 # if none exists (only for Python and Python3)
 if self.__pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
-fn = os.path.join(self.ppath, "__init__.py")
+if isRemote:
-if not os.path.exists(fn):
+fn = self.__remotefsInterface.join(self.ppath, "__init__.py")
-with open(fn, "w", encoding="utf-8"):
+if not self.__remotefsInterface.exists(fn):
-pass
+self.__remotefsInterface.writeFile(fn, b"")
 self.appendFile(fn, True)
+else:
+fn = os.path.join(self.ppath, "__init__.py")
+if not os.path.exists(fn):
+with open(fn, "w", encoding="utf-8"):
+pass
+self.appendFile(fn, True)
 self.saveProject()
 # check, if the existing project directory is already under
 # VCS control
-pluginManager = ericApp().getObject("PluginManager")
+if not isRemote:
-for indicator, vcsData in list(
+pluginManager = ericApp().getObject("PluginManager")
-pluginManager.getVcsSystemIndicators().items()
+for indicator, vcsData in list(
-):
+pluginManager.getVcsSystemIndicators().items()
-if os.path.exists(os.path.join(self.ppath, indicator)):
+):
-if len(vcsData) > 1:
+if os.path.exists(os.path.join(self.ppath, indicator)):
-vcsList = []
+if len(vcsData) > 1:
-for _vcsSystemStr, vcsSystemDisplay in vcsData:
+vcsList = []
-vcsList.append(vcsSystemDisplay)
+for _vcsSystemStr, vcsSystemDisplay in vcsData:
-res, vcs_ok = QInputDialog.getItem(
+vcsList.append(vcsSystemDisplay)
-None,
+res, vcs_ok = QInputDialog.getItem(
-self.tr("New Project"),
+None,
-self.tr("Select Version Control System"),
+self.tr("New Project"),
-vcsList,
+self.tr("Select Version Control System"),
-0,
+vcsList,
-False,
+0,
-)
+False,
-if vcs_ok:
+)
-for vcsSystemStr, vcsSystemDisplay in vcsData:
+if vcs_ok:
-if res == vcsSystemDisplay:
+for vcsSystemStr, vcsSystemDisplay in vcsData:
-vcsSystem = vcsSystemStr
+if res == vcsSystemDisplay:
-break
+vcsSystem = vcsSystemStr
+break
+else:
+vcsSystem = "None"
 else:
 vcsSystem = "None"
 else:
-vcsSystem = "None"
+vcsSystem = vcsData[0][1]
-else:
+self.__pdata["VCS"] = vcsSystem
-vcsSystem = vcsData[0][1]
+self.vcs = self.initVCS()
-self.__pdata["VCS"] = vcsSystem
+self.setDirty(True)
-self.vcs = self.initVCS()
+if self.vcs is not None:
-self.setDirty(True)
+# edit VCS command options
-if self.vcs is not None:
+if self.vcs.vcsSupportCommandOptions():
-# edit VCS command options
+vcores = EricMessageBox.yesNo(
-if self.vcs.vcsSupportCommandOptions():
+self.ui,
-vcores = EricMessageBox.yesNo(
+self.tr("New Project"),
-self.ui,
+self.tr(
-self.tr("New Project"),
+"""Would you like to edit the VCS"""
-self.tr(
+""" command options?"""
-"""Would you like to edit the VCS"""
+),
-""" command options?"""
+)
-),
+else:
-)
+vcores = False
+if vcores:
+codlg = VcsCommandOptionsDialog(self.vcs)
+if codlg.exec() == QDialog.DialogCode.Accepted:
+self.vcs.vcsSetOptions(codlg.getOptions())
+# add project file to repository
+if res == 0:
+apres = EricMessageBox.yesNo(
+self.ui,
+self.tr("New Project"),
+self.tr(
+"Shall the project file be added"
+" to the repository?"
+),
+yesDefault=True,
+)
+if apres:
+self.saveProject()
+self.vcs.vcsAdd(self.pfile)
 else:
-vcores = False
+self.__pdata["VCS"] = "None"
-if vcores:
+self.saveProject()
-codlg = VcsCommandOptionsDialog(self.vcs)
+break
-if codlg.exec() == QDialog.DialogCode.Accepted:
-self.vcs.vcsSetOptions(codlg.getOptions())
-# add project file to repository
-if res == 0:
-apres = EricMessageBox.yesNo(
-self.ui,
-self.tr("New project"),
-self.tr(
-"Shall the project file be added"
-" to the repository?"
-),
-yesDefault=True,
-)
-if apres:
-self.saveProject()
-self.vcs.vcsAdd(self.pfile)
-else:
-self.__pdata["VCS"] = "None"
-self.saveProject()
-break
 # put the project under VCS control
-if self.vcs is None and self.vcsSoftwareAvailable() and self.vcsRequested:
+if (
+not isRemote
+and self.vcs is None
+and self.vcsSoftwareAvailable()
+and self.vcsRequested
+):
 vcsSystemsDict = (
 ericApp()
 .getObject("PluginManager")
 .getPluginDisplayStrings("version_control")
 )
 self.newProject.emit()
 # set the auto save flag to its supposed value
 Preferences.setProject("AutoSaveProject", autoSaveProject)
-if self.__pdata["EMBEDDED_VENV"]:
+if self.__pdata[
+"EMBEDDED_VENV"
+] and not FileSystemUtilities.isRemoteFileName(self.ppath):
 self.__createEmbeddedEnvironment()
-self.menuEnvironmentAct.setEnabled(self.__pdata["EMBEDDED_VENV"])
+self.menuEnvironmentAct.setEnabled(
+self.__pdata["EMBEDDED_VENV"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.projectOpenedHooks.emit()
 self.projectOpened.emit()
 # open the main script
 if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
+if isRemote:
-ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+if not self.__remotefsInterface.isabs(self.__pdata["MAINSCRIPT"]):
+ms = self.__remotefsInterface.join(
+self.ppath, self.__pdata["MAINSCRIPT"]
+)
+else:
+ms = self.__pdata["MAINSCRIPT"]
 else:
-ms = self.__pdata["MAINSCRIPT"]
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+else:
+ms = self.__pdata["MAINSCRIPT"]
 self.sourceFile.emit(ms)
-def newProjectAddFiles(self, mainscript):
+def newProjectAddFiles(self, mainscript, isRemote=False):
 """
 Public method to add files to a new project.
 @param mainscript name of the mainscript
 @type str
+@param isRemote flag indicating a remote project (defaults to False)
+@type bool (optional)
 """
 # Show the file type associations for the user to change
 self.__showFiletypeAssociations()
 ignoreList = []
 if self.__pdata["EMBEDDED_VENV"]:
 environmentPath = self.__findEmbeddedEnvironment()
 if environmentPath:
-# there is already an embeded venv; ignore thie whenn adding files
+# there is already an embedded venv; ignore this when adding files
-ignoreList = [os.path.split(environmentPath)[-1]]
+ignoreList = (
+[self.__remotefsInterface.split(environmentPath)[-1]]
+if isRemote
+else [os.path.split(environmentPath)[-1]]
+)
 with EricOverrideCursor():
 # search the project directory for files with known extensions
 for filespec in self.__pdata["FILETYPES"]:
-files = FileSystemUtilities.direntries(
+files = (
-self.ppath,
+self.__remotefsInterface.direntries(
-filesonly=True,
+self.ppath,
-pattern=filespec,
+filesonly=True,
-ignore=ignoreList,
+pattern=filespec,
+ignore=ignoreList,
+)
+if isRemote
+else FileSystemUtilities.direntries(
+self.ppath,
+filesonly=True,
+pattern=filespec,
+ignore=ignoreList,
+)
 )
 for file in files:
 self.appendFile(file)
 # special handling for translation files
 if self.translationsRoot:
-tpd = os.path.join(self.ppath, self.translationsRoot)
+if isRemote:
-if not self.translationsRoot.endswith(os.sep):
+tpd = self.__remotefsInterface.join(
-tpd = os.path.dirname(tpd)
+self.ppath, self.translationsRoot
+)
+if not self.translationsRoot.endswith(os.sep):
+tpd = self.__remotefsInterface.dirname(tpd)
+else:
+tpd = os.path.join(self.ppath, self.translationsRoot)
+if not self.translationsRoot.endswith(os.sep):
+tpd = os.path.dirname(tpd)
 else:
 tpd = self.ppath
 tslist = []
 if self.__pdata["TRANSLATIONPATTERN"]:
-pattern = os.path.basename(self.__pdata["TRANSLATIONPATTERN"])
+pattern = (
+self.__remotefsInterface.basename(
+self.__pdata["TRANSLATIONPATTERN"]
+)
+if isRemote
+else os.path.basename(self.__pdata["TRANSLATIONPATTERN"])
+)
 if "%language%" in pattern:
 pattern = pattern.replace("%language%", "*")
 else:
 tpd = self.__pdata["TRANSLATIONPATTERN"].split("%language%")[0]
 else:
 pattern = "*.ts"
-tslist.extend(FileSystemUtilities.direntries(tpd, True, pattern))
+tslist.extend(
+self.__remotefsInterface.direntries(tpd, True, pattern)
+if isRemote
+else FileSystemUtilities.direntries(tpd, True, pattern)
+)
 pattern = self.__binaryTranslationFile(pattern)
 if pattern:
-tslist.extend(FileSystemUtilities.direntries(tpd, True, pattern))
+tslist.extend(
+self.__remotefsInterface.direntries(tpd, True, pattern)
+if isRemote
+else FileSystemUtilities.direntries(tpd, True, pattern)
+)
 if tslist:
-if "_" in os.path.basename(tslist[0]):
+hasUnderscore = (
-# the first entry determines the mainscript name
+"_" in self.__remotefsInterface.basename(tslist[0])
-mainscriptname = (
+if isRemote
-os.path.splitext(mainscript)[0]
+else "_" in os.path.basename(tslist[0])
-or os.path.basename(tslist[0]).split("_")[0]
+)
-)
+if hasUnderscore:
-self.__pdata["TRANSLATIONPATTERN"] = os.path.join(
+# the first entry determines the main script name
-os.path.dirname(tslist[0]),
+if isRemote:
-"{0}_%language%{1}".format(
+mainscriptname = (
-os.path.basename(tslist[0]).split("_")[0],
+self.__remotefsInterface.splitext(mainscript)[0]
-os.path.splitext(tslist[0])[1],
+or self.__remotefsInterface.basename(tslist[0]).split("_")[
-),
+0
-)
+]
+)
+self.__pdata["TRANSLATIONPATTERN"] = (
+self.__remotefsInterface.join(
+self.__remotefsInterface.dirname(tslist[0]),
+"{0}_%language%{1}".format(
+self.__remotefsInterface.basename(tslist[0]).split(
+"_"
+)[0],
+self.__remotefsInterface.splitext(tslist[0])[1],
+),
+)
+)
+else:
+mainscriptname = (
+os.path.splitext(mainscript)[0]
+or os.path.basename(tslist[0]).split("_")[0]
+)
+self.__pdata["TRANSLATIONPATTERN"] = os.path.join(
+os.path.dirname(tslist[0]),
+"{0}_%language%{1}".format(
+os.path.basename(tslist[0]).split("_")[0],
+os.path.splitext(tslist[0])[1],
+),
+)
 else:
 mainscriptname = ""
 pattern, ok = QInputDialog.getText(
 None,
 self.tr("Translation Pattern"),
 for ts in tslist:
 if fnmatch.fnmatch(ts, pattern):
 self.__pdata["TRANSLATIONS"].append(ts)
 self.projectFileAdded.emit(ts, "TRANSLATIONS")
 if self.__pdata["TRANSLATIONSBINPATH"]:
-tpd = os.path.join(
+if isRemote:
-self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
+tpd = self.__remotefsInterface.join(
-)
+self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
-pattern = os.path.basename(
+)
-self.__pdata["TRANSLATIONPATTERN"]
+pattern = self.__remotefsInterface.basename(
-).replace("%language%", "*")
+self.__pdata["TRANSLATIONPATTERN"]
+).replace("%language%", "*")
+else:
+tpd = os.path.join(
+self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
+)
+pattern = os.path.basename(
+self.__pdata["TRANSLATIONPATTERN"]
+).replace("%language%", "*")
 pattern = self.__binaryTranslationFile(pattern)
 qmlist = FileSystemUtilities.direntries(tpd, True, pattern)
 for qm in qmlist:
 self.__pdata["TRANSLATIONS"].append(qm)
 self.projectFileAdded.emit(qm, "TRANSLATIONS")
 """
 Private slot to display the properties dialog.
 """
 from .PropertiesDialog import PropertiesDialog
-dlg = PropertiesDialog(self, new=False)
+isRemote = FileSystemUtilities.isRemoteFileName(self.ppath)
+dlg = PropertiesDialog(self, new=False, isRemote=isRemote)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 fileTypesDict = copy.copy(self.__pdata["FILETYPES"])
 dlg.storeData()
 self.setDirty(True)
 if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
+if isRemote:
-ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+if not self.__remotefsInterface.isabs(self.__pdata["MAINSCRIPT"]):
+ms = self.__remotefsInterface.join(
+self.ppath, self.__pdata["MAINSCRIPT"]
+)
+else:
+ms = self.__pdata["MAINSCRIPT"]
+if self.__remotefsInterface.exists(ms):
+self.appendFile(ms)
 else:
-ms = self.__pdata["MAINSCRIPT"]
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-if os.path.exists(ms):
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
-self.appendFile(ms)
+else:
+ms = self.__pdata["MAINSCRIPT"]
+if os.path.exists(ms):
+self.appendFile(ms)
 if self.__pdata["MAKEPARAMS"]["MakeEnabled"]:
 mf = self.__pdata["MAKEPARAMS"]["MakeFile"]
-if mf:
+if isRemote:
-if not os.path.isabs(mf):
+if mf:
-mf = os.path.join(self.ppath, mf)
+if not self.__remotefsInterface.isabs(mf):
+mf = self.__remotefsInterface.join(self.ppath, mf)
+else:
+mf = self.__remotefsInterface.join(
+self.ppath, Project.DefaultMakefile
+)
+exists = self.__remotefsInterface.exists(mf)
 else:
-mf = os.path.join(self.ppath, Project.DefaultMakefile)
+if mf:
-if not os.path.exists(mf):
+if not os.path.isabs(mf):
+mf = os.path.join(self.ppath, mf)
+else:
+mf = os.path.join(self.ppath, Project.DefaultMakefile)
+exists = os.path.exists(mf)
+if not exists:
 try:
-with open(mf, "w"):
+if isRemote:
-pass
+self.__remotefsInterface.writeFile(mf, b"")
+else:
+with open(mf, "w"):
+pass
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
 self.tr("Create Makefile"),
 self.tr(
 ).format(mf, str(err)),
 )
 self.appendFile(mf)
 if self.translationsRoot:
-tp = os.path.join(self.ppath, self.translationsRoot)
+if isRemote:
-if not self.translationsRoot.endswith(os.sep):
+tp = self.__remotefsInterface.join(
-tp = os.path.dirname(tp)
+self.ppath, self.translationsRoot
+)
+if not self.translationsRoot.endswith(
+self.__remotefsInterface.separator()
+):
+tp = self.__remotefsInterface.dirname(tp)
+if not self.__remotefsInterface.isdir(tp):
+self.__remotefsInterface.makedirs(tp)
+else:
+tp = os.path.join(self.ppath, self.translationsRoot)
+if not self.translationsRoot.endswith(os.sep):
+tp = os.path.dirname(tp)
+if not os.path.isdir(tp):
+os.makedirs(tp)
 else:
 tp = self.ppath
-if not os.path.isdir(tp):
-os.makedirs(tp)
 if tp != self.ppath and tp not in self.subdirs:
 self.subdirs.append(tp)
 if self.__pdata["TRANSLATIONSBINPATH"]:
-tp = os.path.join(self.ppath, self.__pdata["TRANSLATIONSBINPATH"])
+if isRemote:
-if not os.path.isdir(tp):
+tp = self.__remotefsInterface.join(
-os.makedirs(tp)
+self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
+)
+if not self.__remotefsInterface.isdir(tp):
+self.__remotefsInterface.makedirs(tp)
+else:
+tp = os.path.join(self.ppath, self.__pdata["TRANSLATIONSBINPATH"])
+if not os.path.isdir(tp):
+os.makedirs(tp)
 if tp != self.ppath and tp not in self.subdirs:
 self.subdirs.append(tp)
 self.pluginGrp.setEnabled(self.__pdata["PROJECTTYPE"] in ["E7Plugin"])
 self.projectPropertiesChanged.emit()
 if self.__pdata["FILETYPES"] != fileTypesDict:
 self.__reorganizeFiles()
-if self.__pdata["EMBEDDED_VENV"] and not self.__findEmbeddedEnvironment():
+if (
+self.__pdata["EMBEDDED_VENV"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+and not self.__findEmbeddedEnvironment()
+):
 self.__createEmbeddedEnvironment()
 def __showUserProperties(self):
 """
 Private slot to display the user specific properties dialog.
 return
 if fn is None:
 fn = EricFileDialog.getOpenFileName(
 self.parent(),
-self.tr("Open project"),
+self.tr("Open Project"),
 Preferences.getMultiProject("Workspace") or OSUtilities.getHomeDir(),
 self.tr("Project Files (*.epj)"),
 )
 if fn and self.closeProject():
 self.__readUserProperties()
 with EricOverrideCursor():
 oldState = self.isDirty()
 self.vcs = self.initVCS()
-if self.vcs is None and self.isDirty() == oldState:
+if not FileSystemUtilities.isRemoteFileName(self.ppath):
-# check, if project is version controlled
+if self.vcs is None and self.isDirty() == oldState:
-pluginManager = ericApp().getObject("PluginManager")
+# check, if project is version controlled
-for (
+pluginManager = ericApp().getObject("PluginManager")
-indicator,
+for (
-vcsData,
+indicator,
-) in pluginManager.getVcsSystemIndicators().items():
+vcsData,
-if os.path.exists(os.path.join(self.ppath, indicator)):
+) in pluginManager.getVcsSystemIndicators().items():
-if len(vcsData) > 1:
+if os.path.exists(os.path.join(self.ppath, indicator)):
-vcsList = []
+if len(vcsData) > 1:
-for _vcsSystemStr, vcsSystemDisplay in vcsData:
+vcsList = []
-vcsList.append(vcsSystemDisplay)
+for _vcsSystemStr, vcsSystemDisplay in vcsData:
-with EricOverridenCursor():
+vcsList.append(vcsSystemDisplay)
-res, vcs_ok = QInputDialog.getItem(
+with EricOverridenCursor():
-None,
+res, vcs_ok = QInputDialog.getItem(
-self.tr("New Project"),
+None,
-self.tr("Select Version Control System"),
+self.tr("New Project"),
-vcsList,
+self.tr(
-0,
+"Select Version Control System"
-False,
+),
-)
+vcsList,
-if vcs_ok:
+0,
-for vcsSystemStr, vcsSystemDisplay in vcsData:
+False,
-if res == vcsSystemDisplay:
+)
-vcsSystem = vcsSystemStr
+if vcs_ok:
-break
+for (
+vcsSystemStr,
+vcsSystemDisplay,
+) in vcsData:
+if res == vcsSystemDisplay:
+vcsSystem = vcsSystemStr
+break
+else:
+vcsSystem = "None"
 else:
 vcsSystem = "None"
 else:
-vcsSystem = "None"
+vcsSystem = vcsData[0][0]
-else:
+self.__pdata["VCS"] = vcsSystem
-vcsSystem = vcsData[0][0]
+self.vcs = self.initVCS()
-self.__pdata["VCS"] = vcsSystem
+self.setDirty(True)
-self.vcs = self.initVCS()
+if self.vcs is not None and (
-self.setDirty(True)
+self.vcs.vcsRegisteredState(self.ppath)
-if self.vcs is not None and (
+!= VersionControlState.Controlled
-self.vcs.vcsRegisteredState(self.ppath)
+):
-!= VersionControlState.Controlled
+self.__pdata["VCS"] = "None"
-):
+self.vcs = self.initVCS()
-self.__pdata["VCS"] = "None"
-self.vcs = self.initVCS()
 self.reloadAct.setEnabled(True)
 self.closeAct.setEnabled(True)
 self.saveasAct.setEnabled(True)
+self.saveasRemoteAct.setEnabled(
+self.__remoteServer.isServerConnected()
+and FileSystemUtilities.isRemoteFileName(self.pfile)
+)
 self.actGrp2.setEnabled(True)
 self.propsAct.setEnabled(True)
-self.userPropsAct.setEnabled(True)
+self.userPropsAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.pfile)
+)
 self.filetypesAct.setEnabled(True)
 self.lexersAct.setEnabled(True)
 self.sessActGrp.setEnabled(True)
 self.dbgActGrp.setEnabled(True)
 self.menuDebuggerAct.setEnabled(True)
 self.menuSessionAct.setEnabled(True)
 self.menuCheckAct.setEnabled(True)
 self.menuShowAct.setEnabled(True)
 self.menuDiagramAct.setEnabled(True)
-self.menuApidocAct.setEnabled(True)
+self.menuApidocAct.setEnabled(
-self.menuPackagersAct.setEnabled(True)
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
+self.menuPackagersAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.pluginGrp.setEnabled(
 self.__pdata["PROJECTTYPE"] in ["E7Plugin"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
 )
 self.addLanguageAct.setEnabled(
 bool(self.__pdata["TRANSLATIONPATTERN"])
 )
-self.makeGrp.setEnabled(self.__pdata["MAKEPARAMS"]["MakeEnabled"])
+self.makeGrp.setEnabled(
+self.__pdata["MAKEPARAMS"]["MakeEnabled"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.menuMakeAct.setEnabled(
 self.__pdata["MAKEPARAMS"]["MakeEnabled"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
 )
 self.menuOtherToolsAct.setEnabled(True)
-self.menuFormattingAct.setEnabled(True)
+self.menuFormattingAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
+self.menuVcsAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 # open a project debugger properties file being quiet
 # about errors
 if Preferences.getProject("AutoLoadDbgProperties"):
 self.__readDebugProperties(True)
 self.__model.projectOpened()
-if self.__pdata["EMBEDDED_VENV"]:
+if self.__pdata[
+"EMBEDDED_VENV"
+] and not FileSystemUtilities.isRemoteFileName(self.ppath):
 envPath = self.__findEmbeddedEnvironment()
 if bool(envPath):
 self.__loadEnvironmentConfiguration()
 if not bool(
 self.__venvConfiguration["interpreter"]
 self.__venvConfiguration["interpreter"], os.X_OK
 ):
 self.__configureEnvironment(envPath)
 else:
 self.__createEmbeddedEnvironment()
-self.menuEnvironmentAct.setEnabled(self.__pdata["EMBEDDED_VENV"])
+self.menuEnvironmentAct.setEnabled(
+self.__pdata["EMBEDDED_VENV"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.projectOpenedHooks.emit()
 self.projectOpened.emit()
 if Preferences.getProject("SearchNewFiles"):
 self.__readSession(quiet=True, indicator="_tmp")
 elif Preferences.getProject("AutoLoadSession"):
 self.__readSession(quiet=True)
 # start the VCS monitor thread
-self.__vcsConnectStatusMonitor()
+if not FileSystemUtilities.isRemoteFileName(self.ppath):
+self.__vcsConnectStatusMonitor()
 else:
 self.__initData()  # delete all invalid data read
 def reopenProject(self):
 """
 if ex:
 fpath = fpath.with_suffix(ex)
 if fpath.exists():
 res = EricMessageBox.yesNo(
 self.ui,
-self.tr("Save File"),
+self.tr("Save Project"),
 self.tr(
 """<p>The file <b>{0}</b> already exists."""
 """ Overwrite it?</p>"""
 ).format(fpath),
 icon=EricMessageBox.Warning,
 )
 if not res:
 return False
-self.name = fpath.stem
 ok = self.__writeProject(str(fpath))
 if ok:
 # create management directory if not present
 self.createProjectManagementDir()
 success &= vm.closeWindow(fn, ignoreDirty=True)
 if not success:
 return False
 # stop the VCS monitor thread
-if self.vcs is not None:
+if (
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+and self.vcs is not None
+):
 self.vcs.stopStatusMonitor()
 # now save the tasks
 if not noSave:
 self.writeTasks()
 self.ui.taskViewer.clearProjectTasks()
 self.ui.taskViewer.setProjectOpen(False)
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+self.__remotefsInterface.removeFromFsCache(self.ppath)
 # now shutdown the vcs interface
-if self.vcs:
+if not FileSystemUtilities.isRemoteFileName(self.ppath) and self.vcs:
 self.vcs.vcsShutdown()
 self.vcs.deleteLater()
 self.vcs = None
 ericApp().getObject("PluginManager").deactivateVcsPlugins()
 self.__closeAllWindows()
 self.__initData()
 self.reloadAct.setEnabled(False)
 self.closeAct.setEnabled(False)
+self.saveasRemoteAct.setEnabled(False)
 self.saveasAct.setEnabled(False)
 self.saveAct.setEnabled(False)
 self.actGrp2.setEnabled(False)
 self.propsAct.setEnabled(False)
 self.userPropsAct.setEnabled(False)
 filesWithSyntaxErrors += 1
 if reportSyntaxErrors and filesWithSyntaxErrors > 0:
 EricMessageBox.critical(
 self.ui,
-self.tr("Syntax errors detected"),
+self.tr("Syntax Errors Detected"),
 self.tr(
 """The project contains %n file(s) with syntax errors.""",
 "",
 filesWithSyntaxErrors,
 ),
 filesWithSyntaxErrors += 1
 if reportSyntaxErrors and filesWithSyntaxErrors > 0:
 EricMessageBox.critical(
 self.ui,
-self.tr("Syntax errors detected"),
+self.tr("Syntax Errors Detected"),
 self.tr(
 """The project contains %n file(s) with syntax errors.""",
 "",
 filesWithSyntaxErrors,
 ),
 @return filename of the projects main script
 @rtype str
 """
 if self.__pdata["MAINSCRIPT"]:
 if normalized:
-return os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return self.__remotefsInterface.join(
+self.ppath, self.__pdata["MAINSCRIPT"]
+)
+else:
+return os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 else:
 return self.__pdata["MAINSCRIPT"]
 else:
 return ""
 """
 if fileType not in self.getFileCategories():
 raise ValueError("Given file type has incorrect value.")
 if normalized:
-return [os.path.join(self.ppath, fn) for fn in self.__pdata[fileType]]
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return [
+self.__remotefsInterface.join(self.ppath, fn)
+for fn in self.__pdata[fileType]
+]
+else:
+return [os.path.join(self.ppath, fn) for fn in self.__pdata[fileType]]
 else:
 return self.__pdata[fileType]
 def getProjectType(self):
 """
 @return tuple containing the absolute path names of the project specific
 word and exclude list
 @rtype tuple of (str, str)
 """
 pwl = ""
-if self.__pdata["SPELLWORDS"]:
-pwl = os.path.join(self.ppath, self.__pdata["SPELLWORDS"])
-if not os.path.isfile(pwl):
-pwl = ""
 pel = ""
-if self.__pdata["SPELLEXCLUDES"]:
-pel = os.path.join(self.ppath, self.__pdata["SPELLEXCLUDES"])
+if not FileSystemUtilities.isRemoteFileName(self.ppath):
-if not os.path.isfile(pel):
+if self.__pdata["SPELLWORDS"]:
-pel = ""
+pwl = os.path.join(self.ppath, self.__pdata["SPELLWORDS"])
+if not os.path.isfile(pwl):
+pwl = ""
+if self.__pdata["SPELLEXCLUDES"]:
+pel = os.path.join(self.ppath, self.__pdata["SPELLEXCLUDES"])
+if not os.path.isfile(pel):
+pel = ""
 return (pwl, pel)
 def getDefaultSourceExtension(self):
 """
 @return project path
 @rtype str
 """
 return self.ppath
-def startswithProjectPath(self, path):
+def startswithProjectPath(self, checkpath):
 """
 Public method to check, if a path starts with the project path.
-@param path path to be checked
+@param checkpath path to be checked
 @type str
 @return flag indicating that the path starts with the project path
 @rtype bool
 """
-return bool(self.ppath) and (
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-path == self.ppath
+return checkpath == self.ppath or checkpath.startswith(
-or FileSystemUtilities.normcasepath(
+self.ppath + self.__remotefsInterface.separator()
-FileSystemUtilities.toNativeSeparators(path)
+)
-).startswith(
+else:
-FileSystemUtilities.normcasepath(
+return bool(self.ppath) and (
-FileSystemUtilities.toNativeSeparators(self.ppath + "/")
+checkpath == self.ppath
+or FileSystemUtilities.normcasepath(
+FileSystemUtilities.toNativeSeparators(checkpath)
+).startswith(
+FileSystemUtilities.normcasepath(
+FileSystemUtilities.toNativeSeparators(self.ppath + "/")
+)
 )
 )
-)
 def getProjectFile(self):
 """
 Public method to get the path of the project file.
 @return name of the project
 @rtype str
 """
 if self.pfile:
-name = os.path.splitext(self.pfile)[0]
+return self.name
-return os.path.basename(name)
 else:
 return ""
 def getProjectManagementDir(self):
 """
 Public method to get the path of the management directory.
 @return path of the management directory
 @rtype str
 """
-return os.path.join(self.ppath, ".eric7project")
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return self.__remotefsInterface.join(self.ppath, ".eric7project")
+else:
+return os.path.join(self.ppath, ".eric7project")
 def createProjectManagementDir(self):
 """
 Public method to create the project management directory.
 It does nothing, if it already exists.
 """
 # create management directory if not present
 mgmtDir = self.getProjectManagementDir()
-if not os.path.exists(mgmtDir):
+if FileSystemUtilities.isRemoteFileName(mgmtDir):
-os.makedirs(mgmtDir)
+self.__remotefsInterface.makedirs(mgmtDir, exist_ok=True)
+else:
+os.makedirs(mgmtDir, exist_ok=True)
 def getHash(self):
 """
 Public method to get the project hash.
 @return project hash as a hex string
 @rtype str
 """
 return self.__pdata["HASH"]
-def getRelativePath(self, path):
+def getRelativePath(self, fullpath):
 """
 Public method to convert a file path to a project relative
 file path.
-@param path file or directory name to convert
+@param fullpath file or directory name to convert
 @type str
 @return project relative path or unchanged path, if path doesn't
 belong to the project
 @rtype str
 """
-if path is None:
+if fullpath is None:
 return ""
 try:
-return str(pathlib.Path(path).relative_to(self.ppath))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+if self.__remotefsInterface.separator() == "\\":
+return str(
+pathlib.PureWindowsPath(fullpath).relative_to(self.ppath)
+)
+else:
+return str(pathlib.PurePosixPath(fullpath).relative_to(self.ppath))
+else:
+return str(pathlib.PurePath(fullpath).relative_to(self.ppath))
 except ValueError:
-return path
+return fullpath
-def getRelativeUniversalPath(self, path):
+def getRelativeUniversalPath(self, fullpath):
 """
 Public method to convert a file path to a project relative
 file path with universal separators.
-@param path file or directory name to convert
+@param fullpath file or directory name to convert
 @type str
 @return project relative path or unchanged path, if path doesn't
 belong to the project
 @rtype str
 """
-return FileSystemUtilities.fromNativeSeparators(self.getRelativePath(path))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return self.__remotefsInterface.fromNativeSeparators(
+self.getRelativePath(fullpath)
+)
+else:
+return FileSystemUtilities.fromNativeSeparators(
+self.getRelativePath(fullpath)
+)
 def getAbsolutePath(self, fn):
 """
 Public method to convert a project relative file path to an absolute
 file path.
 @param fn file or directory name to convert
 @type str
 @return absolute path
 @rtype str
 """
-if not os.path.isabs(fn):
+if not fn.startswith(self.ppath):
-fn = os.path.join(self.ppath, fn)
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+fn = self.__remotefsInterface.join(self.ppath, fn)
+else:
+fn = os.path.join(self.ppath, fn)
 return fn
 def getAbsoluteUniversalPath(self, fn):
 """
 Public method to convert a project relative file path with universal
 @param fn file or directory name to convert
 @type str
 @return absolute path
 @rtype str
 """
-if not os.path.isabs(fn):
+if not fn.startswith(self.ppath):
-fn = os.path.join(self.ppath, FileSystemUtilities.toNativeSeparators(fn))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+fn = self.__remotefsInterface.join(
+self.ppath, self.__remotefsInterface.fromNativeSeparators(fn)
+)
+else:
+fn = os.path.join(
+self.ppath, FileSystemUtilities.fromNativeSeparators(fn)
+)
 return fn
 def getEolString(self):
 """
 Public method to get the EOL-string to be used by the project.
 @return name of the project's virtual environment
 @rtype str
 """
 venvName = (
 self.__venvConfiguration["name"]
-if self.__pdata["EMBEDDED_VENV"] and bool(self.__venvConfiguration["name"])
+if (
+self.__pdata["EMBEDDED_VENV"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+and bool(self.__venvConfiguration["name"])
+)
 else self.getDebugProperty("VIRTUALENV")
 )
 if (
 not venvName
 and resolveDebugger
 Public method to get the path name of the embedded virtual environment.
 @return path name of the embedded virtual environment
 @rtype str
 """
-if self.__pdata["EMBEDDED_VENV"]:
+if self.__pdata["EMBEDDED_VENV"] and not FileSystemUtilities.isRemoteFileName(
+self.ppath
+):
 return self.__findEmbeddedEnvironment()
 else:
 return ""
 def getProjectInterpreter(self, resolveGlobal=True):
 @return path of the project's interpreter
 @rtype str
 """
 interpreter = (
 self.__venvConfiguration["interpreter"]
-if self.__pdata["EMBEDDED_VENV"]
+if (
+self.__pdata["EMBEDDED_VENV"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 else ""
 )
 if not interpreter:
 venvName = self.getProjectVenv()
 if venvName:
 @param fn filename to be checked
 @type str
 @return flag indicating membership
 @rtype bool
 """
-newfn = os.path.abspath(fn)
+newfn = (
+self.__remotefsInterface.abspath(fn)
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else os.path.abspath(fn)
+)
 newfn = self.getRelativePath(newfn)
 return any(
 newfn in self.__pdata[category] for category in self.getFileCategories()
 )
 @param group group to check
 @type str
 @return flag indicating membership
 @rtype bool
 """
-newfn = os.path.abspath(fn)
+newfn = (
+self.__remotefsInterface.abspath(fn)
+if FileSystemUtilities.isRemoteFileName(fn)
+else os.path.abspath(fn)
+)
 newfn = self.getRelativePath(newfn)
 if newfn in self.__pdata[group] or (
 group == "OTHERS"
 and any(newfn.startswith(entry) for entry in self.__pdata[group])
 ):
 return True
-if OSUtilities.isWindowsPlatform():
+if (
+OSUtilities.isWindowsPlatform()
+or self.__remotefsInterface.separator() == "\\"
+):
 # try the above case-insensitive
 newfn = newfn.lower()
 if any(entry.lower() == newfn for entry in self.__pdata[group]):
 return True
 self.tr("""<b>Open...</b><p>This opens an existing project.</p>""")
 )
 act.triggered.connect(self.openProject)
 self.actions.append(act)
+self.openRemoteAct = EricAction(
+self.tr("Open remote project"),
+EricPixmapCache.getIcon("projectOpen-remote"),
+self.tr("Open (Remote)..."),
+0,
+0,
+self.actGrp1,
+"project_open_remote",
+)
+self.openRemoteAct.setStatusTip(self.tr("Open an existing remote project"))
+self.openRemoteAct.setWhatsThis(
+self.tr(
+"<b>Open (Remote)...</b><p>This opens an existing remote project.</p>"
+)
+)
+self.openRemoteAct.triggered.connect(self.__openRemoteProject)
+self.actions.append(self.openRemoteAct)
+self.openRemoteAct.setEnabled(False)  # server is not connected initially
 self.reloadAct = EricAction(
 self.tr("Reload project"),
 EricPixmapCache.getIcon("projectReload"),
 self.tr("Re&load"),
 0,
 """<p>This saves the current project to a new file.</p>"""
 )
 )
 self.saveasAct.triggered.connect(self.saveProjectAs)
 self.actions.append(self.saveasAct)
+self.saveasRemoteAct = EricAction(
+self.tr("Save project as (Remote)"),
+EricPixmapCache.getIcon("projectSaveAs-remote"),
+self.tr("Save as (Remote)..."),
+0,
+0,
+self,
+"project_save_as_remote",
+)
+self.saveasRemoteAct.setStatusTip(
+self.tr("Save the current project to a new remote file")
+)
+self.saveasRemoteAct.setWhatsThis(
+self.tr(
+"""<b>Save as (Remote)</b>"""
+"""<p>This saves the current project to a new remote file.</p>"""
+)
+)
+self.saveasRemoteAct.triggered.connect(self.__saveRemoteProjectAs)
+self.actions.append(self.saveasRemoteAct)
+self.saveasRemoteAct.setEnabled(False)  # server is not connected initially
 ###################################################################
 ## Project management actions
 ###################################################################
 @return tuple of generated menus
 @rtype tuple of (QMenu, QMenu)
 """
 menu = QMenu(self.tr("&Project"), self.parent())
 self.recentMenu = QMenu(self.tr("Open &Recent Projects"), menu)
+self.recentMenu.setIcon(EricPixmapCache.getIcon("projectOpenRecent"))
 self.sessionMenu = QMenu(self.tr("Session"), menu)
 self.debuggerMenu = QMenu(self.tr("Debugger"), menu)
 self.environmentMenu = QMenu(self.tr("Embedded Environment"), menu)
 toolsMenu = QMenu(self.tr("Project-T&ools"), self.parent())
 menu.addSeparator()
 menu.addAction(self.closeAct)
 menu.addSeparator()
 menu.addAction(self.saveAct)
 menu.addAction(self.saveasAct)
+menu.addAction(self.saveasRemoteAct)
 menu.addSeparator()
 menu.addActions(self.actGrp2.actions())
 menu.addSeparator()
 menu.addAction(self.propsAct)
 menu.addAction(self.userPropsAct)
 self.menuSessionAct = menu.addMenu(self.sessionMenu)
 # build the project tools menu
 toolsMenu.setTearOffEnabled(True)
 toolsMenu.addSeparator()
-toolsMenu.addMenu(self.vcsMenu)
+self.menuVcsAct = toolsMenu.addMenu(self.vcsMenu)
 toolsMenu.addSeparator()
 self.menuCheckAct = toolsMenu.addMenu(self.checksMenu)
 toolsMenu.addSeparator()
 self.menuFormattingAct = toolsMenu.addMenu(self.formattingMenu)
 toolsMenu.addSeparator()
 tb.addActions(self.actGrp1.actions())
 tb.addAction(self.closeAct)
 tb.addSeparator()
 tb.addAction(self.saveAct)
 tb.addAction(self.saveasAct)
+tb.addAction(self.saveasRemoteAct)
 toolbarManager.addToolBar(tb, tb.windowTitle())
 toolbarManager.addAction(self.addFilesAct, tb.windowTitle())
 toolbarManager.addAction(self.addDirectoryAct, tb.windowTitle())
 toolbarManager.addAction(self.addLanguageAct, tb.windowTitle())
 def __showMenu(self):
 """
 Private method to set up the project menu.
 """
 self.menuRecentAct.setEnabled(len(self.recent) > 0)
-self.menuEnvironmentAct.setEnabled(self.__pdata["EMBEDDED_VENV"])
+self.menuEnvironmentAct.setEnabled(
+self.__pdata["EMBEDDED_VENV"]
+and not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.showMenu.emit("Main", self.__menus["Main"])
 def __syncRecent(self):
 """
 Private method to synchronize the list of recently opened projects
 with the central store.
 """
 for recent in self.recent[:]:
-if FileSystemUtilities.samepath(self.pfile, recent):
+if (
+FileSystemUtilities.isRemoteFileName(recent) and recent == self.pfile
+) or FileSystemUtilities.samepath(self.pfile, recent):
 self.recent.remove(recent)
 self.recent.insert(0, self.pfile)
 maxRecent = Preferences.getProject("RecentNumber")
 if len(self.recent) > maxRecent:
 self.recent = self.recent[:maxRecent]
 for idx, rp in enumerate(self.recent, start=1):
 formatStr = "&{0:d}. {1}" if idx < 10 else "{0:d}. {1}"
 act = self.recentMenu.addAction(
 formatStr.format(
-idx, FileSystemUtilities.compactPath(rp, self.ui.maxMenuFilePathLen)
+idx,
+(
+self.__remotefsInterface.compactPath(
+rp, self.ui.maxMenuFilePathLen
+)
+if FileSystemUtilities.isRemoteFileName(rp)
+else FileSystemUtilities.compactPath(
+rp, self.ui.maxMenuFilePathLen
+)
+),
 )
 )
 act.setData(rp)
-act.setEnabled(pathlib.Path(rp).exists())
+if FileSystemUtilities.isRemoteFileName(rp):
+act.setEnabled(
+self.__remoteServer.isServerConnected
+and self.__remotefsInterface.exists(rp)
+)
+else:
+act.setEnabled(pathlib.Path(rp).exists())
 self.recentMenu.addSeparator()
 self.recentMenu.addAction(self.tr("&Clear"), self.clearRecent)
 def __openRecent(self, act):
 if self.__findProjectFileDialog is None:
 self.__findProjectFileDialog = QuickFindFileDialog(self)
 self.__findProjectFileDialog.sourceFile.connect(self.sourceFile)
 self.__findProjectFileDialog.designerFile.connect(self.designerFile)
 self.__findProjectFileDialog.linguistFile.connect(self.linguistFile)
-self.__findProjectFileDialog.show()
+self.__findProjectFileDialog.show(
+FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.__findProjectFileDialog.raise_()
 self.__findProjectFileDialog.activateWindow()
 def __doSearchNewFiles(self, AI=True, onUserDemand=False):
 """
 from .AddFoundFilesDialog import AddFoundFilesDialog
 autoInclude = Preferences.getProject("AutoIncludeNewFiles")
 recursiveSearch = Preferences.getProject("SearchNewFilesRecursively")
 newFiles = []
+isRemote = FileSystemUtilities.isRemoteFileName(self.ppath)
 ignore_patterns = [
 pattern
 for pattern, filetype in self.__pdata["FILETYPES"].items()
 if filetype == "__IGNORE__"
 fnmatch.fnmatch(directory, ignore_pattern)
 for ignore_pattern in ignore_patterns
 ):
 continue
-curpath = os.path.join(self.ppath, directory)
+curpath = (
+self.__remotefsInterface.join(self.ppath, directory)
+if isRemote
+else os.path.join(self.ppath, directory)
+)
 try:
-newSources = os.listdir(curpath)
+newSources = (
+[e["name"] for e in self.__remotefsInterface.listdir(curpath)[2]]
+if isRemote
+else os.listdir(curpath)
+)
 except OSError:
 newSources = []
 pattern = (
 self.__pdata["TRANSLATIONPATTERN"].replace("%language%", "*")
 if self.__pdata["TRANSLATIONPATTERN"]
 continue
 # set fn to project relative name
 # then reset ns to fully qualified name for insertion,
 # possibly.
-fn = os.path.join(directory, ns) if directory else ns
+if isRemote:
-ns = os.path.abspath(os.path.join(curpath, ns))
+fn = (
+self.__remotefsInterface.join(directory, ns)
+if directory
+else ns
+)
+ns = self.__remotefsInterface.abspath(
+self.__remotefsInterface.join(curpath, ns)
+)
+isdir_ns = self.__remotefsInterface.isdir(ns)
+else:
+fn = os.path.join(directory, ns) if directory else ns
+ns = os.path.abspath(os.path.join(curpath, ns))
+isdir_ns = os.path.isdir(ns)
 # do not bother with dirs here...
-if os.path.isdir(ns):
+if isdir_ns:
 if recursiveSearch:
 d = self.getRelativePath(ns)
 if d not in dirs:
 dirs.append(d)  # noqa: M569
 continue
 filetype = ""
-bfn = os.path.basename(fn)
+bfn = (
+self.__remotefsInterface.basename(fn)
+if isRemote
+else os.path.basename(fn)
+)
 # check against ignore patterns first (see issue 553)
 if any(
 fnmatch.fnmatch(bfn, ignore_pattern)
 for ignore_pattern in ignore_patterns
 if (
 filetype in self.getFileCategories()
 and (
 fn not in self.__pdata[filetype]
-and (
+or (
 filetype == "OTHERS"
+and fn not in self.__pdata[filetype]
 and os.path.dirname(fn) not in self.__pdata["OTHERS"]
 )
 )
 and (
 filetype != "TRANSLATIONS"
 vcs = None
 forProject = True
 override = False
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return None
 if vcsSystem is None:
 if self.__pdata["VCS"] and self.__pdata["VCS"] != "None":
 vcsSystem = self.__pdata["VCS"]
 else:
 forProject = False
 """
 Private slot used to calculate some code metrics for the project files.
 """
 from eric7.DataViews.CodeMetricsDialog import CodeMetricsDialog
-files = [
+files = (
-os.path.join(self.ppath, file)
+[
-for file in self.__pdata["SOURCES"]
+self.__remotefsInterface.join(self.ppath, file)
-if file.endswith(".py")
+for file in self.__pdata["SOURCES"]
-]
+if file.endswith(".py")
+]
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else [
+os.path.join(self.ppath, file)
+for file in self.__pdata["SOURCES"]
+if file.endswith(".py")
+]
+)
 self.codemetrics = CodeMetricsDialog()
 self.codemetrics.show()
 self.codemetrics.prepare(files)
 def __showCodeCoverage(self):
 else:
 fn = files[0]
 else:
 return
-files = [
+files = (
-os.path.join(self.ppath, file)
+[
-for file in self.__pdata["SOURCES"]
+self.__remotefsInterface.join(self.ppath, file)
-if os.path.splitext(file)[1].startswith(".py")
+for file in self.__pdata["SOURCES"]
-]
+if self.__remotefsInterface.splitext(file)[1].startswith(".py")
+]
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else [
+os.path.join(self.ppath, file)
+for file in self.__pdata["SOURCES"]
+if os.path.splitext(file)[1].startswith(".py")
+]
+)
 self.codecoverage = PyCoverageDialog()
 self.codecoverage.show()
 self.codecoverage.start(fn, files)
 def __showProfileData(self):
 if name == self.__pdata["MAINSCRIPT"]:
 version = self.__pluginExtractVersion(
 os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 )
 if archiveVersion and (
-Globals.versionToTuple(version)
+EricUtilities.versionToTuple(version)
-< Globals.versionToTuple(archiveVersion)
+< EricUtilities.versionToTuple(archiveVersion)
 ):
 version = archiveVersion
 except OSError as why:
 EricMessageBox.critical(
 self.ui,
 Public method to test, if make is enabled for the project.
 @return flag indicating enabled make support
 @rtype bool
 """
-return self.__pdata["MAKEPARAMS"]["MakeEnabled"]
+return self.__pdata["MAKEPARAMS"][
+"MakeEnabled"
+] and not FileSystemUtilities.isRemoteFileName(self.ppath)
 @pyqtSlot()
 def __autoExecuteMake(self):
 """
 Private slot to execute a project specific make run (auto-run)
 (execute or question).
 """
-if Preferences.getProject("AutoExecuteMake"):
+if Preferences.getProject(
+"AutoExecuteMake"
+) and not FileSystemUtilities.isRemoteFileName(self.ppath):
 self.__executeMake(questionOnly=self.__pdata["MAKEPARAMS"]["MakeTestOnly"])
 @pyqtSlot()
 def __executeMake(self, questionOnly=False):
 """
 Private method to execute a project specific make run.
 @param questionOnly flag indicating to ask make for changes only
 @type bool
 """
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+EricMessageBox.critical(
+self.ui,
+self.tr("Execute Make"),
+self.tr("'Make' is not supported for remote projects. Aborting..."),
+)
+return
 if (
 not self.__pdata["MAKEPARAMS"]["MakeEnabled"]
 or self.__makeProcess is not None
 ):
 return
 def __showContextMenuOthers(self):
 """
 Private slot called before the 'Other Tools' menu is shown.
 """
+self.createSBOMAct.setEnabled(
+not FileSystemUtilities.isRemoteFileName(self.ppath)
+)
 self.showMenu.emit("OtherTools", self.othersMenu)
 @pyqtSlot()
 def __createSBOMFile(self):
 """
 @return path of the embedded virtual environment (empty if not found)
 @rtype str
 """
 ppath = self.getProjectPath()
-if ppath and os.path.exists(ppath):
+if FileSystemUtilities.isRemoteFileName(ppath):
-with os.scandir(self.getProjectPath()) as ppathDirEntriesIterator:
+# check for some common names
-for dirEntry in ppathDirEntriesIterator:
-# potential venv directory; check for 'pyvenv.cfg'
-if dirEntry.is_dir() and os.path.exists(
-os.path.join(dirEntry.path, "pyvenv.cfg")
-):
-return dirEntry.path
-# check for some common names in case 'pyvenv.cfg' is missing
 for venvPathName in (".venv", "venv", ".env", "env"):
-venvPath = os.path.join(self.getProjectPath(), venvPathName)
+venvPath = self.__remotefsInterface.join(ppath, venvPathName)
-if os.path.isdir(venvPath):
+if self.__remotefsInterface.isdir(venvPath):
 return venvPath
+else:
+if ppath and os.path.exists(ppath):
+with os.scandir(self.getProjectPath()) as ppathDirEntriesIterator:
+for dirEntry in ppathDirEntriesIterator:
+# potential venv directory; check for 'pyvenv.cfg'
+if dirEntry.is_dir() and os.path.exists(
+os.path.join(dirEntry.path, "pyvenv.cfg")
+):
+return dirEntry.path
+# check for some common names in case 'pyvenv.cfg' is missing
+for venvPathName in (".venv", "venv", ".env", "env"):
+venvPath = os.path.join(ppath, venvPathName)
+if os.path.isdir(venvPath):
+return venvPath
 return ""
 def __setEmbeddedEnvironmentProjectConfig(self, value):
 """
 with os.scandir(directory) as dirEntriesIterator:
 for dirEntry in dirEntriesIterator:
 if dirEntry.is_dir():
 self.__clearByteCodeCaches(dirEntry.path)
+#############################################################################
+## Below are methods implementing the support for 'eric-ide server projects
+#############################################################################
+@pyqtSlot(bool)
+def remoteConnectionChanged(self, connected):
+"""
+Public slot to handle a change of the 'eric-ide' server connection state.
+@param connected flag indicating the connection state
+@type bool
+"""
+self.openRemoteAct.setEnabled(connected)
+self.saveasRemoteAct.setEnabled(
+connected
+and self.opened
+and FileSystemUtilities.isRemoteFileName(self.pfile)
+)
+if not connected and FileSystemUtilities.isRemoteFileName(self.ppath):
+self.closeProject(noSave=True)
+@pyqtSlot()
+def __openRemoteProject(self):
+"""
+Private slot to open a project of an 'eric-ide' server.
+"""
+fn = EricServerFileDialog.getOpenFileName(
+self.parent(),
+self.tr("Open Remote Project"),
+"",
+self.tr("Project Files (*.epj)"),
+)
+if fn:
+self.openProject(fn=fn)
+@pyqtSlot()
+def __saveRemoteProjectAs(self):
+"""
+Private slot to save the current remote project to different remote file.
+"""
+defaultFilter = self.tr("Project Files (*.epj)")
+defaultPath = self.ppath if self.ppath else ""
+fn, selectedFilter = EricServerFileDialog.getSaveFileNameAndFilter(
+self.parent(),
+self.tr("Save Remote Project"),
+defaultPath,
+self.tr("Project Files (*.epj)"),
+defaultFilter,
+)
+if fn:
+fname, ext = self.__remotefsInterface.splitext(fn)
+if not ext:
+ex = selectedFilter.split("(*")[1].split(")")[0]
+if ex:
+fn = f"{fname}{ex}"
+if self.__remotefsInterface.exists(fn):
+res = EricMessageBox.yesNo(
+self.ui,
+self.tr("Save Remote Project"),
+self.tr(
+"""<p>The file <b>{0}</b> already exists."""
+""" Overwrite it?</p>"""
+).format(fn),
+icon=EricMessageBox.Warning,
+)
+if not res:
+return
+ok = self.__writeProject(fn)
+if ok:
+# create management directory if not present
+self.createProjectManagementDir()
+# now save the tasks
+self.writeTasks()
+self.sessActGrp.setEnabled(ok)
+self.menuSessionAct.setEnabled(ok)
+self.projectClosedHooks.emit()
+self.projectClosed.emit(False)
+self.projectOpenedHooks.emit()
+self.projectOpened.emit()
 #
 # eflag: noqa = M601

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py