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

-:b6f5e27daeb5
+:bb0149571d94
 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.
 dn = (
 self.__remotefsInterface.dirname(fn)
 if FileSystemUtilities.isRemoteFileName(fn)
 else os.path.dirname(fn)
 )
-if dn and dn not in self.otherssubdirs:
-self.otherssubdirs.append(dn)
 return res
 def __writeProject(self, fn=None):
 """
 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()
 )
 if not FileSystemUtilities.samepath(
 self.__remotefsInterface.dirname(fn)
 if isRemote
 else os.path.dirname(fn),
-target
+target,
 ):
 try:
 if isRemote:
 if not self.__remotefsInterface.isdir(target):
 self.__remotefsInterface.makedirs(target)
 else:
 if not os.path.isdir(target):
 os.makedirs(target)
-if (
+if (not isRemote and os.path.exists(targetfile)) or (
-not isRemote and os.path.exists(targetfile)
-) or (
 isRemote and self.__remotefsInterface.exists(targetfile)
 ):
 res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Add File"),
 @param target target directory
 @type str
 @param quiet flag indicating quiet operations
 @type bool
 """
-# TODO: adapt to remote server
 # get all relevant filename patterns
 patterns = []
 ignorePatterns = []
 for pattern, patterntype in self.__pdata["FILETYPES"].items():
 if patterntype == filetype:
 ),
 )
 return
 if not FileSystemUtilities.samepath(target, source) and not (
-(not isRemote and os.path.isdir(target)) or (
+(not isRemote and os.path.isdir(target))
-isRemote and self.__remotefsInterface.isdir(target)
+or (isRemote and self.__remotefsInterface.isdir(target))
-)
 ):
 try:
 if isRemote:
 self.__remotefsInterface.makedirs(target)
 else:
 if isRemote
 else os.path.join(target, os.path.basename(file))
 )
 if not FileSystemUtilities.samepath(target, source):
 try:
-if (
+if (not isRemote and os.path.exists(targetfile)) or (
-not isRemote and os.path.exists(targetfile)
-) or (
 isRemote and self.__remotefsInterface.exists(targetfile)
 ):
 res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Add Directory"),
 if not res:
 continue
 # don't overwrite, carry on with next file
 if isRemote:
-self.__remotefsInterface.shutilCopy(file,target )
+self.__remotefsInterface.shutilCopy(file, target)
 else:
 shutil.copy(file, target)
 except OSError:
 continue
 self.appendFile(targetfile)
 @param source source directory
 @type str
 @param target target directory
 @type str
 """
-# TODO: adapt to remote server
 # first perform the addition of source
 self.__addSingleDirectory(filetype, source, target, True)
 ignore_patterns = [
 ".svn",
 @param fileTypeFilter filter to be used by the add directory dialog
 @type str
 @param startdir start directory for the selection dialog
 @type str
 """
-# TODO: adapt to remote server
 from .AddDirectoryDialog import AddDirectoryDialog
 if not startdir:
 startdir = self.ppath
 Public method to add a file/directory to the OTHERS project data.
 @param fn file name or directory name to add
 @type str
 """
-# TODO: adapt to remote server
 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
 """
-# TODO: adapt to remote server
+isRemote = FileSystemUtilities.isRemoteFileName(oldfn)
 fn = self.getRelativePath(oldfn)
 isSourceFile = fn in self.__pdata["SOURCES"]
 if newfn is None:
 newfn = EricFileDialog.getSaveFileName(
 )
 if not newfn:
 return False
 newfn = FileSystemUtilities.toNativeSeparators(newfn)
-if os.path.exists(newfn):
+if (not isRemote and os.path.exists(newfn)) or (
+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.rename(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
 """
-# TODO: adapt to remote server
+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
 """
-# TODO: adapt to remote server
+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.__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))
+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:
 mf = os.path.join(self.ppath, Project.DefaultMakefile)
 if not os.path.exists(mf):
 try:
-os.makedirs(os.path.dirname(mf))
+os.makedirs(os.path.dirname(mf), exist_ok=True)
 with open(mf, "w"):
 pass
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
 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")
 )
 # set the auto save flag to its supposed value
 Preferences.setProject("AutoSaveProject", autoSaveProject)
 if self.__pdata["EMBEDDED_VENV"]:
 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"])
 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.__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):
 """
 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)
 # 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()
 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 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:
 if FileSystemUtilities.isRemoteFileName(self.ppath):
 if self.__remotefsInterface.separator() == "\\":
-return str(pathlib.PureWindowsPath(path).relative_to(self.ppath))
+return str(
+pathlib.PureWindowsPath(fullpath).relative_to(self.ppath)
+)
 else:
-return str(pathlib.PurePosixPath(path).relative_to(self.ppath))
+return str(pathlib.PurePosixPath(fullpath).relative_to(self.ppath))
 else:
-return str(pathlib.PurePath(path).relative_to(self.ppath))
+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
 """
 if FileSystemUtilities.isRemoteFileName(self.ppath):
 return self.__remotefsInterface.fromNativeSeparators(
-self.getRelativePath(path)
+self.getRelativePath(fullpath)
 )
 else:
