def _rex_assigning():
import os
windows = os.name == "nt"
def _print(value):
env.FOO = value
info("%FOO%" if windows else "${FOO}")
env.GREET = "hi"
env.WHO = "Gary"
_print("ello")
_print(literal("ello"))
_print(expandable("ello"))
_print("\\")
_print("\\'")
_print("\\\"")
_print(literal("\\"))
_print(literal("\\'"))
_print(literal("\\\""))
_print("\\path1\\path2\\path3")
_print(literal("\\path1").e("\\path2\\path3"))
_print("hello world")
_print("hello 'world'")
_print('hello "world"')
_print(literal("hello world"))
_print(literal("hello 'world'"))
_print(literal('hello "world"'))
_print("hey %WHO%" if windows else "hey $WHO")
_print("hey %WHO%" if windows else "hey ${WHO}")
_print(expandable("%GREET% " if windows else "${GREET} ").e("%WHO%" if windows else "$WHO"))
_print(expandable("%GREET% " if windows else "${GREET} ").l("$WHO"))
_print(literal("${WHO}"))
_print(literal("${WHO}").e(" %WHO%" if windows else " $WHO"))
def _rex_assigning():
import os
windows = os.name == "nt"
def _print(value):
env.FOO = value
# Wrap the output in quotes to prevent the shell from
# interpreting parts of our output as commands. This can happen
# when we include special characters (&, <, >, ^) in a
# variable.
info('"%FOO%"' if windows else '"${FOO}"')
env.GREET = "hi"
env.WHO = "Gary"
_print("ello")
_print(literal("ello"))
_print(expandable("ello"))
_print("\\")
_print("\\'")
_print("\\\"")
_print(literal("\\"))
_print(literal("\\'"))
_print(literal("\\\""))
_print("\\path1\\path2\\path3")
_print(literal("\\path1").e("\\path2\\path3"))
_print("hello world")
_print("hello 'world'")
_print('hello "world"')
_print(literal("hello world"))
_print(literal("hello 'world'"))
_print(literal('hello "world"'))
_print("hey %WHO%" if windows else "hey $WHO")
_print("hey %WHO%" if windows else "hey ${WHO}")
_print(
expandable("%GREET% " if windows else "${GREET} ").e(
"%WHO%" if windows else "$WHO"))
_print(
expandable("%GREET% " if windows else "${GREET} ").l("$WHO"))
_print(literal("${WHO}"))
_print(literal("${WHO}").e(" %WHO%" if windows else " $WHO"))
# Make sure we are escaping &, <, >, ^ properly.
_print('hey & world')
_print('hey > world')
_print('hey < world')
_print('hey ^ world')
def _rex_assigning():
import os
windows = os.name == "nt"
def _print(value):
env.FOO = value
# Wrap the output in quotes to prevent the shell from
# interpreting parts of our output as commands. This can happen
# when we include special characters (&, <, >, ^) in a
# variable.
info('"%FOO%"' if windows else '"${FOO}"')
env.GREET = "hi"
env.WHO = "Gary"
_print("ello")
_print(literal("ello"))
_print(expandable("ello"))
_print("\\")
_print("\\'")
_print("\\\"")
_print(literal("\\"))
_print(literal("\\'"))
_print(literal("\\\""))
_print("\\path1\\path2\\path3")
_print(literal("\\path1").e("\\path2\\path3"))
_print("hello world")
_print("hello 'world'")
_print('hello "world"')
_print(literal("hello world"))
_print(literal("hello 'world'"))
_print(literal('hello "world"'))
_print("hey %WHO%" if windows else "hey $WHO")
_print("hey %WHO%" if windows else "hey ${WHO}")
_print(expandable("%GREET% " if windows else "${GREET} ").e("%WHO%" if windows else "$WHO"))
_print(expandable("%GREET% " if windows else "${GREET} ").l("$WHO"))
_print(literal("${WHO}"))
_print(literal("${WHO}").e(" %WHO%" if windows else " $WHO"))
# Make sure we are escaping &, <, >, ^ properly.
_print('hey & world')
_print('hey > world')
_print('hey < world')
_print('hey ^ world')
def _rex_appending():
from rez.shells import create_shell
sh = create_shell()
env.FOO.append("hey")
info(sh.get_key_token("FOO"))
env.FOO.append(literal("$DAVE"))
info(sh.get_key_token("FOO"))
env.FOO.append("Dave's not here man")
info(sh.get_key_token("FOO"))
def _rex_appending():
import os
windows = os.name == "nt"
env.FOO.append("hey")
info("%FOO%" if windows else "${FOO}")
env.FOO.append(literal("$DAVE"))
info("%FOO%" if windows else "${FOO}")
env.FOO.append("Dave's not here man")
info("%FOO%" if windows else "${FOO}")
def _rex_appending():
import os
windows = os.name == "nt"
env.FOO.append("hey")
info("%FOO%" if windows else "${FOO}")
env.FOO.append(literal("$DAVE"))
info("%FOO%" if windows else "${FOO}")
env.FOO.append("Dave's not here man")
info("%FOO%" if windows else "${FOO}")
def _rex_assigning():
from rez.shells import create_shell
sh = create_shell()
def _print(value):
env.FOO = value
# Wrap the output in quotes to prevent the shell from
# interpreting parts of our output as commands. This can happen
# when we include special characters (&, <, >, ^) in a
# variable.
info('"${FOO}"')
env.GREET = "hi"
env.WHO = "Gary"
_print("ello")
_print(literal("ello"))
_print(expandable("ello"))
info('')
_print("\\")
_print("\\'")
_print("\\\"")
_print(literal("\\"))
_print(literal("\\'"))
_print(literal("\\\""))
_print("\\path1\\path2\\path3")
_print(literal("\\path1").e("\\path2\\path3"))
_print("hello world")
_print("hello 'world'")
_print('hello "world"')
_print(literal("hello world"))
_print(literal("hello 'world'"))
_print(literal('hello "world"'))
# Generic form of variables
_print("hey $WHO")
_print("hey ${WHO}")
_print(expandable("${GREET} ").e("$WHO"))
_print(expandable("${GREET} ").l("$WHO"))
_print(literal("${WHO}"))
_print(literal("${WHO}").e(" $WHO"))
# Make sure we are escaping &, <, >, ^ properly.
_print('hey & world')
_print('hey > world')
_print('hey < world')
_print('hey ^ world')
# Platform dependent form of variables.
for token in sh.get_all_key_tokens("WHO"):
_print("hey " + token)
_print(expandable("${GREET} ").e(token))
_print(expandable("${GREET} ").l(token))
_print(literal(token))
_print(literal(token).e(" " + token))
def _rex2():
env.BAH = "omg"
env.FOO.append("$BAH")
env.FOO.append(literal("${BAH}"))
env.FOO.append(expandable("like, ").l("$SHE said, ").e("$BAH"))
def _rex():
env.A = "hello"
env.FOO = expandable("$A") # will convert to '${A}'
env.BAH = expandable("${A}")
env.EEK = literal("$A")
def spawn_shell(self, context_file, tmpdir, rcfile=None, norc=False,
stdin=False, command=None, env=None, quiet=False,
pre_command=None, **Popen_args):
startup_sequence = self.get_startup_sequence(rcfile, norc, bool(stdin), command)
shell_command = None
def _record_shell(ex, files, bind_rez=True, print_msg=False):
ex.source(context_file)
if startup_sequence["envvar"]:
ex.unsetenv(startup_sequence["envvar"])
if bind_rez:
ex.interpreter._bind_interactive_rez()
if print_msg and not quiet:
if system.is_production_rez_install:
# previously this was called with the /K flag, however
# that would leave spawn_shell hung on a blocked call
# waiting for the user to type "exit" into the shell that
# was spawned to run the rez context printout
ex.command("cmd /Q /C rez context")
def _create_ex():
return RexExecutor(interpreter=self.new_shell(),
parent_environ={},
add_default_namespaces=False)
executor = _create_ex()
if self.settings.prompt:
newprompt = '%%REZ_ENV_PROMPT%%%s' % self.settings.prompt
executor.interpreter._saferefenv('REZ_ENV_PROMPT')
executor.env.REZ_ENV_PROMPT = literal(newprompt)
if startup_sequence["command"] is not None:
_record_shell(executor, files=startup_sequence["files"])
shell_command = startup_sequence["command"]
else:
_record_shell(executor, files=startup_sequence["files"], print_msg=(not quiet))
if shell_command:
# Launch the provided command in the configured shell and wait
# until it exits.
executor.command(shell_command)
# Test for None specifically because resolved_context.execute_rex_code
# passes '' and we do NOT want to keep a shell open during a rex code
# exec operation.
elif shell_command is None:
# Launch the configured shell itself and wait for user interaction
# to exit.
executor.command('cmd /Q /K')
# Exit the configured shell.
executor.command('exit %errorlevel%')
code = executor.get_output()
target_file = os.path.join(tmpdir, "rez-shell.%s"
% self.file_extension())
with open(target_file, 'w') as f:
f.write(code)
if startup_sequence["stdin"] and stdin and (stdin is not True):
Popen_args["stdin"] = stdin
cmd = []
if pre_command:
if isinstance(pre_command, basestring):
cmd = pre_command.strip().split()
else:
cmd = pre_command
if shell_command:
cmd_flags = ['/Q', '/C']
else:
cmd_flags = ['/Q', '/K']
cmd = cmd + [self.executable] + cmd_flags + ['call {}'.format(target_file)]
is_detached = (cmd[0] == 'START')
p = popen(cmd, env=env, shell=is_detached, **Popen_args)
return p
def _rex2():
env.BAH = "omg"
env.FOO.append("$BAH")
env.FOO.append(literal("${BAH}"))
env.FOO.append(expandable("like, ").l("$SHE said, ").e("$BAH"))
def _rex():
env.A = "hello"
env.FOO = expandable("$A") # will convert to '${A}'
env.BAH = expandable("${A}")
env.EEK = literal("$A")
def spawn_shell(self, context_file, tmpdir, rcfile=None, norc=False,
stdin=False, command=None, env=None, quiet=False,
pre_command=None, **Popen_args):
startup_sequence = self.get_startup_sequence(rcfile, norc, bool(stdin), command)
shell_command = None
def _record_shell(ex, files, bind_rez=True, print_msg=False):
ex.source(context_file)
if startup_sequence["envvar"]:
ex.unsetenv(startup_sequence["envvar"])
if bind_rez:
ex.interpreter._bind_interactive_rez()
if print_msg and not quiet:
# ex.info('')
# ex.info('You are now in a rez-configured environment.')
# ex.info('')
if system.is_production_rez_install:
ex.command("cmd /Q /K rezolve context")
def _create_ex():
return RexExecutor(interpreter=self.new_shell(),
parent_environ={},
add_default_namespaces=False)
executor = _create_ex()
if self.settings.prompt:
newprompt = '%%REZ_ENV_PROMPT%%%s' % self.settings.prompt
executor.interpreter._saferefenv('REZ_ENV_PROMPT')
executor.env.REZ_ENV_PROMPT = literal(newprompt)
if startup_sequence["command"] is not None:
_record_shell(executor, files=startup_sequence["files"])
shell_command = startup_sequence["command"]
else:
_record_shell(executor, files=startup_sequence["files"], print_msg=(not quiet))
if shell_command:
executor.command(shell_command)
executor.command('exit %errorlevel%')
code = executor.get_output()
target_file = os.path.join(tmpdir, "rez-shell.%s"
% self.file_extension())
with open(target_file, 'w') as f:
f.write(code)
if startup_sequence["stdin"] and stdin and (stdin is not True):
Popen_args["stdin"] = stdin
cmd = []
if pre_command:
if isinstance(pre_command, basestring):
cmd = pre_command.strip().split()
else:
cmd = pre_command
cmd = cmd + [self.executable, "/Q", "/K", target_file]
p = subprocess.Popen(cmd, env=env, **Popen_args)
return p
def spawn_shell(self,
context_file,
tmpdir,
rcfile=None,
norc=False,
stdin=False,
command=None,
env=None,
quiet=False,
pre_command=None,
**Popen_args):
startup_sequence = self.get_startup_sequence(rcfile, norc, bool(stdin),
command)
shell_command = None
def _record_shell(ex, files, bind_rez=True, print_msg=False):
ex.source(context_file)
if startup_sequence["envvar"]:
ex.unsetenv(startup_sequence["envvar"])
if bind_rez:
ex.interpreter._bind_interactive_rez()
if print_msg and not quiet:
ex.info('You are now in a rez-configured environment.')
# Output, if Rez is present
ex.command("rez context 2>nul")
def _create_ex():
return RexExecutor(interpreter=self.new_shell(),
parent_environ={},
add_default_namespaces=False)
executor = _create_ex()
if self.settings.prompt:
newprompt = '%%REZ_ENV_PROMPT%%%s' % self.settings.prompt
executor.interpreter._saferefenv('REZ_ENV_PROMPT')
executor.env.REZ_ENV_PROMPT = literal(newprompt)
if startup_sequence["command"] is not None:
_record_shell(executor, files=startup_sequence["files"])
shell_command = startup_sequence["command"]
else:
_record_shell(executor,
files=startup_sequence["files"],
print_msg=(not quiet))
code = executor.get_output()
target_file = os.path.join(tmpdir,
"rez-shell.%s" % self.file_extension())
with open(target_file, 'w') as f:
f.write(code)
if startup_sequence["stdin"] and stdin and (stdin is not True):
Popen_args["stdin"] = stdin
cmd = []
if pre_command:
if isinstance(pre_command, basestring):
cmd = pre_command.strip().split()
else:
cmd = pre_command
# Test for None specifically because resolved_context.execute_rex_code
# passes '' and we do NOT want to keep a shell open during a rex code
# exec operation.
if shell_command is None:
cmd_flags = ['/Q', '/K']
else:
cmd_flags = ['/Q', '/C']
cmd += [self.executable]
cmd += cmd_flags
cmd += ['call {}'.format(target_file)]
if shell_command:
cmd += ["& " + shell_command]
is_detached = (cmd[0] == 'START')
# No environment was explicity passed
if not env and not config.inherit_parent_environment:
env = self.environment()
p = popen(cmd,
env=env,
shell=is_detached,
universal_newlines=True,
**Popen_args)
return p
def spawn_shell(self, context_file, tmpdir, rcfile=None, norc=False,
stdin=False, command=None, env=None, quiet=False,
pre_command=None, **Popen_args):
startup_sequence = self.get_startup_sequence(rcfile, norc, bool(stdin), command)
shell_command = None
def _record_shell(ex, files, bind_rez=True, print_msg=False):
ex.source(context_file)
if startup_sequence["envvar"]:
ex.unsetenv(startup_sequence["envvar"])
if bind_rez:
ex.interpreter._bind_interactive_rez()
if print_msg and not quiet:
# ex.info('')
# ex.info('You are now in a rez-configured environment.')
# ex.info('')
if system.is_production_rez_install:
ex.command("cmd /Q /K rezolve context")
def _create_ex():
return RexExecutor(interpreter=self.new_shell(),
parent_environ={},
add_default_namespaces=False)
executor = _create_ex()
if self.settings.prompt:
newprompt = '%%REZ_ENV_PROMPT%%%s' % self.settings.prompt
executor.interpreter._saferefenv('REZ_ENV_PROMPT')
executor.env.REZ_ENV_PROMPT = literal(newprompt)
if startup_sequence["command"] is not None:
_record_shell(executor, files=startup_sequence["files"])
shell_command = startup_sequence["command"]
else:
_record_shell(executor, files=startup_sequence["files"], print_msg=(not quiet))
if shell_command:
executor.command(shell_command)
executor.command('exit %errorlevel%')
code = executor.get_output()
target_file = os.path.join(tmpdir, "rez-shell.%s"
% self.file_extension())
with open(target_file, 'w') as f:
f.write(code)
if startup_sequence["stdin"] and stdin and (stdin is not True):
Popen_args["stdin"] = stdin
cmd = []
if pre_command:
if isinstance(pre_command, basestring):
cmd = pre_command.strip().split()
else:
cmd = pre_command
cmd = cmd + [self.executable, "/Q", "/K", target_file]
p = subprocess.Popen(cmd, env=env, **Popen_args)
return p
def spawn_shell(self,
context_file,
tmpdir,
rcfile=None,
norc=False,
stdin=False,
command=None,
env=None,
quiet=False,
pre_command=None,
**Popen_args):
startup_sequence = self.get_startup_sequence(rcfile, norc, bool(stdin),
command)
shell_command = None
def _record_shell(ex, files, bind_rez=True, print_msg=False):
ex.source(context_file)
if startup_sequence["envvar"]:
ex.unsetenv(startup_sequence["envvar"])
if bind_rez:
ex.interpreter._bind_interactive_rez()
if print_msg and not quiet:
if system.is_production_rez_install:
# previously this was called with the /K flag, however
# that would leave spawn_shell hung on a blocked call
# waiting for the user to type "exit" into the shell that
# was spawned to run the rez context printout
ex.command("cmd /Q /C rez context")
def _create_ex():
return RexExecutor(interpreter=self.new_shell(),
parent_environ={},
add_default_namespaces=False)
executor = _create_ex()
if self.settings.prompt:
newprompt = '%%REZ_ENV_PROMPT%%%s' % self.settings.prompt
executor.interpreter._saferefenv('REZ_ENV_PROMPT')
executor.env.REZ_ENV_PROMPT = literal(newprompt)
if startup_sequence["command"] is not None:
_record_shell(executor, files=startup_sequence["files"])
shell_command = startup_sequence["command"]
else:
_record_shell(executor,
files=startup_sequence["files"],
print_msg=(not quiet))
if shell_command:
# Launch the provided command in the configured shell and wait
# until it exits.
executor.command(shell_command)
# Test for None specifically because resolved_context.execute_rex_code
# passes '' and we do NOT want to keep a shell open during a rex code
# exec operation.
elif shell_command is None:
# Launch the configured shell itself and wait for user interaction
# to exit.
executor.command('cmd /Q /K')
# Exit the configured shell.
executor.command('exit %errorlevel%')
code = executor.get_output()
target_file = os.path.join(tmpdir,
"rez-shell.%s" % self.file_extension())
with open(target_file, 'w') as f:
f.write(code)
if startup_sequence["stdin"] and stdin and (stdin is not True):
Popen_args["stdin"] = stdin
cmd = []
if pre_command:
if isinstance(pre_command, basestring):
cmd = pre_command.strip().split()
else:
cmd = pre_command
if shell_command:
cmd_flags = ['/Q', '/C']
else:
cmd_flags = ['/Q', '/K']
cmd = cmd + [self.executable
] + cmd_flags + ['call {}'.format(target_file)]
is_detached = (cmd[0] == 'START')
p = popen(cmd, env=env, shell=is_detached, **Popen_args)
return p
