Sintaxe: os.path.realpath(path) Parâmetro: path: A path-like objeto que representa o caminho do sistema de arquivos. Um objeto do tipo caminho é um objeto string ou bytes que representa um caminho. Tipo de retorno: Este método retorna um valor de string que representa o caminho canônico.
Criar soft link ou link simbólico
No Unix ou Linux, um soft link ou link simbólico pode ser criado usando o comando ln. A seguir está a sintaxe para criar um link simbólico na linha de comando:$ ln -s {source-filename} {symbolic-filename} Exemplo 1
def realpath(self, spec, key): """ Resolva e atualize a chave de caminho na especificação com seu realpath, com base no diretório de trabalho. """ if key not in spec: # não faça nada para agora retorne se não for spec[key]: logger.warning( "não pode resolver realpath de `%s ` como não está definido", key) return check = realpath(join(spec.get( WORKING_DIR, ``), spec[key])) if check != spec[key]: spec[key] = check logger.warning( "realpath de `%s` resolvido para `%s`, especificação atualizada", key, check ) return che ck # Configurar métodos relacionados
Exemplo 2
def get_rp_stripper(strip_path): """ Função de retorno para strip ``realpath`` de `strip_path` da string Parâmetros ---------- strip_path: str caminho para retirar do início das strings. Processado para ``strip_prefix`` por ``realpath(strip_path) + os.path.sep` `. Retorna ------- stripper: função func tal que ``stripper(a_string)`` removerá ``strip_prefix`` de ``a_string`` se presente, caso contrário, passará ``a_string`` não modificado """ return get_prefix_stripper(realpath(strip_path) + os.path.sep)
Exemplo 3
def test_toolchain_standard_not_implemented(self): spec = Spec() com self.assertRaises(NotImplementedError): self.toolchain(spec) com self.assertRaises(NotImplementedError): self.toolchain.assemble(spec) com self.assertRaises(NotImplementedError): self.toolchain.link(spec) # Verifique se build_dir está definido na especificação baseada no arquivo temporário self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # Também que foi deletado corretamente. self.assertFalse(exists(spec[`build_dir`] ))
Exemplo 4
def find_system_jdks(): """ Retorna um conjunto de JD válido K diretórios pesquisando locais padrão. """ bases = [ `/Library/Java/JavaVirtualMachines`, `/usr/lib/jvm`, `/usr/java`, `/usr/jdk/instances`, r`C:Program FilesJava`] jdks = set() para base em bases: if isdir(base): para n em 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
Exemplo 5
def _expand_dirs_to_files(files_or_dirs, recursive=False): files = [] files_or_dirs = _ensure_list(files_or_dirs) para file_or_dir em files_or_dirs: file_or_dir = op.realpath(file_or_dir) if op.isdir(file_or_dir): # Ignora dirnames começando com `.` if _to_skip(file_or_dir): continue # Visite os diretórios recursivamente e adicione os arquivos if recursive: files.extend(_expand_dirs_to_files([op.join(file_or_dir, file) for file in os.listdir(file_or_dir)], recursive=recursive) ) else: 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) retorna arquivos
Exemplo 6
def getSubdirs(path, baseNamesOnly=True, excludePythonModulesDirs=True): """Fornece uma lista de subdiretórios para o caminho fornecido"" " subdirs = [] try: path = realpath(path) + sep para item em os.listdir (caminho): candidato = caminho + item if isdir(candidato): if excludePythonModulesDirs: modFile = candidato + sep + "__init__.py" se existe(modFile): continue if baseNamesOnly: subdirs.append(item) else: subdirs.append (candidato) exceto: pass return subdiretórios
Exemplo 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
Exemplo 8
def getParameters(self): """Fornece um dicionário com os parâmetros de pesquisa""" 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- aberto`] = 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()) parâmetros[`file -filter`] = self.filterCombo.currentText().strip() retorna parâmetros Exemplo 9
def _check_if_pyc(fname): """Retorna True se a extensão for . pyc, False se .py e Nenhum caso contrário""" from imp import find_module from os.path import realpath, dirname, basename, splitext # Normaliza o caminho do arquivo para o caminho do arquivo find_module() = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Valida e busca try: fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath]) exceto ImportError : raise IOError("Não foi possível encontrar o arquivo de configuração. " "O caminho pode estar incorreto!: {0}".format(filepath)) return pytype, fileobj, fullpath
Exemplo 10
def get_planetoid_dataset(name, normalize_features=False, transform= Nenhum): caminho = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) dataset = Planetoid(path, name) se transform não for None e normalize_features: dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features: dataset. transform = T.NormalizeFeatures() elif transform não é Nenhum: dataset.transform = transform return dataset
Exemplo 11
def _setup_logger(cls, log_file=None): formatador = 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) if log_file: file_handler = logging.FileHandler(realpath(log_file), mode="w" ) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return logger
Exemplo 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" Ë∑ëbroÊúçÂä°ËøõÁ®ã """ # Ëé∑ÂèñÁªùÂØπË∑ØÂæÑ bro_file = caminho.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 = "o cmd é: %s" % cmd logging.info(msg) # altera pwd para /tmp tmp_dir = path.join(path.dirname(path.realpath(__file__)), `../../tmp/`) chdir(tmp_dir) resultado = r un(cmd) logging.info(result.__dict__)
Exemplo 13
def ProcessFlags(env, flags): for f in flags: if f: env.MergeFlags(str( f)) # corrige o CPPPATH relativo para i, p in enumerate(env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # Cancela qualquer definição anterior de nome, incorporada ou # fornecida com uma opção -D // Problema #191 undefines = [u para u em env.get("CCFLAGS", []) if u.startswith("-U")] if undefines: para undef em undefines: env[`CCFLAGS`].remove(undef) env. Append(_CPPDEFFLAGS=" %s" % " ".join(undefines)) Exemplo 14
def _get_settings_helper(self): main_dir = path.dirname(path.realpath(__file__)) main_dir = caminho.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 # abre o arquivo padrão e obtém informações de versão com open(default_filepath) como default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: não usado 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)
Exemplo 15
def resolve_rpath(lib_path, rpaths ): """ Retorna `lib_path` com seu `@rpath` resolvido Se o `lib_path` não tem `@rpath` então ele é retornado como está. Se `lib_path` tem `@rpath` então retorna a primeira combinação `rpaths`/`lib_path` encontrada. Se a biblioteca não puder ser encontrada em `rpaths`, um aviso detalhado será impresso e `lib_path` será retornado como está. Parâmetros ---------- lib_path: str O caminho para um arquivo de biblioteca, que pode ou não começar com `@rpath`. rpaths: sequence of str Uma sequência de caminhos de busca, geralmente obtida de uma chamada para `get_rpaths`. Retorna ------- lib_path: str Um str com as bibliotecas resolvidas realpath. """ se não lib_path.startswith(`@rpath/`): return lib_path lib_rpath = lib_path.split(`/`, 1)[1] para rpath em rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Não foi possível encontrar { 0} em caminhos: {1}".format( lib_path, ` `.join(realpath( path) for path in rpaths), ) ) return lib_path
Exemplo 16
def wheel_libs(wheel_fname, filt_func=None): """ Retorna a análise das dependências da biblioteca com uma roda do Python Use esta rotina para um dump da árvore de dependência. Parâmetros ---------- wheel_fname: str Nome do arquivo de wheel filt_func: Nenhum ou chamável, opcional Se Nenhum, inspecionar todos os arquivos para dependências de biblioteca. Se pode ser chamado, aceita o nome do arquivo como argumento, retorna True se devemos inspecionar o arquivo, False caso contrário. Retorna ------- lib_dict: dicionário dict com (chave, valor) pares de (``libpath``, ``dependings_dict``). ``libpath`` é a biblioteca da qual depende, em relação ao caminho da raiz da roda se estiver dentro da árvore da roda. ``dependings_dict`` é (chave, valor) de (``depending_lib_path``, ``install_name``). Novamente, ``depending_lib_path`` é uma biblioteca relativa ao caminho da raiz da roda, se estiver dentro da árvore da roda. """ com TemporaryDirectory() como tmpdir: zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) return stripped_lib_dict(lib_dict, realpath(tmpdir) + os.path.sep)
Exemplo 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="Mostrar todas as dependências , incluindo bibliotecas do sistema"), Option("-d", "--depending", action="store_true", help="Mostrar bibliotecas dependendo das dependências")]) (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 = `` if 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) if not opts.all: keys = [key for key in keys if filter_system_libs(key)] if not opts.depending: if len(keys): print(indent + (` ` + recuo).join(chaves)) continue i2 = recuo + ` ` para chave em chaves: print(indent + chave + `:`) libs = lib_dict[chave] if len(libs): print(i2 + (` ` + i2).join(libs)) Exemplo 18
def test_given_directory(): # Teste InGivenDirectory cwd = getcwd() com InGivenDirectory() como tmpdir: assert_equal( tmpdir, abspath(cwd)) assert_equal(tmpdir, abspath(getcwd())) com InGivenDirectory(MY_DIR) como tmpdir: assert_equal(tmpdir, MY_DIR) assert_equal(realpath(MY_DIR), realpath(abspath (getcwd()))) # Estávamos excluindo o diretório Given! Verifique não tão agora. assert_true(isfile(MY_PATH))
Exemplo 19
def decideClean(workDir, architecture, agressivaCleanup): """ Decide o que excluir, sem realmente fazê-lo: - Encontre todos os links simbólicos em "BUILD" - Encontre todos os diretórios em "BUILD" - Agende um diretório para exclusão se ele não tiver um link simbólico """ symlinksBuild = [os.readlink(x) for x in glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP deve sempre ser limpo. Isso não acontece apenas # no caso de ficarmos sem espaço durante a descompactação. # $WORK_DIR//store também pode ser limpo, porque # não precisamos dos tarballs reais depois que eles foram construídos. toDelete = ["%s/TMP" % workDir] se agressivoCleanup: toDelete += ["%s/TARS/%s/store" % (workDir, arquitetura), "%s/SOURCES" % (workDir)] allBuildStuff = glob.glob("%s/BUILD/*" % workDir) toDelete += [x para x em allBuildStuff se não for path.islink(x) e não basename(x) em 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) for y in glob.glob(x + "/latest*")] toDelete += [x for x em glob.glob(installGlob+ "*") se não for path.islink(x) e não path.realpath(x) em symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] return toDelete Exemplo 20
def _get_script_dir(follow_symlinks: bool = True ) -> Caminho: # Obter o caminho para os armazenamentos confiáveis é complicado devido a diferenças sutis no OS X, Linux e Windows if getattr(sys, "frozen", False): # py2exe, PyInstaller, cx_Freeze path = Path(sys.executable).absolute() else: path = Path(inspect.getabsfile (_get_script_dir)) if follow_symlinks: path = Path(realpath(path)) return path.parent
Arquivo
os.path.realpath() em Python é usado para obter o caminho canônico de um nome de arquivo especificado removendo quaisquer links simbólicos encontrados no caminho .
Sintaxe: os.path.realpath (caminho)
Parâmetro:
caminho : A objeto semelhante a um caminho que representa o caminho do sistema de arquivos.
Um objeto semelhante a um caminho é um objeto string ou bytes representando um caminho.Tipo de retorno: Este método retorna um valor de string que representa o caminho canônico.
Criar soft link ou link simbólico
No Unix ou Linux, um soft link ou link simbólico pode ser criado usando o comando ln.¬†Seguindo é a sintaxe para criar um link simbólico na linha de comando:
$ ln -s {source-filename} {symbolic-filename} Exemplo:
Exemplo:
Na saída acima, " / home / ihritik / Desktop / arquivo (atalho) .txt " é um link simbólico.
Código: usando os.path.realpath () método para obter o caminho canônico e links simbólicos de resolução.
|                                 |
Sair:
/ home / ihritik / Documents / file (original) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt