Beispiel #1
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.code_obj = {}
        self.num_array = []
        self.id_array = []
        self.stack = []
        self.environmrnt = {}

        self.instruction_set = {
            0: self.LOAD_NUM,
            1: self.DECL_FAST,
            2: self.STORE_FAST,
            3: self.LOAD_FAST,
            4: self.ADD_TWO_NUMBERS,
            5: self.SUBSTRACT_TWO_NUMBERS,
            6: self.MULTIPLE_TWO_NUMBERS,
            # 7 is initially reversed for division, now use it for print
            7: self.PRINT,
            8: self.COMPARE_TWO_NUMBERS,
            9: self.JUMP,
            10: self.JUMP_IF_FALSE,
            11: self.WHILE_LOOP,
            13: self.QUIT,

            # 14 - 16 is used
            17: self.LOAD_STRING
        }

        self.false_flag = 0
        self.pc = 0
        self.quit_flag = 0

        self.silent = None
Beispiel #2
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)

        self.tts = speechd.Speaker("jupyter_itts_kernel")
        self.possibleCommands = defaultdict(CommandDescriptor)
        self.initializeMagics()
        self.possibleCommands = ChosenMagicsCompleter(self.possibleCommands)
Beispiel #3
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     repl = subprocess_repl.SubprocessRepl([
         'C:\\Program Files\\SimVascular\\SimVascular\\REPLACE_SV_TIMESTAMP\\sv.bat',
         '-tk', '--'
     ])
     self.proxy = simvascular_tk_proxy.ReplProxy(repl)
Beispiel #4
0
 def __init__(self, **kwargs):
     start_time = time.time()
     Kernel.__init__(self, **kwargs)
     self.ansible_cfg = None
     self.ansible_process = None
     self.current_play = None
     self.next_task_file = None
     self.task_files = []
     self.playbook_file = None
     self.silent = False
     self.runner = None
     self.runner_thread = None
     self.shutdown_requested = False
     self.shutdown = False
     self.default_inventory = "[all]\nlocalhost ansible_connection=local\n"
     self.default_play = yaml.dump(dict(hosts='localhost',
                                        name='default',
                                        gather_facts=False))
     self.temp_dir = tempfile.mkdtemp(prefix="ansible_kernel_playbook")
     self.queue = queue.Queue()
     self.tasks_counter = 0
     self.current_task = None
     logger.debug(self.temp_dir)
     os.mkdir(os.path.join(self.temp_dir, 'env'))
     os.mkdir(os.path.join(self.temp_dir, 'project'))
     os.mkdir(os.path.join(self.temp_dir, 'project', 'roles'))
     with open(os.path.join(self.temp_dir, 'env', 'settings'), 'w') as f:
         f.write(json.dumps(dict(idle_timeout=0,
                                 job_timeout=0)))
     self.do_inventory(self.default_inventory)
     self.do_execute_play(self.default_play)
     logger.info("Kernel init finished took %s", time.time() - start_time)
Beispiel #5
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     repl = subprocess_repl.SubprocessRepl([
         '/usr/local/package/simvascular/REPLACE_SV_TIMESTAMP/simvascular',
         '-python', '--', '-i'
     ])
     self.proxy = simvascular_python_proxy.ReplProxy(repl)
Beispiel #6
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self._coqtop = CoqtopWrapper(self)
     self._journal = CellJournal(self)
     self._comms = {}
     for msg_type in ['comm_open', 'comm_msg', 'comm_close']:
         self.shell_handlers[msg_type] = getattr(self, msg_type)
Beispiel #7
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.definitions = Definitions(add_builtin=True)  # TODO Cache
     self.definitions.set_ownvalue('$Line',
                                   Integer(0))  # Reset the line number
     self.establish_comm_manager()  # needed for ipywidgets and Manipulate[]
     self.web_engine = None
