def run_conda_command(command, prefix, *arguments):
"""
Run conda command,
Args:
command: conda create, list, info
prefix: The prefix or the name of environment
*arguments: Extra arguments
"""
p = generate_parser()
prefix = escape_for_winpath(prefix)
if arguments:
arguments = list(map(escape_for_winpath, arguments))
if command is Commands.INFO: # INFO
command_line = "{0} {1}".format(command, " ".join(arguments))
elif command is Commands.LIST: # LIST
command_line = "{0} -n {1} {2}".format(command, prefix,
" ".join(arguments))
else: # CREATE
command_line = "{0} -y -q -n {1} {2}".format(command, prefix,
" ".join(arguments))
from conda._vendor.auxlib.compat import shlex_split_unicode
commands = shlex_split_unicode(command_line)
args = p.parse_args(commands)
context._set_argparse_args(args)
with captured() as c:
do_call(args, p)
return c.stdout, c.stderr
def subprocess_call(command,
env=None,
path=None,
stdin=None,
raise_on_error=True,
capture_output=True,
live_stream=False):
"""This utility function should be preferred for all conda subprocessing.
It handles multiple tricky details.
"""
env = encode_environment(env if env else os.environ)
cwd = sys.prefix if path is None else abspath(path)
if not isiterable(command):
command = shlex_split_unicode(command)
command_str = command if isinstance(command,
string_types) else ' '.join(command)
log.debug("executing>> %s", command_str)
if capture_output:
p = Popen(encode_arguments(command),
cwd=cwd,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
env=env)
ACTIVE_SUBPROCESSES.add(p)
stdin = ensure_binary(stdin) if isinstance(stdin,
string_types) else stdin
if live_stream:
stdout, stderr = _realtime_output_for_subprocess(p)
else:
stdout, stderr = p.communicate(input=stdin)
if hasattr(stdout, "decode"):
stdout = stdout.decode('utf-8', errors='replace')
if hasattr(stderr, "decode"):
stderr = stderr.decode('utf-8', errors='replace')
rc = p.returncode
ACTIVE_SUBPROCESSES.remove(p)
elif stdin:
raise ValueError("When passing stdin, output needs to be captured")
else:
p = Popen(encode_arguments(command), cwd=cwd, env=env)
ACTIVE_SUBPROCESSES.add(p)
p.communicate()
rc = p.returncode
ACTIVE_SUBPROCESSES.remove(p)
stdout = None
stderr = None
if (raise_on_error and rc != 0) or log.isEnabledFor(TRACE):
formatted_output = _format_output(command_str, cwd, rc, stdout, stderr)
if raise_on_error and rc != 0:
log.info(formatted_output)
raise CalledProcessError(rc, command, output=formatted_output)
if log.isEnabledFor(TRACE):
log.trace(formatted_output)
return Response(stdout, stderr, int(rc))
def subprocess_call(command, env=None, path=None, stdin=None, raise_on_error=True):
"""This utility function should be preferred for all conda subprocessing.
It handles multiple tricky details.
"""
env = encode_environment(env if env else os.environ)
cwd = sys.prefix if path is None else abspath(path)
if not isiterable(command):
command = shlex_split_unicode(command)
command_str = command if isinstance(command, string_types) else ' '.join(command)
log.debug("executing>> %s", command_str)
p = Popen(encode_arguments(command), cwd=cwd, stdin=PIPE, stdout=PIPE, stderr=PIPE, env=env)
ACTIVE_SUBPROCESSES.add(p)
stdin = ensure_binary(stdin) if isinstance(stdin, string_types) else stdin
stdout, stderr = p.communicate(input=stdin)
if hasattr(stdout, "decode"):
stdout = stdout.decode('utf-8', errors='replace')
if hasattr(stderr, "decode"):
stderr = stderr.decode('utf-8', errors='replace')
rc = p.returncode
ACTIVE_SUBPROCESSES.remove(p)
if (raise_on_error and rc != 0) or log.isEnabledFor(TRACE):
formatted_output = _format_output(command_str, cwd, rc, stdout, stderr)
if raise_on_error and rc != 0:
log.info(formatted_output)
raise CalledProcessError(rc, command,
output=formatted_output)
if log.isEnabledFor(TRACE):
log.trace(formatted_output)
return Response(stdout, stderr, int(rc))
def run_conda_command(command, prefix, *arguments):
"""
Run conda command,
Args:
command: conda create, list, info
prefix: The prefix or the name of environment
*arguments: Extra arguments
"""
p = generate_parser()
prefix = escape_for_winpath(prefix)
if arguments:
arguments = list(map(escape_for_winpath, arguments))
if command is Commands.INFO: # INFO
command_line = "{0} {1}".format(command, " ".join(arguments))
elif command is Commands.LIST: # LIST
command_line = "{0} -n {1} {2}".format(command, prefix, " ".join(arguments))
else: # CREATE
command_line = "{0} -y -q -n {1} {2}".format(command, prefix, " ".join(arguments))
from conda._vendor.auxlib.compat import shlex_split_unicode
commands = shlex_split_unicode(command_line)
args = p.parse_args(commands)
context._set_argparse_args(args)
with captured() as c:
do_call(args, p)
return c.stdout, c.stderr
def parse_line(line):
# placeholder, filemode, filepath
parts = tuple(x.strip('"\'') for x in shlex_split_unicode(line, posix=False))
if len(parts) == 1:
return ParseResult(PREFIX_PLACEHOLDER, FileMode.text, parts[0])
elif len(parts) == 3:
return ParseResult(parts[0], FileMode(parts[1]), parts[2])
else:
raise CondaVerificationError("Invalid has_prefix file at path: %s" % path)
def native_path_to_unix(paths): # pragma: unix no cover
# on windows, uses cygpath to convert windows native paths to posix paths
if not on_win:
return path_identity(paths)
if paths is None:
return None
from subprocess import CalledProcessError, PIPE, Popen
from conda._vendor.auxlib.compat import shlex_split_unicode
# It is very easy to end up with a bash in one place and a cygpath in another due to e.g.
# using upstream MSYS2 bash, but with a conda env that does not have bash but does have
# cygpath. When this happens, we have two different virtual POSIX machines, rooted at
# different points in the Windows filesystem. We do our path conversions with one and
# expect the results to work with the other. It does not.
from .common.path import which
bash = which('bash')
command = os.path.join(dirname(bash), 'cygpath') if bash else 'cygpath'
command += ' --path -f -'
single_path = isinstance(paths, string_types)
joined = paths if single_path else ("%s" % os.pathsep).join(paths)
if hasattr(joined, 'encode'):
joined = joined.encode('utf-8')
try:
p = Popen(shlex_split_unicode(command),
stdin=PIPE,
stdout=PIPE,
stderr=PIPE)
except EnvironmentError as e:
if e.errno != ENOENT:
raise
# This code path should (hopefully) never be hit be real conda installs. It's here
# as a backup for tests run under cmd.exe with cygpath not available.
def _translation(found_path): # NOQA
found = found_path.group(1).replace("\\",
"/").replace(":", "").replace(
"//", "/")
return "/" + found.rstrip("/")
joined = ensure_fs_path_encoding(joined)
stdout = re.sub(r'([a-zA-Z]:[\/\\\\]+(?:[^:*?\"<>|;]+[\/\\\\]*)*)',
_translation, joined).replace(";/", ":/").rstrip(";")
else:
stdout, stderr = p.communicate(input=joined)
rc = p.returncode
if rc != 0 or stderr:
message = "\n stdout: %s\n stderr: %s\n rc: %s\n" % (stdout,
stderr, rc)
print(message, file=sys.stderr)
raise CalledProcessError(rc, command, message)
if hasattr(stdout, 'decode'):
stdout = stdout.decode('utf-8')
stdout = stdout.strip()
final = stdout and stdout.split(':') or ()
return final[0] if single_path else tuple(final)
def _environ_cols_tput(*_): # pragma: no cover
"""cygwin xterm (windows)"""
try:
from conda._vendor.auxlib.compat import shlex_split_unicode
cols = int(subprocess.check_call(shlex_split_unicode('tput cols')))
# rows = int(subprocess.check_call(shlex_split_unicode('tput lines')))
return cols
except:
pass
return None
def _environ_cols_tput(*_): # pragma: no cover
"""cygwin xterm (windows)"""
try:
from conda._vendor.auxlib.compat import shlex_split_unicode
cols = int(subprocess.check_call(shlex_split_unicode('tput cols')))
# rows = int(subprocess.check_call(shlex_split_unicode('tput lines')))
return cols
except:
pass
return None
def _screen_shape_tput(*_): # pragma: no cover
"""cygwin xterm (windows)"""
try:
import shlex
from conda._vendor.auxlib.compat import shlex_split_unicode
return [
int(subprocess.check_call(shlex_split_unicode('tput ' + i))) - 1
for i in ('cols', 'lines')
]
except:
pass
return None, None
def native_path_to_unix(paths): # pragma: unix no cover
# on windows, uses cygpath to convert windows native paths to posix paths
if not on_win:
return path_identity(paths)
if paths is None:
return None
from subprocess import CalledProcessError, PIPE, Popen
from conda._vendor.auxlib.compat import shlex_split_unicode
# It is very easy to end up with a bash in one place and a cygpath in another due to e.g.
# using upstream MSYS2 bash, but with a conda env that does not have bash but does have
# cygpath. When this happens, we have two different virtual POSIX machines, rooted at
# different points in the Windows filesystem. We do our path conversions with one and
# expect the results to work with the other. It does not.
from .common.path import which
bash = which('bash')
command = os.path.join(dirname(bash), 'cygpath') if bash else 'cygpath'
command += ' --path -f -'
single_path = isinstance(paths, string_types)
joined = paths if single_path else ("%s" % os.pathsep).join(paths)
if hasattr(joined, 'encode'):
joined = joined.encode('utf-8')
try:
p = Popen(shlex_split_unicode(command), stdin=PIPE, stdout=PIPE, stderr=PIPE)
except EnvironmentError as e:
if e.errno != ENOENT:
raise
# This code path should (hopefully) never be hit be real conda installs. It's here
# as a backup for tests run under cmd.exe with cygpath not available.
def _translation(found_path): # NOQA
found = found_path.group(1).replace("\\", "/").replace(":", "").replace("//", "/")
return "/" + found.rstrip("/")
joined = ensure_fs_path_encoding(joined)
stdout = re.sub(
r'([a-zA-Z]:[\/\\\\]+(?:[^:*?\"<>|;]+[\/\\\\]*)*)',
_translation,
joined
).replace(";/", ":/").rstrip(";")
else:
stdout, stderr = p.communicate(input=joined)
rc = p.returncode
if rc != 0 or stderr:
message = "\n stdout: %s\n stderr: %s\n rc: %s\n" % (stdout, stderr, rc)
print(message, file=sys.stderr)
raise CalledProcessError(rc, command, message)
if hasattr(stdout, 'decode'):
stdout = stdout.decode('utf-8')
stdout = stdout.strip()
final = stdout and stdout.split(':') or ()
return final[0] if single_path else tuple(final)
def call(command, path=None, raise_on_error=True):
path = sys.prefix if path is None else abspath(path)
p = Popen(shlex_split_unicode(command), cwd=path, stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate()
rc = p.returncode
log.debug("{0} $ {1}\n"
" stdout: {2}\n"
" stderr: {3}\n"
" rc: {4}".format(path, command, stdout, stderr, rc))
if raise_on_error and rc != 0:
raise CalledProcessError(
rc, command, "stdout: {0}\nstderr: {1}".format(stdout, stderr))
return Response(stdout.decode('utf-8'), stderr.decode('utf-8'), int(rc))
def run_inprocess_conda_command(command, disallow_stderr=True):
# anything that uses this function is an integration test
reset_context(())
# May want to do this to command:
with argv(encode_arguments(shlex_split_unicode(command))), captured(disallow_stderr) as c:
initialize_logging()
try:
exit_code = cli.main(*sys.argv)
except SystemExit:
pass
print(c.stderr, file=sys.stderr)
print(c.stdout)
return c.stdout, c.stderr, exit_code
def run_inprocess_conda_command(command, disallow_stderr=True):
# anything that uses this function is an integration test
reset_context(())
# May want to do this to command:
with argv(encode_arguments(shlex_split_unicode(command))), captured(disallow_stderr) as c:
initialize_logging()
try:
exit_code = cli.main(*sys.argv)
except SystemExit:
pass
print(c.stderr, file=sys.stderr)
print(c.stdout)
return c.stdout, c.stderr, exit_code
def call(command, path=None, raise_on_error=True):
path = sys.prefix if path is None else abspath(path)
p = Popen(shlex_split_unicode(command), cwd=path, stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate()
rc = p.returncode
log.debug("{0} $ {1}\n"
" stdout: {2}\n"
" stderr: {3}\n"
" rc: {4}"
.format(path, command, stdout, stderr, rc))
if raise_on_error and rc != 0:
raise CalledProcessError(rc, command, "stdout: {0}\nstderr: {1}".format(stdout, stderr))
return Response(stdout.decode('utf-8'), stderr.decode('utf-8'), int(rc))