-return FileSystemUtilities.fromNativeSeparators(self.getRelativePath(path))
+return FileSystemUtilities.fromNativeSeparators(
+self.getRelativePath(fullpath)
+)
 def getAbsolutePath(self, fn):
 """
 Public method to convert a project relative file path to an absolute
 file path.
 environment name via the debugger settings if none was configured
 @type bool
 @return name of the project's virtual environment
 @rtype str
 """
+# TODO: remote server not supported yet
 venvName = (
 self.__venvConfiguration["name"]
 if self.__pdata["EMBEDDED_VENV"] and bool(self.__venvConfiguration["name"])
 else self.getDebugProperty("VIRTUALENV")
 )
 Public method to get the path name of the embedded virtual environment.
 @return path name of the embedded virtual environment
 @rtype str
 """
+# TODO: remote server not supported yet
 if self.__pdata["EMBEDDED_VENV"]:
 return self.__findEmbeddedEnvironment()
 else:
 return ""
 environment was configured
 @type bool
 @return path of the project's interpreter
 @rtype str
 """
+# TODO: remote server not supported yet
 interpreter = (
 self.__venvConfiguration["interpreter"]
 if self.__pdata["EMBEDDED_VENV"]
 else ""
 )
 Public method to get the executable search path prefix of the project.
 @return executable search path prefix
 @rtype str
 """
+# TODO: remote server not supported yet
 if self.__pdata["EMBEDDED_VENV"]:
 execPath = self.__venvConfiguration["exec_path"]
 else:
 execPath = ""
 venvName = self.getProjectVenv()
 Public method to get the testing framework name of the project.
 @return testing framework name of the project
 @rtype str
 """
+# TODO: remote server not supported yet
 try:
 return self.__pdata["TESTING_FRAMEWORK"]
 except KeyError:
 return ""
 @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 = fn if FileSystemUtilities.isRemoteFileName(fn) else 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.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()
 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):
 """
 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__"
 ]
-dirs = self.subdirs[:]
+dirs = [""] if recursiveSearch else self.subdirs[:] + [""]
 for directory in dirs:
 skip = False
 for ignore_pattern in ignore_patterns:
 if fnmatch.fnmatch(directory, ignore_pattern):
 skip = True
 break
 if skip:
 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"]
 else "*.ts"
 )
 binpattern = self.__binaryTranslationFile(pattern)
 for ns in newSources:
 # ignore hidden files and directories
-if ns.startswith("."):
+if ns.startswith(".") or ns == "__pycache__":
-continue
-if (
-OSUtilities.isWindowsPlatform()
-and os.path.isdir(os.path.join(curpath, ns))
-and ns.startswith("_")
-):
-# dot net hack
 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: M538
 continue
 filetype = ""
-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
 """
 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):
 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"],
 interactive=False,
 )
 @type bool
 @param interactive flag indicating an interactive invocation (i.e.
 through a menu action)
 @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):
 """

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py