def __init__(self, cmd='', prompt=None, rx=None):
if not cmd: cmd = '{} {}'.format(dist, mimic_bin)
if not prompt: prompt = 'Enter word or sentence (EXIT to break): '
if isinstance(cmd, str):
self._repl = REPLWrapper(cmd, prompt, None)
else:
self._repl = cmd
self.nodes = []
self.rx = rx if rx else '\s+(?P<Word>\S+)\t+.*'
def __init__(
self,
cmd_or_spawn,
extra_init_cmd=None,
):
REPLWrapper.__init__(
self,
cmd_or_spawn,
u"(^|\r\n)> ",
None,
continuation_prompt=u"^ ",
extra_init_cmd=extra_init_cmd,
)
def test_job_attach_tty(helper: Helper) -> None:
job_id = helper.run_job_and_wait_state(UBUNTU_IMAGE_NAME, "sh", tty=True)
status = helper.job_info(job_id)
assert status.container.tty
expect = helper.pexpect(["job", "attach", job_id])
expect.expect("========== Job is running in terminal mode =========")
expect.sendline("\n") # prompt may be missing after the connection.
repl = REPLWrapper(expect, "# ", None)
ret = repl.run_command("echo abc\n")
assert ret.strip() == "echo abc\r\r\nabc"
helper.kill_job(job_id)
def __init__(self,
gdb='riscv64-unknown-elf-gdb',
openocd='openocd',
openocd_config_filename='./testing/targets/ssith_gfe.cfg',
timeout=60):
print_and_log("Starting GDB session...")
if not which(gdb):
raise GdbError('Executable {} not found'.format(gdb))
if not which(openocd):
raise GdbError('Executable {} not found'.format(openocd))
xlen = 32 # Default
try:
run_and_log(print_and_log("Starting openocd"), run([openocd, '-f', openocd_config_filename], \
timeout=0.5, stdout=PIPE, stderr=PIPE))
except TimeoutExpired as exc:
log = str(exc.stderr, encoding='utf-8')
match = re.search('XLEN=(32|64)', log)
if match:
xlen = int(match.group(1))
else:
raise GdbError('XLEN not found by OpenOCD')
# Create temporary files for gdb and openocd. The `NamedTemporaryFile`
# objects are stored in `self` so the files stay around as long as this
# `GdbSession` is in use. We open both in text mode, instead of the
# default 'w+b'.
self.openocd_log = tempfile.NamedTemporaryFile(mode='w',
prefix='openocd.',
suffix='.log')
self.gdb_log = tempfile.NamedTemporaryFile(mode='w',
prefix='gdb.',
suffix='.log')
init_cmds = '\n'.join([
'set confirm off', 'set pagination off'
'set width 0', 'set height 0', 'set print entry-values no',
'set remotetimeout {}'.format(timeout),
'set arch riscv:rv{}'.format(xlen),
'target remote | {} -c "gdb_port pipe; log_output {}" -f {}'.
format(openocd, self.openocd_log.name, openocd_config_filename)
])
self.pty = spawn(gdb,
encoding='utf-8',
logfile=self.gdb_log,
timeout=timeout)
self.repl = REPLWrapper(self.pty,
'(gdb) ',
None,
extra_init_cmd=init_cmds)
def new_session(settings, command=None):
"""Returns a new REPLWrapper"""
return REPLWrapper(
command or settings.shell['command'],
settings.shell['prompt'],
None,
continuation_prompt=settings.shell['continuation'])
class Distance():
# Word2Vec distance wrapper by default
def __init__(self, cmd='', prompt=None, rx=None):
if not cmd: cmd = '{} {}'.format(dist, mimic_bin)
if not prompt: prompt = 'Enter word or sentence (EXIT to break): '
if isinstance(cmd, str):
self._repl = REPLWrapper(cmd, prompt, None)
else:
self._repl = cmd
self.nodes = []
self.rx = rx if rx else '\s+(?P<Word>\S+)\t+.*'
def find(self, words, num, max_levels=1, unique=True, level=0):
first = self._repl.run_command(words, None).split('\n')[5:num + 5]
first = [re.match(self.rx, line).group('Word') for line in first]
if level < max_levels:
rest = [
Distance(self._repl).find(first[idx],
num,
max_levels,
level=level + 1)
for idx in range(len(first))
]
first.extend(rest)
first = [
word for sublist in first if isinstance(sublist, list)
for word in sublist
]
if unique: first = list(set(first))
return first
def start_kotlin_shell(self):
if platform.system() == 'Windows':
kotlin_shell_bin = 'kotlinc-jvm.bat'
else:
kotlin_shell_bin = 'kotlinc-jvm'
kotlin = REPLWrapper(kotlin_shell_bin, '>>> ', None,
continuation_prompt='... ')
return kotlin
class SparkKernel(Kernel):
implementation = 'IPython'
implementation_version = '1.0'
banner = "Spark Kernel"
language = 'en-us'
language_version = '0.1'
language_info = {'mimetype': 'text/plain', 'name': 'python'}
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self._start_spark()
def _start_spark(self):
'''Creates a pexpect.spawn, then passes to the REPLWrapper in order to allow for a larget timeout value.'''
self.spark_spawn = spawn('spark-shell', timeout=60)
self.sparkwrapper = REPLWrapper(self.spark_spawn, u'scala>', None)
# spark_spawn.expect() needs implemented
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False):
if match('exit.*', code):
stream_content = {'name': 'stdout', 'text': 'To exit, just shutdown the kernel!'}
self.send_response(self.iopub_socket, 'stream', stream_content)
return {'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
elif match('%', code):
stream_content = {'name': 'stdout', 'text': 'No magics :-( ....sorry.'}
self.send_response(self.iopub_socket, 'stream', stream_content)
return {'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
else:
output = self.sparkwrapper.run_command(code)
if not silent:
try:
stream_content = {'name': 'stdout', 'text': output}
self.send_response(self.iopub_socket, 'stream', stream_content)
return {'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
finally:
print('finally')
# Need some exception handling here.
def do_shutdown(self, restart):
'''Ensure exit command gets sent to the spark-shell.'''
self.spark_spawn.send('exit\r\n')
self.spark_spawn.expect(EOF)
self.spark_spawn.close()
def cypher_shell():
if platform == 'Windows':
cypher_shell_bin = os.path.join('cypher_kernel', 'java',
'cypher-shell.bat')
else:
cypher_shell_bin = 'cypher_kernel/java/cypher-shell'
base_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
cypher_shell_bin = os.path.join(base_path, cypher_shell_bin)
cypher = REPLWrapper(f'{cypher_shell_bin} -u {test_cfg.user} -p {test_cfg.pwd} --format verbose', 'neo4j> ', None)
return cypher
def do_execute(self,
code,
silent,
store_history=True,
user_expressions=None,
allow_stdin=False):
zdict = REPLWrapper(u"zdict", u"[zDict]: ", None)
output = zdict.run_command(code.strip())
if not silent:
stream_content = {'name': 'stdout', 'text': output}
self.send_response(self.iopub_socket, 'stream', stream_content)
return {
'status': 'ok',
# The base class increments the execution count
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
def start_cypher_shell(self):
if platform.system() == 'Windows':
cypher_shell_bin = os.path.join('java', 'cypher-shell.bat')
else:
cypher_shell_bin = 'java/cypher-shell'
cypher_shell_bin = os.path.join(
os.path.dirname(os.path.abspath(__file__)), cypher_shell_bin)
cypher = REPLWrapper(
f'{cypher_shell_bin} -u {self.user} -p {self.pwd} --format verbose',
'neo4j> ',
None,
continuation_prompt=' ...: ')
return cypher
class WCCGProcess:
"""Holds a wccg process to be reused."""
def __init__(self):
self.mutex = multiprocessing.Lock()
self._new_repl()
def _new_repl(self):
self.repl = REPLWrapper(
f'wccg -prompt "{PEXPECT_PROMPT}" -showsem -showall {os.environ.get("GRAMMAR_DIR", "/grammar")}',
PEXPECT_PROMPT + ' ', None)
def parse(self, sentence):
"""Parse a sentence by passing it to the wccg process and read the results.
This is thread-safe, so multiple processes can try to access the process.
"""
with self.mutex:
return self.repl.run_command(sentence)
def feedback_loop(phase_settings, program_path, cwd=str(Path.cwd() / '..')):
amplifiers = [
REPLWrapper(f'python3 ../intcomputer.py -p "> " {program_path}', '> ',
None) for i in 'abcde'
]
# init phases
for amplifier, phase in zip(amplifiers, phase_settings):
try:
amplifier.run_command(str(phase), timeout=2)
except (pexpect.TIMEOUT, pexpect.EOF):
print('Failed at initialization')
signal = str(0)
running = True
while running:
for c, amplifier in zip('abcde', amplifiers):
try:
signal = amplifier.run_command(signal,
timeout=1).splitlines()[0]
except (pexpect.EOF, OSError):
running = False
break
return int(signal)
def _new_repl(self):
self.repl = REPLWrapper(
f'wccg -prompt "{PEXPECT_PROMPT}" -showsem -showall {os.environ.get("GRAMMAR_DIR", "/grammar")}',
PEXPECT_PROMPT + ' ', None)
def _start_spark(self):
'''Creates a pexpect.spawn, then passes to the REPLWrapper in order to allow for a larget timeout value.'''
self.spark_spawn = spawn('spark-shell', timeout=60)
self.sparkwrapper = REPLWrapper(self.spark_spawn, u'scala>', None)
class GdbSession(object):
'''Wraps a pseudo-terminal interface to GDB on the FPGA via OpenOCD.'''
def __init__(self,
gdb='riscv64-unknown-elf-gdb',
openocd='openocd',
openocd_config_filename='./testing/targets/ssith_gfe.cfg',
timeout=60):
print_and_log("Starting GDB session...")
if not which(gdb):
raise GdbError('Executable {} not found'.format(gdb))
if not which(openocd):
raise GdbError('Executable {} not found'.format(openocd))
xlen = 32 # Default
try:
run_and_log(print_and_log("Starting openocd"), run([openocd, '-f', openocd_config_filename], \
timeout=0.5, stdout=PIPE, stderr=PIPE))
except TimeoutExpired as exc:
log = str(exc.stderr, encoding='utf-8')
match = re.search('XLEN=(32|64)', log)
if match:
xlen = int(match.group(1))
else:
raise GdbError('XLEN not found by OpenOCD')
# Create temporary files for gdb and openocd. The `NamedTemporaryFile`
# objects are stored in `self` so the files stay around as long as this
# `GdbSession` is in use. We open both in text mode, instead of the
# default 'w+b'.
self.openocd_log = tempfile.NamedTemporaryFile(mode='w',
prefix='openocd.',
suffix='.log')
self.gdb_log = tempfile.NamedTemporaryFile(mode='w',
prefix='gdb.',
suffix='.log')
init_cmds = '\n'.join([
'set confirm off', 'set pagination off'
'set width 0', 'set height 0', 'set print entry-values no',
'set remotetimeout {}'.format(timeout),
'set arch riscv:rv{}'.format(xlen),
'target remote | {} -c "gdb_port pipe; log_output {}" -f {}'.
format(openocd, self.openocd_log.name, openocd_config_filename)
])
self.pty = spawn(gdb,
encoding='utf-8',
logfile=self.gdb_log,
timeout=timeout)
self.repl = REPLWrapper(self.pty,
'(gdb) ',
None,
extra_init_cmd=init_cmds)
def __del__(self):
print_and_log("Closing GDB session...")
self.pty.close()
def cmd(self, gdb_command_string, timeout=-1):
if not self.pty.isalive():
raise GdbError('Dead process')
try:
reply = self.repl.run_command(gdb_command_string, timeout=timeout)
except TIMEOUT as exc:
self.pty.close()
raise GdbError('Timeout expired') from exc
except EOF as exc:
self.pty.close()
raise GdbError('Read end of file') from exc
return reply
def cont(self):
if not self.pty.isalive():
raise GdbError('Dead process')
self.pty.send("continue\n")
def interrupt(self):
# send ctrl-c and wait for prompt
return self.cmd('\003')
def c(self, timeout):
try:
self.cmd('c', timeout=timeout)
except GdbError:
self.interrupt()
def x(self, address, size='w'):
output = self.cmd("x/{} {:#x}".format(size, address))
print_and_log('Read raw output: {}'.format(output))
if ':' in output:
value = int(output.split(':')[1], base=0)
else:
raise GdbError('Failed to read from address {:#x}'.format(address))
return value
def read32(self, address, debug_text=None):
value = self.x(address=address, size="1w")
if debug_text is not None:
print_and_log("{} Read: {:#x} from {:#x}".format(
debug_text, value, address))
return value