def preview(self, item):
# return the preview of variable.
try:
return "", self.sos_kernel.get_response(
f'..sos.preview("{item}")', ('stream', ),
name=('stdout', ))[0][1]['text']
except Exception as e:
env.log_to_file('VARIABLE', f'Preview of {item} failed: {e}')
return None
def preview(self, item):
try:
response = self.sos_kernel.get_response(
f'pickle.dumps(__preview_var("{item}"))',
['execute_result'])[-1][1]
return self.load_pickled(eval(response['data']['text/plain']))
except Exception as e:
env.log_to_file('PREVIEW', f'Failed to preview {item}: {e}')
return '', f'No preview is available {e}'
def get_vars(self, var_names):
"""
Functionality to transfer CAS objects and TypeSystem from SoS (python) kernel to the IRuta kernel.
This function is called when a use invokes the line magic %get or %with.
"""
if len(var_names) != 1:
raise Exception(
"%get takes exactly one variable name as argument."
"If you want to transfer multiple CAS, then please write them to a directory and use `%inputDir` in IRuta kernel."
)
var_name = var_names[0]
var_content = env.sos_dict[var_name]
# Step 1: Writing Cas and TypeSystem to disk using dkpro-cassis
temp_directory = tempfile.TemporaryDirectory()
temp_typesystem_file = tempfile.NamedTemporaryFile(
suffix=".xml", dir=temp_directory.name, delete=False)
temp_typesystem_file_path = os.path.normpath(
temp_typesystem_file.name).replace('\\', "/")
temp_xmi_file = tempfile.NamedTemporaryFile(suffix=".xmi",
dir=temp_directory.name,
delete=False)
temp_xmi_file_path = os.path.normpath(temp_xmi_file.name).replace(
'\\', "/")
if isinstance(var_content, cassis.Cas):
var_content.to_xmi(temp_xmi_file_path)
var_content.typesystem.to_xml(temp_typesystem_file_path)
cmd_transfer_var = "%displayMode NONE\n" \
f"%loadCas {temp_xmi_file_path}\n" \
f"%loadTypeSystem {temp_typesystem_file_path}"
elif isinstance(var_content, cassis.TypeSystem):
var_content.to_xml(temp_typesystem_file_path)
cmd_transfer_var = "%displayMode NONE\n" \
f"%loadTypeSystem {temp_typesystem_file_path}"
else:
raise Exception(
'%get only support transfering UIMA CAS objects or TypeSystem objects. '
'Use %expand for transfering string variables. Received datatype {}'
.format(short_repr(var_content)))
# Step 2: Loading files
env.log_to_file('KERNEL', f'Executing "{cmd_transfer_var}"')
self.ruta_kernel.run_cell(
cmd_transfer_var,
silent=True,
store_history=False,
on_error=f'Failed to get variable {var_name}')
# Step 3: Clean-up temp files
temp_typesystem_file.close()
temp_xmi_file.close()
temp_directory.cleanup()
def get_vars(self, names):
for name in names:
if name.startswith('_'):
self.sos_kernel.warn(
f'Variable {name} is passed from SoS to kernel {self.kernel_name} as {"." + name[1:]}'
)
newname = '.' + name[1:]
else:
newname = name
r_repr = _R_repr(env.sos_dict[name])
env.log_to_file('VARIABLE', r_repr)
self.sos_kernel.run_cell(
f'{newname} <- {r_repr}',
True,
False,
on_error=f'Failed to get variable {name} to R')
def put_vars(self, items, to_kernel=None):
"""
Functionality to transfer CAS objects from the IRuta kernel to the SoS (Python) kernel.
This function is called when a user invokes the line magic %put or %with.
"""
if len(items) != 1:
raise Exception(
"%put takes exactly one variable name as argument. ")
var_name = items[0]
temp_directory = tempfile.TemporaryDirectory()
temp_typesystem_file = tempfile.NamedTemporaryFile(
suffix=".xml", dir=temp_directory.name, delete=False)
temp_typesystem_file_path = os.path.normpath(
temp_typesystem_file.name).replace('\\', "/")
temp_xmi_file = tempfile.NamedTemporaryFile(suffix=".xmi",
dir=temp_directory.name,
delete=False)
temp_xmi_file_path = os.path.normpath(temp_xmi_file.name).replace(
'\\', "/")
# Step 1: Writing CAS and TypeSystem to disk with Ruta
cmd_transfer_var = f"%displayMode NONE\n" \
f"%saveTypeSystem {temp_typesystem_file_path}\n" \
f"%saveCas {temp_xmi_file_path}"
env.log_to_file('KERNEL', f'Executing "{cmd_transfer_var}"')
self.ruta_kernel.run_cell(cmd_transfer_var,
silent=True,
store_history=False,
on_error='Failed to write UIMA CAS to disk.')
# Step 2: Reading CAS and TypeSystem from disk with python/cassis
typesystem = cassis.load_typesystem(temp_typesystem_file)
cas = cassis.load_cas_from_xmi(temp_xmi_file, typesystem=typesystem)
# Step 3: Clean-up temp files
temp_typesystem_file.close()
temp_xmi_file.close()
temp_directory.cleanup()
return {var_name: cas}
def Rmarkdown(
script=None,
input=None,
output=None,
args="{input:r}, output_file={output:ar}",
**kwargs,
):
"""Convert input file to output using Rmarkdown
The input can be specified in three ways:
1. instant script, which is assumed to be in md format
Rmarkdown: output='report.html'
script
2. one or more input files. The format is determined by extension of input file
Rmarkdown(input, output='report.html')
3. input file specified by command line option `-r` .
Rmarkdown(output='report.html')
If no output is specified, it is assumed to be in html format
and is written to standard output.
You can specify more options using the args parameter of the action. The default value
of args is `${input!r} --output ${output!ar}'
"""
if not R_library("rmarkdown").target_exists():
raise RuntimeError("Library rmarkdown does not exist")
input = sos_targets(collect_input(script, input))
output = sos_targets(output)
if len(output) == 0:
write_to_stdout = True
output = sos_targets(
tempfile.NamedTemporaryFile(mode="w+t",
suffix=".html",
delete=False).name)
else:
write_to_stdout = False
#
ret = 1
try:
# render(input, output_format = NULL, output_file = NULL, output_dir = NULL,
# output_options = NULL, intermediates_dir = NULL,
# runtime = c("auto", "static", "shiny"),
# clean = TRUE, params = NULL, knit_meta = NULL, envir = parent.frame(),
# run_Rmarkdown = TRUE, quiet = FALSE, encoding = getOption("encoding"))
cmd = interpolate(
f'Rscript -e "rmarkdown::render({args})"',
{
"input": input,
"output": output
},
)
if "ACTION" in env.config["SOS_DEBUG"] or "ALL" in env.config[
"SOS_DEBUG"]:
env.log_to_file("ACTION", f'Running command "{cmd}"')
if env.config["run_mode"] == "interactive":
# need to catch output and send to python output, which will in trun be hijacked by SoS notebook
p = subprocess.Popen(cmd,
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
# pid = p.pid
out, err = p.communicate()
sys.stdout.write(out.decode())
sys.stderr.write(err.decode())
ret = p.returncode
else:
p = subprocess.Popen(cmd, shell=True)
# pid = p.pid
ret = p.wait()
except Exception as e:
env.logger.error(str(e))
if ret != 0:
temp_file = os.path.join(".sos", f'{"Rmarkdown"}_{os.getpid()}.md')
shutil.copyfile(str(input), temp_file)
cmd = interpolate(
f'Rscript -e "rmarkdown::render({args})"',
{
"input": input,
"output": sos_targets(temp_file)
},
)
raise RuntimeError(
f'Failed to execute script. Please use command \n"{cmd}"\nunder {os.getcwd()} to test it.'
)
if write_to_stdout:
with open(str(output[0])) as out:
sys.stdout.write(out.read())
else:
env.logger.info(f"Report saved to {output}")
def execute_scratch_cell(code, raw_args, kernel):
# we then have to change the parse to disable args.workflow when
# there is no workflow option.
raw_args = shlex.split(raw_args) if isinstance(raw_args, str) else raw_args
if code is None or '-h' in raw_args:
parser = get_run_parser(interactive=True, with_workflow=True)
parser.print_help()
return
if raw_args and raw_args[0].lstrip().startswith('-'):
parser = get_run_parser(interactive=True, with_workflow=False)
parser.error = _parse_error
args, workflow_args = parser.parse_known_args(raw_args)
args.workflow = None
else:
parser = get_run_parser(interactive=True, with_workflow=True)
parser.error = _parse_error
args, workflow_args = parser.parse_known_args(raw_args)
if not code.strip():
return
# for reporting purpose
sys.argv = ['%run'] + raw_args
env.verbosity = args.verbosity
if not any(
isinstance(x, NotebookLoggingHandler)
for x in env.logger.handlers):
env.logger.handlers = [
x for x in env.logger.handlers
if type(x) is not logging.StreamHandler
]
levels = {
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
3: logging.DEBUG,
4: logging.DEBUG,
None: logging.INFO
}
env.logger.addHandler(
NotebookLoggingHandler(levels[env.verbosity],
kernel,
title=' '.join(sys.argv)))
else:
env.logger.handers[0].setTitle(' '.join(sys.argv))
global last_cell_id
# we retain step_input etc only when we step through a cell #256
if kernel and kernel.cell_id != last_cell_id:
# clear __step_input__, __step_output__ etc because there is
# no concept of passing input/outputs across cells.
env.sos_dict.set('__step_output__', sos_targets([]))
for k in [
'__step_input__', '__default_output__', 'step_input',
'step_output', 'step_depends', '_input', '_output', '_depends'
]:
env.sos_dict.pop(k, None)
last_cell_id = kernel.cell_id
config = {
'config_file':
args.__config__,
'default_queue':
args.__queue__,
'run_mode':
'dryrun' if args.dryrun else 'interactive',
# issue 230, ignore sig mode in interactive mode
'sig_mode':
'ignore',
'verbosity':
args.verbosity,
# for backward compatibility, we try both args.__worker_procs__ and args.__max_procs__
'worker_procs':
args.__worker_procs__
if hasattr(args, '__worker_procs__') else args.__max_procs__,
'max_running_jobs':
args.__max_running_jobs__,
# for infomration and resume only
'workdir':
os.getcwd(),
'workflow':
args.workflow,
'targets':
args.__targets__,
'workflow_args':
workflow_args,
'workflow_id':
textMD5(code),
# interactive work is also a slave of the controller
'slave_id':
kernel.cell_id,
}
env.sos_dict.set('workflow_id', config['workflow_id'])
env.config.update(config)
try:
if not any([
SOS_SECTION_HEADER.match(line) or line.startswith('%from')
or line.startswith('%include') for line in code.splitlines()
]):
code = f'[cell_{str(kernel.cell_id)[:8] if kernel and kernel.cell_id else "0"}]\n' + code
script = SoS_Script(content=code)
else:
return
workflow = script.workflow(args.workflow)
section = workflow.sections[0]
res = analyze_section(section)
env.sos_dict.quick_update({
'__signature_vars__': res['signature_vars'],
'__environ_vars__': res['environ_vars'],
'__changed_vars__': res['changed_vars']
})
executor = Interactive_Step_Executor(section, mode='interactive')
ret = executor.run()
try:
return ret['__last_res__']
except Exception as e:
raise RuntimeError(
f'Unknown result returned from executor {ret}: {e}')
except (UnknownTarget, RemovedTarget) as e:
raise RuntimeError(f'Unavailable target {e.target}')
except TerminateExecution as e:
return
except SystemExit:
# this happens because the executor is in resume mode but nothing
# needs to be resumed, we simply pass
return
except Exception:
env.log_to_file('PROCESS', get_traceback())
raise
