def start(self, lua_source, sandboxed, lua_package_path,
lua_sandbox_allowed_modules):
self.log(lua_source)
self.sandboxed = sandboxed
self.lua = SplashLuaRuntime(
sandboxed=sandboxed,
lua_package_path=lua_package_path,
lua_sandbox_allowed_modules=lua_sandbox_allowed_modules)
self.splash = Splash(self.lua, self.tab, self.render_options)
self.runner = SplashScriptRunner(
lua=self.lua,
splash=self.splash,
log=self.log,
sandboxed=sandboxed,
)
try:
main_coro = self.get_main(lua_source)
except (ValueError, lupa.LuaSyntaxError, lupa.LuaError) as e:
raise ScriptError("lua_source: " + repr(e))
self.runner.start(
main_coro=main_coro,
return_result=self.return_result,
return_error=self.return_error,
)
def __init__(self, **kwargs):
super(SplashKernel, self).__init__(**kwargs)
self.tab = init_browser()
self.lua = SplashLuaRuntime(self.sandboxed, "", ())
self.splash = Splash(lua=self.lua, tab=self.tab)
self.lua.add_to_globals("splash", self.splash.get_wrapped())
self.runner = DeferredSplashRunner(self.lua, self.splash, self.sandboxed) #, self.log_msg)
self.completer = Completer(self.lua)
self.inspector = Inspector(self.lua)
def start(self, lua_source, sandboxed, lua_package_path,
lua_sandbox_allowed_modules):
self.log(lua_source)
self.sandboxed = sandboxed
self.lua = SplashLuaRuntime(
sandboxed=sandboxed,
lua_package_path=lua_package_path,
lua_sandbox_allowed_modules=lua_sandbox_allowed_modules
)
self.splash = Splash(self.lua, self.tab, self.render_options)
self.runner = SplashScriptRunner(
lua=self.lua,
splash=self.splash,
log=self.log,
sandboxed=sandboxed,
)
try:
main_coro = self.get_main(lua_source)
except (ValueError, lupa.LuaSyntaxError, lupa.LuaError) as e:
raise ScriptError("lua_source: " + repr(e))
self.runner.start(
main_coro=main_coro,
return_result=self.return_result,
return_error=self.return_error,
)
class LuaRender(RenderScript):
default_min_log_level = 2
@stop_on_error
def start(self, lua_source, sandboxed, lua_package_path,
lua_sandbox_allowed_modules):
self.log(lua_source)
self.sandboxed = sandboxed
self.lua = SplashLuaRuntime(
sandboxed=sandboxed,
lua_package_path=lua_package_path,
lua_sandbox_allowed_modules=lua_sandbox_allowed_modules
)
self.splash = Splash(self.lua, self.tab, self.render_options)
self.runner = MainCoroutineRunner(
lua=self.lua,
splash=self.splash,
log=self.log,
sandboxed=sandboxed,
)
try:
main_coro = self.get_main_coro(lua_source)
except lupa.LuaSyntaxError as e:
# XXX: is this code active?
# It looks like we're always getting LuaError
# because of sandbox and coroutine handling code.
raise ScriptError({
'type': ScriptError.SYNTAX_ERROR,
'message': e.args[0],
})
except lupa.LuaError as e:
# Error happened before starting coroutine
info = parse_error_message(e.args[0])
info.update({
"type": ScriptError.LUA_INIT_ERROR,
"message": e.args[0],
})
raise ScriptError(info)
# except ValueError as e:
# # XXX: when does it happen?
# raise ScriptError({
# "type": ScriptError.UNKNOWN_ERROR,
# "message": repr(e),
# })
self.runner.start(
main_coro=main_coro,
return_result=self.return_result,
return_error=self.return_error,
)
def get_main_coro(self, lua_source):
if self.sandboxed:
main, env = get_main_sandboxed(self.lua, lua_source)
else:
main, env = get_main(self.lua, lua_source)
return self.lua.create_coroutine(main)
def start(self, lua_source, sandboxed, lua_package_path, lua_sandbox_allowed_modules):
self.exceptions = StoredExceptions()
self.log(lua_source)
self.sandboxed = sandboxed
self.lua = SplashLuaRuntime(
sandboxed=sandboxed,
lua_package_path=lua_package_path,
lua_sandbox_allowed_modules=lua_sandbox_allowed_modules,
)
self.splash = Splash(self.lua, self.exceptions, self.tab, self.render_options, log=self.log)
self.extras = Extras(self.lua, self.exceptions)
self.extras.inject_to_globals()
self.runner = MainCoroutineRunner(lua=self.lua, splash=self.splash, log=self.log, sandboxed=sandboxed)
try:
main_coro = self.get_main_coro(lua_source)
except lupa.LuaSyntaxError as e:
# XXX: is this code active?
# It looks like we're always getting LuaError
# because of sandbox and coroutine handling code.
raise ScriptError({"type": ScriptError.SYNTAX_ERROR, "message": to_unicode(e.args[0])})
except lupa.LuaError as e:
# Error happened before starting coroutine
info = parse_error_message(e.args[0])
info.update({"type": ScriptError.LUA_INIT_ERROR, "message": to_unicode(e.args[0])})
raise ScriptError(info)
# except ValueError as e:
# # XXX: when does it happen?
# raise ScriptError({
# "type": ScriptError.UNKNOWN_ERROR,
# "message": repr(e),
# })
self.runner.start(main_coro=main_coro, return_result=self.return_result, return_error=self.return_error)
class LuaRender(RenderScript):
default_min_log_level = 2
@stop_on_error
def start(self, lua_source, sandboxed, lua_package_path, lua_sandbox_allowed_modules):
self.log(lua_source)
self.sandboxed = sandboxed
self.lua = SplashLuaRuntime(
sandboxed=sandboxed,
lua_package_path=lua_package_path,
lua_sandbox_allowed_modules=lua_sandbox_allowed_modules,
)
self.splash = Splash(self.lua, self.tab, self.render_options)
self.runner = SplashScriptRunner(lua=self.lua, splash=self.splash, log=self.log, sandboxed=sandboxed)
try:
main_coro = self.get_main(lua_source)
except (ValueError, lupa.LuaSyntaxError, lupa.LuaError) as e:
raise ScriptError("lua_source: " + repr(e))
self.runner.start(main_coro=main_coro, return_result=self.return_result, return_error=self.return_error)
def get_main(self, lua_source):
if self.sandboxed:
main, env = get_main_sandboxed(self.lua, lua_source)
else:
main, env = get_main(self.lua, lua_source)
return self.lua.create_coroutine(main)
def __init__(self, **kwargs):
super(SplashKernel, self).__init__(**kwargs)
self.tab = init_browser(SplashKernel.network_manager_factory)
self.lua = SplashLuaRuntime(self.sandboxed, "", ())
self.exceptions = StoredExceptions()
self.splash = Splash(lua=self.lua,
exceptions=self.exceptions,
tab=self.tab)
self.lua.add_to_globals("splash", self.splash.get_wrapped())
self.extras = Extras(self.lua, self.exceptions)
self.extras.inject_to_globals()
self.runner = DeferredSplashRunner(self.lua, self.splash,
self.sandboxed) #, self.log_msg)
self.completer = Completer(self.lua)
self.inspector = Inspector(self.lua)
def __init__(self, **kwargs):
super(SplashKernel, self).__init__(**kwargs)
self.tab = init_browser()
self.lua = SplashLuaRuntime(self.sandboxed, "", ())
self.splash = Splash(lua=self.lua, tab=self.tab)
self.lua.add_to_globals("splash", self.splash.get_wrapped())
self.runner = DeferredSplashRunner(self.lua, self.splash, self.sandboxed) #, self.log_msg)
self.completer = Completer(self.lua)
self.inspector = Inspector(self.lua)
def __init__(self, **kwargs):
super(SplashKernel, self).__init__(**kwargs)
self.tab = init_browser(SplashKernel.network_manager_factory)
self.lua = SplashLuaRuntime(self.sandboxed, "", ())
self.exceptions = StoredExceptions()
self.splash = Splash(
lua=self.lua,
exceptions=self.exceptions,
tab=self.tab
)
self.lua.add_to_globals("splash", self.splash.get_wrapped())
self.extras = Extras(self.lua, self.exceptions)
self.extras.inject_to_globals()
self.runner = DeferredSplashRunner(self.lua, self.splash, self.sandboxed) #, self.log_msg)
self.completer = Completer(self.lua)
self.inspector = Inspector(self.lua)
class LuaRender(RenderScript):
default_min_log_level = 2
@stop_on_error
def start(self, lua_source, sandboxed, lua_package_path,
lua_sandbox_allowed_modules):
self.log(lua_source)
self.sandboxed = sandboxed
self.lua = SplashLuaRuntime(
sandboxed=sandboxed,
lua_package_path=lua_package_path,
lua_sandbox_allowed_modules=lua_sandbox_allowed_modules
)
self.splash = Splash(self.lua, self.tab, self.render_options)
self.runner = SplashScriptRunner(
lua=self.lua,
splash=self.splash,
log=self.log,
sandboxed=sandboxed,
)
try:
main_coro = self.get_main(lua_source)
except (ValueError, lupa.LuaSyntaxError, lupa.LuaError) as e:
raise ScriptError("lua_source: " + repr(e))
self.runner.start(
main_coro=main_coro,
return_result=self.return_result,
return_error=self.return_error,
)
def get_main(self, lua_source):
if self.sandboxed:
main, env = get_main_sandboxed(self.lua, lua_source)
else:
main, env = get_main(self.lua, lua_source)
return self.lua.create_coroutine(main)
class SplashKernel(Kernel):
implementation = 'Splash'
implementation_version = splash.__version__
language = 'Lua'
language_version = get_version()
language_info = {
'name': 'Splash',
'mimetype': 'application/x-lua',
'display_name': 'Splash',
'language': 'lua',
'codemirror_mode': {
"name": "text/x-lua",
},
'file_extension': '.lua',
'pygments_lexer': 'lua',
'version': get_version(),
}
banner = "Splash kernel - write browser automation scripts interactively"
help_links = [
{
'text':
"Splash Tutorial",
'url':
'http://splash.readthedocs.org/en/latest/scripting-tutorial.html'
},
{
'text': "Splash Reference",
'url': 'http://splash.readthedocs.org/en/latest/scripting-ref.html'
},
{
'text': "Programming in Lua",
'url': 'http://www.lua.org/pil/contents.html'
},
{
'text': "Lua 5.2 Manual",
'url': 'http://www.lua.org/manual/5.2/'
},
]
sandboxed = False
def __init__(self, **kwargs):
super(SplashKernel, self).__init__(**kwargs)
self.tab = init_browser(SplashKernel.network_manager_factory)
self.lua = SplashLuaRuntime(self.sandboxed, "", ())
self.exceptions = StoredExceptions()
self.splash = Splash(lua=self.lua,
exceptions=self.exceptions,
tab=self.tab)
self.lua.add_to_globals("splash", self.splash.get_wrapped())
self.extras = Extras(self.lua, self.exceptions)
self.extras.inject_to_globals()
self.runner = DeferredSplashRunner(self.lua, self.splash,
self.sandboxed) #, self.log_msg)
self.completer = Completer(self.lua)
self.inspector = Inspector(self.lua)
#
# try:
# sys.stdout.write = self._print
# sys.stderr.write = self._print
# except:
# pass # Can't change stdout
def send_execute_reply(self, stream, ident, parent, md, reply_content):
def done(result):
reply, result, ct = result
if result:
data = {
'text/plain':
result
if isinstance(result, six.text_type) else str(result),
}
if isinstance(result, BinaryCapsule):
if result.content_type in {'image/png', 'image/jpeg'}:
data[result.content_type] = result.as_b64()
self._publish_execute_result(parent, data, {},
self.execution_count)
super(SplashKernel,
self).send_execute_reply(stream, ident, parent, md, reply)
assert isinstance(reply_content, defer.Deferred)
reply_content.addCallback(done)
def do_execute(self,
code,
silent,
store_history=True,
user_expressions=None,
allow_stdin=False):
def success(res):
result, content_type, headers, status_code = res
reply = {
'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
return reply, result, content_type or 'text/plain'
def error(failure):
text = "<unknown error>"
try:
failure.raiseException()
except Exception as e:
text = error_repr(e)
reply = {
'status': 'error',
'execution_count': self.execution_count,
'ename': '',
'evalue': text,
'traceback': []
}
return reply, text, 'text/plain'
try:
try:
# XXX: this ugly formatting is important for exception
# line numbers to be displayed properly!
lua_source = 'local repr = require("repr"); function main(splash) return repr(%s) end' % code
main_coro = self._get_main(lua_source)
except lupa.LuaSyntaxError:
try:
lines = code.splitlines(False)
lua_source = '''local repr = require("repr"); function main(splash) %s
return repr(%s)
end
''' % ("\n".join(lines[:-1]), lines[-1])
main_coro = self._get_main(lua_source)
except lupa.LuaSyntaxError:
lua_source = "function main(splash) %s end" % code
main_coro = self._get_main(lua_source)
except (lupa.LuaSyntaxError, lupa.LuaError) as e:
d = defer.Deferred()
d.addCallbacks(success, error)
d.errback(e)
return d
except Exception:
d = defer.Deferred()
d.addCallbacks(success, error)
d.errback()
return d
d = self.runner.run(main_coro)
d.addCallbacks(success, error)
return d
def do_complete(self, code, cursor_pos):
return self.completer.complete(code, cursor_pos)
def do_inspect(self, code, cursor_pos, detail_level=0):
return self.inspector.help(code, cursor_pos, detail_level)
def _publish_execute_result(self, parent, data, metadata, execution_count):
msg = {
u'data': data,
u'metadata': metadata,
u'execution_count': execution_count
}
self.session.send(self.iopub_socket,
u'execute_result',
msg,
parent=parent,
ident=self._topic('execute_result'))
def log_msg(self, text, min_level=2):
self._print(text + "\n")
def _print(self, message):
stream_content = {
'name': 'stdout',
'text': message,
'metadata': dict()
}
self.log.debug('Write: %s' % message)
self.send_response(self.iopub_socket, 'stream', stream_content)
def _get_main(self, lua_source):
if self.sandboxed:
main, env = get_main_sandboxed(self.lua, lua_source)
else:
main, env = get_main(self.lua, lua_source)
return self.lua.create_coroutine(main)
def configured_lua():
from splash.lua_runtime import SplashLuaRuntime
return SplashLuaRuntime(False, "", ())
class SplashKernel(Kernel):
implementation = 'Splash'
implementation_version = splash.__version__
language = 'Lua'
language_version = get_version()
language_info = {
'name': 'Splash',
'mimetype': 'application/x-lua',
'display_name': 'Splash',
'language': 'lua',
'codemirror_mode': {
"name": "text/x-lua",
},
'file_extension': '.lua',
'pygments_lexer': 'lua',
'version': get_version(),
}
banner = "Splash kernel - write browser automation scripts interactively"
help_links = [
{
'text': "Splash Tutorial",
'url': 'http://splash.readthedocs.org/en/latest/scripting-tutorial.html'
},
{
'text': "Splash Reference",
'url': 'http://splash.readthedocs.org/en/latest/scripting-ref.html'
},
{
'text': "Programming in Lua",
'url': 'http://www.lua.org/pil/contents.html'
},
{
'text': "Lua 5.2 Manual",
'url': 'http://www.lua.org/manual/5.2/'
},
]
sandboxed = False
def __init__(self, **kwargs):
super(SplashKernel, self).__init__(**kwargs)
self.tab = init_browser()
self.lua = SplashLuaRuntime(self.sandboxed, "", ())
self.splash = Splash(lua=self.lua, tab=self.tab)
self.lua.add_to_globals("splash", self.splash.get_wrapped())
self.runner = DeferredSplashRunner(self.lua, self.splash, self.sandboxed) #, self.log_msg)
self.completer = Completer(self.lua)
self.inspector = Inspector(self.lua)
#
# try:
# sys.stdout.write = self._print
# sys.stderr.write = self._print
# except:
# pass # Can't change stdout
def send_execute_reply(self, stream, ident, parent, md, reply_content):
def done(result):
reply, result, ct = result
if result:
data = {
'text/plain': result if isinstance(result, basestring) else str(result),
}
if isinstance(result, BinaryCapsule):
data[result.content_type] = result.as_b64()
self._publish_execute_result(parent, data, {}, self.execution_count)
super(SplashKernel, self).send_execute_reply(stream, ident, parent, md, reply)
assert isinstance(reply_content, defer.Deferred)
reply_content.addCallback(done)
def do_execute(self, code, silent, store_history=True, user_expressions=None,
allow_stdin=False):
def success(res):
result, content_type, headers, status_code = res
reply = {
'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
return reply, result, content_type or 'text/plain'
def error(failure):
text = "<unknown error>"
try:
failure.raiseException()
except (lupa.LuaSyntaxError, lupa.LuaError, ScriptError) as e:
tp, line_num, message = parse_lua_error(e)
text = "<%s error> [input]:%s: %s" % (tp, line_num, message)
except Exception as e:
text = repr(e)
reply = {
'status': 'error',
'execution_count': self.execution_count,
'ename': '',
'evalue': text,
'traceback': []
}
return reply, text, 'text/plain'
try:
try:
# XXX: this ugly formatting is important for exception
# line numbers to be displayed properly!
lua_source = 'local repr = require("repr"); function main(splash) return repr(%s) end' % code
main_coro = self._get_main(lua_source)
except lupa.LuaSyntaxError:
try:
lines = code.splitlines(False)
lua_source = '''local repr = require("repr"); function main(splash) %s
return repr(%s)
end
''' % ("\n".join(lines[:-1]), lines[-1])
main_coro = self._get_main(lua_source)
except lupa.LuaSyntaxError:
lua_source = "function main(splash) %s end" % code
main_coro = self._get_main(lua_source)
except (lupa.LuaSyntaxError, lupa.LuaError) as e:
d = defer.Deferred()
d.addCallbacks(success, error)
d.errback(e)
return d
except Exception:
d = defer.Deferred()
d.addCallbacks(success, error)
d.errback()
return d
d = self.runner.run(main_coro)
d.addCallbacks(success, error)
return d
def do_complete(self, code, cursor_pos):
return self.completer.complete(code, cursor_pos)
def do_inspect(self, code, cursor_pos, detail_level=0):
return self.inspector.help(code, cursor_pos, detail_level)
def _publish_execute_result(self, parent, data, metadata, execution_count):
msg = {
u'data': data,
u'metadata': metadata,
u'execution_count': execution_count
}
self.session.send(self.iopub_socket, u'execute_result', msg,
parent=parent, ident=self._topic('execute_result')
)
def log_msg(self, text, min_level=2):
self._print(text + "\n")
def _print(self, message):
stream_content = {'name': 'stdout', 'text': message, 'metadata': dict()}
self.log.debug('Write: %s' % message)
self.send_response(self.iopub_socket, 'stream', stream_content)
def _get_main(self, lua_source):
if self.sandboxed:
main, env = get_main_sandboxed(self.lua, lua_source)
else:
main, env = get_main(self.lua, lua_source)
return self.lua.create_coroutine(main)
def configured_lua():
from splash.lua_runtime import SplashLuaRuntime
return SplashLuaRuntime(sandboxed=False,
lua_package_path="",
lua_sandbox_allowed_modules=())
