| |
| |
|
|
| """ |
| **Project Name:** MakeHuman |
| |
| **Product Home Page:** http://www.makehumancommunity.org/ |
| |
| **Github Code Home Page:** https://github.com/makehumancommunity/ |
| |
| **Authors:** Jonas Hauquier, Glynn Clements, Joel Palmius, Marc Flerackers |
| |
| **Copyright(c):** MakeHuman Team 2001-2020 |
| |
| **Licensing:** AGPL3 |
| |
| This file is part of MakeHuman Community (www.makehumancommunity.org). |
| |
| This program is free software: you can redistribute it and/or modify |
| it under the terms of the GNU Affero General Public License as |
| published by the Free Software Foundation, either version 3 of the |
| License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| |
| |
| Abstract |
| -------- |
| |
| Utility module for finding the user home path. |
| """ |
|
|
| import os |
| import sys |
|
|
| from library.xdg_parser import XDG_PATHS |
|
|
| __home_path = None |
|
|
| |
| |
|
|
| if sys.platform.startswith("linux"): |
|
|
| configFile = os.path.expanduser("~/.config/makehuman.conf") |
|
|
| elif sys.platform.startswith("darwin"): |
|
|
| configFile = os.path.expanduser("~/Library/Application Support/MakeHuman/makehuman.conf") |
|
|
| elif sys.platform.startswith("win32"): |
|
|
| configFile = os.path.join(os.getenv("LOCALAPPDATA", ""), "makehuman.conf") |
|
|
| else: |
|
|
| configFile = "" |
|
|
| configPath = "" |
|
|
| if os.path.isfile(configFile): |
| with open(configFile, "r", encoding="utf-8") as f: |
| configPath = f.readline().strip() |
|
|
| if os.path.isdir(configPath): |
| __home_path = os.path.normpath(configPath).replace("\\", "/") |
|
|
|
|
| def pathToUnicode(path): |
| """ |
| Unicode representation of the filename. |
| Bytes is decoded with the codeset used by the filesystem of the operating |
| system. |
| Unicode representations of paths are fit for use in GUI. |
| """ |
|
|
| if isinstance(path, bytes): |
| |
| try: |
| return str(path, "utf-8") |
| except UnicodeDecodeError: |
| pass |
| try: |
| return str(path, sys.getfilesystemencoding()) |
| except UnicodeDecodeError: |
| pass |
| try: |
| return str(path, sys.getdefaultencoding()) |
| except UnicodeDecodeError: |
| pass |
| try: |
| import locale |
|
|
| return str(path, locale.getpreferredencoding()) |
| except UnicodeDecodeError: |
| return path |
| else: |
| return path |
|
|
|
|
| def formatPath(path): |
| if path is None: |
| return None |
| return pathToUnicode(os.path.normpath(path).replace("\\", "/")) |
|
|
|
|
| def canonicalPath(path): |
| """ |
| Return canonical name for location specified by path. |
| Useful for comparing paths. |
| """ |
| return formatPath(os.path.realpath(path)) |
|
|
|
|
| def localPath(path): |
| """ |
| Returns the path relative to the MH program directory, |
| i.e. the inverse of canonicalPath. |
| """ |
| path = os.path.realpath(path) |
| root = os.path.realpath(getSysPath()) |
| return formatPath(os.path.relpath(path, root)) |
|
|
|
|
| def getHomePath(): |
| """ |
| Find the user home path. |
| Note: If you are looking for MakeHuman data, you probably want getPath()! |
| """ |
| |
| global __home_path |
|
|
| |
| alt_home_path = os.environ.get("MH_HOME_LOCATION", "") |
| if os.path.isdir(alt_home_path): |
| __home_path = formatPath(alt_home_path) |
|
|
| if __home_path is not None: |
| return __home_path |
|
|
| |
| if sys.platform.startswith("win"): |
| import winreg |
|
|
| keyname = r"Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" |
| |
| with winreg.OpenKey(winreg.HKEY_CURRENT_USER, keyname) as k: |
| try: |
| value, type_ = winreg.QueryValueEx(k, "Personal") |
| except FileNotFoundError: |
| value, type_ = r"%USERPROFILE%\Documents", winreg.REG_EXPAND_SZ |
| if type_ == winreg.REG_EXPAND_SZ: |
| __home_path = formatPath(winreg.ExpandEnvironmentStrings(value)) |
| return __home_path |
| elif type_ == winreg.REG_SZ: |
| __home_path = formatPath(value) |
| return __home_path |
| else: |
| raise RuntimeError("Couldn't determine user folder") |
|
|
| |
| elif sys.platform.startswith("linux"): |
| doc_folder = XDG_PATHS.get("DOCUMENTS", "") |
| if os.path.isdir(doc_folder): |
| __home_path = doc_folder |
| else: |
| __home_path = pathToUnicode(os.path.expanduser("~")) |
|
|
| |
| else: |
| __home_path = os.path.expanduser("~") |
|
|
| return __home_path |
|
|
|
|
| def getPath(subPath=""): |
| """ |
| Get MakeHuman folder that contains per-user files, located in the user home |
| path. |
| """ |
| path = getHomePath() |
|
|
| |
| if sys.platform.startswith("win"): |
| path = os.path.join(path, "makehuman") |
|
|
| |
| elif sys.platform.startswith("darwin"): |
| path = os.path.join(path, "Documents") |
| path = os.path.join(path, "MakeHuman") |
|
|
| |
| else: |
| path = os.path.join(path, "makehuman") |
|
|
| path = os.path.join(path, "v1py3") |
|
|
| if subPath: |
| path = os.path.join(path, subPath) |
|
|
| return formatPath(path) |
|
|
|
|
| def getDataPath(subPath=""): |
| """ |
| Path to per-user data folder, should always be the same as getPath('data'). |
| """ |
| if subPath: |
| path = getPath(os.path.join("data", subPath)) |
| else: |
| path = getPath("data") |
| return formatPath(path) |
|
|
|
|
| def getSysDataPath(subPath=""): |
| """ |
| Path to the data folder that is installed with MakeHuman system-wide. |
| NOTE: do NOT assume that getSysPath("data") == getSysDataPath()! |
| """ |
| if subPath: |
| path = getSysPath(os.path.join("data", subPath)) |
| else: |
| path = getSysPath("data") |
| return formatPath(path) |
|
|
|
|
| def getSysPath(subPath=""): |
| """ |
| Path to the system folder where MakeHuman is installed (it is possible that |
| data is stored in another path). |
| Writing to this folder or modifying this data usually requires admin rights, |
| contains system-wide data (for all users). |
| """ |
| if subPath: |
| path = os.path.join(".", subPath) |
| else: |
| path = "." |
| return formatPath(path) |
|
|
|
|
| def _allnamesequal(name): |
| return all(n == name[0] for n in name[1:]) |
|
|
|
|
| def commonprefix(paths, sep="/"): |
| """ |
| Implementation of os.path.commonprefix that works as you would expect. |
| |
| Source: http://rosettacode.org/wiki/Find_Common_Directory_Path#Python |
| """ |
| from itertools import takewhile |
|
|
| bydirectorylevels = list(zip(*[p.split(sep) for p in paths])) |
| return sep.join(x[0] for x in takewhile(_allnamesequal, bydirectorylevels)) |
|
|
|
|
| def isSubPath(subpath, path): |
| """ |
| Verifies whether subpath is within path. |
| """ |
| subpath = canonicalPath(subpath) |
| path = canonicalPath(path) |
| return commonprefix([subpath, path]) == path |
|
|
|
|
| def isSamePath(path1, path2): |
| """ |
| Determines whether two paths point to the same location. |
| """ |
| return canonicalPath(path1) == canonicalPath(path2) |
|
|
|
|
| def getRelativePath(path, relativeTo=[getDataPath(), getSysDataPath()], strict=False): |
| """ |
| Return a relative file path, relative to one of the specified search paths. |
| First valid path is returned, so order in which search paths are given matters. |
| """ |
| if not isinstance(relativeTo, list): |
| relativeTo = [relativeTo] |
|
|
| relto = None |
| for p in relativeTo: |
| if isSubPath(path, p): |
| relto = p |
| if relto is None: |
| if strict: |
| return None |
| else: |
| return path |
|
|
| relto = os.path.abspath(os.path.realpath(relto)) |
| path = os.path.abspath(os.path.realpath(path)) |
| rpath = os.path.relpath(path, relto) |
| return formatPath(rpath) |
|
|
|
|
| def findFile(relPath, searchPaths=[getDataPath(), getSysDataPath()], strict=False): |
| """ |
| Inverse of getRelativePath: find an absolute path from specified relative |
| path in one of the search paths. |
| First occurence is returned, so order in which search paths are given matters. |
| Note: does NOT treat the path as relative to the current working dir, unless |
| you explicitly specify '.' as one of the searchpaths. |
| """ |
| if not isinstance(searchPaths, list): |
| searchPaths = [searchPaths] |
|
|
| for dataPath in searchPaths: |
| path = os.path.join(dataPath, relPath) |
| if os.path.isfile(path): |
| return formatPath(path) |
|
|
| if strict: |
| return None |
| else: |
| return relPath |
|
|
|
|
| def thoroughFindFile(filename, searchPaths=[], searchDefaultPaths=True): |
| """ |
| Extensively search the data paths to find a file with matching filename in |
| as much cases as possible. If file is found, returns absolute filename. |
| If nothing is found return the most probable filename. |
| """ |
| |
| filename.replace("\\", "/") |
|
|
| if not isinstance(searchPaths, list): |
| searchPaths = [searchPaths] |
|
|
| if searchDefaultPaths: |
| |
| searchPaths = list(searchPaths) |
| searchPaths.extend([getDataPath(), getSysDataPath(), getPath(), getSysPath()]) |
|
|
| path = findFile(filename, searchPaths, strict=True) |
| if path: |
| return canonicalPath(path) |
|
|
| |
| if os.path.isfile(filename): |
| return canonicalPath(filename) |
|
|
| |
| if filename.startswith("data/"): |
| result = thoroughFindFile(filename[5:], searchPaths, False) |
| if os.path.isfile(result): |
| return result |
|
|
| |
| return formatPath(filename) |
|
|
|
|
| def search(paths, extensions, recursive=True, mutexExtensions=False): |
| """ |
| Search for files with specified extensions in specified paths. |
| If mutexExtensions is True, no duplicate files with only differing extension |
| will be returned. Instead, only the file with highest extension precedence |
| (extensions occurs earlier in the extensions list) is kept. |
| """ |
| if isinstance(paths, str): |
| paths = [paths] |
| if isinstance(extensions, str): |
| extensions = [extensions] |
| extensions = [e[1:].lower() if e.startswith(".") else e.lower() for e in extensions] |
|
|
| if mutexExtensions: |
| discovered = dict() |
|
|
| def _aggregate_files_mutexExt(filepath): |
| basep, ext = os.path.splitext(filepath) |
| ext = ext[1:] |
| if basep in discovered: |
| if extensions.index(ext) < extensions.index(discovered[basep]): |
| discovered[basep] = ext |
| else: |
| discovered[basep] = ext |
|
|
| if recursive: |
| for path in paths: |
| for root, dirs, files in os.walk(path): |
| for f in files: |
| ext = os.path.splitext(f)[1][1:].lower() |
| if ext in extensions: |
| if mutexExtensions: |
| _aggregate_files_mutexExt(os.path.join(root, f)) |
| else: |
| yield pathToUnicode(os.path.join(root, f)) |
| else: |
| for path in paths: |
| if not os.path.isdir(path): |
| continue |
| for f in os.listdir(path): |
| f = os.path.join(path, f) |
| if os.path.isfile(f): |
| ext = os.path.splitext(f)[1][1:].lower() |
| if ext in extensions: |
| if mutexExtensions: |
| _aggregate_files_mutexExt(f) |
| else: |
| yield pathToUnicode(f) |
|
|
| if mutexExtensions: |
| for f in ["%s.%s" % (p, e) for p, e in list(discovered.items())]: |
| yield pathToUnicode(f) |
|
|
|
|
| def getJailedPath(filepath, relativeTo, jailLimits=[getDataPath(), getSysDataPath()]): |
| """ |
| Get a path to filepath, relative to relativeTo path, confined within the |
| jailLimits folders. Returns None if the path would fall outside of the jail. |
| This is a portable path which can be used for distributing eg. materials |
| (texture paths are portable). |
| Returns None if the filepath falls outside of the jail folders. Returns |
| a path to filename relative to relativeTo path if it is a subpath of it, |
| else returns a path relative to the jailLimits. |
| """ |
|
|
| def _withinJail(path): |
| for j in jailLimits: |
| if isSubPath(path, j): |
| return True |
| return False |
|
|
| |
| |
| filepath = os.path.realpath(filepath) |
|
|
| if relativeTo is str: |
| relativeTo = os.path.realpath(relativeTo) |
|
|
| output = None |
|
|
| if _withinJail(filepath): |
| relPath = getRelativePath(filepath, relativeTo, strict=True) |
| if relPath: |
| output = relPath |
| else: |
| output = getRelativePath(filepath, jailLimits) |
| return output |
|
|