Beispiel #8
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.log.setLevel(logging.INFO)
        self.delimiter = ";"
        self.client_config = ClientConfig(self.log)
        self.mariadb_client = MariaDBClient(self.log, self.client_config)
        self.mariadb_server = None
        self.data = {"last_select": pandas.DataFrame([])}

        try:
            self.mariadb_client.start()
        except ServerIsDownError:
            if not self.client_config.start_server():
                self.log.error(
                    "The options passed through mariadb_kernel.json "
                    "prevent the kernel from starting a testing "
                    "MariaDB server instance")
                raise

            # Start a single MariaDB server for a better experience
            # if user wants to quickly test the kernel
            self.mariadb_server = MariaDBServer(self.log, self.client_config)
            self.mariadb_server.start()

            # Reconnect the client now that the server is up
            if self.mariadb_server.is_up():
                self.mariadb_client.start()
Beispiel #9
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)

        # Get context
        r = requests.post('{}/ctx/new'.format(self.address))

        self.context = r.text
Beispiel #10
0
	def __init__(self, **kwargs):
		Kernel.__init__(self, **kwargs)
		if os.path.exists(self.mysql_setting_file):
			with open(self.mysql_setting_file,"r") as f:
				self.mysql_config.update(json.load(f))
		self.parser = MysqlParser()
		self.connect()
Beispiel #11
0
    def __init__(self,
                 target_name='',
                 data=None,
                 metadata=None,
                 buffers=None,
                 **kwargs):
        self.primary = True  # Am I the primary or secondary Comm?
        self.target_name = target_name
        # requirejs module from which to load comm target
        self.target_module = kwargs.get('target_module', None)
        self.open_hook = None
        self._closed = True
        self._close_callback = None
        self._msg_callback = None
        try:
            self.kernel = kwargs['kernel']
        except KeyError:
            if Kernel.initialized():
                self.kernel = Kernel.instance()
            else:
                self.kernel = None
        try:
            self.comm_id = kwargs['comm_id']
        except KeyError:
            self.comm_id = uuid.uuid4().hex
        self.topic = kwargs.get('topic',
                                ('comm-%s' % self.comm_id).encode('ascii'))
        self.log = log.get_logger()

        if self.kernel:
            if self.primary:
                # I am primary, open my peer.
                self.open(data=data, metadata=metadata, buffers=buffers)
            else:
                self._closed = False
Beispiel #12
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self._coqtop = Coqtop(self, self.coqtop_args)
     self._journal = CellJournal(self)
     self._renderer = Renderer()
     self._kernel_comms = []
     for msg_type in ['comm_open', 'comm_msg', 'comm_close']:
         self.shell_handlers[msg_type] = getattr(self, msg_type)
Beispiel #13
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     log('inside init')
     # Catch KeyboardInterrupt, cancel query, raise QueryCancelledError
     psycopg2.extensions.set_wait_callback(wait_select_inter)
     self._conn_string = os.getenv('DATABASE_URL', '')
     self._conn = None
     self._start_connection()
Beispiel #14
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     env_interpreter = os.environ.get(ENV_WASM_INTERPRETER, "wasm")
     self._interpreter_path = shutil.which(env_interpreter)
     if self._interpreter_path is None:
         raise Exception("Unable to find a `%s` executable in $PATH: %s" %
                         (env_interpreter, os.environ.get("PATH")))
     self._start_wasm()
Beispiel #15
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     log('inside init')
     # Catch KeyboardInterrupt, cancel query, raise QueryCancelledError
     psycopg2.extensions.set_wait_callback(wait_select_inter)
     self._conn_string = os.getenv('DATABASE_URL', '')
     self._autocommit = True
     self._conn = None
     self._start_connection()
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.silent = False
        self.dc = deviceconnector.DeviceConnector(self.sres, self.sresSYS)
        self.mpycrossexe = None

        self.srescapturemode = 0  # 0 none, 1 print lines, 2 print on-going line count (--quiet), 3 print only final line count (--QUIET)
        self.srescapturedoutputfile = None  # used by %capture command
        self.srescapturedlinecount = 0
        self.srescapturedlasttime = 0  # to control the frequency of capturing reported
