Méthode Python | os.path.realpath ()

Michael Zippo

Le module Python OS fournit des fonctions pour interagir avec le système d`exploitation. Le système d`exploitation est livré avec des modules de service Python standard. Ce module fournit un moyen portable d`utiliser les fonctionnalités spécifiques du système d`exploitation. Le module os.path est un sous-module du module Python OS utilisé pour gérer les chemins partagés. os.path.realpath () en Python est utilisé pour obtenir le chemin canonique du nom de fichier spécifié par supprimer tous les liens symboliques qui se produisent dans le chemin.

Syntaxe : os.path.realpath(path) Paramètre : path : un chemin semblable à objet représentant le chemin du système de fichiers. Un objet de type chemin est soit une chaîne, soit un objet d`octets représentant un chemin. Type de retour : cette méthode renvoie une valeur de chaîne qui représente le chemin canonique.

Créer un lien symbolique ou un lien symbolique

Sous Unix ou Linux, un lien symbolique ou un lien symbolique peut être créé à l`aide de la commande ln. Voici la syntaxe pour créer un lien symbolique sur la ligne de commande :

$ ln -s {source-filename} {symbolic-filename}

Exemple 1

def realpath(self, spec, key): """ Résolvez et mettez à jour la clé de chemin dans la spécification avec son realpath, basé sur le répertoire de travail. """ si la clé n`est pas dans les spécifications : # ne rien faire pour renvoie maintenant si ce n`est pas spec [clé] : logger.warning( "impossible de résoudre realpath de `%s ` car il n`est pas défini", clé) return check = realpath(join(spec.get( WORKING_DIR, ``), spec[key])) if check != spec[key]: spec[key] = check logger.warning( "realpath de `%s` résolu en `%s`, la spécification est mise à jour", key, check ) return che ck # Méthodes liées à la configuration

Exemple 2

def get_rp_stripper(strip_path): """ Renvoie la fonction pour supprimer ``realpath`` de `strip_path` à partir de la chaîne Paramètres ---------- strip_path : str chemin à supprimer depuis le début des chaînes. Traité en ``strip_prefix`` par ``realpath(strip_path) + os.path.sep` `. Renvoie ------- stripper : fonction func telle que ``stripper(a_string)`` supprimera ``strip_prefix`` de ``a_string`` s`il est présent, sinon passer ``a_string`` non modifié """ return get_prefix_stripper(realpath(strip_path) + os.path.sep)

Exemple 3

def test_toolchain_standard_not_implemented(self) : spec = Spec() with self.assertRaises(NotImplementedError) : self.toolchain(spec) with self.assertRaises(NotImplementedError) : self.toolchain.assemble(spec) with self.assertRaises(NotImplementedError): self.toolchain.link(spec) # Vérifiez que le build_dir est défini sur la spécification basée sur le fichier temporaire self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # De plus, il a été supprimé correctement. self.assertFalse(exists(spec[`build_dir`] ))

Exemple 4

def find_system_jdks() : """ Renvoie un ensemble de JD valides Répertoires K en recherchant des emplacements standard. """ bases = [ `/Library/Java/JavaVirtualMachines`, `/usr/lib/jvm`, `/usr/java`, `/usr/jdk/instances`, r`C:Program FilesJava` ] jdks = set() for base in bases: if isdir(base): for n in os.listdir(base): jdk = join(base, n) mac_jdk = join(jdk, `Contents`, `Home`) if isdir(mac_jdk ): jdk = mac_jdk if is_valid_jdk(jdk): jdks.add(realpath(jdk)) return jdks

Exemple 5

