--- a/src/eric7/Utilities/__init__.py Sun Dec 18 14:19:10 2022 +0100
+++ b/src/eric7/Utilities/__init__.py Sun Dec 18 19:33:46 2022 +0100
@@ -9,22 +9,12 @@
import codecs
import contextlib
-import ctypes
-import fnmatch
-import functools
-import getpass
import glob
import json
import os
-import pathlib
import re
import shlex
-import subprocess # secok
import sys
-
-with contextlib.suppress(ImportError):
- import pwd # only available on Unix systems
-
import warnings
from codecs import BOM_UTF8, BOM_UTF16, BOM_UTF32
@@ -38,7 +28,6 @@
QByteArray,
QCoreApplication,
QCryptographicHash,
- QDir,
QProcess,
qVersion,
)
@@ -46,23 +35,73 @@
from eric7 import Preferences
from eric7.EricWidgets.EricApplication import ericApp
-# import these methods into the Utilities namespace
-from eric7.Globals import ( # __IGNORE_WARNING__
+# imports from eric7.SystemUtilities are for backward compatibility
+from eric7.Globals import ( # __IGNORE_FLAKES_WARNING__
desktopName,
getConfig,
getConfigDir,
- getPyQt6ModulesDirectory,
- getPyQtToolsPath,
getPythonExecutable,
getPythonLibraryDirectory,
getPythonScriptsDirectory,
- getQtBinariesPath,
+ sessionType,
+ setConfigDir,
+ toBool,
+)
+from eric7.SystemUtilities import DesktopUtilities
+from eric7.SystemUtilities.FileSystemUtilities import ( # __IGNORE_FLAKES_WARNING__
+ absolutePath,
+ absoluteUniversalPath,
+ compactPath,
+ direntries,
+ findVolume,
+ fromNativeSeparators,
+ getDirs,
+ getExecutablePath,
+ getExecutablePaths,
+ getWindowsExecutablePath,
+ isDrive,
+ isExecutable,
+ isinpath,
+ joinext,
+ normabsjoinpath,
+ normcaseabspath,
+ normcasepath,
+ normjoinpath,
+ relativeUniversalPath,
+ samefilepath,
+ samepath,
+ splitPath,
+ startswithPath,
+ toNativeSeparators,
+)
+from eric7.SystemUtilities.OSUtilities import ( # __IGNORE_FLAKES_WARNING__
+ getEnvironmentEntry,
+ getHomeDir,
+ getUserName,
+ hasEnvironmentEntry,
isLinuxPlatform,
isMacPlatform,
isWindowsPlatform,
+ win32_getRealName,
+ win32_GetUserName,
+ win32_Kill,
+)
+from eric7.SystemUtilities.PythonUtilities import ( # __IGNORE_FLAKES_WARNING__
+ determinePythonVersion,
+ getPythonLibPath,
+ getPythonVersion,
+)
+from eric7.SystemUtilities.QtUtilities import ( # __IGNORE_FLAKES_WARNING__
+ checkPyside,
+ generatePyQtToolPath,
+ generatePySideToolPath,
+ generateQtToolName,
+ getPyQt6ModulesDirectory,
+ getPyQtToolsPath,
+ getQtBinariesPath,
+ getQtMacBundle,
+ prepareQtMacBundle,
qVersionTuple,
- sessionType,
- setConfigDir,
)
from eric7.UI.Info import Program, Version
@@ -803,601 +842,6 @@
return ntxt
-def toNativeSeparators(path):
- """
- Function returning a path, that is using native separator characters.
-
- @param path path to be converted
- @type str
- @return path with converted separator characters
- @rtype str
- """
- return str(pathlib.PurePath(path)) if bool(path) else ""
-
-
-def fromNativeSeparators(path):
- """
- Function returning a path, that is using "/" separator characters.
-
- @param path path to be converted
- @type str
- @return path with converted separator characters
- @rtype str
- """
- return pathlib.PurePath(path).as_posix() if bool(path) else ""
-
-
-def normcasepath(path):
- """
- Function returning a path, that is normalized with respect to its case
- and references.
-
- @param path file path (string)
- @return case normalized path (string)
- """
- return os.path.normcase(os.path.normpath(path))
-
-
-def normcaseabspath(path):
- """
- Function returning an absolute path, that is normalized with respect to
- its case and references.
-
- @param path file path (string)
- @return absolute, normalized path (string)
- """
- return os.path.normcase(os.path.abspath(path))
-
-
-def normjoinpath(a, *p):
- """
- Function returning a normalized path of the joined parts passed into it.
-
- @param a first path to be joined (string)
- @param p variable number of path parts to be joined (string)
- @return normalized path (string)
- """
- return os.path.normpath(os.path.join(a, *p))
-
-
-def normabsjoinpath(a, *p):
- """
- Function returning a normalized, absolute path of the joined parts passed
- into it.
-
- @param a first path to be joined (string)
- @param p variable number of path parts to be joind (string)
- @return absolute, normalized path (string)
- """
- return os.path.abspath(os.path.join(a, *p))
-
-
-def isinpath(file):
- """
- Function to check for an executable file.
-
- @param file filename of the executable to check (string)
- @return flag to indicate, if the executable file is accessible
- via the searchpath defined by the PATH environment variable.
- """
- if os.path.isabs(file):
- return os.access(file, os.X_OK)
-
- if os.path.exists(os.path.join(os.curdir, file)):
- return os.access(os.path.join(os.curdir, file), os.X_OK)
-
- path = getEnvironmentEntry("PATH")
-
- # environment variable not defined
- if path is None:
- return False
-
- dirs = path.split(os.pathsep)
- return any(os.access(os.path.join(directory, file), os.X_OK) for directory in dirs)
-
-
-def startswithPath(path, start):
- """
- Function to check, if a path starts with a given start path.
-
- @param path path to be checked
- @type str
- @param start start path
- @type str
- @return flag indicating that the path starts with the given start
- path
- @rtype bool
- """
- return bool(start) and (
- path == start or normcasepath(path).startswith(normcasepath(start + "/"))
- )
-
-
-def relativeUniversalPath(path, start):
- """
- Function to convert a file path to a path relative to a start path
- with universal separators.
-
- @param path file or directory name to convert (string)
- @param start start path (string)
- @return relative path or unchanged path, if path does not start with
- the start path with universal separators (string)
- """
- return fromNativeSeparators(os.path.relpath(path, start))
-
-
-def absolutePath(path, start):
- """
- Public method to convert a path relative to a start path to an
- absolute path.
-
- @param path file or directory name to convert (string)
- @param start start path (string)
- @return absolute path (string)
- """
- if not os.path.isabs(path):
- path = os.path.normpath(os.path.join(start, path))
- return path
-
-
-def absoluteUniversalPath(path, start):
- """
- Public method to convert a path relative to a start path with
- universal separators to an absolute path.
-
- @param path file or directory name to convert (string)
- @param start start path (string)
- @return absolute path with native separators (string)
- """
- if not os.path.isabs(path):
- path = toNativeSeparators(os.path.normpath(os.path.join(start, path)))
- return path
-
-
-def getExecutablePath(file):
- """
- Function to build the full path of an executable file from the environment.
-
- @param file filename of the executable to check (string)
- @return full executable name, if the executable file is accessible
- via the searchpath defined by the PATH environment variable, or an
- empty string otherwise.
- """
- if os.path.isabs(file):
- if os.access(file, os.X_OK):
- return file
- else:
- return ""
-
- cur_path = os.path.join(os.curdir, file)
- if os.path.exists(cur_path) and os.access(cur_path, os.X_OK):
- return cur_path
-
- path = os.getenv("PATH")
-
- # environment variable not defined
- if path is None:
- return ""
-
- dirs = path.split(os.pathsep)
- for directory in dirs:
- exe = os.path.join(directory, file)
- if os.access(exe, os.X_OK):
- return exe
-
- return ""
-
-
-def getExecutablePaths(file):
- """
- Function to build all full path of an executable file from the environment.
-
- @param file filename of the executable (string)
- @return list of full executable names (list of strings), if the executable
- file is accessible via the searchpath defined by the PATH environment
- variable, or an empty list otherwise.
- """
- paths = []
-
- if os.path.isabs(file):
- if os.access(file, os.X_OK):
- return [file]
- else:
- return []
-
- cur_path = os.path.join(os.curdir, file)
- if os.path.exists(cur_path) and os.access(cur_path, os.X_OK):
- paths.append(cur_path)
-
- path = os.getenv("PATH")
-
- # environment variable not defined
- if path is not None:
- dirs = path.split(os.pathsep)
- for directory in dirs:
- exe = os.path.join(directory, file)
- if os.access(exe, os.X_OK) and exe not in paths:
- paths.append(exe)
-
- return paths
-
-
-def getWindowsExecutablePath(file):
- """
- Function to build the full path of an executable file from the environment
- on Windows platforms.
-
- First an executable with the extension .exe is searched for, thereafter
- such with the extensions .cmd or .bat and finally the given file name as
- is. The first match is returned.
-
- @param file filename of the executable to check (string)
- @return full executable name, if the executable file is accessible
- via the searchpath defined by the PATH environment variable, or an
- empty string otherwise.
- """
- if os.path.isabs(file):
- if os.access(file, os.X_OK):
- return file
- else:
- return ""
-
- filenames = [file + ".exe", file + ".cmd", file + ".bat", file]
-
- for filename in filenames:
- cur_path = os.path.join(os.curdir, filename)
- if os.path.exists(cur_path) and os.access(cur_path, os.X_OK):
- return os.path.abspath(cur_path)
-
- path = os.getenv("PATH")
-
- # environment variable not defined
- if path is None:
- return ""
-
- dirs = path.split(os.pathsep)
- for directory in dirs:
- for filename in filenames:
- exe = os.path.join(directory, filename)
- if os.access(exe, os.X_OK):
- return exe
-
- return ""
-
-
-def isExecutable(exe):
- """
- Function to check, if a file is executable.
-
- @param exe filename of the executable to check (string)
- @return flag indicating executable status (boolean)
- """
- return os.access(exe, os.X_OK)
-
-
-def isDrive(path):
- """
- Function to check, if a path is a Windows drive.
-
- @param path path name to be checked
- @type str
- @return flag indicating a Windows drive
- @rtype bool
- """
- isDrive = False
- drive, directory = os.path.splitdrive(path)
- if (
- drive
- and len(drive) == 2
- and drive.endswith(":")
- and directory in ["", "\\", "/"]
- ):
- isDrive = True
-
- return isDrive
-
-
-def samepath(f1, f2):
- """
- Function to compare two paths.
-
- @param f1 first path for the compare (string)
- @param f2 second path for the compare (string)
- @return flag indicating whether the two paths represent the
- same path on disk.
- """
- if f1 is None or f2 is None:
- return False
-
- if normcaseabspath(os.path.realpath(f1)) == normcaseabspath(os.path.realpath(f2)):
- return True
-
- return False
-
-
-def samefilepath(f1, f2):
- """
- Function to compare two paths. Strips the filename.
-
- @param f1 first filepath for the compare (string)
- @param f2 second filepath for the compare (string)
- @return flag indicating whether the two paths represent the
- same path on disk.
- """
- if f1 is None or f2 is None:
- return False
-
- if normcaseabspath(os.path.dirname(os.path.realpath(f1))) == normcaseabspath(
- os.path.dirname(os.path.realpath(f2))
- ):
- return True
-
- return False
-
-
-try:
- EXTSEP = os.extsep
-except AttributeError:
- EXTSEP = "."
-
-
-def splitPath(name):
- """
- Function to split a pathname into a directory part and a file part.
-
- @param name path name (string)
- @return a tuple of 2 strings (dirname, filename).
- """
- if os.path.isdir(name):
- dn = os.path.abspath(name)
- fn = "."
- else:
- dn, fn = os.path.split(name)
- return (dn, fn)
-
-
-def joinext(prefix, ext):
- """
- Function to join a file extension to a path.
-
- The leading "." of ext is replaced by a platform specific extension
- separator if necessary.
-
- @param prefix the basepart of the filename (string)
- @param ext the extension part (string)
- @return the complete filename (string)
- """
- if ext[0] != ".":
- ext = ".{0}".format(ext)
- # require leading separator to match os.path.splitext
- return prefix + EXTSEP + ext[1:]
-
-
-def compactPath(path, width, measure=len):
- """
- Function to return a compacted path fitting inside the given width.
-
- @param path path to be compacted (string)
- @param width width for the compacted path (integer)
- @param measure reference to a function used to measure the length of the
- string
- @return compacted path (string)
- """
- if measure(path) <= width:
- return path
-
- ellipsis = "..."
-
- head, tail = os.path.split(path)
- mid = len(head) // 2
- head1 = head[:mid]
- head2 = head[mid:]
- while head1:
- # head1 is same size as head2 or one shorter
- path = os.path.join("{0}{1}{2}".format(head1, ellipsis, head2), tail)
- if measure(path) <= width:
- return path
- head1 = head1[:-1]
- head2 = head2[1:]
- path = os.path.join(ellipsis, tail)
- if measure(path) <= width:
- return path
- while tail:
- path = "{0}{1}".format(ellipsis, tail)
- if measure(path) <= width:
- return path
- tail = tail[1:]
- return ""
-
-
-def direntries(
- path, filesonly=False, pattern=None, followsymlinks=True, checkStop=None
-):
- """
- Function returning a list of all files and directories.
-
- @param path root of the tree to check
- @type str
- @param filesonly flag indicating that only files are wanted
- @type bool
- @param pattern a filename pattern or list of filename patterns to check
- against
- @type str or list of str
- @param followsymlinks flag indicating whether symbolic links
- should be followed
- @type bool
- @param checkStop function to be called to check for a stop
- @type function
- @return list of all files and directories in the tree rooted
- at path. The names are expanded to start with path.
- @rtype list of strs
- """
- patterns = pattern if isinstance(pattern, list) else [pattern]
- files = [] if filesonly else [path]
- try:
- entries = os.listdir(path)
- for entry in entries:
- if checkStop and checkStop():
- break
-
- if entry in [
- ".svn",
- ".hg",
- ".git",
- ".ropeproject",
- ".eric7project",
- ".jedi",
- ]:
- continue
-
- fentry = os.path.join(path, entry)
- if (
- pattern
- and not os.path.isdir(fentry)
- and not any(fnmatch.fnmatch(entry, p) for p in patterns)
- ):
- # entry doesn't fit the given pattern
- continue
-
- if os.path.isdir(fentry):
- if os.path.islink(fentry) and not followsymlinks:
- continue
- files += direntries(
- fentry, filesonly, pattern, followsymlinks, checkStop
- )
- else:
- files.append(fentry)
- except OSError:
- pass
- except UnicodeDecodeError:
- pass
- return files
-
-
-def getDirs(path, excludeDirs):
- """
- Function returning a list of all directories below path.
-
- @param path root of the tree to check
- @param excludeDirs basename of directories to ignore
- @return list of all directories found
- """
- try:
- names = os.listdir(path)
- except OSError:
- return []
-
- dirs = []
- for name in names:
- if os.path.isdir(os.path.join(path, name)) and not os.path.islink(
- os.path.join(path, name)
- ):
- exclude = 0
- for e in excludeDirs:
- if name.split(os.sep, 1)[0] == e:
- exclude = 1
- break
- if not exclude:
- dirs.append(os.path.join(path, name))
-
- for name in dirs[:]:
- if not os.path.islink(name):
- dirs += getDirs(name, excludeDirs)
-
- return dirs
-
-
-def findVolume(volumeName, findAll=False):
- """
- Function to find the directory belonging to a given volume name.
-
- @param volumeName name of the volume to search for
- @type str
- @param findAll flag indicating to get the directories for all volumes
- starting with the given name (defaults to False)
- @type bool (optional)
- @return directory path or list of directory paths for the given volume
- name
- @rtype str or list of str
- """
- volumeDirectories = []
- volumeDirectory = None
-
- if isWindowsPlatform():
- # we are on a Windows platform
- def getVolumeName(diskName):
- """
- Local function to determine the volume of a disk or device.
-
- Each disk or external device connected to windows has an
- attribute called "volume name". This function returns the
- volume name for the given disk/device.
-
- Code from http://stackoverflow.com/a/12056414
- """
- volumeNameBuffer = ctypes.create_unicode_buffer(1024)
- ctypes.windll.kernel32.GetVolumeInformationW(
- ctypes.c_wchar_p(diskName),
- volumeNameBuffer,
- ctypes.sizeof(volumeNameBuffer),
- None,
- None,
- None,
- None,
- 0,
- )
- return volumeNameBuffer.value
-
- #
- # In certain circumstances, volumes are allocated to USB
- # storage devices which cause a Windows popup to raise if their
- # volume contains no media. Wrapping the check in SetErrorMode
- # with SEM_FAILCRITICALERRORS (1) prevents this popup.
- #
- oldMode = ctypes.windll.kernel32.SetErrorMode(1)
- try:
- for disk in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
- dirpath = "{0}:\\".format(disk)
- if os.path.exists(dirpath):
- if findAll:
- if getVolumeName(dirpath).startswith(volumeName):
- volumeDirectories.append(dirpath)
- else:
- if getVolumeName(dirpath) == volumeName:
- volumeDirectory = dirpath
- break
- finally:
- ctypes.windll.kernel32.SetErrorMode(oldMode)
- else:
- # we are on a Linux or macOS platform
- for mountCommand in ["mount", "/sbin/mount", "/usr/sbin/mount"]:
- with contextlib.suppress(FileNotFoundError):
- mountOutput = subprocess.run( # secok
- mountCommand, check=True, capture_output=True, text=True
- ).stdout.splitlines()
- mountedVolumes = [
- x.split(" type")[0].split(maxsplit=2)[2] for x in mountOutput
- ]
- if findAll:
- for volume in mountedVolumes:
- if volumeName in volume:
- volumeDirectories.append(volume)
- if volumeDirectories:
- break
- else:
- for volume in mountedVolumes:
- if volume.endswith(volumeName):
- volumeDirectory = volume
- break
- if volumeDirectory:
- break
-
- if findAll:
- return volumeDirectories
- else:
- return volumeDirectory
-
-
def getTestFileNames(fn):
"""
Function to build the potential file names of a test file.
@@ -1633,146 +1077,6 @@
)
-def getUserName():
- """
- Function to get the user name.
-
- @return user name (string)
- """
- user = getpass.getuser()
-
- if isWindowsPlatform() and not user:
- return win32_GetUserName()
-
- return user
-
-
-def getRealName():
- """
- Function to get the real name of the user.
-
- @return real name of the user (string)
- """
- if isWindowsPlatform():
- return win32_getRealName()
- else:
- user = getpass.getuser()
- return pwd.getpwnam(user).pw_gecos
-
-
-def getHomeDir():
- """
- Function to get a users home directory.
-
- @return home directory (string)
- """
- return QDir.homePath()
-
-
-def getPythonLibPath():
- """
- Function to determine the path to Python's library.
-
- @return path to the Python library (string)
- """
- pyFullVers = sys.version.split()[0]
-
- vl = re.findall("[0-9.]*", pyFullVers)[0].split(".")
- major = vl[0]
- minor = vl[1]
-
- pyVers = major + "." + minor
-
- if isWindowsPlatform():
- libDir = sys.prefix + "\\Lib"
- else:
- try:
- syslib = sys.lib
- except AttributeError:
- syslib = "lib"
- libDir = sys.prefix + "/" + syslib + "/python" + pyVers
-
- return libDir
-
-
-def getPythonVersion():
- """
- Function to get the Python version (major, minor) as an integer value.
-
- @return An integer representing major and minor version number (integer)
- """
- return sys.hexversion >> 16
-
-
-def determinePythonVersion(filename, source, editor=None):
- """
- Function to determine the python version of a given file.
-
- @param filename name of the file with extension (str)
- @param source of the file (str)
- @param editor reference to the editor, if the file is opened
- already (Editor object)
- @return Python version if file is Python3 (int)
- """
- pyAssignment = {
- "Python3": 3,
- "MicroPython": 3,
- "Cython": 3,
- }
-
- if not editor:
- viewManager = ericApp().getObject("ViewManager")
- editor = viewManager.getOpenEditor(filename)
-
- # Maybe the user has changed the language
- if editor and editor.getFileType() in pyAssignment:
- return pyAssignment[editor.getFileType()]
-
- pyVer = 0
- if filename:
- if not source:
- source = readEncodedFile(filename)[0]
- flags = extractFlags(source)
- ext = os.path.splitext(filename)[1]
- py3Ext = Preferences.getPython("Python3Extensions")
- project = ericApp().getObject("Project")
- basename = os.path.basename(filename)
-
- if "FileType" in flags:
- pyVer = pyAssignment.get(flags["FileType"], 0)
- elif project.isOpen() and project.isProjectFile(filename):
- language = project.getEditorLexerAssoc(basename)
- if not language:
- language = Preferences.getEditorLexerAssoc(basename)
- if language == "Python3":
- pyVer = pyAssignment[language]
-
- if pyVer:
- # Skip the next tests
- pass
- elif (
- Preferences.getProject("DeterminePyFromProject")
- and project.isOpen()
- and project.isProjectFile(filename)
- and ext in py3Ext
- ):
- pyVer = pyAssignment.get(project.getProjectLanguage(), 0)
- elif ext in py3Ext:
- pyVer = 3
- elif source:
- if isinstance(source, str):
- line0 = source.splitlines()[0]
- else:
- line0 = source[0]
- if line0.startswith("#!") and (("python3" in line0) or ("python" in line0)):
- pyVer = 3
-
- if pyVer == 0 and ext in py3Ext:
- pyVer = 3
-
- return pyVer
-
-
def rxIndex(rx, txt):
"""
Function to get the index (start position) of a regular expression match
@@ -1793,247 +1097,6 @@
###############################################################################
-## functions for environment handling
-###############################################################################
-
-
-def getEnvironmentEntry(key, default=None):
- """
- Module function to get an environment entry.
-
- @param key key of the requested environment entry (string)
- @param default value to be returned, if the environment doesn't contain
- the requested entry (string)
- @return the requested entry or the default value, if the entry wasn't
- found (string or None)
- """
- pattern = "^{0}[ \t]*=".format(key)
- filterRe = (
- re.compile(pattern, re.IGNORECASE)
- if isWindowsPlatform()
- else re.compile(pattern)
- )
-
- entries = [
- e for e in QProcess.systemEnvironment() if filterRe.search(e) is not None
- ]
- if not entries:
- return default
-
- # if there are multiple entries, just consider the first one
- ename, value = entries[0].split("=", 1)
- return value.strip()
-
-
-def hasEnvironmentEntry(key):
- """
- Module function to check, if the environment contains an entry.
-
- @param key key of the requested environment entry
- @type str
- @return flag indicating the presence of the requested entry
- @rtype bool
- """
- pattern = "^{0}[ \t]*=".format(key)
- filterRe = (
- re.compile(pattern, re.IGNORECASE)
- if isWindowsPlatform()
- else re.compile(pattern)
- )
-
- entries = [
- e for e in QProcess.systemEnvironment() if filterRe.search(e) is not None
- ]
- return len(entries) > 0
-
-
-###############################################################################
-## Qt utility functions below
-###############################################################################
-
-
-def generateQtToolName(toolname):
- """
- Module function to generate the executable name for a Qt tool like
- designer.
-
- @param toolname base name of the tool (string)
- @return the Qt tool name without extension (string)
- """
- return "{0}{1}{2}".format(
- Preferences.getQt("QtToolsPrefix"),
- toolname,
- Preferences.getQt("QtToolsPostfix"),
- )
-
-
-def getQtMacBundle(toolname):
- """
- Module function to determine the correct Mac OS X bundle name for Qt tools.
-
- @param toolname plain name of the tool (e.g. "designer") (string)
- @return bundle name of the Qt tool (string)
- """
- qtDir = getQtBinariesPath()
- bundles = [
- os.path.join(qtDir, "bin", generateQtToolName(toolname.capitalize())) + ".app",
- os.path.join(qtDir, "bin", generateQtToolName(toolname)) + ".app",
- os.path.join(qtDir, generateQtToolName(toolname.capitalize())) + ".app",
- os.path.join(qtDir, generateQtToolName(toolname)) + ".app",
- ]
- if toolname == "designer":
- # support the standalone Qt Designer installer from
- # https://build-system.fman.io/qt-designer-download
- designer = "Qt Designer.app"
- bundles.extend(
- [
- os.path.join(qtDir, "bin", designer),
- os.path.join(qtDir, designer),
- ]
- )
- for bundle in bundles:
- if os.path.exists(bundle):
- return bundle
- return ""
-
-
-def prepareQtMacBundle(toolname, args):
- """
- Module function for starting Qt tools that are Mac OS X bundles.
-
- @param toolname plain name of the tool (e.g. "designer")
- @type str
- @param args name of input file for tool, if any
- @type list of str
- @return command-name and args for QProcess
- @rtype tuple of (str, list of str)
- """
- fullBundle = getQtMacBundle(toolname)
- if fullBundle == "":
- return ("", [])
-
- newArgs = []
- newArgs.append("-a")
- newArgs.append(fullBundle)
- if args:
- newArgs.append("--args")
- newArgs += args
-
- return ("open", newArgs)
-
-
-###############################################################################
-## PyQt utility functions below
-###############################################################################
-
-
-def generatePyQtToolPath(toolname, alternatives=None):
- """
- Module function to generate the executable path for a PyQt tool.
-
- @param toolname base name of the tool
- @type str
- @param alternatives list of alternative tool names to try
- @type list of str
- @return executable path name of the tool
- @rtype str
- """
- pyqtVariant = int(toolname[-1])
- pyqtToolsPath = getPyQtToolsPath(pyqtVariant)
- if pyqtToolsPath:
- exe = os.path.join(pyqtToolsPath, toolname)
- if isWindowsPlatform():
- exe += ".exe"
- else:
- if isWindowsPlatform():
- exe = getWindowsExecutablePath(toolname)
- else:
- exe = toolname
-
- if not isinpath(exe) and alternatives:
- ex_ = generatePyQtToolPath(alternatives[0], alternatives[1:])
- if isinpath(ex_):
- exe = ex_
-
- return exe
-
-
-###############################################################################
-## PySide2/PySide6 utility functions below
-###############################################################################
-
-
-def generatePySideToolPath(toolname, variant=2):
- """
- Module function to generate the executable path for a PySide2/PySide6 tool.
-
- @param toolname base name of the tool
- @type str
- @param variant indicator for the PySide variant
- @type int or str
- @return the PySide2/PySide6 tool path with extension
- @rtype str
- """
- if isWindowsPlatform():
- hasPyside = checkPyside(variant)
- if not hasPyside:
- return ""
-
- venvName = Preferences.getQt("PySide{0}VenvName".format(variant))
- if not venvName:
- venvName = Preferences.getDebugger("Python3VirtualEnv")
- interpreter = (
- ericApp().getObject("VirtualEnvManager").getVirtualenvInterpreter(venvName)
- )
- if interpreter == "" or not isinpath(interpreter):
- interpreter = getPythonExecutable()
- prefix = os.path.dirname(interpreter)
- if not prefix.endswith("Scripts"):
- prefix = os.path.join(prefix, "Scripts")
- return os.path.join(prefix, toolname + ".exe")
- else:
- # step 1: check, if the user has configured a tools path
- path = Preferences.getQt("PySide{0}ToolsDir".format(variant))
- if path:
- return os.path.join(path, toolname)
-
- # step 2: determine from used Python interpreter
- dirName = os.path.dirname(sys.executable)
- if os.path.exists(os.path.join(dirName, toolname)):
- return os.path.join(dirName, toolname)
-
- return toolname
-
-
-@functools.lru_cache()
-def checkPyside(variant=2):
- """
- Module function to check the presence of PySide2/PySide6.
-
- @param variant indicator for the PySide variant
- @type int or str
- @return flags indicating the presence of PySide2/PySide6
- @rtype bool
- """
- venvName = Preferences.getQt("PySide{0}VenvName".format(variant))
- if not venvName:
- venvName = Preferences.getDebugger("Python3VirtualEnv")
- interpreter = (
- ericApp().getObject("VirtualEnvManager").getVirtualenvInterpreter(venvName)
- )
- if interpreter == "" or not isinpath(interpreter):
- interpreter = getPythonExecutable()
-
- checker = os.path.join(getConfig("ericDir"), "Utilities", "PySideImporter.py")
- args = [checker, "--variant={0}".format(variant)]
- proc = QProcess()
- proc.setProcessChannelMode(QProcess.ProcessChannelMode.MergedChannels)
- proc.start(interpreter, args)
- finished = proc.waitForFinished(30000)
- return finished and proc.exitCode() == 0
-
-
-###############################################################################
## Other utility functions below
###############################################################################
@@ -2093,11 +1156,11 @@
if os.environ.get("SOMMELIER_VERSION", ""):
info[-1] += ", ChromeOS"
info.append(sys.version)
- desktop = desktopName()
+ desktop = DesktopUtilities.desktopName()
if desktop:
info.append("")
info.append("Desktop: {0}".format(desktop))
- session = sessionType()
+ session = DesktopUtilities.sessionType()
if session:
info.append("")
info.append("Session Type: {0}".format(session))
@@ -2160,21 +1223,6 @@
return linesep.join(info)
-def toBool(dataStr):
- """
- Module function to convert a string to a boolean value.
-
- @param dataStr string to be converted (string)
- @return converted boolean value (boolean)
- """
- if dataStr in ["True", "true", "1", "Yes", "yes"]:
- return True
- elif dataStr in ["False", "false", "0", "No", "no"]:
- return False
- else:
- return bool(dataStr)
-
-
def getSysPath(interpreter):
"""
Module function to get the Python path (sys.path) of a specific
@@ -2203,62 +1251,3 @@
sysPath.remove("")
return sysPath
-
-
-###############################################################################
-## posix compatibility functions below
-###############################################################################
-
-# None right now
-
-###############################################################################
-## win32 compatibility functions below
-###############################################################################
-
-
-def win32_Kill(pid):
- """
- Function to provide an os.kill equivalent for Win32.
-
- @param pid process id (integer)
- @return result of the kill (boolean)
- """
- import win32api # __IGNORE_WARNING_I102__
-
- handle = win32api.OpenProcess(1, 0, pid)
- return 0 != win32api.TerminateProcess(handle, 0)
-
-
-def win32_GetUserName():
- """
- Function to get the user name under Win32.
-
- @return user name (string)
- """
- try:
- import win32api # __IGNORE_WARNING_I10__
-
- return win32api.GetUserName()
- except ImportError:
- try:
- u = getEnvironmentEntry("USERNAME")
- except KeyError:
- u = getEnvironmentEntry("username", None)
- return u
-
-
-def win32_getRealName():
- """
- Function to get the user's real name (aka. display name) under Win32.
-
- @return real name of the current user (string)
- """
- GetUserNameEx = ctypes.windll.secur32.GetUserNameExW
- NameDisplay = 3
-
- size = ctypes.pointer(ctypes.c_ulong(0))
- GetUserNameEx(NameDisplay, None, size)
-
- nameBuffer = ctypes.create_unicode_buffer(size.contents.value)
- GetUserNameEx(NameDisplay, nameBuffer, size)
- return nameBuffer.value