Beispiel #17
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     logger = logging.getLogger('rax_kernel')
     fh = logging.FileHandler('rax_kernel.log')
     fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
     fh.setFormatter(fmt)
     logger.addHandler(fh)
     logger.setLevel(logging.DEBUG)
     self.logger = logger
     self.rax_running = False
Beispiel #18
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        # The path to the unix micropython should be in the PATH, if not check
        # the env for MPUNIX
        #TODO: Use shutil.which() in python 3.3+
        self.micropython_exe = 'micropython'
        if os.environ.get('MPUNIX') is not None:
            self.micropython_exe = os.environ.get('MPUNIX')

        self._start_interpreter()
Beispiel #19
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self._replace_get_ipython()
     self.comm_manager = CommManager(shell=None, parent=self,
                                     kernel=self)
     self.shell_handlers['comm_open'] = self.comm_manager.comm_open
     self.shell_handlers['comm_msg'] = self.comm_manager.comm_msg
     self.shell_handlers['comm_close'] = self.comm_manager.comm_close
     if ipywidgets_extension_loaded:
         self.comm_manager.register_target('ipython.widget', Widget.handle_comm_opened)
     self._start_polymake()
Beispiel #20
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self._replace_get_ipython()
        self.comm_manager = CommManager(shell=None, parent=self, kernel=self)

        self.shell_handlers["comm_open"] = self.comm_manager.comm_open
        self.shell_handlers["comm_msg"] = self.comm_manager.comm_msg
        self.shell_handlers["comm_close"] = self.comm_manager.comm_close

        self.comm_manager.register_target("ipython.widget", Widget.handle_comm_opened)
        self._start_singular()
Beispiel #21
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self._replace_get_ipython()
     self.comm_manager = CommManager(shell=None, parent=self,
                                     kernel=self)
     self.shell_handlers['comm_open'] = self.comm_manager.comm_open
     self.shell_handlers['comm_msg'] = self.comm_manager.comm_msg
     self.shell_handlers['comm_close'] = self.comm_manager.comm_close
     if ipywidgets_extension_loaded:
         self.comm_manager.register_target('ipython.widget', Widget.handle_comm_opened)
     self._start_polymake()
Beispiel #22
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self._start_jython()

        try:
            self.hist_file = os.path.join(locate_profile(),'jython_kernel.hist')
        except:
            self.hist_file = None
            self.log.warn('No default profile found, history unavailable')

        self.max_hist_cache = 1000
        self.hist_cache = []
Beispiel #23
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self._start_jython()

        try:
            self.hist_file = os.path.join(locate_profile(),'jython_kernel.hist')
        except:
            self.hist_file = None
            self.log.warn('No default profile found, history unavailable')

        self.max_hist_cache = 1000
        self.hist_cache = []
Beispiel #24
0
    def __init__(self, **kwargs):
        self.mathjax_initialized = False
        Kernel.__init__(self, **kwargs)
        if self.log is None:
            # This occurs if we call as a stand-alone kernel
            # (eg, not as a process)
            # FIXME: take care of input/output, eg StringIO
            #        make work without a session
            self.log = logging.Logger("NotebookApp")

        self.definitions = Definitions(add_builtin=True)        # TODO Cache
        self.definitions.set_ownvalue('$Line', Integer(0))  # Reset the line number
Beispiel #25
0
    def __init__(self, **kwargs):
        """
        Constructor
        """
        Kernel.__init__(self, **kwargs)
        opt = ""
        if "LOG4J_CONF_FILE" in os.environ:
            opt += " -4 " + os.environ["LOG4J_CONF_FILE"]
        # Start grunt
        self.pig = pexpect.spawn("/opt/pig-0.15.0/bin/pig -x local " + opt)

        # Wait until grunt start
        self.pig.expect(GRUNT_NEW_LINE_MODEL, timeout=GRUNT_START_TIMEOUT)