def _expand_dirs_to_files(files_or_dirs, recursive=False) : files = [] files_or_dirs = _ensure_list(files_or_dirs) for file_or_dir in files_or_dirs : file_or_dir = op.realpath(file_or_dir) if op.isdir(file_or_dir): # Ignorer les noms de répertoire commençant par `.` if _to_skip(file_or_dir): continue # Visitez récursivement les répertoires et ajoutez les fichiers. if recursive: files.extend(_expand_dirs_to_files([op.join(file_or_dir, file) for file in os.listdir(file_or_dir)], recursive=recursive) ) sinon : files.extend([op.join(file_or_dir, file) for file in os.listdir(file_or_dir)]) elif `*` in file_or_dir : files.extend(glob.glob(file_or_dir)) else : files.append (file_or_dir) return files

Example 6

def getSubdirs(path, baseNamesOnly=True, excludePythonModulesDirs=True): """Fournit une liste de sous-répertoires pour le chemin donné"" " subdirs = [] essayez : path = realpath(path) + sep pour l`élément dans os.listdir (chemin) : candidat = chemin + élément si isdir(candidat) : si excludePythonModulesDirs : modFile = candidat + sep + "__init__.py" si existe (modFile) : continuer si baseNamesOnly : subdirs.append(item) else : subdirs.append (candidat) sauf : pass return subdirs

Exemple 7

def get_dataset(num_points) : name = `ModelNet10` path = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) pre_transform = T.NormalizeScale() transform = T.SamplePoints(num_points) train_dataset = ModelNet( path, name=`10`, train=True, transform=transform, pre_transform=pre_transform) test_dataset = ModelNet( path, name=`10`, train=False, transform=transform, pre_transform=pre_transform) return train_dataset, test_dataset

Exemple 8

def getParameters(self): """Fournit un dictionnaire avec les paramètres de recherche""" parameters = {`term`: self.findCombo.currentText(), `case`: self.caseCheckBox.isChecked( ), `whole` : self.wordCheckBox.isChecked(), `regexp` : self.regexpCheckBox.isChecked()} if self.projectRButton.isChecked() : parameters[`in-project`] = True parameters[`in- open`] = False parameters[`in-dir`] = `` elif self.openFilesRButton.isChecked(): parameters[`in-project`] = F alse parameters[`in-opened`] = True parameters[`in-dir`] = `` else: parameters[`in-project`] = False parameters[`in-opened`] = False parameters[`in-dir `] = realpath( self.dirEditCombo.currentText().strip()) parameters[`file -filter`] = self.filterCombo.currentText().strip() renvoie les paramètres

Exemple 9

def _check_if_pyc(fname) : """Renvoie Vrai si l`extension est . pyc, False si .py et None sinon""" from imp import find_module from os.path import realpath, dirname, basename, splitext # Normaliser le chemin de fichier pour le chemin de fichier find_module() = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Valider et récupérer try: fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath]) except ImportError : raise IOError("Impossible de trouver le fichier de configuration. " "Le chemin est peut-être incorrect ! : {0}".format(filepath)) return pytype, fileobj, fullpath

Exemple 10

def get_planetoid_dataset(name, normalize_features=False, transform= Aucun): chemin = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) dataset = Planetoid(path, name) if transform is not None and normalize_features : dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features : dataset. transform = T.NormalizeFeatures() elif transform n`est pas None : dataset.transform = transform return dataset

Exemple 11

def _setup_logger(cls, log_file=None) : formatter = logging. Formatter( fmt="%(asctime)s %(levelname)-8s %(message)s", datefmt="%Y-%m-%d %H:%M:%S" ) screen_handler = logging.StreamHandler( stream=sys.stdout) screen_handler.setFormatter(formatter) logger = logging.getLogger(cls.__name__) logger.setLevel(logging.DEBUG) logger.addHandler(screen_handl er) si log_file : file_handler = logging.FileHandler(realpath(log_file), mode="w" ) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return logger

Exemple 12