Beispiel #26
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        
        # powershell_command env variable is set by the kernel to allow both powershell and pwsh
        # but on python2 we cannot pass it thru env variable, see https://github.com/vors/jupyter-powershell/issues/7
        # TODO(python2): can we pass it somehow differently and still provide user-picked value on python2?
        try:
            powershell_command = environ['powershell_command']
        except:
            powershell_command = get_powershell()

        repl = subprocess_repl.SubprocessRepl([powershell_command, '-noprofile', '-File', '-'])
        self.proxy = powershell_proxy.ReplProxy(repl)
Beispiel #27
0
    def __init__(self, **kwargs):
        """
        Constructor
        """
        Kernel.__init__(self, **kwargs);
        opt = "";
        if "LOG4J_CONF_FILE" in os.environ:
            opt += " -4 " + os.environ["LOG4J_CONF_FILE"];
        # Start grunt
        self.pig = pexpect.spawn("/opt/pig-0.15.0/bin/pig -x local " + opt);

        # Wait until grunt start
        self.pig.expect(GRUNT_NEW_LINE_MODEL, timeout=GRUNT_START_TIMEOUT);
Beispiel #28
0
    def __init__(self, **kwargs):
        conf_file = os.path.expanduser(CONFIG_FILE)
        if os.path.isfile(conf_file):
            with open(conf_file, mode='r') as file_hanlde:
                self.conf = json.load(file_hanlde)
        pyhiveconf, sql_req = self.parse_code(code="")

        self.create_conn(**pyhiveconf)

        #if self.last_conn is None:
        #    raise ConnectionNotCreated()

        Kernel.__init__(self, **kwargs)
Beispiel #29
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        
        # powershell_command env variable is set by the kernel to allow both powershell and pwsh
        # but on python2 we cannot pass it thru env variable, see https://github.com/vors/jupyter-powershell/issues/7
        # TODO(python2): can we pass it somehow differently and still provide user-picked value on python2?
        try:
            powershell_command = environ['powershell_command']
        except:
            powershell_command = get_powershell()

        repl = subprocess_repl.SubprocessRepl([powershell_command, '-noprofile', '-File', '-'])
        self.proxy = powershell_proxy.ReplProxy(repl)
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     logger = logging.getLogger('ansible_kernel.kernel.__init__')
     self.ansible_cfg = None
     self.ansible_process = None
     self.current_play = None
     self.default_play = yaml.dump(
         dict(hosts='localhost', name='default', gather_facts=False))
     self.temp_dir = tempfile.mkdtemp(prefix="ansible_kernel_playbook")
     self.queue = Queue()
     self.tasks_counter = 0
     self.current_task = None
     logger.debug(self.temp_dir)
     self.do_execute_play(self.default_play)
Beispiel #31
0
    def __init__(self, **kwargs):
        """
        Constructor
        """
        Kernel.__init__(self, **kwargs);
        opt = "";
        if "LOG4J_CONF_FILE" in os.environ:
            opt += " -4 " + os.environ["LOG4J_CONF_FILE"];
        # Start grunt
        pig_home = "/usr/pig" if os.environ.get("PIG_HOME") == None else os.environ["PIG_HOME"]
        self.pig = pexpect.spawn(pig_home + "/bin/pig -x local " + opt);

        # Wait until grunt start
        self.pig.expect(GRUNT_NEW_LINE_MODEL, timeout=GRUNT_START_TIMEOUT);
Beispiel #32
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self._start_ncl()

        try:
            self.hist_file = os.path.join(locate_profile(),'ncl_kernel.hist')
        except:
            self.hist_file = None
            self.log.warn('No default profile found, history unavailable')

        self.max_hist_cache = 1000
        self.hist_cache = []
	#self._default_matches=cPickle.load(open('data/inbuilt_list', 'rb'))
        self._default_matches=self.inbuiltlist()
Beispiel #33
0
def hold_comm_open(kernel=None):
    if kernel is None:
        if not Kernel.initialized():
            raise ValueError(
                'No kernel passed, and current kernel not initialized')
        kernel = Kernel.instance()

    comm_manager = getattr(kernel, 'comm_manager', None)
    if comm_manager is None:
        raise RuntimeError("Comms cannot be opened without a kernel "
                           "and a comm_manager attached to that kernel.")

    patched_comms = []

    messages = []
    buffers = []

    def patched_register_comm(comm):
        original_publish_msg = comm._publish_msg

        def patched_publish_msg(msg_type, **kwargs):
            if msg_type != 'comm_open':
                original_publish_msg(msg_type, **kwargs)
            msg, msg_bufs = _convert_message(comm, **kwargs)
            messages.append(msg)
            buffers.extend(msg_bufs)

        patched_comms.append((comm, original_publish_msg))
        comm._publish_msg = patched_publish_msg

    original_register_comm = comm_manager.register_comm
    comm_manager.register_comm = patched_register_comm

    try:
        yield
    finally:
        comm_manager.register_comm = original_register_comm
        for comm, original_publish_msg in patched_comms:
            comm._publish_msg = original_publish_msg

    data = dict(messages=messages, )

    args = dict(target_name='jupyter.widget-tunnel',
                data=data,
                buffers=buffers,
                metadata={'version': __protocol_version__})

    comm = Comm(**args)
    comm.close()
Beispiel #34
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.delimiter = ";"
        self.client_config = ClientConfig(self.log)
        self.mariadb_client = MariaDBClient(self.log, self.client_config)
        self.mariadb_server = None
        self.data = {"last_select": pandas.DataFrame([])}

        if self.client_config.debug_logging():
            self.log.setLevel(logging.DEBUG)
        else:
            self.log.setLevel(logging.INFO)

        try:
            self.mariadb_client.start()
        except ServerIsDownError:
            if not self.client_config.start_server():
                self.log.error(
                    "The options passed through mariadb_kernel.json "
                    "prevent the kernel from starting a testing "
                    "MariaDB server instance")
                raise

            # Start a single MariaDB server for a better experience
            # if user wants to quickly test the kernel
            self.mariadb_server = MariaDBServer(self.log, self.client_config)
            self.mariadb_server.start()

            # Reconnect the client now that the server is up
            if self.mariadb_server.is_up():
                self.mariadb_client.start()

        # Create autocompletion/introspection objects based on whether
        # the user enabled this feature or not
        self.autocompleter = None
        self.introspector = None
        if self.client_config.autocompletion_enabled():
            try:
                self.autocompleter = Autocompleter(self.mariadb_client,
                                                   self.client_config,
                                                   self.log)
                self.introspector = Introspector()
            except:
                # Something went terribly wrong, disabling the feature
                self.log.error(
                    "Code completion functionalities were disabled due to an unexpected error"
                )
                self.autocompleter = None
                self.introspector = None
Beispiel #35
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self._start_ncl()
        
        self.pexpect_version=pexpect.__version__    
        try:
            self.hist_file = os.path.join(locate_profile(),'ncl_kernel.hist')
        except:
            self.hist_file = None
            self.log.warn('No default profile found, history unavailable')

        self.max_hist_cache = 1000
        self.hist_cache = []
        #self._default_matches=cPickle.load(open('data/inbuilt_list', 'rb'))
        self._default_matches=self.inbuiltlist()
Beispiel #36
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)

        # Instantiate IPython.core.debugger.Pdb here, pass it a phony 
        # stdout that provides a dummy flush() method and a write() method
        # that internally sends data using a function so that it can
        # be initialized to use self.send_response()
        write_func = lambda s: self.send_response(self.iopub_socket,
                                                  'stream',
                                                  {'name': 'stdout',
                                                   'text': s})
        sys.excepthook = functools.partial(BdbQuit_excepthook,
                                           excepthook=sys.excepthook)
        self.debugger = Pdb(stdout=PhonyStdout(write_func))
        self.debugger.set_trace(sys._getframe().f_back)