def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro") : u""" Ë∑ëbroÊúçÂä°ËøõÁ®ã """ # Ëé∑ÂèñÁªùÂØπË∑ØÂæÑ bro_file = path.realpath(bro_file) http_file = "/usr/local/bro/share/bro/base/protocols/http/main.bro" bro_scripts = ` `.join([bro_file, http_file ]) cmd = "sudo {bro_path} -C -b -i {interface} {bro_scripts}" cmd = cmd.format(bro_path=bro_path, interface=interface, bro_scripts=bro_scripts) msg = "la cmd est : %s" % cmd logging.info(msg) # changer pwd en /tmp tmp_dir = path.join(path.dirname(path.realpath(__file__)), `../../tmp/`) chdir(tmp_dir) résultat = r un(cmd) logging.info(result.__dict__)

Exemple 13

def ProcessFlags(env, flags): for f in flags: if f: env.MergeFlags(str( f)) # corrige CPPPATH relatif pour i, p dans enumerate(env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # Annuler toute définition précédente du nom, qu`elle soit intégrée ou # fournie avec une option -D // Problème #191 undefines = [u for u in env.get("CCFLAGS", []) if u.startswith("-U")] if undefines : for undef in undefines : env[`CCFLAGS`].remove(undef) env. Append(_CPPDEFFLAGS=" %s" % " ".join(undefines))

Exemple 14

def _get_settings_helper(self) : main_dir = path.dirname(path.realpath(__file__)) main_dir = path.realpath(path.join(main_dir, `..`, `..`)) default_filepath = path.join(main_dir, `default_settings. yml`) user_filepath = path.join(main_dir, `settings.yml`) args = self._get_args() if args.settings_path: user_filepath = args.settings_path # ouvre le fichier par défaut et obtient les informations de version avec open(default_filepath) comme default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: non utilisé current_version = default_filesettings[`version`].split(`.`) # flake8: noqa if path.exists(user_filepath): filepath = user_filepath else: filepath = default_filepath with open(filepath) as setting_file : self.settings = yaml.load(setting_file, _OrderedLoader) return SpecialDict(**self.settings)

Exemple 15

def resolve_rpath(lib_path, rpaths ): """ Renvoie `lib_path` avec son `@rpath` résolu Si le `lib_path` n`a pas `@rpath` alors il est retourné tel quel. Si `lib_path` a `@rpath` alors renvoie la première combinaison `rpaths`/`lib_path` trouvée. Si la bibliothèque est introuvable dans `rpaths`, un avertissement détaillé est affiché et `lib_path` est renvoyé tel quel. Paramètres ---------- lib_path : str Le chemin vers un fichier de bibliothèque, qui peut commencer ou non par `@rpath`. rpaths : séquence de str Une séquence de chemins de recherche, généralement obtenue à partir d`un appel à `get_rpaths`. Renvoie ------- lib_path : str Une chaîne avec les bibliothèques résolues realpath. """ sinon lib_path.startswith(`@rpath/`) : renvoie lib_path lib_rpath = lib_path.split(`/`, 1)[1] pour rpath dans rpaths : rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Impossible de trouver { 0} sur les chemins : {1}".format( lib_path, ` `.join(realpath( path) for path in rpaths), ) ) return lib_path

Example 16

def wheel_libs(wheel_fname, filt_func=None): """ Renvoie l`analyse des dépendances de la bibliothèque avec une roue Python Utilisez cette routine pour un vidage de l`arborescence des dépendances. Paramètres ---------- wheel_fname : str Nom de fichier de la roue filt_func : Aucun ou appelable, facultatif Si aucun, inspecte tous les fichiers pour les dépendances de la bibliothèque. Si appelable, accepte le nom de fichier comme argument, renvoie True si nous devons inspecter le fichier, False sinon. Renvoie ------- lib_dict : dictionnaire dict avec des paires (clé, valeur) de (``libpath``, ``dependings_dict``). `` libpath `` est la bibliothèque dont on dépend, par rapport au chemin de la racine de la roue si dans l`arborescence de la roue. ``dependings_dict`` est (clé, valeur) de (``depending_lib_path``, ``install_name``). Encore une fois, `` depending_lib_path `` est la bibliothèque relative au chemin de la racine de la roue, si elle se trouve dans l`arborescence des roues. """ avec TemporaryDirectory() comme tmpdir : zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) return stripped_lib_dict(lib_dict, realpath(tmpdir) + os.path.sep)

Exemple 17

def main() : parser = OptionParser( usage="%s WHEEL_OR_PATH_TO_ANALYZE " % sys.argv[0] + __doc__, version="%prog " + __version__) parser.add_options([ Option("-a", "--all", action="store_true", help="Afficher toutes les dépendances , y compris les bibliothèques système"), Option("-d", "--depending", action="store_true", help="Afficher les bibliothèques en fonction des dépendances")]) (opts, paths) = parser.parse_args() if len(paths) < 1 : parser.print_help() sys.exit(1) multi = len(paths) > 1 for path in paths : if multi : print(path + `:`) indent = ` ` else : indent = `` si isdir(path): lib_dict = tree_libs(path) lib_dict = stripped_lib_dict(lib_dict, realpath (getcwd()) + psep) e lse : lib_dict = wheel_libs(path) keys = sorted(lib_dict) sinon opts.all : keys = [key for key in keys if filter_system_libs(key)] sinon opts.depending : if len(keys) : print(indent + (` ` + indent).join(keys)) continue i2 = indent + ` ` for key in keys : print(indent + key + `:`) libs = lib_dict[key] if len(libs): print(i2 + (` ` + i2).join(libs))

Exemple 18

def test_given_directory() : # Test InGivenDirectory cwd = getcwd() avec InGivenDirectory() comme tmpdir : assert_equal( tmpdir, abspath(cwd)) assert_equal(tmpdir, abspath(getcwd())) avec InGivenDirectory(MY_DIR) comme tmpdir : assert_equal(tmpdir, MY_DIR) assert_equal(realpath(MY_DIR), realpath(abspath (getcwd()))) # Nous supprimions le répertoire donné ! Vérifiez pas si maintenant. assert_true(isfile(MY_PATH))

Exemple 19

def decideClean(workDir, architecture, agressifCleanup): """ Décide ce qu`il faut supprimer, sans le faire réellement : - Trouve tous les liens symboliques dans "BUILD" - Trouver tous les répertoires dans "BUILD" - Planifier la suppression d`un répertoire s`il n`a pas de lien symbolique """ symlinksBuild = [os.readlink(x) for x in glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP doit toujours être nettoyé. Cela ne se produit pas seulement # dans le cas où nous manquons d`espace lors du déballage. # $WORK_DIR//store peut également être nettoyé, car # nous n`avons pas besoin des archives tar réelles après leur construction. toDelete = ["%s/TMP" % workDir] si agressifCleanup : toDelete += ["%s/TARS/%s/store" % (workDir, architecture), "%s/SOURCES" % (workDir)] allBuildStuff = glob.glob("%s/BUILD/*" % workDir) toDelete += [x for x in allBuildStuff if not path.islink(x) and not basename(x) in symlinksBuild] installGlob ="%s/%s/ */" % (workDir, architecture) installedPackages = set([dirname(x) for x in glob.glob(installGlob)]) symlinksInstall = [] for x in installedPackages : symlinksInstall += [path.realpath(y) pour y dans glob.glob(x + "/latest*")] toDelete += [x pour x dans glob.glob(installGlob+ "*") sinon path.islink(x) et not path.realpath(x) in symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] return toDelete

Exemple 20

def _get_script_dir(follow_symlinks: bool = True ) -> Chemin : # Obtenir le chemin vers les magasins de confiance est délicat en raison de différences subtiles sur OS X, Linux et Windows if getattr(sys, "frozen", False): # py2exe, PyInstaller, cx_Freeze path = Path(sys.executable).absolute() else: path = Path(inspect.getabsfile (_get_script_dir)) si follow_symlinks : path = Path(realpath(path)) return path.parent