Beispiel #37
0
    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        ON_POSIX = 'posix' in sys.builtin_module_names

        def enqueue_output(out, queue):
            for line in iter(out.readline, b''):
                queue.put(line)
            out.close()
        
        self._gforth = Popen('gforth', stdin=PIPE, stdout=PIPE, bufsize=2, close_fds=ON_POSIX)
        self._gforth_queue = Queue()

        t = Thread(target=enqueue_output, args=(self._gforth.stdout, self._gforth_queue))
        t.daemon = True
        t.start()
 def test_rank_symbol_theme_layer(self, mock_send):
     """
     :type mock_send:Mock
     :type layer:RankSymbolThemeLayer
     :param mock_send:
     :return:
     """
     layer = RankSymbolThemeLayer(name='test1',
                                  data=[{
                                      'name': '北京市',
                                      'value': 23014.59
                                  }, {
                                      'name': '天津市',
                                      'value': 16538.189999999999
                                  }, {
                                      'name': '河北省',
                                      'value': 29806.110000000001
                                  }],
                                  address_key='name',
                                  value_key='value')
     layer._map = MapView()
     comm = Comm()
     comm.kernel = Kernel()
     layer.comm = comm
     layer.name = "test"
     expected = {
         'method': 'update',
         'state': {
             'name': 'test'
         },
         'buffer_paths': []
     }
     mock_send.assert_called_with(data=expected, buffers=[])
 def test_cloud_tile_layer(self, mock_send):
     """
     :type mock_send:Mock
     :param mock_send:
     :return:
     """
     layer = CloudTileLayer()
     layer._map = MapView()
     comm = Comm()
     comm.kernel = Kernel()
     layer.comm = comm
     layer.map_name = 'quanguo'
     expected = {
         'method': 'update',
         'state': {
             'map_name': 'quanguo'
         },
         'buffer_paths': []
     }
     mock_send.assert_called_with(data=expected, buffers=[])
     layer.type = 'web'
     expectedVisibility = {
         'method': 'update',
         'state': {
             'type': 'web'
         },
         'buffer_paths': []
     }
     mock_send.assert_called_with(data=expectedVisibility, buffers=[])
     self.assertEqual(mock_send.call_count, 2)
Beispiel #40
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.dir = get_kernel_spec('vim_kernel').resource_dir
     self.vim = Popen([
         'vim',
         '-X',
         '-N',
         '-u',
         'NONE',
         '-i',
         'NONE',
         '-e',
         '-s',
         '-S',
         path.join(self.dir, 'kernel.vim')
         ], stdout=PIPE, stderr=STDOUT, shell=False, env=environ.copy())
Beispiel #41
0
    def apply(self, expr, args, evaluation):
        'Manipulate[expr_, args__]'
        if (not _jupyter) or (not Kernel.initialized()) or (Kernel.instance() is None):
            return evaluation.message('Manipulate', 'jupyter')

        instantiator = _WidgetInstantiator()  # knows about the arguments and their widgets

        for arg in args.get_sequence():
            try:
                if not instantiator.add(arg, evaluation):  # not a valid argument pattern?
                    return
            except IllegalWidgetArguments as e:
                return evaluation.message('Manipulate', 'widgetargs', strip_context(str(e.var)))
            except JupyterWidgetError as e:
                return evaluation.message('Manipulate', 'widgetmake', e.err)

        clear_output_callback = evaluation.output.clear
        display_data_callback = evaluation.output.display  # for pushing updates

        try:
            clear_output_callback(wait=True)
        except NotImplementedError:
            return evaluation.message('Manipulate', 'imathics')

        def callback(**kwargs):
            clear_output_callback(wait=True)

            line_no = evaluation.definitions.get_line_no()

            vars = [Expression('Set', Symbol(name), value) for name, value in kwargs.items()]
            evaluatable = Expression('ReleaseHold', Expression('Module', Expression('List', *vars), expr))

            result = evaluation.evaluate(evaluatable, timeout=settings.TIMEOUT)
            if result:
                display_data_callback(data=result.result, metadata={})

            evaluation.definitions.set_line_no(line_no)  # do not increment line_no for manipulate computations

        widgets = instantiator.get_widgets()
        if len(widgets) > 0:
            box = _interactive(instantiator.build_callback(callback), widgets)  # create the widget
            formatter = IPythonDisplayFormatter()
            if not formatter(box):  # make the widget appear on the Jupyter notebook
                return evaluation.message('Manipulate', 'widgetdisp')

        return Symbol('Null')  # the interactive output is pushed via kernel.display_data_callback (see above)
Beispiel #42
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     repl = subprocess_repl.SubprocessRepl(['C:\\cygwin64\\bin\\bash.exe','-i'])
     self.proxy = cygwin_bash_proxy.ReplProxy(repl)
Beispiel #43
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     repl = subprocess_repl.SubprocessRepl(['C:\\Program Files\\SimVascular\\SimVascular\\2019-02-05\\sv.bat', '-tcl', '--'])
     self.proxy = simvascular_tcl_proxy.ReplProxy(repl)
Beispiel #44
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.cookery = Cookery(jupyter=True)
     self.cookery.log = self.log.getChild(self.implementation)
Beispiel #45
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self._start_magma()
Beispiel #46
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.tcl = Tkinter.Tcl()
     self.execution_count = 0
     putsredef = 'rename puts original_puts \nproc puts {args} {\n    if {[llength $args] == 1} {\n        return "=> [lindex $args 0]"\n    } else {\n        eval original_puts $args\n    }\n}\n'
     self.tcl.eval(putsredef)
Beispiel #47
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.tcl = Tkinter.Tcl()
     self.execution_count = 0
Beispiel #48
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     repl = subprocess_repl.SubprocessRepl(['C:\\Program Files\\SimVascular\\SimVascular\\REPLACE_SV_TIMESTAMP\\sv.bat', '-python', '--', '-i'])
     self.proxy = simvascular_python_proxy.ReplProxy(repl)
Beispiel #49
0
 def _default_kernel(self):
     if Kernel.initialized():
         return Kernel.instance()
Beispiel #50
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.repl = ReplWrapper()
Beispiel #51
0
 def __init__(self, **kwargs):
   Kernel.__init__(self, **kwargs)
   self._start_spark()
Beispiel #52
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.hostname = os.environ.get('CASSANDRA_HOSTNAME','localhost')
     self._start_cql()
Beispiel #53
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     repl = subprocess_repl.SubprocessRepl(['/usr/local/package/simvascular/REPLACE_SV_TIMESTAMP/simvascular', '-python', '--', '-i'])
     self.proxy = simvascular_python_proxy.ReplProxy(repl)
Beispiel #54
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self._start_gap()
Beispiel #55
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.client = command.Client()
     self.qsh = sh.QSh(self.client)
Beispiel #56
0
 def __init__(self, **kwargs):
     
     Kernel.__init__(self, **kwargs)
     self._start_interpreter()
Beispiel #57
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.start_redis(**kwargs)
     self.get_commands()
     self.start_history()
Beispiel #58
0
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.definitions = Definitions(add_builtin=True)        # TODO Cache
     self.definitions.set_ownvalue('$Line', Integer(0))  # Reset the line number
     self.establish_comm_manager()  # needed for ipywidgets and Manipulate[]
 def __init__(self, **kwargs):
     Kernel.__init__(self, **kwargs)
     self.omc = OMCSessionZMQ()
     self.matfile = None